1use std::collections::HashMap;
6
7use super::types::{
8 BloomFilterApprox, CacheManager, ConfigNode, DecisionNode, DefEqCache, Either2,
9 FlatSubstitution, FocusStack, InferCache, LabelSet, LruCache, MultiLevelCache, NonEmptyVec,
10 PathBuf, RewriteRule, RewriteRuleSet, SimpleDag, SimplifiedExpr, SlidingSum, SmallMap,
11 SparseVec, StackCalc, StatSummary, Stopwatch, StringPool, TokenBucket, TransformStat,
12 TransitiveClosure, TtlCache, VersionedRecord, WhnfCache, WindowIterator, WriteOnce,
13};
14
15pub fn fnv1a_hash<T: AsRef<[u8]>>(data: T) -> u64 {
18 const FNV_OFFSET_BASIS: u64 = 0xcbf29ce484222325;
19 const FNV_PRIME: u64 = 0x100000001b3;
20 let bytes = data.as_ref();
21 let mut hash = FNV_OFFSET_BASIS;
22 for &byte in bytes {
23 hash ^= byte as u64;
24 hash = hash.wrapping_mul(FNV_PRIME);
25 }
26 hash
27}
28#[cfg(test)]
29mod tests {
30 use super::*;
31 #[test]
32 fn test_fnv1a_hash_basic() {
33 let hash1 = fnv1a_hash("test");
34 let hash2 = fnv1a_hash("test");
35 assert_eq!(hash1, hash2, "Same input should produce same hash");
36 }
37 #[test]
38 fn test_fnv1a_hash_different() {
39 let hash1 = fnv1a_hash("test1");
40 let hash2 = fnv1a_hash("test2");
41 assert_ne!(
42 hash1, hash2,
43 "Different inputs should produce different hashes"
44 );
45 }
46 #[test]
47 fn test_fnv1a_hash_consistency() {
48 let data = b"consistency_test";
49 let hash1 = fnv1a_hash(data);
50 let hash2 = fnv1a_hash(data);
51 assert_eq!(hash1, hash2);
52 }
53 #[test]
54 fn test_lru_cache_new() {
55 let cache: LruCache<String, i32> = LruCache::new(10);
56 assert_eq!(cache.len(), 0);
57 assert_eq!(cache.capacity(), 10);
58 assert!(cache.is_empty());
59 }
60 #[test]
61 fn test_lru_cache_insert_and_get() {
62 let mut cache: LruCache<String, i32> = LruCache::new(10);
63 cache.insert("key1".to_string(), 42);
64 assert_eq!(cache.get(&"key1".to_string()), Some(42));
65 assert_eq!(cache.len(), 1);
66 }
67 #[test]
68 fn test_lru_cache_get_nonexistent() {
69 let mut cache: LruCache<String, i32> = LruCache::new(10);
70 assert_eq!(cache.get(&"nonexistent".to_string()), None);
71 }
72 #[test]
73 fn test_lru_cache_contains_key() {
74 let mut cache: LruCache<String, i32> = LruCache::new(10);
75 cache.insert("key1".to_string(), 42);
76 assert!(cache.contains_key(&"key1".to_string()));
77 assert!(!cache.contains_key(&"key2".to_string()));
78 }
79 #[test]
80 fn test_lru_cache_eviction() {
81 let mut cache: LruCache<String, i32> = LruCache::new(3);
82 cache.insert("a".to_string(), 1);
83 cache.insert("b".to_string(), 2);
84 cache.insert("c".to_string(), 3);
85 assert_eq!(cache.len(), 3);
86 cache.insert("d".to_string(), 4);
87 assert_eq!(cache.len(), 3);
88 assert!(!cache.contains_key(&"a".to_string()));
89 assert!(cache.contains_key(&"d".to_string()));
90 }
91 #[test]
92 fn test_lru_cache_update_moves_to_head() {
93 let mut cache: LruCache<String, i32> = LruCache::new(3);
94 cache.insert("a".to_string(), 1);
95 cache.insert("b".to_string(), 2);
96 cache.insert("c".to_string(), 3);
97 cache.get(&"a".to_string());
98 cache.insert("d".to_string(), 4);
99 assert!(cache.contains_key(&"a".to_string()));
100 assert!(!cache.contains_key(&"b".to_string()));
101 }
102 #[test]
103 fn test_lru_cache_remove() {
104 let mut cache: LruCache<String, i32> = LruCache::new(10);
105 cache.insert("key1".to_string(), 42);
106 assert_eq!(cache.remove(&"key1".to_string()), Some(42));
107 assert_eq!(cache.len(), 0);
108 assert!(!cache.contains_key(&"key1".to_string()));
109 }
110 #[test]
111 fn test_lru_cache_clear() {
112 let mut cache: LruCache<String, i32> = LruCache::new(10);
113 cache.insert("a".to_string(), 1);
114 cache.insert("b".to_string(), 2);
115 cache.clear();
116 assert_eq!(cache.len(), 0);
117 assert!(cache.is_empty());
118 }
119 #[test]
120 fn test_lru_cache_stats() {
121 let mut cache: LruCache<String, i32> = LruCache::new(10);
122 cache.insert("a".to_string(), 1);
123 cache.get(&"a".to_string());
124 cache.get(&"b".to_string());
125 let (hits, misses) = cache.stats();
126 assert_eq!(hits, 1);
127 assert_eq!(misses, 1);
128 }
129 #[test]
130 fn test_lru_cache_hit_rate() {
131 let mut cache: LruCache<String, i32> = LruCache::new(10);
132 cache.insert("a".to_string(), 1);
133 cache.get(&"a".to_string());
134 cache.get(&"a".to_string());
135 cache.get(&"b".to_string());
136 let hit_rate = cache.hit_rate();
137 assert!((hit_rate - 66.666666).abs() < 0.01);
138 }
139 #[test]
140 fn test_expr_hash_consistency() {
141 let expr1 = SimplifiedExpr::Var("x".to_string());
142 let expr2 = SimplifiedExpr::Var("x".to_string());
143 assert_eq!(expr1.hash(), expr2.hash());
144 }
145 #[test]
146 fn test_expr_hash_different() {
147 let expr1 = SimplifiedExpr::Var("x".to_string());
148 let expr2 = SimplifiedExpr::Var("y".to_string());
149 assert_ne!(expr1.hash(), expr2.hash());
150 }
151 #[test]
152 fn test_expr_hash_complex() {
153 let expr1 = SimplifiedExpr::App(
154 Box::new(SimplifiedExpr::Var("f".to_string())),
155 Box::new(SimplifiedExpr::Var("x".to_string())),
156 );
157 let expr2 = SimplifiedExpr::App(
158 Box::new(SimplifiedExpr::Var("f".to_string())),
159 Box::new(SimplifiedExpr::Var("x".to_string())),
160 );
161 assert_eq!(expr1.hash(), expr2.hash());
162 }
163 #[test]
164 fn test_whnf_cache_new() {
165 let cache = WhnfCache::new(10, false);
166 assert!(!cache.is_transparent());
167 }
168 #[test]
169 fn test_whnf_cache_lookup_store() {
170 let mut cache = WhnfCache::new(10, false);
171 let expr = SimplifiedExpr::Var("x".to_string());
172 let whnf = SimplifiedExpr::Var("y".to_string());
173 cache.store(&expr, whnf.clone());
174 let result = cache.lookup(&expr);
175 assert_eq!(result, Some(whnf));
176 }
177 #[test]
178 fn test_whnf_cache_transparency_mode() {
179 let mut cache = WhnfCache::new(10, false);
180 let expr = SimplifiedExpr::Var("x".to_string());
181 let whnf = SimplifiedExpr::Var("y".to_string());
182 cache.store(&expr, whnf);
183 cache.set_transparency(true);
184 let result = cache.lookup(&expr);
185 assert_eq!(
186 result, None,
187 "Transparent mode should not return cached values"
188 );
189 }
190 #[test]
191 fn test_whnf_cache_stats() {
192 let mut cache = WhnfCache::new(10, false);
193 let expr = SimplifiedExpr::Var("x".to_string());
194 let whnf = SimplifiedExpr::Var("y".to_string());
195 cache.store(&expr, whnf);
196 cache.lookup(&expr);
197 cache.lookup(&expr);
198 let (hits, misses) = cache.stats();
199 assert_eq!(hits, 2);
200 assert_eq!(misses, 0);
201 }
202 #[test]
203 fn test_whnf_cache_clear() {
204 let mut cache = WhnfCache::new(10, false);
205 let expr = SimplifiedExpr::Var("x".to_string());
206 let whnf = SimplifiedExpr::Var("y".to_string());
207 cache.store(&expr, whnf);
208 cache.clear();
209 let result = cache.lookup(&expr);
210 assert_eq!(result, None);
211 }
212 #[test]
213 fn test_defeq_cache_new() {
214 let cache = DefEqCache::new(10);
215 let (hits, misses) = cache.stats();
216 assert_eq!(hits, 0);
217 assert_eq!(misses, 0);
218 }
219 #[test]
220 fn test_defeq_cache_store_and_check() {
221 let mut cache = DefEqCache::new(10);
222 let expr1 = SimplifiedExpr::Var("x".to_string());
223 let expr2 = SimplifiedExpr::Var("y".to_string());
224 cache.store_result(&expr1, &expr2, true);
225 let result = cache.check_cache(&expr1, &expr2);
226 assert_eq!(result, Some(true));
227 }
228 #[test]
229 fn test_defeq_cache_symmetry() {
230 let mut cache = DefEqCache::new(10);
231 let expr1 = SimplifiedExpr::Var("x".to_string());
232 let expr2 = SimplifiedExpr::Var("y".to_string());
233 cache.store_result(&expr1, &expr2, true);
234 let result = cache.check_cache(&expr2, &expr1);
235 assert_eq!(result, Some(true), "DefEq cache should be symmetry-aware");
236 }
237 #[test]
238 fn test_defeq_cache_false_result() {
239 let mut cache = DefEqCache::new(10);
240 let expr1 = SimplifiedExpr::Var("x".to_string());
241 let expr2 = SimplifiedExpr::Var("y".to_string());
242 cache.store_result(&expr1, &expr2, false);
243 let result = cache.check_cache(&expr1, &expr2);
244 assert_eq!(result, Some(false));
245 }
246 #[test]
247 fn test_defeq_cache_clear() {
248 let mut cache = DefEqCache::new(10);
249 let expr1 = SimplifiedExpr::Var("x".to_string());
250 let expr2 = SimplifiedExpr::Var("y".to_string());
251 cache.store_result(&expr1, &expr2, true);
252 cache.clear();
253 let result = cache.check_cache(&expr1, &expr2);
254 assert_eq!(result, None);
255 }
256 #[test]
257 fn test_infer_cache_new() {
258 let cache = InferCache::new(10);
259 assert!(cache.is_empty());
260 assert_eq!(cache.len(), 0);
261 }
262 #[test]
263 fn test_infer_cache_store_and_lookup() {
264 let mut cache = InferCache::new(10);
265 let expr = SimplifiedExpr::Var("x".to_string());
266 let inferred_type = SimplifiedExpr::Var("Type".to_string());
267 cache.store(&expr, inferred_type.clone());
268 let result = cache.lookup(&expr);
269 assert_eq!(result, Some(inferred_type));
270 }
271 #[test]
272 fn test_infer_cache_stats() {
273 let mut cache = InferCache::new(10);
274 let expr = SimplifiedExpr::Var("x".to_string());
275 let inferred_type = SimplifiedExpr::Var("Type".to_string());
276 cache.store(&expr, inferred_type);
277 cache.lookup(&expr);
278 cache.lookup(&expr);
279 let (hits, misses) = cache.stats();
280 assert_eq!(hits, 2);
281 assert_eq!(misses, 0);
282 }
283 #[test]
284 fn test_infer_cache_clear() {
285 let mut cache = InferCache::new(10);
286 let expr = SimplifiedExpr::Var("x".to_string());
287 let inferred_type = SimplifiedExpr::Var("Type".to_string());
288 cache.store(&expr, inferred_type);
289 cache.clear();
290 assert!(cache.is_empty());
291 }
292 #[test]
293 fn test_cache_manager_new() {
294 let manager = CacheManager::new();
295 let stats = manager.statistics();
296 assert_eq!(stats.total_hits(), 0);
297 assert_eq!(stats.total_misses(), 0);
298 }
299 #[test]
300 fn test_cache_manager_with_capacities() {
301 let manager = CacheManager::with_capacities(512, 256, 128);
302 assert!(manager.whnf.cache.capacity() >= 512);
303 assert!(manager.defeq.cache.capacity() >= 256);
304 assert!(manager.infer.cache.capacity() >= 128);
305 }
306 #[test]
307 fn test_cache_manager_clear_all() {
308 let mut manager = CacheManager::new();
309 let expr = SimplifiedExpr::Var("x".to_string());
310 let whnf = SimplifiedExpr::Var("y".to_string());
311 manager.whnf_mut().store(&expr, whnf);
312 manager.clear_all();
313 let result = manager.whnf_mut().lookup(&expr);
314 assert_eq!(result, None);
315 }
316 #[test]
317 fn test_cache_manager_statistics() {
318 let mut manager = CacheManager::new();
319 let expr = SimplifiedExpr::Var("x".to_string());
320 let whnf = SimplifiedExpr::Var("y".to_string());
321 manager.whnf_mut().store(&expr, whnf);
322 manager.whnf_mut().lookup(&expr);
323 let stats = manager.statistics();
324 assert_eq!(stats.whnf_hits, 1);
325 }
326 #[test]
327 fn test_cache_statistics_overall_hit_rate() {
328 let mut manager = CacheManager::new();
329 let expr = SimplifiedExpr::Var("x".to_string());
330 let whnf = SimplifiedExpr::Var("y".to_string());
331 manager.whnf_mut().store(&expr, whnf.clone());
332 manager.whnf_mut().lookup(&expr);
333 manager.whnf_mut().lookup(&expr);
334 let stats = manager.statistics();
335 assert!(stats.overall_hit_rate() > 50.0);
336 }
337 #[test]
338 fn test_cache_manager_default() {
339 let _manager = CacheManager::default();
340 }
341}
342#[cfg(test)]
343mod cache_extra_tests {
344 use super::*;
345 #[test]
346 fn test_ttl_cache_insert_get() {
347 let mut cache: TtlCache<String, i32> = TtlCache::new(5);
348 cache.insert("a".to_string(), 42);
349 assert_eq!(cache.get(&"a".to_string()), Some(42));
350 }
351 #[test]
352 fn test_ttl_cache_expiry() {
353 let mut cache: TtlCache<String, i32> = TtlCache::new(3);
354 cache.insert("a".to_string(), 1);
355 cache.tick_n(3);
356 assert_eq!(cache.get(&"a".to_string()), None);
357 }
358 #[test]
359 fn test_ttl_cache_not_expired_yet() {
360 let mut cache: TtlCache<String, i32> = TtlCache::new(5);
361 cache.insert("b".to_string(), 99);
362 cache.tick_n(4);
363 assert_eq!(cache.get(&"b".to_string()), Some(99));
364 }
365 #[test]
366 fn test_ttl_cache_custom_ttl() {
367 let mut cache: TtlCache<String, i32> = TtlCache::new(10);
368 cache.insert_with_ttl("x".to_string(), 7, 1);
369 cache.tick();
370 assert_eq!(cache.get(&"x".to_string()), None);
371 }
372 #[test]
373 fn test_ttl_cache_purge_expired() {
374 let mut cache: TtlCache<String, i32> = TtlCache::new(2);
375 cache.insert("a".to_string(), 1);
376 cache.insert("b".to_string(), 2);
377 cache.tick_n(3);
378 cache.purge_expired();
379 assert!(cache.is_empty());
380 }
381 #[test]
382 fn test_ttl_cache_clear() {
383 let mut cache: TtlCache<String, i32> = TtlCache::new(10);
384 cache.insert("a".to_string(), 1);
385 cache.clear();
386 assert!(cache.is_empty());
387 }
388 #[test]
389 fn test_multi_level_cache_l1_hit() {
390 let mut cache: MultiLevelCache<String, i32> = MultiLevelCache::new(4, 16);
391 cache.insert("k".to_string(), 42);
392 let v = cache.get(&"k".to_string());
393 assert_eq!(v, Some(42));
394 assert_eq!(cache.l1_hits(), 1);
395 }
396 #[test]
397 fn test_multi_level_cache_l2_promotion() {
398 let mut cache: MultiLevelCache<String, i32> = MultiLevelCache::new(2, 16);
399 cache.insert_l2_only("k".to_string(), 99);
400 let v = cache.get(&"k".to_string());
401 assert_eq!(v, Some(99));
402 assert_eq!(cache.l2_hits(), 1);
403 let v2 = cache.get(&"k".to_string());
404 assert_eq!(v2, Some(99));
405 assert_eq!(cache.l1_hits(), 1);
406 }
407 #[test]
408 fn test_multi_level_cache_miss() {
409 let mut cache: MultiLevelCache<String, i32> = MultiLevelCache::new(4, 16);
410 let v = cache.get(&"absent".to_string());
411 assert!(v.is_none());
412 assert_eq!(cache.misses(), 1);
413 }
414 #[test]
415 fn test_multi_level_cache_clear_all() {
416 let mut cache: MultiLevelCache<String, i32> = MultiLevelCache::new(4, 16);
417 cache.insert("k".to_string(), 1);
418 cache.get(&"k".to_string());
419 cache.clear_all();
420 assert_eq!(cache.total_requests(), 0);
421 assert!(cache.get(&"k".to_string()).is_none());
422 }
423 #[test]
424 fn test_bloom_filter_insert_might_contain() {
425 let mut bf = BloomFilterApprox::new(256);
426 bf.insert(b"hello");
427 assert!(bf.might_contain(b"hello"));
428 }
429 #[test]
430 fn test_bloom_filter_clear() {
431 let mut bf = BloomFilterApprox::new(256);
432 bf.insert(b"world");
433 bf.clear();
434 assert!(!bf.might_contain(b"world"));
435 }
436 #[test]
437 fn test_bloom_filter_set_bit_count() {
438 let mut bf = BloomFilterApprox::new(256);
439 let before = bf.set_bit_count();
440 bf.insert(b"test");
441 let after = bf.set_bit_count();
442 assert!(after >= before);
443 }
444 #[test]
445 fn test_bloom_filter_size() {
446 let bf = BloomFilterApprox::new(512);
447 assert_eq!(bf.size(), 512);
448 }
449 #[test]
450 fn test_multi_level_cache_hit_rate() {
451 let mut cache: MultiLevelCache<String, i32> = MultiLevelCache::new(4, 16);
452 cache.insert("a".to_string(), 1);
453 cache.get(&"a".to_string());
454 cache.get(&"z".to_string());
455 let rate = cache.hit_rate();
456 assert!((rate - 50.0).abs() < 0.01);
457 }
458}
459#[cfg(test)]
460mod tests_padding_infra {
461 use super::*;
462 #[test]
463 fn test_stat_summary() {
464 let mut ss = StatSummary::new();
465 ss.record(10.0);
466 ss.record(20.0);
467 ss.record(30.0);
468 assert_eq!(ss.count(), 3);
469 assert!((ss.mean().expect("mean should succeed") - 20.0).abs() < 1e-9);
470 assert_eq!(ss.min().expect("min should succeed") as i64, 10);
471 assert_eq!(ss.max().expect("max should succeed") as i64, 30);
472 }
473 #[test]
474 fn test_transform_stat() {
475 let mut ts = TransformStat::new();
476 ts.record_before(100.0);
477 ts.record_after(80.0);
478 let ratio = ts.mean_ratio().expect("ratio should be present");
479 assert!((ratio - 0.8).abs() < 1e-9);
480 }
481 #[test]
482 fn test_small_map() {
483 let mut m: SmallMap<u32, &str> = SmallMap::new();
484 m.insert(3, "three");
485 m.insert(1, "one");
486 m.insert(2, "two");
487 assert_eq!(m.get(&2), Some(&"two"));
488 assert_eq!(m.len(), 3);
489 let keys = m.keys();
490 assert_eq!(*keys[0], 1);
491 assert_eq!(*keys[2], 3);
492 }
493 #[test]
494 fn test_label_set() {
495 let mut ls = LabelSet::new();
496 ls.add("foo");
497 ls.add("bar");
498 ls.add("foo");
499 assert_eq!(ls.count(), 2);
500 assert!(ls.has("bar"));
501 assert!(!ls.has("baz"));
502 }
503 #[test]
504 fn test_config_node() {
505 let mut root = ConfigNode::section("root");
506 let child = ConfigNode::leaf("key", "value");
507 root.add_child(child);
508 assert_eq!(root.num_children(), 1);
509 }
510 #[test]
511 fn test_versioned_record() {
512 let mut vr = VersionedRecord::new(0u32);
513 vr.update(1);
514 vr.update(2);
515 assert_eq!(*vr.current(), 2);
516 assert_eq!(vr.version(), 2);
517 assert!(vr.has_history());
518 assert_eq!(*vr.at_version(0).expect("value should be present"), 0);
519 }
520 #[test]
521 fn test_simple_dag() {
522 let mut dag = SimpleDag::new(4);
523 dag.add_edge(0, 1);
524 dag.add_edge(1, 2);
525 dag.add_edge(2, 3);
526 assert!(dag.can_reach(0, 3));
527 assert!(!dag.can_reach(3, 0));
528 let order = dag.topological_sort().expect("order should be present");
529 assert_eq!(order, vec![0, 1, 2, 3]);
530 }
531 #[test]
532 fn test_focus_stack() {
533 let mut fs: FocusStack<&str> = FocusStack::new();
534 fs.focus("a");
535 fs.focus("b");
536 assert_eq!(fs.current(), Some(&"b"));
537 assert_eq!(fs.depth(), 2);
538 fs.blur();
539 assert_eq!(fs.current(), Some(&"a"));
540 }
541}
542#[cfg(test)]
543mod tests_extra_iterators {
544 use super::*;
545 #[test]
546 fn test_window_iterator() {
547 let data = vec![1u32, 2, 3, 4, 5];
548 let windows: Vec<_> = WindowIterator::new(&data, 3).collect();
549 assert_eq!(windows.len(), 3);
550 assert_eq!(windows[0], &[1, 2, 3]);
551 assert_eq!(windows[2], &[3, 4, 5]);
552 }
553 #[test]
554 fn test_non_empty_vec() {
555 let mut nev = NonEmptyVec::singleton(10u32);
556 nev.push(20);
557 nev.push(30);
558 assert_eq!(nev.len(), 3);
559 assert_eq!(*nev.first(), 10);
560 assert_eq!(*nev.last(), 30);
561 }
562}
563#[cfg(test)]
564mod tests_padding2 {
565 use super::*;
566 #[test]
567 fn test_sliding_sum() {
568 let mut ss = SlidingSum::new(3);
569 ss.push(1.0);
570 ss.push(2.0);
571 ss.push(3.0);
572 assert!((ss.sum() - 6.0).abs() < 1e-9);
573 ss.push(4.0);
574 assert!((ss.sum() - 9.0).abs() < 1e-9);
575 assert_eq!(ss.count(), 3);
576 }
577 #[test]
578 fn test_path_buf() {
579 let mut pb = PathBuf::new();
580 pb.push("src");
581 pb.push("main");
582 assert_eq!(pb.as_str(), "src/main");
583 assert_eq!(pb.depth(), 2);
584 pb.pop();
585 assert_eq!(pb.as_str(), "src");
586 }
587 #[test]
588 fn test_string_pool() {
589 let mut pool = StringPool::new();
590 let s = pool.take();
591 assert!(s.is_empty());
592 pool.give("hello".to_string());
593 let s2 = pool.take();
594 assert!(s2.is_empty());
595 assert_eq!(pool.free_count(), 0);
596 }
597 #[test]
598 fn test_transitive_closure() {
599 let mut tc = TransitiveClosure::new(4);
600 tc.add_edge(0, 1);
601 tc.add_edge(1, 2);
602 tc.add_edge(2, 3);
603 assert!(tc.can_reach(0, 3));
604 assert!(!tc.can_reach(3, 0));
605 let r = tc.reachable_from(0);
606 assert_eq!(r.len(), 4);
607 }
608 #[test]
609 fn test_token_bucket() {
610 let mut tb = TokenBucket::new(100, 10);
611 assert_eq!(tb.available(), 100);
612 assert!(tb.try_consume(50));
613 assert_eq!(tb.available(), 50);
614 assert!(!tb.try_consume(60));
615 assert_eq!(tb.capacity(), 100);
616 }
617 #[test]
618 fn test_rewrite_rule_set() {
619 let mut rrs = RewriteRuleSet::new();
620 rrs.add(RewriteRule::unconditional(
621 "beta",
622 "App(Lam(x, b), v)",
623 "b[x:=v]",
624 ));
625 rrs.add(RewriteRule::conditional("comm", "a + b", "b + a"));
626 assert_eq!(rrs.len(), 2);
627 assert_eq!(rrs.unconditional_rules().len(), 1);
628 assert_eq!(rrs.conditional_rules().len(), 1);
629 assert!(rrs.get("beta").is_some());
630 let disp = rrs
631 .get("beta")
632 .expect("element at \'beta\' should exist")
633 .display();
634 assert!(disp.contains("→"));
635 }
636}
637#[cfg(test)]
638mod tests_padding3 {
639 use super::*;
640 #[test]
641 fn test_decision_node() {
642 let tree = DecisionNode::Branch {
643 key: "x".into(),
644 val: "1".into(),
645 yes_branch: Box::new(DecisionNode::Leaf("yes".into())),
646 no_branch: Box::new(DecisionNode::Leaf("no".into())),
647 };
648 let mut ctx = std::collections::HashMap::new();
649 ctx.insert("x".into(), "1".into());
650 assert_eq!(tree.evaluate(&ctx), "yes");
651 ctx.insert("x".into(), "2".into());
652 assert_eq!(tree.evaluate(&ctx), "no");
653 assert_eq!(tree.depth(), 1);
654 }
655 #[test]
656 fn test_flat_substitution() {
657 let mut sub = FlatSubstitution::new();
658 sub.add("foo", "bar");
659 sub.add("baz", "qux");
660 assert_eq!(sub.apply("foo and baz"), "bar and qux");
661 assert_eq!(sub.len(), 2);
662 }
663 #[test]
664 fn test_stopwatch() {
665 let mut sw = Stopwatch::start();
666 sw.split();
667 sw.split();
668 assert_eq!(sw.num_splits(), 2);
669 assert!(sw.elapsed_ms() >= 0.0);
670 for &s in sw.splits() {
671 assert!(s >= 0.0);
672 }
673 }
674 #[test]
675 fn test_either2() {
676 let e: Either2<i32, &str> = Either2::First(42);
677 assert!(e.is_first());
678 let mapped = e.map_first(|x| x * 2);
679 assert_eq!(mapped.first(), Some(84));
680 let e2: Either2<i32, &str> = Either2::Second("hello");
681 assert!(e2.is_second());
682 assert_eq!(e2.second(), Some("hello"));
683 }
684 #[test]
685 fn test_write_once() {
686 let wo: WriteOnce<u32> = WriteOnce::new();
687 assert!(!wo.is_written());
688 assert!(wo.write(42));
689 assert!(!wo.write(99));
690 assert_eq!(wo.read(), Some(42));
691 }
692 #[test]
693 fn test_sparse_vec() {
694 let mut sv: SparseVec<i32> = SparseVec::new(100);
695 sv.set(5, 10);
696 sv.set(50, 20);
697 assert_eq!(*sv.get(5), 10);
698 assert_eq!(*sv.get(50), 20);
699 assert_eq!(*sv.get(0), 0);
700 assert_eq!(sv.nnz(), 2);
701 sv.set(5, 0);
702 assert_eq!(sv.nnz(), 1);
703 }
704 #[test]
705 fn test_stack_calc() {
706 let mut calc = StackCalc::new();
707 calc.push(3);
708 calc.push(4);
709 calc.add();
710 assert_eq!(calc.peek(), Some(7));
711 calc.push(2);
712 calc.mul();
713 assert_eq!(calc.peek(), Some(14));
714 }
715}