From 96fd779639f91e3a124c3d1ed7b141cf785db4bc Mon Sep 17 00:00:00 2001 From: Runxi Yu Date: Wed, 17 Sep 2025 04:02:37 +0800 Subject: [PATCH] Update test routines --- ds/map/fnv/test.ha | 36 ++---------------------------------- ds/map/hashmap/test.ha | 49 +++++++++++++++++++++++++++++++++++++++++++++++++ ds/map/siphash/test.ha | 36 ++---------------------------------- ds/map/slice_basic/test.ha | 4 ++-- ds/set/bloom/test.ha | 59 +++++++++++++++++++++++++++++++++++++++++++++++++++++ diff --git a/ds/map/fnv/test.ha b/ds/map/fnv/test.ha index 304e6f50e851807af9513bd10cc6eb5bb8a85c28..119e65ad49def84a700371b1db3b4c298b358389 100644 --- a/ds/map/fnv/test.ha +++ b/ds/map/fnv/test.ha @@ -14,41 +14,9 @@ case nomem => return nomem; }; }; -fn mk_slice_sorted() (*map::map | nomem) = { - match (slice_sorted::new()) { - case let p: *slice_sorted::map => return (p: *map::map); - case nomem => return nomem; - }; -}; - -fn mk_btree2() (*map::map | nomem) = { - match (btree::new(2)) { - case let p: *btree::map => return (p: *map::map); - case errors::invalid => abort("btree(2) invalid"); - case nomem => return nomem; - }; -}; - -fn mk_rbtree() (*map::map | nomem) = { - match (rbtree::new()) { - case let p: *rbtree::map => return (p: *map::map); - case nomem => return nomem; - }; -}; - -fn mk_swiss() (*map::map | nomem) = { - let key: [16]u8 = [0...]; - random::buffer(&key); - match (swiss_siphash::new(1, key)) { - case let p: *swiss_siphash::map => return (p: *map::map); - case errors::invalid => abort("swiss: invalid"); - case nomem => return nomem; - }; -}; - @test fn test() void = { - const buckets: [2]size = [128z, 256z]; - const makers: [5]*fn() (*map::map | nomem) = [&mk_slice_basic, &mk_slice_sorted, &mk_btree2, &mk_rbtree, &mk_swiss]; + const buckets: [_]size = [128z, 256z]; + const makers: [_]*fn() (*map::map | nomem) = [&mk_slice_basic]; for (let bi = 0z; bi < len(buckets); bi += 1) { for (let mi = 0z; mi < len(makers); mi += 1) { diff --git a/ds/map/hashmap/test.ha b/ds/map/hashmap/test.ha new file mode 100644 index 0000000000000000000000000000000000000000..b54a661aac8fb09bd01a1d9e4445f2ab8d22d946 --- /dev/null +++ b/ds/map/hashmap/test.ha @@ -0,0 +1,49 @@ +use crypto::random; +use ds::map; +use ds::map::slice_basic; +use ds::map::slice_sorted; +use ds::map::btree; +use ds::map::rbtree; +use ds::map::swiss_siphash; +use errors; + +fn testhash(_params: nullable *opaque, key: []u8) size = { + let val: u64 = 0; + let limit = if (len(key) < 8z) len(key) else 8z; + for (let i = 0z; i < limit; i += 1) { + val |= (key[i]: u64) << (8u64 * (i: u64)); + }; + return (val: size); +}; + +fn mk_slice_basic() (*map::map | nomem) = { + match (slice_basic::new()) { + case let p: *slice_basic::map => return (p: *map::map); + case nomem => return nomem; + }; +}; + +@test fn invalid() void = { + match (new(&mk_slice_basic, 0, &testhash, null)) { + case errors::invalid => void; + case *map => abort("hashmap: accepted n=0"); + case nomem => abort("hashmap: nomem for n=0"); + }; +}; + +@test fn test() void = { + const buckets: [_]size = [64z, 128z]; + const makers: [_]*fn() (*map::map | nomem) = [&mk_slice_basic]; + + for (let bi = 0z; bi < len(buckets); bi += 1) { + for (let mi = 0z; mi < len(makers); mi += 1) { + let m = match (new(makers[mi], buckets[bi], &testhash, null)) { + case let p: *map => yield p; + case errors::invalid => abort("hashmap: invalid parameters"); + case nomem => abort("hashmap: nomem"); + }; + defer finish(m); + map::stress_test(m, 20000); + }; + }; +}; diff --git a/ds/map/siphash/test.ha b/ds/map/siphash/test.ha index 189844106b7869d53cd985277b5f8fd4e494f711..dc18906489de1a0e6b5bc5186cda879a634b1cd7 100644 --- a/ds/map/siphash/test.ha +++ b/ds/map/siphash/test.ha @@ -14,41 +14,9 @@ case nomem => return nomem; }; }; -fn mk_slice_sorted() (*map::map | nomem) = { - match (slice_sorted::new()) { - case let p: *slice_sorted::map => return (p: *map::map); - case nomem => return nomem; - }; -}; - -fn mk_btree2() (*map::map | nomem) = { - match (btree::new(2)) { - case let p: *btree::map => return (p: *map::map); - case errors::invalid => abort("btree(2) invalid"); - case nomem => return nomem; - }; -}; - -fn mk_rbtree() (*map::map | nomem) = { - match (rbtree::new()) { - case let p: *rbtree::map => return (p: *map::map); - case nomem => return nomem; - }; -}; - -fn mk_swiss() (*map::map | nomem) = { - let key: [16]u8 = [0...]; - random::buffer(&key); - match (swiss_siphash::new(1, key)) { - case let p: *swiss_siphash::map => return (p: *map::map); - case errors::invalid => abort("swiss: invalid"); - case nomem => return nomem; - }; -}; - @test fn test() void = { - const buckets: [2]size = [128z, 256z]; - const makers: [5]*fn() (*map::map | nomem) = [&mk_slice_basic, &mk_slice_sorted, &mk_btree2, &mk_rbtree, &mk_swiss]; + const buckets: [_]size = [128z, 256z]; + const makers: [_]*fn() (*map::map | nomem) = [&mk_slice_basic]; let key1: [16]u8 = [0...]; let key2: [16]u8 = [0...]; diff --git a/ds/map/slice_basic/test.ha b/ds/map/slice_basic/test.ha index 4d27fed55c14cf5aced3b941213c52f5368fafdd..df9090e13a330863053671ac8639583c220cea35 100644 --- a/ds/map/slice_basic/test.ha +++ b/ds/map/slice_basic/test.ha @@ -1,10 +1,10 @@ use ds::map; -@test fn test() void = { +@test fn test_2000() void = { let m: *map = match (new()) { case let p: *map => yield p; case nomem => abort("slice_basic: nomem"); }; defer finish(m); - map::stress_test(m, 20000); + map::stress_test(m, 2000); }; diff --git a/ds/set/bloom/test.ha b/ds/set/bloom/test.ha new file mode 100644 index 0000000000000000000000000000000000000000..04131bd694d9bdfba87d6985064b8c7935aaa359 --- /dev/null +++ b/ds/set/bloom/test.ha @@ -0,0 +1,59 @@ +use ds::set; +use errors; + +fn testhash(_params: nullable *opaque, key: []u8) size = { + let val: u64 = 0; + let limit = if (len(key) < 8z) len(key) else 8z; + for (let i = 0z; i < limit; i += 1) { + val |= (key[i]: u64) << (8u64 * (i: u64)); + }; + return (val: size); +}; + +fn put_le64(dst: *[8]u8, v: u64) []u8 = { + for (let i = 0z; i < 8z; i += 1) { + dst[i] = ((v >> (8u64 * (i: u64))) & 0xFFu64): u8; + }; + return dst[..]; +}; + +@test fn invalid() void = { + match (new(0, 1, &testhash, null)) { + case errors::invalid => void; + case *set => abort("new accepted m=0"); + case nomem => abort("new(m=0) returned nomem"); + }; + match (new(64, 0, &testhash, null)) { + case errors::invalid => void; + case *set => abort("new accepted k=0"); + case nomem => abort("new(k=0) returned nomem"); + }; +}; + +@test fn basic() void = { + let s = match (new(256, 2, &testhash, null)) { + case let sp: *set => yield sp; + case errors::invalid => abort("basic: invalid"); + case nomem => abort("basic: nomem"); + }; + defer finish(s); + let iface: *set::set = (s: *set::set); + + const inserted: [4]u64 = [1u64, 3u64, 17u64, 41u64]; + let keybuf: [8]u8 = [0...]; + for (let i = 0z; i < len(inserted); i += 1) { + let key = put_le64(&keybuf, inserted[i]); + assert(!contains(s, key), "contains before add"); + match (set::add(iface, key)) { + case void => void; + case nomem => abort("basic: add nomem"); + }; + assert(set::contains(iface, key), "contains after add"); + }; + + const missing: [3]u64 = [11u64, 21u64, 111u64]; + for (let i = 0z; i < len(missing); i += 1) { + let key = put_le64(&keybuf, missing[i]); + assert(!set::contains(iface, key), "contains false positive"); + }; +}; -- 2.48.1