73 lines
2.5 KiB
Rust
73 lines
2.5 KiB
Rust
use super::*;
|
|
#[test]
|
|
fn collision_chains_distinguish_full_identity_and_survive_tombstones() {
|
|
let b = RuntimeBudget::default();
|
|
let mut table = IdentityIndex::new(&b);
|
|
let keys: Vec<_> = (0..1000)
|
|
.map(|address| Identity { address, length: 4 })
|
|
.filter(|k| k.hash() & 7 == 0)
|
|
.take(4)
|
|
.collect();
|
|
for (i, key) in keys.iter().enumerate() {
|
|
table.prepare(&b).unwrap();
|
|
table.insert(*key, i);
|
|
}
|
|
for key in &keys {
|
|
assert!(table.contains(*key, || {}));
|
|
}
|
|
table.retain(|i| *i != 1);
|
|
assert!(!table.contains(keys[1], || {}));
|
|
assert!(table.contains(keys[3], || {}));
|
|
assert!(!table.contains(Identity { length: 5, ..keys[3] }, || {}));
|
|
table.prepare(&b).unwrap(); // Rebuild removes tombstones at half occupancy.
|
|
table.insert(keys[1], 1);
|
|
assert_eq!(table.len(), 4);
|
|
assert_eq!(table.tombstones, 0);
|
|
}
|
|
|
|
#[test]
|
|
fn tombstone_reuse_keeps_collision_successors_and_length_is_part_of_key() {
|
|
let b = RuntimeBudget::default();
|
|
let mut t = IdentityIndex::new(&b);
|
|
let key = Identity { address: 16, length: 0 };
|
|
t.prepare(&b).unwrap();
|
|
t.insert(key, 1);
|
|
t.prepare(&b).unwrap();
|
|
t.insert(Identity { length: 1, ..key }, 2);
|
|
t.retain(|v| *v != 1);
|
|
assert_eq!(t.tombstones, 1);
|
|
t.prepare(&b).unwrap();
|
|
t.insert(key, 3);
|
|
assert_eq!(t.tombstones, 0);
|
|
assert!(t.contains(key, || {}));
|
|
assert!(t.contains(Identity { length: 1, ..key }, || {}));
|
|
}
|
|
|
|
#[test]
|
|
fn controlled_probe_counts_and_half_load_survive_growth_and_rebuild() {
|
|
let b = RuntimeBudget::default();
|
|
let mut table = IdentityIndex::new(&b);
|
|
for n in 0..1024 {
|
|
table.prepare(&b).unwrap();
|
|
table.insert(Identity { address: n * 16, length: n % 7 }, n);
|
|
assert!(table.live * 2 <= table.buckets.len());
|
|
}
|
|
let mut max_probes = 0;
|
|
for n in 0..2048 {
|
|
let mut probes = 0;
|
|
assert_eq!(
|
|
table.contains(Identity { address: n * 16, length: n % 7 }, || probes += 1),
|
|
n < 1024
|
|
);
|
|
max_probes = max_probes.max(probes);
|
|
}
|
|
// A reproducible synthetic-key bound for this fixture, not a hash-table
|
|
// worst-case claim or a constraint on allocator-selected real addresses.
|
|
assert!(max_probes <= 32, "fixture probes={max_probes}");
|
|
table.retain(|n| n % 2 == 0);
|
|
table.prepare(&b).unwrap();
|
|
for n in 0..1024 {
|
|
assert_eq!(table.contains(Identity { address: n * 16, length: n % 7 }, || {}), n % 2 == 0);
|
|
}
|
|
}
|