genarena 0.1.2

use crate::Arena;

#[test]
fn remove_twice() {
    let mut arena = Arena::new_with_default();

    let k = arena.insert(10);

    assert_eq!(arena.remove(k), Some(10));
    assert_eq!(arena.remove(k), None);

    assert!(!arena.contains_key(k));
    assert_eq!(arena.len(), 0);
}

#[test]
fn stale_key_does_not_access_reused_slot() {
    let mut arena = Arena::new_with_default();

    let k1 = arena.insert(1);
    arena.remove(k1);

    let k2 = arena.insert(2);

    assert!(!arena.contains_key(k1));
    assert_eq!(arena.get(k1), None);

    assert!(arena.contains_key(k2));
    assert_eq!(arena.get(k2), Some(&2));
}

#[test]
fn reuses_vacant_slots() {
    let mut arena = Arena::new_with_default();

    let k1 = arena.insert(1);
    let _k2 = arena.insert(2);

    arena.remove(k1);

    let k3 = arena.insert(3);

    // Make sure the removed entry was reused.
    assert_eq!(arena.entries.len(), 2);
    assert_eq!(k1.index, k3.index);
}

#[test]
fn reservation_does_not_change_len() {
    let mut arena = Arena::new_with_default();

    arena.insert(1);

    let r = arena.reserve();
    assert_eq!(arena.len(), 1);

    arena.cancel(r);
    assert_eq!(arena.len(), 1);
}

#[test]
fn claim_increments_len() {
    let mut arena = Arena::new_with_default();

    let r = arena.reserve();
    let k = arena.claim(r, 42);

    assert_eq!(arena.len(), 1);
    assert_eq!(arena.get(k), Some(&42));
}

#[test]
fn cancel_reuses_slot() {
    let mut arena = Arena::new_with_default();

    let r = arena.reserve();
    let k_old = r.key();

    arena.cancel(r);

    let k_new = arena.insert(5);

    assert_eq!(k_old.index, k_new.index);
    assert!(!arena.contains_key(k_old));
    assert!(arena.contains_key(k_new));
}

#[test]
fn claim_preserves_key() {
    let mut arena = Arena::new_with_default();

    let r = arena.reserve();
    let expected = r.key();

    let actual = arena.claim(r, 7);

    assert_eq!(expected, actual);
}

#[test]
fn get_mut_then_remove() {
    let mut arena = Arena::new_with_default();

    let k = arena.insert(1);

    *arena.get_mut(k).unwrap() = 5;

    assert_eq!(arena.remove(k), Some(5));
}

#[test]
#[should_panic]
fn index_panics_on_invalid_key() {
    let mut arena = Arena::new_with_default();

    let k = arena.insert(1);
    arena.remove(k);

    let _ = arena[k]; // should panic
}

#[test]
fn dense_insert_remove() {
    let mut arena = Arena::new_with_default();

    let mut keys = Vec::new();

    for i in 0..100 {
        keys.push(arena.insert(i));
    }

    for k in keys.iter().step_by(2) {
        arena.remove(*k);
    }

    for i in 100..150 {
        arena.insert(i);
    }

    assert_eq!(arena.len(), 100);
    assert_eq!(arena.entries.len(), 100);
}

#[test]
fn iter_skips_vacant() {
    let mut arena = Arena::new_with_default();

    let _a = arena.insert(1);
    let b = arena.insert(2);
    let _c = arena.insert(3);

    arena.remove(b);

    let items: Vec<_> = arena.values().copied().collect();
    assert_eq!(items.len(), 2);
    assert!(items.contains(&1));
    assert!(items.contains(&3));
}

#[test]
fn iter_skips_reserved() {
    let mut arena = Arena::new_with_default();

    arena.insert(1);
    let _r = arena.reserve(); // not claimed
    arena.insert(2);

    let values: Vec<_> = arena.values().copied().collect();

    assert_eq!(values.len(), 2);
    assert!(values.contains(&1));
    assert!(values.contains(&2));
}

#[test]
fn iter_len_matches() {
    let mut arena = Arena::new_with_default();

    for i in 0..10 {
        arena.insert(i);
    }

    let mut iter = arena.iter();

    assert_eq!(iter.len(), 10);

    iter.next();
    assert_eq!(iter.len(), 9);

    iter.next_back();
    assert_eq!(iter.len(), 8);

    let remaining: Vec<_> = iter.collect();
    assert_eq!(remaining.len(), 8);
}

#[test]
fn iter_forward_backward_equivalence() {
    let mut arena = Arena::new_with_default();

    for i in 0..10 {
        arena.insert(i);
    }

    let fwd: Vec<_> = arena.iter().collect();
    let bwd: Vec<_> = arena.iter().rev().collect();

    let mut rev_fwd = fwd.clone();
    rev_fwd.reverse();

    assert_eq!(bwd, rev_fwd);
}

#[test]
fn iter_mut_allows_modification() {
    let mut arena = Arena::new_with_default();

    for i in 0..5 {
        arena.insert(i);
    }

    for (_, v) in arena.iter_mut() {
        *v *= 2;
    }

    let values: Vec<_> = arena.values().copied().collect();
    assert_eq!(values, vec![0, 2, 4, 6, 8]);
}

#[test]
fn keys_values_match() {
    let mut arena = Arena::new_with_default();

    for i in 0..5 {
        arena.insert(i);
    }

    let keys: Vec<_> = arena.keys().collect();
    let values: Vec<_> = arena.values().copied().collect();

    assert_eq!(keys.len(), values.len());

    for (k, v) in keys.into_iter().zip(values) {
        assert_eq!(arena[k], v);
    }
}