Files
prometeu-runtime/crates/console/prometeu-vm/src/string_identity_index/tests.rs
T

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);
}
}