sklears_utils/data_structures/
functions.rs1#[allow(non_snake_case)]
6#[cfg(test)]
7mod tests {
8 use super::super::types::*;
9 #[test]
10 fn test_graph_basic_operations() {
11 let mut graph = Graph::new();
12 let _a = graph.add_vertex("A");
13 let _b = graph.add_vertex("B");
14 let _c = graph.add_vertex("C");
15 graph.add_edge(&"A", &"B").unwrap();
16 graph.add_edge(&"B", &"C").unwrap();
17 graph.add_edge(&"C", &"A").unwrap();
18 assert_eq!(graph.num_vertices(), 3);
19 assert_eq!(graph.num_edges(), 3);
20 let neighbors = graph.neighbors(&"A").unwrap();
21 assert_eq!(neighbors.len(), 1);
22 assert_eq!(neighbors[0], &"B");
23 }
24 #[test]
25 fn test_graph_bfs() {
26 let mut graph = Graph::new();
27 graph.add_vertex("A");
28 graph.add_vertex("B");
29 graph.add_vertex("C");
30 graph.add_vertex("D");
31 graph.add_edge(&"A", &"B").unwrap();
32 graph.add_edge(&"A", &"C").unwrap();
33 graph.add_edge(&"B", &"D").unwrap();
34 let bfs_result = graph.bfs(&"A").unwrap();
35 assert_eq!(bfs_result[0], &"A");
36 assert!(bfs_result.contains(&&"B"));
37 assert!(bfs_result.contains(&&"C"));
38 assert!(bfs_result.contains(&&"D"));
39 }
40 #[test]
41 fn test_graph_has_cycle() {
42 let mut graph = Graph::new();
43 graph.add_vertex(1);
44 graph.add_vertex(2);
45 graph.add_vertex(3);
46 graph.add_edge(&1, &2).unwrap();
47 graph.add_edge(&2, &3).unwrap();
48 assert!(!graph.has_cycle());
49 graph.add_edge(&3, &1).unwrap();
50 assert!(graph.has_cycle());
51 }
52 #[test]
53 fn test_binary_search_tree() {
54 let mut bst = BinarySearchTree::new();
55 bst.insert(5);
56 bst.insert(3);
57 bst.insert(7);
58 bst.insert(1);
59 bst.insert(9);
60 assert!(bst.search(&5));
61 assert!(bst.search(&1));
62 assert!(!bst.search(&6));
63 let inorder = bst.inorder();
64 assert_eq!(inorder, vec![&1, &3, &5, &7, &9]);
65 assert_eq!(bst.height(), 3);
66 }
67 #[test]
68 fn test_trie() {
69 let mut trie = Trie::new();
70 trie.insert("cat");
71 trie.insert("car");
72 trie.insert("card");
73 trie.insert("care");
74 trie.insert("careful");
75 assert!(trie.search("cat"));
76 assert!(trie.search("car"));
77 assert!(!trie.search("ca"));
78 assert!(trie.starts_with("ca"));
79 let words = trie.words_with_prefix("car");
80 assert!(words.contains(&"car".to_string()));
81 assert!(words.contains(&"card".to_string()));
82 assert!(words.contains(&"care".to_string()));
83 assert!(words.contains(&"careful".to_string()));
84 assert!(!words.contains(&"cat".to_string()));
85 }
86 #[test]
87 fn test_tree_serialization_visualization() {
88 let mut bst = BinarySearchTree::new();
89 bst.insert(5);
90 bst.insert(3);
91 bst.insert(7);
92 bst.insert(1);
93 let serialized = bst.serialize();
94 assert!(serialized.contains("node: 5"));
95 assert!(serialized.contains("node: 3"));
96 let visualized = bst.visualize();
97 assert!(visualized.contains("5"));
98 assert!(visualized.contains("3"));
99 assert!(visualized.contains("7"));
100 }
101 #[test]
102 fn test_tree_comparison() {
103 let mut bst1 = BinarySearchTree::new();
104 bst1.insert(5);
105 bst1.insert(3);
106 bst1.insert(7);
107 let mut bst2 = BinarySearchTree::new();
108 bst2.insert(5);
109 bst2.insert(3);
110 bst2.insert(7);
111 let mut bst3 = BinarySearchTree::new();
112 bst3.insert(5);
113 bst3.insert(2);
114 bst3.insert(7);
115 assert!(bst1.structural_equals(&bst2));
116 assert!(!bst1.structural_equals(&bst3));
117 assert!(bst1.same_structure(&bst2));
118 }
119 #[test]
120 fn test_tree_statistics() {
121 let mut bst = BinarySearchTree::new();
122 bst.insert(5);
123 bst.insert(3);
124 bst.insert(7);
125 bst.insert(1);
126 bst.insert(9);
127 let stats = bst.statistics();
128 assert_eq!(stats.node_count, 5);
129 assert_eq!(stats.leaf_count, 2);
130 assert_eq!(stats.internal_count, 3);
131 assert!(stats.max_depth >= 2);
132 assert!(bst.is_balanced());
133 }
134 #[test]
135 fn test_trie_serialization_visualization() {
136 let mut trie = Trie::new();
137 trie.insert("cat");
138 trie.insert("car");
139 let serialized = trie.serialize();
140 assert!(serialized.contains("word: cat"));
141 assert!(serialized.contains("word: car"));
142 let visualized = trie.visualize();
143 assert!(visualized.contains("Trie"));
144 assert!(visualized.contains("cat") || visualized.contains("car"));
145 }
146 #[test]
147 fn test_trie_comparison() {
148 let mut trie1 = Trie::new();
149 trie1.insert("cat");
150 trie1.insert("car");
151 let mut trie2 = Trie::new();
152 trie2.insert("cat");
153 trie2.insert("car");
154 let mut trie3 = Trie::new();
155 trie3.insert("dog");
156 assert!(trie1.structural_equals(&trie2));
157 assert!(!trie1.structural_equals(&trie3));
158 assert!(trie1.contains_trie(&trie2));
159 assert!(!trie1.contains_trie(&trie3));
160 }
161 #[test]
162 fn test_trie_statistics() {
163 let mut trie = Trie::new();
164 trie.insert("cat");
165 trie.insert("car");
166 trie.insert("care");
167 let stats = trie.statistics();
168 assert_eq!(stats.word_count, 3);
169 assert!(stats.node_count >= 3);
170 assert!(stats.max_depth >= 3);
171 assert!(stats.branch_factor >= 1);
172 }
173 #[test]
174 fn test_trie_removal() {
175 let mut trie = Trie::new();
176 trie.insert("cat");
177 trie.insert("car");
178 trie.insert("card");
179 assert!(trie.search("car"));
180 assert!(trie.remove("car"));
181 assert!(!trie.search("car"));
182 assert!(trie.search("card"));
183 assert!(trie.search("cat"));
184 }
185 #[test]
186 fn test_trie_longest_common_prefix() {
187 let mut trie = Trie::new();
188 trie.insert("preprocessing");
189 trie.insert("preprocess");
190 let prefix = trie.longest_common_prefix();
191 assert!(prefix.starts_with("pre"));
192 }
193 #[test]
194 fn test_ring_buffer() {
195 let mut buffer = RingBuffer::new(3);
196 assert!(buffer.is_empty());
197 assert!(!buffer.is_full());
198 buffer.push(1);
199 buffer.push(2);
200 buffer.push(3);
201 assert!(buffer.is_full());
202 assert_eq!(buffer.len(), 3);
203 let old = buffer.push(4);
204 assert_eq!(old, Some(1));
205 let values: Vec<&i32> = buffer.iter().collect();
206 assert_eq!(values, vec![&2, &3, &4]);
207 assert_eq!(buffer.pop(), Some(2));
208 assert_eq!(buffer.len(), 2);
209 }
210 #[test]
211 fn test_block_matrix() {
212 let mut matrix = BlockMatrix::new(4, 4, 2);
213 matrix.set(0, 0, 1).unwrap();
214 matrix.set(1, 1, 2).unwrap();
215 matrix.set(2, 2, 3).unwrap();
216 matrix.set(3, 3, 4).unwrap();
217 assert_eq!(*matrix.get(0, 0).unwrap(), 1);
218 assert_eq!(*matrix.get(1, 1).unwrap(), 2);
219 assert_eq!(*matrix.get(2, 2).unwrap(), 3);
220 assert_eq!(*matrix.get(3, 3).unwrap(), 4);
221 assert_eq!(matrix.dim(), (4, 4));
222 assert!(matrix.set(5, 5, 1).is_err());
223 assert!(matrix.get(5, 5).is_err());
224 }
225 #[test]
226 fn test_weighted_graph_mst() {
227 let mut graph = WeightedGraph::new();
228 graph.add_vertex("A");
229 graph.add_vertex("B");
230 graph.add_vertex("C");
231 graph.add_vertex("D");
232 graph.add_edge(&"A", &"B", 1).unwrap();
233 graph.add_edge(&"B", &"A", 1).unwrap();
234 graph.add_edge(&"B", &"C", 2).unwrap();
235 graph.add_edge(&"C", &"B", 2).unwrap();
236 graph.add_edge(&"C", &"D", 3).unwrap();
237 graph.add_edge(&"D", &"C", 3).unwrap();
238 graph.add_edge(&"A", &"D", 4).unwrap();
239 graph.add_edge(&"D", &"A", 4).unwrap();
240 let mst = graph.minimum_spanning_tree().unwrap();
241 assert!(mst.len() <= 3);
242 for (_, _, weight) in &mst {
243 assert!(*weight >= 1 && *weight <= 4);
244 }
245 }
246 #[test]
247 fn test_concurrent_hashmap() {
248 let map = ConcurrentHashMap::new();
249 assert!(map.insert("key1".to_string(), 1).unwrap().is_none());
250 assert_eq!(map.get(&"key1".to_string()).unwrap(), Some(1));
251 assert!(map.contains_key(&"key1".to_string()).unwrap());
252 assert_eq!(map.len().unwrap(), 1);
253 assert_eq!(map.insert("key1".to_string(), 2).unwrap(), Some(1));
254 assert_eq!(map.get(&"key1".to_string()).unwrap(), Some(2));
255 assert_eq!(map.remove(&"key1".to_string()).unwrap(), Some(2));
256 assert_eq!(map.get(&"key1".to_string()).unwrap(), None);
257 assert!(map.is_empty().unwrap());
258 }
259 #[test]
260 fn test_concurrent_ring_buffer() {
261 let buffer = ConcurrentRingBuffer::new(3);
262 assert!(buffer.is_empty().unwrap());
263 assert!(!buffer.is_full().unwrap());
264 assert!(buffer.push(1).unwrap().is_none());
265 assert!(buffer.push(2).unwrap().is_none());
266 assert!(buffer.push(3).unwrap().is_none());
267 assert!(buffer.is_full().unwrap());
268 assert_eq!(buffer.len().unwrap(), 3);
269 let old = buffer.push(4).unwrap();
270 assert_eq!(old, Some(1));
271 assert_eq!(buffer.pop().unwrap(), Some(2));
272 assert_eq!(buffer.len().unwrap(), 2);
273 }
274 #[test]
275 fn test_concurrent_queue() {
276 let queue = ConcurrentQueue::new();
277 assert!(queue.is_empty().unwrap());
278 queue.push_back(1).unwrap();
279 queue.push_back(2).unwrap();
280 queue.push_front(0).unwrap();
281 assert_eq!(queue.len().unwrap(), 3);
282 assert_eq!(queue.pop_front().unwrap(), Some(0));
283 assert_eq!(queue.pop_back().unwrap(), Some(2));
284 assert_eq!(queue.pop_front().unwrap(), Some(1));
285 assert!(queue.is_empty().unwrap());
286 }
287 #[test]
288 fn test_atomic_counter() {
289 let counter = AtomicCounter::new(10);
290 assert_eq!(counter.get(), 10);
291 assert_eq!(counter.increment(), 11);
292 assert_eq!(counter.decrement(), 10);
293 assert_eq!(counter.add(5), 15);
294 assert_eq!(counter.sub(3), 12);
295 counter.set(100);
296 assert_eq!(counter.get(), 100);
297 assert_eq!(counter.compare_and_swap(100, 200), 100);
298 assert_eq!(counter.get(), 200);
299 assert_eq!(counter.compare_and_swap(100, 300), 200);
300 assert_eq!(counter.get(), 200);
301 }
302 #[test]
303 fn test_work_queue() {
304 let queue = WorkQueue::new();
305 assert!(!queue.has_work().unwrap());
306 assert_eq!(queue.queue_size().unwrap(), 0);
307 assert_eq!(queue.active_worker_count(), 0);
308 queue.add_work("task1".to_string()).unwrap();
309 queue.add_work("task2".to_string()).unwrap();
310 assert!(queue.has_work().unwrap());
311 assert_eq!(queue.queue_size().unwrap(), 2);
312 queue.register_worker();
313 queue.register_worker();
314 assert_eq!(queue.active_worker_count(), 2);
315 assert_eq!(queue.get_work().unwrap(), Some("task1".to_string()));
316 assert_eq!(queue.get_work().unwrap(), Some("task2".to_string()));
317 assert_eq!(queue.get_work().unwrap(), None);
318 queue.unregister_worker();
319 assert_eq!(queue.active_worker_count(), 1);
320 }
321 #[test]
322 fn test_graph_serialization() {
323 let mut graph = Graph::new();
324 graph.add_vertex("A");
325 graph.add_vertex("B");
326 graph.add_vertex("C");
327 graph.add_edge(&"A", &"B").unwrap();
328 graph.add_edge(&"B", &"C").unwrap();
329 graph.add_edge(&"C", &"A").unwrap();
330 let serialized = graph.serialize();
331 assert!(serialized.contains("Graph {"));
332 assert!(serialized.contains("vertices: 3 nodes"));
333 assert!(serialized.contains("edges: 3 connections"));
334 assert!(serialized.contains("A: [B]"));
335 assert!(serialized.contains("B: [C]"));
336 assert!(serialized.contains("C: [A]"));
337 }
338 #[test]
339 fn test_graph_visualization() {
340 let mut graph = Graph::new();
341 graph.add_vertex("A");
342 graph.add_vertex("B");
343 graph.add_edge(&"A", &"B").unwrap();
344 let visualized = graph.visualize();
345 assert!(visualized.contains("Graph Visualization:"));
346 assert!(visualized.contains("Vertices: 2"));
347 assert!(visualized.contains("Edges: 1"));
348 assert!(visualized.contains("Has cycle: false"));
349 assert!(visualized.contains("A -> [B]"));
350 assert!(visualized.contains("B -> []"));
351 }
352 #[test]
353 fn test_graph_structural_equals() {
354 let mut graph1 = Graph::new();
355 graph1.add_vertex("A");
356 graph1.add_vertex("B");
357 graph1.add_edge(&"A", &"B").unwrap();
358 let mut graph2 = Graph::new();
359 graph2.add_vertex("A");
360 graph2.add_vertex("B");
361 graph2.add_edge(&"A", &"B").unwrap();
362 let mut graph3 = Graph::new();
363 graph3.add_vertex("A");
364 graph3.add_vertex("C");
365 graph3.add_edge(&"A", &"C").unwrap();
366 assert!(graph1.structural_equals(&graph2));
367 assert!(!graph1.structural_equals(&graph3));
368 }
369 #[test]
370 fn test_weighted_graph_serialization() {
371 let mut graph = WeightedGraph::new();
372 graph.add_vertex("A");
373 graph.add_vertex("B");
374 graph.add_vertex("C");
375 graph.add_edge(&"A", &"B", 1.5).unwrap();
376 graph.add_edge(&"B", &"C", 2.0).unwrap();
377 let serialized = graph.serialize();
378 assert!(serialized.contains("WeightedGraph {"));
379 assert!(serialized.contains("vertices: 3 nodes"));
380 assert!(serialized.contains("edges: 2 weighted connections"));
381 assert!(serialized.contains("A: [B:1.5]"));
382 assert!(serialized.contains("B: [C:2]"));
383 assert!(serialized.contains("C: []"));
384 }
385 #[test]
386 fn test_weighted_graph_visualization() {
387 let mut graph = WeightedGraph::new();
388 graph.add_vertex("A");
389 graph.add_vertex("B");
390 graph.add_edge(&"A", &"B", 10).unwrap();
391 let visualized = graph.visualize();
392 assert!(visualized.contains("Weighted Graph Visualization:"));
393 assert!(visualized.contains("Vertices: 2"));
394 assert!(visualized.contains("Weighted Edges: 1"));
395 assert!(visualized.contains("A -> [B(w:10)]"));
396 assert!(visualized.contains("B -> []"));
397 }
398 #[test]
399 fn test_weighted_graph_structural_equals() {
400 let mut graph1 = WeightedGraph::new();
401 graph1.add_vertex("A");
402 graph1.add_vertex("B");
403 graph1.add_edge(&"A", &"B", 5).unwrap();
404 let mut graph2 = WeightedGraph::new();
405 graph2.add_vertex("A");
406 graph2.add_vertex("B");
407 graph2.add_edge(&"A", &"B", 5).unwrap();
408 let mut graph3 = WeightedGraph::new();
409 graph3.add_vertex("A");
410 graph3.add_vertex("B");
411 graph3.add_edge(&"A", &"B", 10).unwrap();
412 assert!(graph1.structural_equals(&graph2));
413 assert!(!graph1.structural_equals(&graph3));
414 }
415}