//! Tests for the VecMap collection.
//!
//! This is in a sibling module so that the tests are guaranteed to only cover
//! states that can be created by the public API.

use crate::vecmap::*;

#[test]
fn test_entry_vacant_or_insert() {
    let mut map: VecMap<&str, i32> = VecMap::new();
    let value = map.entry("a").or_insert(1);
    assert_eq!(*value, 1);
    assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&"a", &1)]);
}

#[test]
fn test_entry_occupied_or_insert_keeps_existing() {
    let mut map: VecMap<&str, i32> = VecMap::new();
    map.entry("a").or_insert(1);
    let value = map.entry("a").or_insert(99);
    assert_eq!(*value, 1);
    assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&"a", &1)]);
}

#[test]
fn test_entry_or_insert_with() {
    let mut map: VecMap<&str, i32> = VecMap::new();
    map.entry("a").or_insert_with(|| 42);
    assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&"a", &42)]);
}

#[test]
fn test_entry_or_insert_with_not_called_when_occupied() {
    let mut map: VecMap<&str, i32> = VecMap::new();
    map.entry("a").or_insert(1);
    map.entry("a")
        .or_insert_with(|| panic!("should not be called"));
    assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&"a", &1)]);
}

#[test]
fn test_entry_or_insert_with_key() {
    let mut map: VecMap<&str, String> = VecMap::new();
    map.entry("hello").or_insert_with_key(|k| k.to_uppercase());
    assert_eq!(
        map.iter().collect::<Vec<_>>(),
        vec![(&"hello", &"HELLO".to_string())]
    );
}

#[test]
fn test_entry_or_insert_default() {
    let mut map: VecMap<&str, i32> = VecMap::new();
    map.entry("a").or_insert_default();
    assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&"a", &0)]);
}

#[test]
fn test_entry_key() {
    let mut map: VecMap<&str, i32> = VecMap::new();
    assert_eq!(*map.entry("a").key(), "a");
    map.entry("a").or_insert(1);
    assert_eq!(*map.entry("a").key(), "a");
}

#[test]
fn test_entry_mut_ref_can_be_updated() {
    let mut map: VecMap<&str, i32> = VecMap::new();
    let value = map.entry("a").or_insert(0);
    *value = 5;
    assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&"a", &5)]);
}

#[test]
fn test_insertion_order_preserved() {
    let mut map: VecMap<&str, i32> = VecMap::new();
    map.entry("b").or_insert(2);
    map.entry("a").or_insert(1);
    map.entry("c").or_insert(3);
    assert_eq!(
        map.iter().collect::<Vec<_>>(),
        vec![(&"b", &2), (&"a", &1), (&"c", &3)]
    );
}

#[test]
fn test_multiple_entries_independent() {
    let mut map: VecMap<i32, i32> = VecMap::new();
    map.entry(1).or_insert(10);
    map.entry(2).or_insert(20);
    map.entry(3).or_insert(30);
    assert_eq!(map.iter().count(), 3);
    // Re-inserting does not duplicate keys
    map.entry(1).or_insert(99);
    assert_eq!(map.iter().count(), 3);
}

// entry_ref tests

use std::cell::Cell;
use std::rc::Rc;

#[derive(PartialEq, Eq)]
struct CountedKey {
    value: String,
    clone_count: Rc<Cell<usize>>,
}

impl Clone for CountedKey {
    fn clone(&self) -> Self {
        self.clone_count.set(self.clone_count.get() + 1);
        CountedKey {
            value: self.value.clone(),
            clone_count: self.clone_count.clone(),
        }
    }
}

#[test]
fn test_entry_ref_vacant_or_insert() {
    let mut map: VecMap<String, i32> = VecMap::new();
    let key = "a".to_string();
    let value = map.entry_ref(&key).or_insert(1);
    assert_eq!(*value, 1);
    assert_eq!(map.iter().count(), 1);
}

#[test]
fn test_entry_ref_occupied_or_insert_keeps_existing() {
    let mut map: VecMap<String, i32> = VecMap::new();
    map.entry_ref(&"a".to_string()).or_insert(1);
    let value = map.entry_ref(&"a".to_string()).or_insert(99);
    assert_eq!(*value, 1);
    assert_eq!(map.iter().count(), 1);
}

#[test]
fn test_entry_ref_key_not_cloned_when_occupied() {
    let clone_count = Rc::new(Cell::new(0));
    let key = CountedKey {
        value: "a".to_string(),
        clone_count: clone_count.clone(),
    };

    let mut map: VecMap<CountedKey, i32> = VecMap::new();
    map.entry_ref(&key).or_insert(1);
    let clones_after_insert = clone_count.get();

    // Looking up an existing key must not clone it.
    map.entry_ref(&key).or_insert(99);
    assert_eq!(clone_count.get(), clones_after_insert);
}

#[test]
fn test_entry_ref_key_cloned_exactly_once_on_vacant_insert() {
    let clone_count = Rc::new(Cell::new(0));
    let key = CountedKey {
        value: "a".to_string(),
        clone_count: clone_count.clone(),
    };

    let mut map: VecMap<CountedKey, i32> = VecMap::new();
    map.entry_ref(&key).or_insert(1);
    assert_eq!(clone_count.get(), 1);
}

#[test]
fn test_entry_ref_or_insert_with_key() {
    let mut map: VecMap<String, String> = VecMap::new();
    let key = "hello".to_string();
    map.entry_ref(&key).or_insert_with_key(|k| k.to_uppercase());
    assert_eq!(
        map.iter().collect::<Vec<_>>(),
        vec![(&"hello".to_string(), &"HELLO".to_string())]
    );
}

#[test]
fn test_entry_ref_or_insert_with_not_called_when_occupied() {
    let mut map: VecMap<String, i32> = VecMap::new();
    let key = "a".to_string();
    map.entry_ref(&key).or_insert(1);
    map.entry_ref(&key)
        .or_insert_with(|| panic!("should not be called"));
    assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&key, &1)]);
}

#[test]
fn test_entry_ref_or_insert_default() {
    let mut map: VecMap<String, i32> = VecMap::new();
    map.entry_ref(&"a".to_string()).or_insert_default();
    assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&"a".to_string(), &0)]);
}

#[test]
fn test_entry_ref_key() {
    let mut map: VecMap<String, i32> = VecMap::new();
    let key = "a".to_string();
    assert_eq!(*map.entry_ref(&key).key(), key);
    map.entry_ref(&key).or_insert(1);
    assert_eq!(*map.entry_ref(&key).key(), key);
}

#[test]
fn test_entry_ref_mut_ref_can_be_updated() {
    let mut map: VecMap<String, i32> = VecMap::new();
    let key = "a".to_string();
    let value = map.entry_ref(&key).or_insert(0);
    *value = 5;
    assert_eq!(map.iter().collect::<Vec<_>>(), vec![(&key, &5)]);
}