vendor/im-rc/src/tests/hashset.rs

   1 #![allow(clippy::unit_arg)]
   2
   3 use std::collections::HashSet as NatSet;
   4 use std::fmt::{Debug, Error, Formatter, Write};
   5 use std::hash::Hash;
   6
   7 use crate::HashSet;
   8
   9 use proptest::proptest;
  10 use proptest_derive::Arbitrary;
  11
  12 #[derive(Arbitrary, Debug)]
  13 enum Action<A> {
  14     Insert(A),
  15     Remove(A),
  16 }
  17
  18 #[derive(Arbitrary)]
  19 struct Actions<A>(Vec<Action<A>>)
  20 where
  21     A: Hash + Eq + Clone;
  22
  23 impl<A> Debug for Actions<A>
  24 where
  25     A: Hash + Eq + Debug + Clone,
  26 {
  27     fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error> {
  28         let mut out = String::new();
  29         let mut expected = NatSet::new();
  30         writeln!(out, "let mut set = HashSet::new();")?;
  31         for action in &self.0 {
  32             match action {
  33                 Action::Insert(ref value) => {
  34                     expected.insert(value.clone());
  35                     writeln!(out, "set.insert({:?});", value)?;
  36                 }
  37                 Action::Remove(ref value) => {
  38                     expected.remove(value);
  39                     writeln!(out, "set.remove({:?});", value)?;
  40                 }
  41             }
  42         }
  43         writeln!(
  44             out,
  45             "let expected = vec!{:?};",
  46             expected.into_iter().collect::<Vec<_>>()
  47         )?;
  48         writeln!(out, "assert_eq!(HashSet::from(expected), set);")?;
  49         write!(f, "{}", super::code_fmt(&out))
  50     }
  51 }
  52
  53 proptest! {
  54     #[test]
  55     fn comprehensive(actions: Actions<u8>) {
  56         let mut set = HashSet::new();
  57         let mut nat = NatSet::new();
  58         for action in actions.0 {
  59             match action {
  60                 Action::Insert(value) => {
  61                     let len = nat.len() + if nat.contains(&value) {
  62                         0
  63                     } else {
  64                         1
  65                     };
  66                     nat.insert(value);
  67                     set.insert(value);
  68                     assert_eq!(len, set.len());
  69                 }
  70                 Action::Remove(value) => {
  71                     let len = nat.len() - if nat.contains(&value) {
  72                         1
  73                     } else {
  74                         0
  75                     };
  76                     nat.remove(&value);
  77                     set.remove(&value);
  78                     assert_eq!(len, set.len());
  79                 }
  80             }
  81             assert_eq!(nat.len(), set.len());
  82             assert_eq!(HashSet::from(nat.clone()), set);
  83         }
  84     }
  85 }