weak-table 0.4.0-pre2

use crate as weak_table;

use crate::compat::{
    rc::{Rc, Weak},
    *,
};
use quickcheck::quickcheck;

use weak_table::weak_key_hash_map::Entry;
use weak_table::WeakKeyHashMap;

use super::{
    ExecuteMapCmd, ForgetStrategy, InsertStrategy, MapScript, ModifyStrategy, RemoveStrategy,
};

fn test_script<K, V>(script: &MapScript<K, V>) -> bool
where
    K: Clone + Debug + Eq + Hash + Ord,
    V: Clone + Debug + Eq + Ord,
{
    let mut tester = Tester::with_capacity(4);
    tester.execute_script(script);
    tester.check()
}

quickcheck! {
    fn prop_u8_u8(script: MapScript<u8, u8>) -> bool {
        test_script(&script)
    }

    fn prop_string_usize(script: MapScript<String, usize>) -> bool {
        test_script(&script)
    }
}
#[derive(Clone, Debug)]
pub struct Tester<K: Hash + Eq, V> {
    weak: WeakKeyHashMap<Weak<K>, V>,
    strong: HashMap<Rc<K>, V>,
    log: Vec<K>,
}

impl<K, V> Tester<K, V>
where
    K: Hash + Eq + Clone + Debug + Ord,
    V: Eq + Clone + Debug + Ord,
{
    pub fn with_capacity(capacity: usize) -> Self {
        Tester {
            weak: WeakKeyHashMap::with_capacity(capacity),
            strong: HashMap::default(),
            log: Vec::new(),
        }
    }

    #[allow(clippy::cognitive_complexity)]
    pub fn check(&self) -> bool {
        // We'll use a variety of accessors here to make sure they give us
        // similar answers.

        // Check length accessors.
        assert!(self.weak.len() >= self.strong.len());
        {
            let mut weak2 = self.weak.clone();
            weak2.remove_expired();
            assert_eq!(weak2.len(), self.strong.len());
        }
        #[allow(clippy::len_zero)]
        {
            assert_eq!(self.weak.is_empty(), self.weak.len() == 0);
        }

        // Check capacity is plausible.
        assert!(self.weak.capacity() >= self.weak.len());

        // Construct new versions of weak table in several ways; make sure they are the same.
        {
            let weak2: WeakKeyHashMap<Weak<K>, V> = self
                .strong
                .iter()
                .map(|(k, v)| (k.clone(), v.clone()))
                .collect();
            assert_eq!(&weak2, &self.weak);

            let weak3 = weak2.clone();
            assert_eq!(&weak3, &self.weak);
        }

        // Use index functionality to test for matches.
        {
            let mut weak2 = self.weak.clone();
            for (k, v) in self.strong.iter() {
                assert_eq!(&self.weak[k], v);
                assert_eq!(&mut weak2[k], v);
            }
        }
        // Use get functionality to test for matches.
        {
            for (k, v) in self.strong.iter() {
                assert_eq!(self.weak.get(k.as_ref()), Some(v));
                assert_eq!(self.weak.get_both(k.as_ref()), Some((k.clone(), v)));
                assert!(Rc::ptr_eq(
                    &self.weak.get_key(k.as_ref()).expect("Key suddenly absent"),
                    k
                ));
                assert!(self.weak.contains_key(k.as_ref()));
            }
            let mut weak2: WeakKeyHashMap<Weak<K>, V> = self.weak.clone();
            for (k, v) in self.strong.clone().iter_mut() {
                assert_eq!(weak2.get_mut(k.as_ref()), Some(v));
            }
            for (k, v) in self.strong.clone().iter_mut() {
                assert_eq!(weak2.get_both_mut(k.as_ref()), Some((k.clone(), v)));
            }
        }

        // Use Entry functionality to test for matches.
        {
            let mut weak2 = self.weak.clone();
            for (k, v) in self.strong.iter() {
                let ent = weak2.entry(k.clone());
                assert_eq!(ent.key(), k);
                match ent {
                    Entry::Occupied(mut occ) => {
                        assert_eq!(occ.key(), k);
                        assert_eq!(occ.get(), v);
                        assert_eq!(occ.get_mut(), v);
                        assert_eq!(occ.into_mut(), v);
                    }
                    Entry::Vacant(_) => panic!("entry not present"),
                }
            }
        }

        // Check key and value iterators; make sure they match.
        {
            let mut k1: Vec<Rc<K>> = self.weak.keys().collect();
            let mut k2: Vec<Rc<K>> = self.strong.keys().cloned().collect();
            k1.sort();
            k2.sort();
            assert_eq!(k1, k2);

            let mut v1: Vec<V> = self.weak.values().cloned().collect();
            let mut v2: Vec<V> = self.strong.values().cloned().collect();
            v1.sort();
            v2.sort();
            assert_eq!(v1, v2);
        }

        // Check into_keys and into_values iterators; make sure they match.
        {
            let mut k1: Vec<_> = self.weak.clone().into_keys().collect();
            let mut k2: Vec<_> = self.strong.clone().into_keys().collect();
            k1.sort();
            k2.sort();
            assert_eq!(k1, k2);

            let mut v1: Vec<_> = self.weak.clone().into_values().collect();
            let mut v2: Vec<_> = self.strong.clone().into_values().collect();
            v1.sort();
            v2.sort();
            assert_eq!(v1, v2);
        }

        // Check mutable iterators, make sure they match.
        {
            let mut weak2 = self.weak.clone();
            let mut v1: Vec<V> = weak2.values_mut().map(|v| v.clone()).collect();
            let mut v2: Vec<V> = self.strong.values().cloned().collect();
            v1.sort();
            v2.sort();
            assert_eq!(v1, v2);

            let mut e1: Vec<(Rc<K>, V)> = weak2
                .iter_mut()
                .map(|(k, v)| (k.clone(), v.clone()))
                .collect();
            let mut e2: Vec<(Rc<K>, V)> = self
                .strong
                .iter()
                .map(|(k, v)| (k.clone(), v.clone()))
                .collect();
            e1.sort();
            e2.sort();
            assert_eq!(e1, e2);
        }

        // Use a few other iterator types to construct a version of the strong
        // table.
        {
            let weak2 = self.weak.clone();
            let copy: HashMap<_, _> = weak2.into_iter().collect();
            assert_eq!(copy, self.strong);

            let mut weak3 = self.weak.clone();
            let copy: HashMap<_, _> = weak3.drain().collect();
            assert_eq!(copy, self.strong);
            assert!(weak3.is_empty());

            let copy: HashMap<_, _> = (&self.weak)
                .into_iter()
                .map(|(k, v)| (k, v.clone()))
                .collect();
            assert_eq!(copy, self.strong);
        }

        // Construct version of strong table, make sure it is the same.
        let copy = self.weak.iter().map(|(k, v)| (k, v.clone())).collect();
        if self.strong == copy {
            //            eprintln!("Tester::check: succeeded: {:?}", self.weak);
            true
        } else {
            eprintln!("Tester::check: failed: {:?} ≠ {:?}", self.strong, copy);
            false
        }
    }

    fn nth_key_mod_len(&self, n: usize) -> Option<K> {
        if self.log.is_empty() {
            None
        } else {
            Some(self.log[n % self.log.len()].clone())
        }
    }
}

impl<K, V> ExecuteMapCmd<K, V> for Tester<K, V>
where
    K: Clone + Debug + Eq + Hash + Ord,
    V: Clone + Debug + Eq + Ord,
{
    fn insert(&mut self, strategy: InsertStrategy, key: &K, value: &V, log: bool) {
        let key_ptr = Rc::new(key.clone());
        match strategy {
            InsertStrategy::ViaEntry => {
                let ent = self.weak.entry(key_ptr.clone());
                assert_eq!(ent.key(), &key_ptr);
                match ent {
                    Entry::Occupied(mut occ) => {
                        assert_eq!(occ.key(), &key_ptr);
                        occ.insert(value.clone());
                    }
                    Entry::Vacant(vac) => {
                        assert_eq!(vac.key(), &key_ptr);
                        vac.insert(value.clone());
                    }
                }
            }
            InsertStrategy::ViaInsert => {
                let _ = self.weak.insert(key_ptr.clone(), value.clone());
            }
            InsertStrategy::ViaExtend => {
                let lst = [(key_ptr.clone(), value.clone())];
                self.weak.extend(lst);
            }
            InsertStrategy::ViaExtendRef => {
                let lst = [(&key_ptr, value)];
                self.weak.extend(lst);
            }
        }
        self.strong.remove(key);
        self.strong.insert(key_ptr, value.clone());
        if log {
            self.log.push(key.clone());
        }
    }

    fn reinsert(&mut self, strategy: InsertStrategy, index: usize, value: &V) {
        if let Some(key) = self.nth_key_mod_len(index) {
            self.insert(strategy, &key, value, false);
        }
    }

    fn remove_inserted(&mut self, strategy: RemoveStrategy, index: usize) {
        if let Some(key) = self.nth_key_mod_len(index) {
            self.remove_other(strategy, &key);
        }
    }

    fn remove_other(&mut self, strategy: RemoveStrategy, key: &K) {
        let old_w = match strategy {
            RemoveStrategy::ViaEntry => {
                let key_ptr = Rc::new(key.clone());
                let ent = self.weak.entry(key_ptr);
                match ent {
                    Entry::Occupied(occ) => Some(occ.remove()),
                    Entry::Vacant(_) => None,
                }
            }
            RemoveStrategy::ViaRemove => self.weak.remove(key),
            RemoveStrategy::ViaRemoveEntry => self.weak.remove_entry(key).map(|(k, v)| {
                assert_eq!(k.as_ref(), key);
                v
            }),
            RemoveStrategy::ViaRetain => {
                let mut removed: Option<V> = None;
                self.weak.retain(|k, v| {
                    if k.as_ref() == key {
                        removed = Some(v.clone());
                        false
                    } else {
                        true
                    }
                });
                removed
            }
            RemoveStrategy::ViaExtractIf => {
                let removed: Vec<_> = self.weak.extract_if(|k, _| k.as_ref() == key).collect();
                assert!(removed.len() <= 1);
                removed.get(0).map(|(_, v)| v.clone())
            }
        };
        let old_s = self.strong.remove(key);
        assert_eq!(old_s, old_w);
    }

    fn modify_inserted(&mut self, strategy: ModifyStrategy, index: usize, value: &V) {
        if let Some(key) = self.nth_key_mod_len(index) {
            let key_ptr = match self.strong.get_key_value(&key) {
                Some((k, _)) => k.clone(),
                None => Rc::new(key.clone()),
            };
            let old_val_w = match strategy {
                ModifyStrategy::Reinsert => self.weak.insert(key_ptr.clone(), value.clone()),
                ModifyStrategy::Entry => match self.weak.entry(key_ptr.clone()) {
                    Entry::Occupied(mut occupied) => Some(occupied.insert(value.clone())),
                    Entry::Vacant(vacant_entry) => {
                        let _ignore = vacant_entry.insert_entry(value.clone());
                        None
                    }
                },
                ModifyStrategy::EntryAndModify => {
                    let mut prev = None;
                    let newval = self
                        .weak
                        .entry(key_ptr.clone())
                        .and_modify(|vp| {
                            let mut v = value.clone();
                            mem::swap(&mut v, vp);
                            prev = Some(v);
                        })
                        .or_insert(value.clone());
                    assert_eq!(newval, value);

                    prev
                }
                ModifyStrategy::GetDisjointMut => {
                    if let [Some(p)] = self.weak.get_disjoint_mut([&key]) {
                        let mut v = value.clone();
                        mem::swap(p, &mut v);
                        Some(v)
                    } else {
                        self.weak.insert(key_ptr.clone(), value.clone());
                        None
                    }
                }
                ModifyStrategy::GetBothDisjointMut => {
                    if let [Some((kp, vp))] = self.weak.get_both_disjoint_mut([&key]) {
                        assert_eq!(kp.as_ref(), &key);
                        let mut v = value.clone();
                        mem::swap(vp, &mut v);
                        Some(v)
                    } else {
                        self.weak.insert(key_ptr.clone(), value.clone());
                        None
                    }
                }
                ModifyStrategy::GetMut => {
                    if let Some(p) = self.weak.get_mut(&key) {
                        let mut v = value.clone();
                        mem::swap(p, &mut v);
                        Some(v)
                    } else {
                        self.weak.insert(key_ptr.clone(), value.clone());
                        None
                    }
                }
            };

            let old_val_s = self.strong.insert(key_ptr.clone(), value.clone());
            assert_eq!(old_val_s, old_val_w);
        }
    }

    fn forget_inserted(&mut self, _: ForgetStrategy, index: usize) {
        if let Some(key) = self.nth_key_mod_len(index) {
            self.strong.remove(&key);
        }
    }

    fn reserve(&mut self, n: usize, try_reserve: bool) {
        if try_reserve {
            self.weak.try_reserve(n).expect("failed");
        } else {
            self.weak.reserve(n);
        }
    }

    fn shrink(&mut self, min_capacity: Option<usize>) {
        match min_capacity {
            Some(n) => self.weak.shrink_to(n),
            None => self.weak.shrink_to_fit(),
        }
    }

    fn clear(&mut self) {
        self.weak.clear();
        self.strong.clear();
    }
}