bumpish 0.2.0

use bumpish::BumpMap;
use bumpish::map::Entry;
use pretty_assertions::{assert_eq, assert_ne};
use std::any::{Any, TypeId};
use std::hash::{Hash, Hasher, RandomState};

#[test]
fn map_new() {
    let map = BumpMap::<i32, i32>::new();
    assert_eq!(map.capacity(), 0);
    assert_eq!(map.len(), 0);
    assert!(map.is_empty());
}

#[test]
fn map_with_capacity() {
    let map = BumpMap::<i32, i32>::with_capacity(10);
    assert!(map.capacity() >= 10);
    assert_eq!(map.len(), 0);
    assert!(map.is_empty());
}

#[test]
fn map_with_hasher() {
    let hasher = RandomState::new();
    let map = BumpMap::<i32, i32, _>::with_hasher(hasher);
    assert_eq!(map.capacity(), 0);
    assert_eq!(map.len(), 0);
    assert!(map.is_empty());
}

#[test]
fn map_with_capacity_and_hasher() {
    let hasher = RandomState::new();
    let map = BumpMap::<i32, i32, _>::with_capacity_and_hasher(10, hasher);
    assert!(map.capacity() >= 10);
    assert_eq!(map.len(), 0);
    assert!(map.is_empty());
}

#[test]
fn map_hasher() {
    let map = BumpMap::<i32, i32>::new();
    assert_eq!(map.hasher().type_id(), TypeId::of::<RandomState>());
}

#[test]
fn map_insert() {
    let hasher = RandomState::new();
    let map = BumpMap::<_, _, _>::with_hasher(hasher);
    map.insert(0, 0);
    assert_eq!(map.insert(1, 1), Some(&1));
    assert_eq!(map.insert(2, 2), Some(&2));
    assert_eq!(map.insert(2, 3), None);

    assert_eq!(map.insert_full(3, 3), Some((&3, &3)));
    assert_eq!(map.insert_full(2, 3), None);
}

#[test]
fn map_insert_mut() {
    let hasher = RandomState::new();
    let mut map = BumpMap::<_, _, _>::with_hasher(hasher);
    map.insert(0, 0);
    assert_eq!(map.insert_mut(1, 1), Some(&mut 1));
    assert_eq!(map.insert_mut(2, 2), Some(&mut 2));
    assert_eq!(map.insert_mut(2, 3), None);

    assert_eq!(map.insert_full_mut(3, 3), Some((&3, &mut 3)));
    assert_eq!(map.insert_full_mut(2, 3), None);
}

#[test]
fn map_replace() {
    #[derive(Eq, Clone, Copy)]
    struct Key {
        key: i32,
        load: usize,
    }
    impl PartialEq for Key {
        fn eq(&self, other: &Self) -> bool {
            self.key == other.key
        }
    }
    impl Hash for Key {
        fn hash<H: Hasher>(&self, state: &mut H) {
            self.key.hash(state);
        }
    }
    let key_1 = Key { key: 1, load: 1 };
    let key_2 = Key { key: 2, load: 2 };
    let key_3 = Key { key: 2, load: 3 };
    let mut map = BumpMap::new();
    assert_eq!(map.replace(key_1, 1), None);
    assert_eq!(map.replace(key_2, 2), None);
    assert_eq!(map.get_key_value(&key_2).unwrap().0.load, 2);
    assert_eq!(map.replace(key_3, 3), Some(2));
    assert_eq!(map.get_key_value(&key_2).unwrap().0.load, 2);
    assert_eq!(map.get(&key_2), Some(&3));
    assert_eq!(map.get(&key_3), Some(&3));
    assert_eq!(
        map.get_key_value(&key_2).unwrap().0.load,
        map.get_key_value(&key_3).unwrap().0.load,
    );
}

#[test]
fn map_replace_full() {
    #[derive(Eq, Clone, Copy, Debug)]
    struct Key {
        key: i32,
        load: usize,
    }
    impl PartialEq for Key {
        fn eq(&self, other: &Self) -> bool {
            self.key == other.key
        }
    }
    impl Hash for Key {
        fn hash<H: Hasher>(&self, state: &mut H) {
            self.key.hash(state);
        }
    }
    let key_1 = Key { key: 1, load: 1 };
    let key_2 = Key { key: 2, load: 2 };
    let key_3 = Key { key: 2, load: 3 };
    let mut map = BumpMap::new();
    assert_eq!(map.replace_full(key_1, 1), None);
    assert_eq!(map.replace_full(key_2, 2), None);
    assert_eq!(map.get_key_value(&key_2).unwrap().0.load, 2);
    assert_eq!(map.replace_full(key_3, 3), Some((key_2, 2)));
    assert_eq!(map.get_key_value(&key_2).unwrap().0.load, 3);
    assert_eq!(map.get(&key_2), Some(&3));
    assert_eq!(map.get(&key_3), Some(&3));
    assert_eq!(
        map.get_key_value(&key_2).unwrap().0.load,
        map.get_key_value(&key_3).unwrap().0.load,
    );
}

#[test]
fn map_clear() {
    let hasher = RandomState::new();
    let mut map = BumpMap::<_, _, _>::with_hasher(hasher);
    map.insert("a".to_owned(), "a".to_owned());
    map.insert("b".to_owned(), "b".to_owned());
    map.insert("c".to_owned(), "c".to_owned());
    map.clear();
    assert!(map.is_empty());
    assert!(map.capacity() > 0);
}

#[test]
fn map_contains_key() {
    let hasher = RandomState::new();
    let map = BumpMap::<_, _, _>::with_hasher(hasher);
    assert!(!map.contains_key("a"));
    map.insert("a".to_owned(), "a".to_owned());
    map.insert("b".to_owned(), "b".to_owned());
    map.insert("c".to_owned(), "c".to_owned());
    assert!(map.contains_key("a"));
    assert!(map.contains_key("b"));
    assert!(map.contains_key("c"));
    assert!(!map.contains_key("d"));
    assert!(!map.contains_key("A"));
}

#[test]
fn map_iter() {
    let map = BumpMap::new();
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    map.insert(4, 4);
    map.insert(5, 5);
    assert_eq!(map.iter().count(), 5);
    assert_eq!(
        map.iter().collect::<Vec<_>>(),
        [(&1, &1), (&2, &2), (&3, &3), (&4, &4), (&5, &5)],
    );
    assert_eq!(map.iter().nth(2), Some((&3, &3)));
    assert_eq!(map.iter().last(), Some((&5, &5)));
    assert_eq!(map.iter().next_back(), Some((&5, &5)));
    for (k, v) in &map {
        assert_eq!(k, v);
    }
}

#[test]
fn map_iter_mut() {
    let mut map = BumpMap::new();
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    map.insert(4, 4);
    map.insert(5, 5);
    assert_eq!(map.iter_mut().count(), 5);
    assert_eq!(map.iter_mut().next_back(), Some((&5, &mut 5)));
    for (k, v) in &mut map {
        assert_eq!(k, v);
    }

    map.iter_mut().for_each(|(k, v)| *v += *k);
    assert_eq!(
        map.iter().collect::<Vec<_>>(),
        [(&1, &2), (&2, &4), (&3, &6), (&4, &8), (&5, &10)],
    );
}

#[test]
fn map_keys() {
    let hasher = RandomState::new();
    let map = BumpMap::<_, _, _>::with_hasher(hasher);
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    map.insert(4, 4);
    map.insert(5, 5);
    assert_eq!(map.keys().count(), 5);
    assert_eq!(map.keys().collect::<Vec<_>>(), [&1, &2, &3, &4, &5],);
    assert_eq!(map.keys().nth(2), Some(&3));
    assert_eq!(map.keys().last(), Some(&5));
}

#[test]
fn map_values() {
    let map = BumpMap::new();
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    map.insert(4, 4);
    map.insert(5, 5);
    assert_eq!(map.values().count(), 5);
    assert_eq!(map.values().collect::<Vec<_>>(), [&1, &2, &3, &4, &5],);
    assert_eq!(map.values().nth(2), Some(&3));
    assert_eq!(map.values().last(), Some(&5));
}

#[test]
fn map_values_mut() {
    let mut map = BumpMap::new();
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    map.insert(4, 4);
    map.insert(5, 5);
    assert_eq!(map.values_mut().count(), 5);
    assert_eq!(
        map.values_mut().collect::<Vec<_>>(),
        [&mut 1, &mut 2, &mut 3, &mut 4, &mut 5],
    );
    assert_eq!(map.values_mut().nth(2), Some(&mut 3));
    assert_eq!(map.values_mut().last(), Some(&mut 5));
}

#[test]
fn map_drain() {
    let hasher = RandomState::new();
    let mut map = BumpMap::<_, _, _>::with_hasher(hasher);
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    map.insert(4, 4);
    map.insert(5, 5);
    let mut drain = map.drain();
    assert_eq!(drain.next(), Some((5, 5)));
    assert_eq!(drain.next(), Some((4, 4)));
    assert_eq!(drain.next(), Some((3, 3)));
    drop(drain);
    assert_eq!(map.iter().count(), 0);
}

#[test]
fn map_into_iter() {
    let hasher = RandomState::new();
    let map = BumpMap::<_, _, _>::with_hasher(hasher);
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    map.insert(4, 4);
    map.insert(5, 5);
    let mut iter = map.into_iter();
    assert_eq!(iter.next(), Some((5, 5)));
    assert_eq!(iter.next(), Some((4, 4)));
    assert_eq!(iter.next(), Some((3, 3)));
    assert_eq!(iter.count(), 2);
}

#[test]
fn map_entry() {
    let hasher = RandomState::new();
    let map = BumpMap::<_, _, _>::with_hasher(hasher);

    assert_eq!(&'a', map.entry("a".to_string()).or_insert_with(|| 'a'));
    assert_eq!(&'a', map.entry("a".to_string()).or_insert_with(|| 'b'));

    assert_eq!(&'\0', map.entry("b".to_string()).or_default(),);
    assert_eq!(&'\0', map.entry("b".to_string()).or_insert('b'));

    assert_eq!(&'c', map.entry("c".to_string()).or_insert('c'),);
    assert_eq!(&'c', map.entry("c".to_string()).or_insert('d'),);

    assert_eq!(
        &'d',
        map.entry("d".to_string())
            .or_insert_with_key(|k| k.chars().next().unwrap()),
    );
    assert_eq!(&'d', map.entry("d".to_string()).or_insert_with_key(|_| 'e'),);

    assert_eq!(map.entry("a".to_owned()).key(), &"a");
    assert_eq!(map.entry("e".to_owned()).key(), &"e");

    assert_eq!(
        format!("{:?}", map.entry("a".to_owned())),
        r#"Entry(OccupiedEntry { key: "a", value: 'a', .. })"#
    );
    assert_eq!(
        format!("{:?}", map.entry("e".to_owned())),
        r#"Entry(VacantEntry { key: "e", .. })"#
    );

    let vacant_entry = match map.entry("z".to_owned()) {
        Entry::Vacant(entry) => entry,
        _ => unreachable!(),
    };
    assert_eq!(vacant_entry.into_key(), "z");

    let vacant_entry = match map.entry("z".to_owned()) {
        Entry::Vacant(entry) => entry,
        _ => unreachable!(),
    };
    assert_eq!(vacant_entry.insert_entry('z').into_ref(), &'z');
}

#[test]
fn map_get() {
    let hasher = RandomState::new();
    let map = BumpMap::<_, _, _>::with_hasher(hasher);
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    assert_eq!(map.get(&1), Some(&1));
    assert_eq!(map.get(&2), Some(&2));
    assert_eq!(map.get(&3), Some(&3));
    assert_eq!(map.get(&4), None);
    assert_eq!(map.get_key_value(&1), Some((&1, &1)));
    assert_eq!(map.get_key_value(&2), Some((&2, &2)));
    assert_eq!(map.get_key_value(&3), Some((&3, &3)));
    assert_eq!(map.get_key_value(&4), None);
}

#[test]
fn map_get_mut() {
    let hasher = RandomState::new();
    let mut map = BumpMap::<_, _, _>::with_hasher(hasher);
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    assert_eq!(map.get_mut(&1), Some(&mut 1));
    assert_eq!(map.get_mut(&2), Some(&mut 2));
    assert_eq!(map.get_mut(&3), Some(&mut 3));
    assert_eq!(map.get_mut(&4), None);
    *map.get_mut(&2).unwrap() = 42;
    assert_eq!(map.get_mut(&2), Some(&mut 42));
}

#[test]
fn map_clone() {
    let hasher = RandomState::new();
    let map = BumpMap::<_, _, _>::with_hasher(hasher);
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    let clone = map.clone();
    assert_eq!(clone.get(&1), map.get(&1));
    assert_eq!(clone.get(&2), map.get(&2));
    assert_eq!(clone.get(&3), map.get(&3));
    assert_eq!(clone.get(&4), map.get(&4));
    assert_eq!(clone.get_key_value(&1), map.get_key_value(&1));
    assert_eq!(clone.get_key_value(&2), map.get_key_value(&2));
    assert_eq!(clone.get_key_value(&3), map.get_key_value(&3));
    assert_eq!(clone.get_key_value(&4), map.get_key_value(&4));
}

#[test]
fn map_debug_fmt() {
    let map = BumpMap::new();
    map.insert(1, 1);
    map.insert(2, 2);
    map.insert(3, 3);
    assert_eq!(format!("{:?}", map), "{1: 1, 2: 2, 3: 3}");
}

#[test]
fn map_partial_eq() {
    let map1 = BumpMap::new();
    map1.insert(1, 1);
    map1.insert(2, 2);
    map1.insert(3, 3);

    let map2 = BumpMap::new();
    map2.insert(1, 1);
    map2.insert(2, 2);
    map2.insert(3, 3);

    let map3 = BumpMap::new();
    map3.insert(1, 1);
    map3.insert(2, 2);
    map3.insert(4, 4);

    let map4 = BumpMap::new();
    map4.insert(1, 1);
    map4.insert(2, 2);

    assert_eq!(map1, map2);
    assert_ne!(map1, map3);
    assert_ne!(map1, map4);
}

#[test]
fn map_from() {
    let map = BumpMap::from([(1, 1), (2, 2), (3, 3)]);
    assert_eq!(format!("{:?}", map), "{1: 1, 2: 2, 3: 3}");
}

#[test]
fn map_extend() {
    let mut map = BumpMap::from([(1, 1), (2, 2), (3, 3)]);
    map.extend([(4, 4), (2, 3)]);
    assert_eq!(format!("{:?}", map), "{1: 1, 2: 3, 3: 3, 4: 4}");
    map.extend([(&5, &5), (&5, &6)]);
    assert_eq!(format!("{:?}", map), "{1: 1, 2: 3, 3: 3, 4: 4, 5: 6}");
}

#[test]
fn map_augment() {
    let map = BumpMap::from([(1, 1), (2, 2), (3, 3)]);
    map.augment([(4, 4), (2, 3)]);
    assert_eq!(format!("{:?}", map), "{1: 1, 2: 2, 3: 3, 4: 4}");
    map.augment([(5, 5), (5, 6)]);
    assert_eq!(format!("{:?}", map), "{1: 1, 2: 2, 3: 3, 4: 4, 5: 5}");
}

#[test]
fn map_index() {
    let map = BumpMap::from([(0, 0), (1, 1), (2, 2), (3, 3)]);
    for i in 0..map.len() {
        assert_eq!(Some(&map[&i]), map.get(&i));
    }
}