weak-table 0.4.0-pre1

use crate as weak_table2;
use crate::tests::proptest::ForgetStrategy;

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

use quickcheck::quickcheck;

use weak_table2::weak_weak_hash_map::Entry;
use weak_table2::WeakWeakHashMap;

use super::{ExecuteMapCmd, InsertStrategy, MapScript, 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: WeakWeakHashMap<Weak<K>, Weak<V>>,
    strong: HashMap<Rc<K>, Rc<V>>,
    log: Vec<K>,

    // objects that we are retaining only to keep them alive.
    retain_keys: Vec<Rc<K>>,
    retain_values: Vec<Rc<V>>,
}

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: WeakWeakHashMap::with_capacity(capacity),
            strong: HashMap::default(),
            log: Vec::new(),
            retain_keys: Vec::new(),
            retain_values: 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: WeakWeakHashMap<Weak<K>, Weak<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 get functionality to test for matches.
        {
            for (k, v) in self.strong.iter() {
                assert_eq!(self.weak.get(k.as_ref()), Some(v.clone()));
                assert_eq!(self.weak.get_both(k.as_ref()), Some((k.clone(), v.clone())));
                assert_eq!(self.weak.get_key(k.as_ref()), Some(k.clone()));
                assert!(self.weak.contains_key(k.as_ref()));
            }
        }

        // 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(occ) => {
                        assert_eq!(occ.key(), k);
                        assert_eq!(occ.get(), v);
                        assert_eq!(occ.get_strong(), v.clone());
                    }
                    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<Rc<V>> = self.weak.values().collect();
            let mut v2: Vec<Rc<V>> = self.strong.values().cloned().collect();
            v1.sort();
            v2.sort();
            assert_eq!(v1, v2);
        }

        // 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());
        }

        // 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());
        let val_ptr = Rc::new(value.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(val_ptr.clone());
                    }
                    Entry::Vacant(vac) => {
                        assert_eq!(vac.key(), &key_ptr);
                        vac.insert(val_ptr.clone());
                    }
                }
            }
            InsertStrategy::ViaInsert => {
                let _ = self.weak.insert(key_ptr.clone(), val_ptr.clone());
            }
            InsertStrategy::ViaExtend => {
                let lst = [(key_ptr.clone(), val_ptr.clone())];
                self.weak.extend(lst);
            }
        }
        self.strong.remove(key);
        self.strong.insert(key_ptr, val_ptr.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::ViaRetain => {
                let mut removed = None;
                self.weak.retain(|k, v| {
                    if k.as_ref() == key {
                        removed = Some(v.clone());
                        false
                    } else {
                        true
                    }
                });
                removed
            }
        };
        let old_s = self.strong.remove(key);
        assert_eq!(old_s, old_w);
    }

    fn forget_inserted(&mut self, strategy: ForgetStrategy, index: usize) {
        if let Some(key) = self.nth_key_mod_len(index) {
            if let Some((k, v)) = self.strong.remove_entry(&key) {
                match strategy {
                    ForgetStrategy::ForgetKey => {
                        drop(k);
                        self.retain_values.push(v);
                    }
                    ForgetStrategy::ForgetValue => {
                        drop(v);
                        self.retain_keys.push(k);
                    }
                    ForgetStrategy::ForgetBoth => {
                        drop(k);
                        drop(v);
                    }
                }
            }
        }
    }

    fn reserve(&mut self, n: usize) {
        self.weak.reserve(n);
    }

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