1use crate::{Expr, Name};
6use std::collections::HashMap;
7
8use super::types::{
9 BuiltinExterns, CallingConvention, ConfigNode, DecisionNode, Either2, ExternDecl,
10 ExternRegistry, FfiError, FfiSafety, FfiSignature, FfiType, FfiValue, Fixture,
11 FlatSubstitution, FocusStack, LabelSet, LibraryManifest, LibraryVersion, MinHeap, NonEmptyVec,
12 PathBuf, PrefixCounter, RewriteRule, RewriteRuleSet, SimpleDag, SlidingSum, SmallMap,
13 SparseVec, StackCalc, StatSummary, Stopwatch, StringPool, SymbolMetadata, TokenBucket,
14 TransformStat, TransitiveClosure, VersionedRecord, WindowIterator, WriteOnce,
15};
16
17#[cfg(test)]
18mod tests {
19 use super::*;
20 #[test]
21 fn test_ffi_type_display() {
22 assert_eq!(FfiType::Bool.to_string(), "bool");
23 assert_eq!(FfiType::UInt64.to_string(), "u64");
24 assert_eq!(FfiType::Int32.to_string(), "i32");
25 assert_eq!(FfiType::Float64.to_string(), "f64");
26 assert_eq!(FfiType::String.to_string(), "string");
27 assert_eq!(FfiType::Unit.to_string(), "()");
28 }
29 #[test]
30 fn test_ffi_type_is_ffi_safe() {
31 assert!(FfiType::Bool.is_ffi_safe());
32 assert!(FfiType::UInt64.is_ffi_safe());
33 assert!(FfiType::String.is_ffi_safe());
34 assert!(FfiType::Ptr(Box::new(FfiType::UInt32)).is_ffi_safe());
35 assert!(!FfiType::OxiLean("Expr".to_string()).is_ffi_safe());
36 }
37 #[test]
38 fn test_ffi_type_size_bytes() {
39 assert_eq!(FfiType::Bool.size_bytes(), Some(1));
40 assert_eq!(FfiType::UInt8.size_bytes(), Some(1));
41 assert_eq!(FfiType::UInt16.size_bytes(), Some(2));
42 assert_eq!(FfiType::UInt32.size_bytes(), Some(4));
43 assert_eq!(FfiType::UInt64.size_bytes(), Some(8));
44 assert_eq!(FfiType::Float32.size_bytes(), Some(4));
45 assert_eq!(FfiType::Float64.size_bytes(), Some(8));
46 assert_eq!(FfiType::Unit.size_bytes(), Some(0));
47 assert_eq!(FfiType::String.size_bytes(), None);
48 }
49 #[test]
50 fn test_ffi_safety_display() {
51 assert_eq!(FfiSafety::Safe.to_string(), "safe");
52 assert_eq!(FfiSafety::Unsafe.to_string(), "unsafe");
53 assert_eq!(FfiSafety::System.to_string(), "system");
54 }
55 #[test]
56 fn test_calling_convention_display() {
57 assert_eq!(CallingConvention::Rust.to_string(), "rust");
58 assert_eq!(CallingConvention::C.to_string(), "c");
59 assert_eq!(CallingConvention::System.to_string(), "system");
60 }
61 #[test]
62 fn test_ffi_value_display() {
63 assert_eq!(FfiValue::Bool(true).to_string(), "true");
64 assert_eq!(FfiValue::UInt(42).to_string(), "42");
65 assert_eq!(FfiValue::Int(-42).to_string(), "-42");
66 assert_eq!(FfiValue::Str("hello".to_string()).to_string(), "\"hello\"");
67 assert_eq!(FfiValue::Unit.to_string(), "()");
68 }
69 #[test]
70 fn test_ffi_value_to_expr() {
71 let bool_val = FfiValue::Bool(true);
72 let _expr = bool_val.to_expr();
73 let uint_val = FfiValue::UInt(42);
74 let expr = uint_val.to_expr();
75 match expr {
76 Expr::Lit(crate::Literal::Nat(n)) => assert_eq!(n, 42),
77 _ => panic!("Expected Nat literal"),
78 }
79 }
80 #[test]
81 fn test_ffi_error_display() {
82 let err = FfiError::SymbolNotFound("strlen".to_string());
83 assert!(err.to_string().contains("strlen"));
84 let err = FfiError::LibraryNotFound("libc".to_string());
85 assert!(err.to_string().contains("libc"));
86 let err = FfiError::DuplicateSymbol("builtin_print".to_string());
87 assert!(err.to_string().contains("builtin_print"));
88 }
89 #[test]
90 fn test_ffi_signature_new() {
91 let sig = FfiSignature::new(
92 vec![FfiType::String, FfiType::UInt64],
93 Box::new(FfiType::Int32),
94 );
95 assert_eq!(sig.params.len(), 2);
96 assert_eq!(*sig.ret_type, FfiType::Int32);
97 }
98 #[test]
99 fn test_ffi_signature_validate_safe() {
100 let sig = FfiSignature::new(
101 vec![FfiType::UInt64, FfiType::String],
102 Box::new(FfiType::Int32),
103 );
104 assert!(sig.validate().is_ok());
105 }
106 #[test]
107 fn test_ffi_signature_validate_unsafe() {
108 let sig = FfiSignature::new(
109 vec![FfiType::OxiLean("Expr".to_string())],
110 Box::new(FfiType::Int32),
111 );
112 assert!(sig.validate().is_err());
113 }
114 #[test]
115 fn test_extern_decl_new() {
116 let decl = ExternDecl::new(
117 Name::str("my_strlen"),
118 Expr::Const(Name::str("String"), vec![]),
119 "libc".to_string(),
120 "strlen".to_string(),
121 FfiSafety::Unsafe,
122 CallingConvention::C,
123 FfiSignature::new(vec![FfiType::String], Box::new(FfiType::UInt64)),
124 );
125 assert_eq!(decl.lib_name, "libc");
126 assert_eq!(decl.symbol_name, "strlen");
127 assert_eq!(decl.safety, FfiSafety::Unsafe);
128 }
129 #[test]
130 fn test_extern_decl_validate_valid() {
131 let decl = ExternDecl::new(
132 Name::str("strlen"),
133 Expr::Const(Name::str("String"), vec![]),
134 "libc".to_string(),
135 "strlen".to_string(),
136 FfiSafety::Unsafe,
137 CallingConvention::C,
138 FfiSignature::new(vec![FfiType::String], Box::new(FfiType::UInt64)),
139 );
140 assert!(decl.validate().is_ok());
141 }
142 #[test]
143 fn test_extern_decl_validate_invalid_lib() {
144 let decl = ExternDecl::new(
145 Name::str("strlen"),
146 Expr::Const(Name::str("String"), vec![]),
147 "".to_string(),
148 "strlen".to_string(),
149 FfiSafety::Unsafe,
150 CallingConvention::C,
151 FfiSignature::new(vec![FfiType::String], Box::new(FfiType::UInt64)),
152 );
153 assert!(decl.validate().is_err());
154 }
155 #[test]
156 fn test_extern_registry_new() {
157 let registry = ExternRegistry::new();
158 assert_eq!(registry.count(), 0);
159 }
160 #[test]
161 fn test_extern_registry_register() {
162 let mut registry = ExternRegistry::new();
163 let decl = ExternDecl::new(
164 Name::str("strlen"),
165 Expr::Const(Name::str("String"), vec![]),
166 "libc".to_string(),
167 "strlen".to_string(),
168 FfiSafety::Unsafe,
169 CallingConvention::C,
170 FfiSignature::new(vec![FfiType::String], Box::new(FfiType::UInt64)),
171 );
172 assert!(registry.register(decl).is_ok());
173 assert_eq!(registry.count(), 1);
174 }
175 #[test]
176 fn test_extern_registry_duplicate_symbol() {
177 let mut registry = ExternRegistry::new();
178 let decl1 = ExternDecl::new(
179 Name::str("strlen1"),
180 Expr::Const(Name::str("String"), vec![]),
181 "libc".to_string(),
182 "strlen".to_string(),
183 FfiSafety::Unsafe,
184 CallingConvention::C,
185 FfiSignature::new(vec![FfiType::String], Box::new(FfiType::UInt64)),
186 );
187 let decl2 = ExternDecl::new(
188 Name::str("strlen2"),
189 Expr::Const(Name::str("String"), vec![]),
190 "libc".to_string(),
191 "strlen".to_string(),
192 FfiSafety::Unsafe,
193 CallingConvention::C,
194 FfiSignature::new(vec![FfiType::String], Box::new(FfiType::UInt64)),
195 );
196 assert!(registry.register(decl1).is_ok());
197 assert!(registry.register(decl2).is_err());
198 }
199 #[test]
200 fn test_extern_registry_lookup() {
201 let mut registry = ExternRegistry::new();
202 let decl = ExternDecl::new(
203 Name::str("strlen"),
204 Expr::Const(Name::str("String"), vec![]),
205 "libc".to_string(),
206 "strlen".to_string(),
207 FfiSafety::Unsafe,
208 CallingConvention::C,
209 FfiSignature::new(vec![FfiType::String], Box::new(FfiType::UInt64)),
210 );
211 registry.register(decl).expect("value should be present");
212 let found = registry.lookup(&Name::str("strlen"));
213 assert!(found.is_ok());
214 }
215 #[test]
216 fn test_extern_registry_lookup_not_found() {
217 let registry = ExternRegistry::new();
218 let found = registry.lookup(&Name::str("nonexistent"));
219 assert!(found.is_err());
220 }
221 #[test]
222 fn test_extern_registry_lookup_by_symbol() {
223 let mut registry = ExternRegistry::new();
224 let decl = ExternDecl::new(
225 Name::str("strlen"),
226 Expr::Const(Name::str("String"), vec![]),
227 "libc".to_string(),
228 "strlen".to_string(),
229 FfiSafety::Unsafe,
230 CallingConvention::C,
231 FfiSignature::new(vec![FfiType::String], Box::new(FfiType::UInt64)),
232 );
233 registry.register(decl).expect("value should be present");
234 let found = registry.lookup_by_symbol("libc", "strlen");
235 assert!(found.is_ok());
236 }
237 #[test]
238 fn test_extern_registry_validate_all() {
239 let mut registry = ExternRegistry::new();
240 let decl = ExternDecl::new(
241 Name::str("strlen"),
242 Expr::Const(Name::str("String"), vec![]),
243 "libc".to_string(),
244 "strlen".to_string(),
245 FfiSafety::Unsafe,
246 CallingConvention::C,
247 FfiSignature::new(vec![FfiType::String], Box::new(FfiType::UInt64)),
248 );
249 registry.register(decl).expect("value should be present");
250 assert!(registry.validate_all().is_ok());
251 }
252 #[test]
253 fn test_builtin_externs_register() {
254 let mut registry = ExternRegistry::new();
255 assert!(BuiltinExterns::register_builtins(&mut registry).is_ok());
256 assert!(registry.count() > 0);
257 }
258 #[test]
259 fn test_builtin_externs_io() {
260 let mut registry = ExternRegistry::new();
261 BuiltinExterns::register_io(&mut registry).expect("value should be present");
262 assert!(registry.lookup(&Name::str("builtin_print")).is_ok());
263 }
264 #[test]
265 fn test_builtin_externs_string() {
266 let mut registry = ExternRegistry::new();
267 BuiltinExterns::register_string(&mut registry).expect("value should be present");
268 assert!(registry.lookup(&Name::str("builtin_strlen")).is_ok());
269 }
270 #[test]
271 fn test_builtin_externs_arithmetic() {
272 let mut registry = ExternRegistry::new();
273 BuiltinExterns::register_arithmetic(&mut registry).expect("value should be present");
274 assert!(registry.lookup(&Name::str("builtin_abs")).is_ok());
275 }
276 #[test]
277 fn test_ffi_type_ptr_display() {
278 let ptr_type = FfiType::Ptr(Box::new(FfiType::UInt32));
279 assert_eq!(ptr_type.to_string(), "*u32");
280 }
281 #[test]
282 fn test_ffi_type_fn_display() {
283 let fn_type = FfiType::Fn(
284 vec![FfiType::UInt64, FfiType::String],
285 Box::new(FfiType::Int32),
286 );
287 assert_eq!(fn_type.to_string(), "fn(u64, string) -> i32");
288 }
289}
290#[cfg(test)]
291mod extra_ffi_tests {
292 use super::*;
293 #[test]
294 fn test_library_version_new() {
295 let v = LibraryVersion::new("libc", 2, 31, 0);
296 assert_eq!(v.major, 2);
297 assert_eq!(v.minor, 31);
298 assert_eq!(v.patch, 0);
299 }
300 #[test]
301 fn test_library_version_at_least() {
302 let v = LibraryVersion::new("libc", 2, 31, 0);
303 assert!(v.at_least(2, 31, 0));
304 assert!(v.at_least(2, 30, 0));
305 assert!(!v.at_least(2, 32, 0));
306 }
307 #[test]
308 fn test_library_version_display() {
309 let v = LibraryVersion::new("libm", 1, 2, 3);
310 assert_eq!(format!("{}", v), "libm 1.2.3");
311 }
312 #[test]
313 fn test_library_manifest_new() {
314 let m = LibraryManifest::new();
315 assert!(m.is_empty());
316 }
317 #[test]
318 fn test_library_manifest_require() {
319 let mut m = LibraryManifest::new();
320 m.require(LibraryVersion::new("libc", 2, 31, 0));
321 assert_eq!(m.len(), 1);
322 assert!(m.requires_lib("libc"));
323 }
324 #[test]
325 fn test_library_manifest_not_required() {
326 let m = LibraryManifest::new();
327 assert!(!m.requires_lib("libz"));
328 }
329 #[test]
330 fn test_symbol_metadata_new() {
331 let sm = SymbolMetadata::new("strlen", "libc");
332 assert_eq!(sm.symbol, "strlen");
333 assert_eq!(sm.library, "libc");
334 assert!(!sm.weak);
335 assert!(!sm.thread_local);
336 }
337 #[test]
338 fn test_symbol_metadata_weak() {
339 let sm = SymbolMetadata::new("optional_fn", "libopt").with_weak();
340 assert!(sm.weak);
341 }
342 #[test]
343 fn test_symbol_metadata_thread_local() {
344 let sm = SymbolMetadata::new("tls_var", "libx").with_thread_local();
345 assert!(sm.thread_local);
346 }
347 #[test]
348 fn test_symbol_metadata_display() {
349 let sm = SymbolMetadata::new("puts", "libc").with_weak();
350 let s = format!("{}", sm);
351 assert!(s.contains("libc::puts"));
352 assert!(s.contains("weak"));
353 }
354 #[test]
355 fn test_ffi_value_try_from_expr_nat() {
356 let expr = Expr::Lit(crate::Literal::Nat(42));
357 let v = FfiValue::try_from_expr(&expr, &FfiType::UInt64);
358 assert!(v.is_ok());
359 assert_eq!(v.expect("v should be valid"), FfiValue::UInt(42));
360 }
361 #[test]
362 fn test_ffi_value_try_from_expr_str() {
363 let expr = Expr::Lit(crate::Literal::Str("hello".into()));
364 let v = FfiValue::try_from_expr(&expr, &FfiType::String);
365 assert!(v.is_ok());
366 }
367 #[test]
368 fn test_ffi_value_try_from_expr_mismatch() {
369 let expr = Expr::Sort(crate::Level::zero());
370 let v = FfiValue::try_from_expr(&expr, &FfiType::UInt64);
371 assert!(v.is_err());
372 }
373}
374#[cfg(test)]
375mod tests_padding_infra {
376 use super::*;
377 #[test]
378 fn test_stat_summary() {
379 let mut ss = StatSummary::new();
380 ss.record(10.0);
381 ss.record(20.0);
382 ss.record(30.0);
383 assert_eq!(ss.count(), 3);
384 assert!((ss.mean().expect("mean should succeed") - 20.0).abs() < 1e-9);
385 assert_eq!(ss.min().expect("min should succeed") as i64, 10);
386 assert_eq!(ss.max().expect("max should succeed") as i64, 30);
387 }
388 #[test]
389 fn test_transform_stat() {
390 let mut ts = TransformStat::new();
391 ts.record_before(100.0);
392 ts.record_after(80.0);
393 let ratio = ts.mean_ratio().expect("ratio should be present");
394 assert!((ratio - 0.8).abs() < 1e-9);
395 }
396 #[test]
397 fn test_small_map() {
398 let mut m: SmallMap<u32, &str> = SmallMap::new();
399 m.insert(3, "three");
400 m.insert(1, "one");
401 m.insert(2, "two");
402 assert_eq!(m.get(&2), Some(&"two"));
403 assert_eq!(m.len(), 3);
404 let keys = m.keys();
405 assert_eq!(*keys[0], 1);
406 assert_eq!(*keys[2], 3);
407 }
408 #[test]
409 fn test_label_set() {
410 let mut ls = LabelSet::new();
411 ls.add("foo");
412 ls.add("bar");
413 ls.add("foo");
414 assert_eq!(ls.count(), 2);
415 assert!(ls.has("bar"));
416 assert!(!ls.has("baz"));
417 }
418 #[test]
419 fn test_config_node() {
420 let mut root = ConfigNode::section("root");
421 let child = ConfigNode::leaf("key", "value");
422 root.add_child(child);
423 assert_eq!(root.num_children(), 1);
424 }
425 #[test]
426 fn test_versioned_record() {
427 let mut vr = VersionedRecord::new(0u32);
428 vr.update(1);
429 vr.update(2);
430 assert_eq!(*vr.current(), 2);
431 assert_eq!(vr.version(), 2);
432 assert!(vr.has_history());
433 assert_eq!(*vr.at_version(0).expect("value should be present"), 0);
434 }
435 #[test]
436 fn test_simple_dag() {
437 let mut dag = SimpleDag::new(4);
438 dag.add_edge(0, 1);
439 dag.add_edge(1, 2);
440 dag.add_edge(2, 3);
441 assert!(dag.can_reach(0, 3));
442 assert!(!dag.can_reach(3, 0));
443 let order = dag.topological_sort().expect("order should be present");
444 assert_eq!(order, vec![0, 1, 2, 3]);
445 }
446 #[test]
447 fn test_focus_stack() {
448 let mut fs: FocusStack<&str> = FocusStack::new();
449 fs.focus("a");
450 fs.focus("b");
451 assert_eq!(fs.current(), Some(&"b"));
452 assert_eq!(fs.depth(), 2);
453 fs.blur();
454 assert_eq!(fs.current(), Some(&"a"));
455 }
456}
457#[cfg(test)]
458mod tests_extra_iterators {
459 use super::*;
460 #[test]
461 fn test_window_iterator() {
462 let data = vec![1u32, 2, 3, 4, 5];
463 let windows: Vec<_> = WindowIterator::new(&data, 3).collect();
464 assert_eq!(windows.len(), 3);
465 assert_eq!(windows[0], &[1, 2, 3]);
466 assert_eq!(windows[2], &[3, 4, 5]);
467 }
468 #[test]
469 fn test_non_empty_vec() {
470 let mut nev = NonEmptyVec::singleton(10u32);
471 nev.push(20);
472 nev.push(30);
473 assert_eq!(nev.len(), 3);
474 assert_eq!(*nev.first(), 10);
475 assert_eq!(*nev.last(), 30);
476 }
477}
478#[cfg(test)]
479mod tests_padding2 {
480 use super::*;
481 #[test]
482 fn test_sliding_sum() {
483 let mut ss = SlidingSum::new(3);
484 ss.push(1.0);
485 ss.push(2.0);
486 ss.push(3.0);
487 assert!((ss.sum() - 6.0).abs() < 1e-9);
488 ss.push(4.0);
489 assert!((ss.sum() - 9.0).abs() < 1e-9);
490 assert_eq!(ss.count(), 3);
491 }
492 #[test]
493 fn test_path_buf() {
494 let mut pb = PathBuf::new();
495 pb.push("src");
496 pb.push("main");
497 assert_eq!(pb.as_str(), "src/main");
498 assert_eq!(pb.depth(), 2);
499 pb.pop();
500 assert_eq!(pb.as_str(), "src");
501 }
502 #[test]
503 fn test_string_pool() {
504 let mut pool = StringPool::new();
505 let s = pool.take();
506 assert!(s.is_empty());
507 pool.give("hello".to_string());
508 let s2 = pool.take();
509 assert!(s2.is_empty());
510 assert_eq!(pool.free_count(), 0);
511 }
512 #[test]
513 fn test_transitive_closure() {
514 let mut tc = TransitiveClosure::new(4);
515 tc.add_edge(0, 1);
516 tc.add_edge(1, 2);
517 tc.add_edge(2, 3);
518 assert!(tc.can_reach(0, 3));
519 assert!(!tc.can_reach(3, 0));
520 let r = tc.reachable_from(0);
521 assert_eq!(r.len(), 4);
522 }
523 #[test]
524 fn test_token_bucket() {
525 let mut tb = TokenBucket::new(100, 10);
526 assert_eq!(tb.available(), 100);
527 assert!(tb.try_consume(50));
528 assert_eq!(tb.available(), 50);
529 assert!(!tb.try_consume(60));
530 assert_eq!(tb.capacity(), 100);
531 }
532 #[test]
533 fn test_rewrite_rule_set() {
534 let mut rrs = RewriteRuleSet::new();
535 rrs.add(RewriteRule::unconditional(
536 "beta",
537 "App(Lam(x, b), v)",
538 "b[x:=v]",
539 ));
540 rrs.add(RewriteRule::conditional("comm", "a + b", "b + a"));
541 assert_eq!(rrs.len(), 2);
542 assert_eq!(rrs.unconditional_rules().len(), 1);
543 assert_eq!(rrs.conditional_rules().len(), 1);
544 assert!(rrs.get("beta").is_some());
545 let disp = rrs
546 .get("beta")
547 .expect("element at \'beta\' should exist")
548 .display();
549 assert!(disp.contains("→"));
550 }
551}
552#[cfg(test)]
553mod tests_padding3 {
554 use super::*;
555 #[test]
556 fn test_decision_node() {
557 let tree = DecisionNode::Branch {
558 key: "x".into(),
559 val: "1".into(),
560 yes_branch: Box::new(DecisionNode::Leaf("yes".into())),
561 no_branch: Box::new(DecisionNode::Leaf("no".into())),
562 };
563 let mut ctx = std::collections::HashMap::new();
564 ctx.insert("x".into(), "1".into());
565 assert_eq!(tree.evaluate(&ctx), "yes");
566 ctx.insert("x".into(), "2".into());
567 assert_eq!(tree.evaluate(&ctx), "no");
568 assert_eq!(tree.depth(), 1);
569 }
570 #[test]
571 fn test_flat_substitution() {
572 let mut sub = FlatSubstitution::new();
573 sub.add("foo", "bar");
574 sub.add("baz", "qux");
575 assert_eq!(sub.apply("foo and baz"), "bar and qux");
576 assert_eq!(sub.len(), 2);
577 }
578 #[test]
579 fn test_stopwatch() {
580 let mut sw = Stopwatch::start();
581 sw.split();
582 sw.split();
583 assert_eq!(sw.num_splits(), 2);
584 assert!(sw.elapsed_ms() >= 0.0);
585 for &s in sw.splits() {
586 assert!(s >= 0.0);
587 }
588 }
589 #[test]
590 fn test_either2() {
591 let e: Either2<i32, &str> = Either2::First(42);
592 assert!(e.is_first());
593 let mapped = e.map_first(|x| x * 2);
594 assert_eq!(mapped.first(), Some(84));
595 let e2: Either2<i32, &str> = Either2::Second("hello");
596 assert!(e2.is_second());
597 assert_eq!(e2.second(), Some("hello"));
598 }
599 #[test]
600 fn test_write_once() {
601 let wo: WriteOnce<u32> = WriteOnce::new();
602 assert!(!wo.is_written());
603 assert!(wo.write(42));
604 assert!(!wo.write(99));
605 assert_eq!(wo.read(), Some(42));
606 }
607 #[test]
608 fn test_sparse_vec() {
609 let mut sv: SparseVec<i32> = SparseVec::new(100);
610 sv.set(5, 10);
611 sv.set(50, 20);
612 assert_eq!(*sv.get(5), 10);
613 assert_eq!(*sv.get(50), 20);
614 assert_eq!(*sv.get(0), 0);
615 assert_eq!(sv.nnz(), 2);
616 sv.set(5, 0);
617 assert_eq!(sv.nnz(), 1);
618 }
619 #[test]
620 fn test_stack_calc() {
621 let mut calc = StackCalc::new();
622 calc.push(3);
623 calc.push(4);
624 calc.add();
625 assert_eq!(calc.peek(), Some(7));
626 calc.push(2);
627 calc.mul();
628 assert_eq!(calc.peek(), Some(14));
629 }
630}
631#[cfg(test)]
632mod tests_final_padding {
633 use super::*;
634 #[test]
635 fn test_min_heap() {
636 let mut h = MinHeap::new();
637 h.push(5u32);
638 h.push(1u32);
639 h.push(3u32);
640 assert_eq!(h.peek(), Some(&1));
641 assert_eq!(h.pop(), Some(1));
642 assert_eq!(h.pop(), Some(3));
643 assert_eq!(h.pop(), Some(5));
644 assert!(h.is_empty());
645 }
646 #[test]
647 fn test_prefix_counter() {
648 let mut pc = PrefixCounter::new();
649 pc.record("hello");
650 pc.record("help");
651 pc.record("world");
652 assert_eq!(pc.count_with_prefix("hel"), 2);
653 assert_eq!(pc.count_with_prefix("wor"), 1);
654 assert_eq!(pc.count_with_prefix("xyz"), 0);
655 }
656 #[test]
657 fn test_fixture() {
658 let mut f = Fixture::new();
659 f.set("key1", "val1");
660 f.set("key2", "val2");
661 assert_eq!(f.get("key1"), Some("val1"));
662 assert_eq!(f.get("key3"), None);
663 assert_eq!(f.len(), 2);
664 }
665}