#[allow(non_snake_case)]
#[cfg(test)]
mod tests {
use super::super::types::*;
#[test]
fn test_graph_basic_operations() {
let mut graph = Graph::new();
let _a = graph.add_vertex("A");
let _b = graph.add_vertex("B");
let _c = graph.add_vertex("C");
graph
.add_edge(&"A", &"B")
.expect("operation should succeed");
graph
.add_edge(&"B", &"C")
.expect("operation should succeed");
graph
.add_edge(&"C", &"A")
.expect("operation should succeed");
assert_eq!(graph.num_vertices(), 3);
assert_eq!(graph.num_edges(), 3);
let neighbors = graph.neighbors(&"A").expect("operation should succeed");
assert_eq!(neighbors.len(), 1);
assert_eq!(neighbors[0], &"B");
}
#[test]
fn test_graph_bfs() {
let mut graph = Graph::new();
graph.add_vertex("A");
graph.add_vertex("B");
graph.add_vertex("C");
graph.add_vertex("D");
graph
.add_edge(&"A", &"B")
.expect("operation should succeed");
graph
.add_edge(&"A", &"C")
.expect("operation should succeed");
graph
.add_edge(&"B", &"D")
.expect("operation should succeed");
let bfs_result = graph.bfs(&"A").expect("operation should succeed");
assert_eq!(bfs_result[0], &"A");
assert!(bfs_result.contains(&&"B"));
assert!(bfs_result.contains(&&"C"));
assert!(bfs_result.contains(&&"D"));
}
#[test]
fn test_graph_has_cycle() {
let mut graph = Graph::new();
graph.add_vertex(1);
graph.add_vertex(2);
graph.add_vertex(3);
graph.add_edge(&1, &2).expect("operation should succeed");
graph.add_edge(&2, &3).expect("operation should succeed");
assert!(!graph.has_cycle());
graph.add_edge(&3, &1).expect("operation should succeed");
assert!(graph.has_cycle());
}
#[test]
fn test_binary_search_tree() {
let mut bst = BinarySearchTree::new();
bst.insert(5);
bst.insert(3);
bst.insert(7);
bst.insert(1);
bst.insert(9);
assert!(bst.search(&5));
assert!(bst.search(&1));
assert!(!bst.search(&6));
let inorder = bst.inorder();
assert_eq!(inorder, vec![&1, &3, &5, &7, &9]);
assert_eq!(bst.height(), 3);
}
#[test]
fn test_trie() {
let mut trie = Trie::new();
trie.insert("cat");
trie.insert("car");
trie.insert("card");
trie.insert("care");
trie.insert("careful");
assert!(trie.search("cat"));
assert!(trie.search("car"));
assert!(!trie.search("ca"));
assert!(trie.starts_with("ca"));
let words = trie.words_with_prefix("car");
assert!(words.contains(&"car".to_string()));
assert!(words.contains(&"card".to_string()));
assert!(words.contains(&"care".to_string()));
assert!(words.contains(&"careful".to_string()));
assert!(!words.contains(&"cat".to_string()));
}
#[test]
fn test_tree_serialization_visualization() {
let mut bst = BinarySearchTree::new();
bst.insert(5);
bst.insert(3);
bst.insert(7);
bst.insert(1);
let serialized = bst.serialize();
assert!(serialized.contains("node: 5"));
assert!(serialized.contains("node: 3"));
let visualized = bst.visualize();
assert!(visualized.contains("5"));
assert!(visualized.contains("3"));
assert!(visualized.contains("7"));
}
#[test]
fn test_tree_comparison() {
let mut bst1 = BinarySearchTree::new();
bst1.insert(5);
bst1.insert(3);
bst1.insert(7);
let mut bst2 = BinarySearchTree::new();
bst2.insert(5);
bst2.insert(3);
bst2.insert(7);
let mut bst3 = BinarySearchTree::new();
bst3.insert(5);
bst3.insert(2);
bst3.insert(7);
assert!(bst1.structural_equals(&bst2));
assert!(!bst1.structural_equals(&bst3));
assert!(bst1.same_structure(&bst2));
}
#[test]
fn test_tree_statistics() {
let mut bst = BinarySearchTree::new();
bst.insert(5);
bst.insert(3);
bst.insert(7);
bst.insert(1);
bst.insert(9);
let stats = bst.statistics();
assert_eq!(stats.node_count, 5);
assert_eq!(stats.leaf_count, 2);
assert_eq!(stats.internal_count, 3);
assert!(stats.max_depth >= 2);
assert!(bst.is_balanced());
}
#[test]
fn test_trie_serialization_visualization() {
let mut trie = Trie::new();
trie.insert("cat");
trie.insert("car");
let serialized = trie.serialize();
assert!(serialized.contains("word: cat"));
assert!(serialized.contains("word: car"));
let visualized = trie.visualize();
assert!(visualized.contains("Trie"));
assert!(visualized.contains("cat") || visualized.contains("car"));
}
#[test]
fn test_trie_comparison() {
let mut trie1 = Trie::new();
trie1.insert("cat");
trie1.insert("car");
let mut trie2 = Trie::new();
trie2.insert("cat");
trie2.insert("car");
let mut trie3 = Trie::new();
trie3.insert("dog");
assert!(trie1.structural_equals(&trie2));
assert!(!trie1.structural_equals(&trie3));
assert!(trie1.contains_trie(&trie2));
assert!(!trie1.contains_trie(&trie3));
}
#[test]
fn test_trie_statistics() {
let mut trie = Trie::new();
trie.insert("cat");
trie.insert("car");
trie.insert("care");
let stats = trie.statistics();
assert_eq!(stats.word_count, 3);
assert!(stats.node_count >= 3);
assert!(stats.max_depth >= 3);
assert!(stats.branch_factor >= 1);
}
#[test]
fn test_trie_removal() {
let mut trie = Trie::new();
trie.insert("cat");
trie.insert("car");
trie.insert("card");
assert!(trie.search("car"));
assert!(trie.remove("car"));
assert!(!trie.search("car"));
assert!(trie.search("card"));
assert!(trie.search("cat"));
}
#[test]
fn test_trie_longest_common_prefix() {
let mut trie = Trie::new();
trie.insert("preprocessing");
trie.insert("preprocess");
let prefix = trie.longest_common_prefix();
assert!(prefix.starts_with("pre"));
}
#[test]
fn test_ring_buffer() {
let mut buffer = RingBuffer::new(3);
assert!(buffer.is_empty());
assert!(!buffer.is_full());
buffer.push(1);
buffer.push(2);
buffer.push(3);
assert!(buffer.is_full());
assert_eq!(buffer.len(), 3);
let old = buffer.push(4);
assert_eq!(old, Some(1));
let values: Vec<&i32> = buffer.iter().collect();
assert_eq!(values, vec![&2, &3, &4]);
assert_eq!(buffer.pop(), Some(2));
assert_eq!(buffer.len(), 2);
}
#[test]
fn test_block_matrix() {
let mut matrix = BlockMatrix::new(4, 4, 2);
matrix.set(0, 0, 1).expect("operation should succeed");
matrix.set(1, 1, 2).expect("operation should succeed");
matrix.set(2, 2, 3).expect("operation should succeed");
matrix.set(3, 3, 4).expect("operation should succeed");
assert_eq!(*matrix.get(0, 0).expect("operation should succeed"), 1);
assert_eq!(*matrix.get(1, 1).expect("operation should succeed"), 2);
assert_eq!(*matrix.get(2, 2).expect("operation should succeed"), 3);
assert_eq!(*matrix.get(3, 3).expect("operation should succeed"), 4);
assert_eq!(matrix.dim(), (4, 4));
assert!(matrix.set(5, 5, 1).is_err());
assert!(matrix.get(5, 5).is_err());
}
#[test]
fn test_weighted_graph_mst() {
let mut graph = WeightedGraph::new();
graph.add_vertex("A");
graph.add_vertex("B");
graph.add_vertex("C");
graph.add_vertex("D");
graph
.add_edge(&"A", &"B", 1)
.expect("operation should succeed");
graph
.add_edge(&"B", &"A", 1)
.expect("operation should succeed");
graph
.add_edge(&"B", &"C", 2)
.expect("operation should succeed");
graph
.add_edge(&"C", &"B", 2)
.expect("operation should succeed");
graph
.add_edge(&"C", &"D", 3)
.expect("operation should succeed");
graph
.add_edge(&"D", &"C", 3)
.expect("operation should succeed");
graph
.add_edge(&"A", &"D", 4)
.expect("operation should succeed");
graph
.add_edge(&"D", &"A", 4)
.expect("operation should succeed");
let mst = graph
.minimum_spanning_tree()
.expect("operation should succeed");
assert!(mst.len() <= 3);
for (_, _, weight) in &mst {
assert!(*weight >= 1 && *weight <= 4);
}
}
#[test]
fn test_concurrent_hashmap() {
let map = ConcurrentHashMap::new();
assert!(map
.insert("key1".to_string(), 1)
.expect("operation should succeed")
.is_none());
assert_eq!(
map.get(&"key1".to_string())
.expect("operation should succeed"),
Some(1)
);
assert!(map
.contains_key(&"key1".to_string())
.expect("operation should succeed"));
assert_eq!(map.len().expect("operation should succeed"), 1);
assert_eq!(
map.insert("key1".to_string(), 2)
.expect("operation should succeed"),
Some(1)
);
assert_eq!(
map.get(&"key1".to_string())
.expect("operation should succeed"),
Some(2)
);
assert_eq!(
map.remove(&"key1".to_string())
.expect("operation should succeed"),
Some(2)
);
assert_eq!(
map.get(&"key1".to_string())
.expect("operation should succeed"),
None
);
assert!(map.is_empty().expect("operation should succeed"));
}
#[test]
fn test_concurrent_ring_buffer() {
let buffer = ConcurrentRingBuffer::new(3);
assert!(buffer.is_empty().expect("operation should succeed"));
assert!(!buffer.is_full().expect("operation should succeed"));
assert!(buffer.push(1).expect("operation should succeed").is_none());
assert!(buffer.push(2).expect("operation should succeed").is_none());
assert!(buffer.push(3).expect("operation should succeed").is_none());
assert!(buffer.is_full().expect("operation should succeed"));
assert_eq!(buffer.len().expect("operation should succeed"), 3);
let old = buffer.push(4).expect("operation should succeed");
assert_eq!(old, Some(1));
assert_eq!(buffer.pop().expect("operation should succeed"), Some(2));
assert_eq!(buffer.len().expect("operation should succeed"), 2);
}
#[test]
fn test_concurrent_queue() {
let queue = ConcurrentQueue::new();
assert!(queue.is_empty().expect("operation should succeed"));
queue.push_back(1).expect("operation should succeed");
queue.push_back(2).expect("operation should succeed");
queue.push_front(0).expect("operation should succeed");
assert_eq!(queue.len().expect("operation should succeed"), 3);
assert_eq!(
queue.pop_front().expect("operation should succeed"),
Some(0)
);
assert_eq!(queue.pop_back().expect("operation should succeed"), Some(2));
assert_eq!(
queue.pop_front().expect("operation should succeed"),
Some(1)
);
assert!(queue.is_empty().expect("operation should succeed"));
}
#[test]
fn test_atomic_counter() {
let counter = AtomicCounter::new(10);
assert_eq!(counter.get(), 10);
assert_eq!(counter.increment(), 11);
assert_eq!(counter.decrement(), 10);
assert_eq!(counter.add(5), 15);
assert_eq!(counter.sub(3), 12);
counter.set(100);
assert_eq!(counter.get(), 100);
assert_eq!(counter.compare_and_swap(100, 200), 100);
assert_eq!(counter.get(), 200);
assert_eq!(counter.compare_and_swap(100, 300), 200);
assert_eq!(counter.get(), 200);
}
#[test]
fn test_work_queue() {
let queue = WorkQueue::new();
assert!(!queue.has_work().expect("operation should succeed"));
assert_eq!(queue.queue_size().expect("operation should succeed"), 0);
assert_eq!(queue.active_worker_count(), 0);
queue
.add_work("task1".to_string())
.expect("operation should succeed");
queue
.add_work("task2".to_string())
.expect("operation should succeed");
assert!(queue.has_work().expect("operation should succeed"));
assert_eq!(queue.queue_size().expect("operation should succeed"), 2);
queue.register_worker();
queue.register_worker();
assert_eq!(queue.active_worker_count(), 2);
assert_eq!(
queue.get_work().expect("operation should succeed"),
Some("task1".to_string())
);
assert_eq!(
queue.get_work().expect("operation should succeed"),
Some("task2".to_string())
);
assert_eq!(queue.get_work().expect("operation should succeed"), None);
queue.unregister_worker();
assert_eq!(queue.active_worker_count(), 1);
}
#[test]
fn test_graph_serialization() {
let mut graph = Graph::new();
graph.add_vertex("A");
graph.add_vertex("B");
graph.add_vertex("C");
graph
.add_edge(&"A", &"B")
.expect("operation should succeed");
graph
.add_edge(&"B", &"C")
.expect("operation should succeed");
graph
.add_edge(&"C", &"A")
.expect("operation should succeed");
let serialized = graph.serialize();
assert!(serialized.contains("Graph {"));
assert!(serialized.contains("vertices: 3 nodes"));
assert!(serialized.contains("edges: 3 connections"));
assert!(serialized.contains("A: [B]"));
assert!(serialized.contains("B: [C]"));
assert!(serialized.contains("C: [A]"));
}
#[test]
fn test_graph_visualization() {
let mut graph = Graph::new();
graph.add_vertex("A");
graph.add_vertex("B");
graph
.add_edge(&"A", &"B")
.expect("operation should succeed");
let visualized = graph.visualize();
assert!(visualized.contains("Graph Visualization:"));
assert!(visualized.contains("Vertices: 2"));
assert!(visualized.contains("Edges: 1"));
assert!(visualized.contains("Has cycle: false"));
assert!(visualized.contains("A -> [B]"));
assert!(visualized.contains("B -> []"));
}
#[test]
fn test_graph_structural_equals() {
let mut graph1 = Graph::new();
graph1.add_vertex("A");
graph1.add_vertex("B");
graph1
.add_edge(&"A", &"B")
.expect("operation should succeed");
let mut graph2 = Graph::new();
graph2.add_vertex("A");
graph2.add_vertex("B");
graph2
.add_edge(&"A", &"B")
.expect("operation should succeed");
let mut graph3 = Graph::new();
graph3.add_vertex("A");
graph3.add_vertex("C");
graph3
.add_edge(&"A", &"C")
.expect("operation should succeed");
assert!(graph1.structural_equals(&graph2));
assert!(!graph1.structural_equals(&graph3));
}
#[test]
fn test_weighted_graph_serialization() {
let mut graph = WeightedGraph::new();
graph.add_vertex("A");
graph.add_vertex("B");
graph.add_vertex("C");
graph
.add_edge(&"A", &"B", 1.5)
.expect("operation should succeed");
graph
.add_edge(&"B", &"C", 2.0)
.expect("operation should succeed");
let serialized = graph.serialize();
assert!(serialized.contains("WeightedGraph {"));
assert!(serialized.contains("vertices: 3 nodes"));
assert!(serialized.contains("edges: 2 weighted connections"));
assert!(serialized.contains("A: [B:1.5]"));
assert!(serialized.contains("B: [C:2]"));
assert!(serialized.contains("C: []"));
}
#[test]
fn test_weighted_graph_visualization() {
let mut graph = WeightedGraph::new();
graph.add_vertex("A");
graph.add_vertex("B");
graph
.add_edge(&"A", &"B", 10)
.expect("operation should succeed");
let visualized = graph.visualize();
assert!(visualized.contains("Weighted Graph Visualization:"));
assert!(visualized.contains("Vertices: 2"));
assert!(visualized.contains("Weighted Edges: 1"));
assert!(visualized.contains("A -> [B(w:10)]"));
assert!(visualized.contains("B -> []"));
}
#[test]
fn test_weighted_graph_structural_equals() {
let mut graph1 = WeightedGraph::new();
graph1.add_vertex("A");
graph1.add_vertex("B");
graph1
.add_edge(&"A", &"B", 5)
.expect("operation should succeed");
let mut graph2 = WeightedGraph::new();
graph2.add_vertex("A");
graph2.add_vertex("B");
graph2
.add_edge(&"A", &"B", 5)
.expect("operation should succeed");
let mut graph3 = WeightedGraph::new();
graph3.add_vertex("A");
graph3.add_vertex("B");
graph3
.add_edge(&"A", &"B", 10)
.expect("operation should succeed");
assert!(graph1.structural_equals(&graph2));
assert!(!graph1.structural_equals(&graph3));
}
}