#![cfg(test)]
use super::run_state::{self, Key, Store};
use std::collections::HashSet;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Barrier};
use std::thread;
#[test]
fn cloned_keys_share_identity_while_fresh_keys_and_stores_are_isolated() {
let first = Key::<u32>::new();
let cloned = first.clone();
let second = Key::<u32>::new();
assert!(first == cloned);
assert!(first != second);
let mut keys = HashSet::new();
assert!(keys.insert(first.clone()));
assert!(!keys.insert(cloned));
assert!(keys.insert(second.clone()));
let left = Store::new();
let right = Store::new();
assert!(left.set(&first, Arc::new(1)).is_none());
assert!(left.set(&second, Arc::new(2)).is_none());
assert_eq!(*left.load(&first).unwrap(), 1);
assert_eq!(*left.load(&second).unwrap(), 2);
assert!(right.load(&first).is_none());
assert!(right.set(&first, Arc::new(3)).is_none());
assert_eq!(*left.load(&first).unwrap(), 1);
assert_eq!(*right.load(&first).unwrap(), 3);
}
#[test]
fn slot_lifecycle_preserves_arc_identity_and_explicit_none_presence() {
let store = Store::new();
let key = Key::<String>::new();
assert!(store.load(&key).is_none());
assert!(store.delete(&key).is_none());
let original = Arc::new(String::from("first"));
assert!(store.set(&key, Arc::clone(&original)).is_none());
let loaded = store.load(&key).unwrap();
assert!(Arc::ptr_eq(&loaded, &original));
let replacement = Arc::new(String::from("second"));
let previous = store.set(&key, Arc::clone(&replacement)).unwrap();
assert!(Arc::ptr_eq(&previous, &original));
let deleted = store.delete(&key).unwrap();
assert!(Arc::ptr_eq(&deleted, &replacement));
assert!(store.load(&key).is_none());
let optional = Key::<Option<u8>>::new();
let none = Arc::new(None);
let (inserted, loaded) = store.load_or_store(&optional, Arc::clone(&none));
assert!(!loaded);
assert!(Arc::ptr_eq(&inserted, &none));
let (existing, loaded) = store.load_or_store(&optional, Arc::new(Some(1)));
assert!(loaded);
assert!(existing.is_none());
}
#[test]
fn store_holds_exactly_one_arc_until_replaced_or_deleted() {
struct CountDrop(Arc<AtomicUsize>);
impl Drop for CountDrop {
fn drop(&mut self) {
self.0.fetch_add(1, Ordering::SeqCst);
}
}
let drops = Arc::new(AtomicUsize::new(0));
let store = Store::new();
let key = Key::<CountDrop>::new();
let first = Arc::new(CountDrop(Arc::clone(&drops)));
store.set(&key, Arc::clone(&first));
drop(first);
assert_eq!(drops.load(Ordering::SeqCst), 0);
let second = Arc::new(CountDrop(Arc::clone(&drops)));
let old = store.set(&key, Arc::clone(&second)).unwrap();
assert_eq!(drops.load(Ordering::SeqCst), 0);
drop(old);
assert_eq!(drops.load(Ordering::SeqCst), 1);
drop(second);
assert_eq!(drops.load(Ordering::SeqCst), 1);
drop(store.delete(&key));
assert_eq!(drops.load(Ordering::SeqCst), 2);
}
#[test]
fn concurrent_fresh_keys_are_unique_and_load_or_store_has_one_winner() {
const WORKERS: usize = 24;
let store = Arc::new(Store::new());
let shared = Arc::new(Key::<usize>::new());
let barrier = Arc::new(Barrier::new(WORKERS));
let inserted = Arc::new(AtomicUsize::new(0));
let handles: Vec<_> = (0..WORKERS)
.map(|value| {
let store = Arc::clone(&store);
let shared = Arc::clone(&shared);
let barrier = Arc::clone(&barrier);
let inserted = Arc::clone(&inserted);
thread::spawn(move || {
let fresh = Key::<usize>::new();
store.set(&fresh, Arc::new(value));
barrier.wait();
let (_, loaded) = store.load_or_store(&shared, Arc::new(value));
if !loaded {
inserted.fetch_add(1, Ordering::SeqCst);
}
(fresh, value)
})
})
.collect();
let mut keys = HashSet::new();
for handle in handles {
let (key, value) = handle.join().unwrap();
assert!(keys.insert(key.clone()));
assert_eq!(*store.load(&key).unwrap(), value);
assert_eq!(*store.delete(&key).unwrap(), value);
}
assert_eq!(inserted.load(Ordering::SeqCst), 1);
assert!(store.load(&shared).is_some());
}
#[test]
fn private_type_corruption_panics_instead_of_becoming_a_miss() {
let store = Store::new();
let key = Key::<u32>::new();
run_state::corrupt(&store, &key, Arc::new(String::from("wrong")));
let panic = std::panic::catch_unwind(|| store.load(&key));
assert!(panic.is_err());
}
#[test]
fn key_debug_prints_a_slot_identity_with_no_value_bound() {
struct NotDebug;
let key = Key::<NotDebug>::new();
let cloned = key.clone();
let other = Key::<NotDebug>::new();
let rendering = format!("{key:?}");
assert!(rendering.starts_with("Key { slot: 0x"), "{rendering}");
assert_eq!(rendering, format!("{cloned:?}"));
assert_ne!(rendering, format!("{other:?}"));
}
#[test]
fn store_debug_counts_occupied_slots_and_never_waits_for_them() {
let store = Store::new();
assert_eq!(format!("{store:?}"), "Store { slots: 0 }");
let key = Key::<u32>::new();
store.set(&key, Arc::new(7));
assert_eq!(format!("{store:?}"), "Store { slots: 1 }");
let held = Barrier::new(2);
let release = Barrier::new(2);
thread::scope(|scope| {
scope.spawn(|| run_state::hold_slot_lock(&store, &held, &release));
held.wait();
assert_eq!(format!("{store:?}"), "Store { slots: <locked> }");
release.wait();
});
assert_eq!(format!("{store:?}"), "Store { slots: 1 }");
}