enumset/tests/ops.rs

   1 #![allow(dead_code)]
   2
   3 use enumset::*;
   4 use std::collections::{HashSet, BTreeSet};
   5
   6 #[derive(EnumSetType, Debug)]
   7 pub enum EmptyEnum { }
   8
   9 #[derive(EnumSetType, Debug)]
  10 pub enum Enum1 {
  11     A,
  12 }
  13
  14 #[derive(EnumSetType, Debug)]
  15 pub enum SmallEnum {
  16     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
  17 }
  18 #[derive(EnumSetType, Debug)]
  19 pub enum LargeEnum {
  20     _00,  _01,  _02,  _03,  _04,  _05,  _06,  _07,
  21     _10,  _11,  _12,  _13,  _14,  _15,  _16,  _17,
  22     _20,  _21,  _22,  _23,  _24,  _25,  _26,  _27,
  23     _30,  _31,  _32,  _33,  _34,  _35,  _36,  _37,
  24     _40,  _41,  _42,  _43,  _44,  _45,  _46,  _47,
  25     _50,  _51,  _52,  _53,  _54,  _55,  _56,  _57,
  26     _60,  _61,  _62,  _63,  _64,  _65,  _66,  _67,
  27     _70,  _71,  _72,  _73,  _74,  _75,  _76,  _77,
  28     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
  29 }
  30 #[derive(EnumSetType, Debug)]
  31 pub enum Enum8 {
  32     A, B, C, D, E, F, G, H,
  33 }
  34 #[derive(EnumSetType, Debug)]
  35 pub enum Enum128 {
  36     A, B, C, D, E, F, G, H, _8, _9, _10, _11, _12, _13, _14, _15,
  37     _16, _17, _18, _19, _20, _21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31,
  38     _32, _33, _34, _35, _36, _37, _38, _39, _40, _41, _42, _43, _44, _45, _46, _47,
  39     _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, _59, _60, _61, _62, _63,
  40     _64, _65, _66, _67, _68, _69, _70, _71, _72, _73, _74, _75, _76, _77, _78, _79,
  41     _80, _81, _82, _83, _84, _85, _86, _87, _88, _89, _90, _91, _92, _93, _94, _95,
  42     _96, _97, _98, _99, _100, _101, _102, _103, _104, _105, _106, _107, _108, _109,
  43     _110, _111, _112, _113, _114, _115, _116, _117, _118, _119, _120, _121, _122,
  44     _123, _124,  _125, _126, _127,
  45 }
  46 #[derive(EnumSetType, Debug)]
  47 pub enum SparseEnum {
  48     A = 0xA, B = 20, C = 30, D = 40, E = 50, F = 60, G = 70, H = 80,
  49 }
  50
  51 macro_rules! test_variants {
  52     ($enum_name:ident $all_empty_test:ident $($variant:ident,)*) => {
  53         #[test]
  54         fn $all_empty_test() {
  55             let all = EnumSet::<$enum_name>::all();
  56             let empty = EnumSet::<$enum_name>::empty();
  57
  58             $(
  59                 assert!(!empty.contains($enum_name::$variant));
  60                 assert!(all.contains($enum_name::$variant));
  61             )*
  62         }
  63     }
  64 }
  65 test_variants! { SmallEnum small_enum_all_empty
  66     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
  67 }
  68 test_variants! { LargeEnum large_enum_all_empty
  69     _00,  _01,  _02,  _03,  _04,  _05,  _06,  _07,
  70     _10,  _11,  _12,  _13,  _14,  _15,  _16,  _17,
  71     _20,  _21,  _22,  _23,  _24,  _25,  _26,  _27,
  72     _30,  _31,  _32,  _33,  _34,  _35,  _36,  _37,
  73     _40,  _41,  _42,  _43,  _44,  _45,  _46,  _47,
  74     _50,  _51,  _52,  _53,  _54,  _55,  _56,  _57,
  75     _60,  _61,  _62,  _63,  _64,  _65,  _66,  _67,
  76     _70,  _71,  _72,  _73,  _74,  _75,  _76,  _77,
  77     A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z,
  78 }
  79 test_variants! { SparseEnum sparse_enum_all_empty
  80     A, B, C, D, E, F, G,
  81 }
  82
  83 macro_rules! test_enum {
  84     ($e:ident, $mem_size:expr) => {
  85         const CONST_SET: EnumSet<$e> = enum_set!($e::A | $e::C);
  86         const EMPTY_SET: EnumSet<$e> = enum_set!();
  87         #[test]
  88         fn const_set() {
  89             assert_eq!(CONST_SET.len(), 2);
  90             assert!(CONST_SET.contains($e::A));
  91             assert!(CONST_SET.contains($e::C));
  92             assert!(EMPTY_SET.is_empty());
  93         }
  94
  95         #[test]
  96         fn basic_add_remove() {
  97             let mut set = EnumSet::new();
  98             set.insert($e::A);
  99             set.insert($e::B);
 100             set.insert($e::C);
 101             assert_eq!(set, $e::A | $e::B | $e::C);
 102             set.remove($e::B);
 103             assert_eq!(set, $e::A | $e::C);
 104             set.insert($e::D);
 105             assert_eq!(set, $e::A | $e::C | $e::D);
 106             set.insert_all($e::F | $e::E | $e::G);
 107             assert_eq!(set, $e::A | $e::C | $e::D | $e::F | $e::E | $e::G);
 108             set.remove_all($e::A | $e::D | $e::G);
 109             assert_eq!(set, $e::C | $e::F | $e::E);
 110             assert!(!set.is_empty());
 111             set.clear();
 112             assert!(set.is_empty());
 113         }
 114
 115         #[test]
 116         fn empty_is_empty() {
 117             assert_eq!(EnumSet::<$e>::empty().len(), 0)
 118         }
 119
 120         #[test]
 121         fn all_len() {
 122             assert_eq!(EnumSet::<$e>::all().len(), EnumSet::<$e>::variant_count() as usize)
 123         }
 124
 125         #[test]
 126         fn basic_iter_test() {
 127             let mut set = EnumSet::new();
 128             set.insert($e::A);
 129             set.insert($e::B);
 130             set.insert($e::C);
 131             set.insert($e::E);
 132
 133             let mut set_2 = EnumSet::new();
 134             let vec: Vec<$e> = set.iter().collect();
 135             for val in vec {
 136                 assert!(!set_2.contains(val));
 137                 set_2.insert(val);
 138             }
 139             assert_eq!(set, set_2);
 140
 141             let mut set_3 = EnumSet::new();
 142             for val in set {
 143                 assert!(!set_3.contains(val));
 144                 set_3.insert(val);
 145             }
 146             assert_eq!(set, set_3);
 147         }
 148
 149         fn check_iter_size_hint(set: EnumSet<$e>) {
 150             let count = set.len();
 151             let mut itr = set.iter();
 152             for idx in 0 .. count {
 153                 assert_eq!(itr.size_hint(), (count-idx, Some(count-idx)));
 154                 assert!(itr.next().is_some());
 155             }
 156             assert_eq!(itr.size_hint(), (0, Some(0)));
 157         }
 158         #[test]
 159         fn test_iter_size_hint() {
 160             check_iter_size_hint(EnumSet::<$e>::all());
 161             let mut set = EnumSet::new();
 162             set.insert($e::A);
 163             set.insert($e::C);
 164             set.insert($e::E);
 165             check_iter_size_hint(set);
 166         }
 167
 168         #[test]
 169         fn iter_ops_test() {
 170             let set = $e::A | $e::B | $e::C | $e::E;
 171             let set2 = set.iter().filter(|&v| v != $e::B).collect::<EnumSet<_>>();
 172             assert_eq!(set2, $e::A | $e::C | $e::E);
 173         }
 174
 175         #[test]
 176         fn basic_ops_test() {
 177             assert_eq!(($e::A | $e::B) | ($e::B | $e::C), $e::A | $e::B | $e::C);
 178             assert_eq!(($e::A | $e::B) & ($e::B | $e::C), $e::B);
 179             assert_eq!(($e::A | $e::B) ^ ($e::B | $e::C), $e::A | $e::C);
 180             assert_eq!(($e::A | $e::B) - ($e::B | $e::C), $e::A);
 181             assert_eq!($e::A | !$e::A, EnumSet::<$e>::all());
 182         }
 183
 184         #[test]
 185         fn mutable_ops_test() {
 186             let mut set = $e::A | $e::B;
 187             assert_eq!(set, $e::A | $e::B);
 188             set |= $e::C | $e::D;
 189             assert_eq!(set, $e::A | $e::B | $e::C | $e::D);
 190             set -= $e::C;
 191             assert_eq!(set, $e::A | $e::B | $e::D);
 192             set ^= $e::B | $e::E;
 193             assert_eq!(set, $e::A | $e::D | $e::E);
 194             set &= $e::A | $e::E | $e::F;
 195             assert_eq!(set, $e::A | $e::E);
 196         }
 197
 198         #[test]
 199         fn basic_set_status() {
 200             assert!(($e::A | $e::B | $e::C).is_disjoint($e::D | $e::E | $e::F));
 201             assert!(!($e::A | $e::B | $e::C | $e::D).is_disjoint($e::D | $e::E | $e::F));
 202             assert!(($e::A | $e::B).is_subset($e::A | $e::B | $e::C));
 203             assert!(!($e::A | $e::D).is_subset($e::A | $e::B | $e::C));
 204         }
 205
 206         #[test]
 207         fn debug_impl() {
 208             assert_eq!(format!("{:?}", $e::A | $e::B | $e::D), "EnumSet(A | B | D)");
 209         }
 210
 211         #[test]
 212         fn to_from_bits() {
 213             let value = $e::A | $e::C | $e::D | $e::F | $e::E | $e::G;
 214             assert_eq!(EnumSet::from_bits(value.to_bits()), value);
 215         }
 216
 217         #[test]
 218         #[should_panic]
 219         fn too_many_bits() {
 220             if EnumSet::<$e>::variant_count() == 128 {
 221                 panic!("(test skipped)")
 222             }
 223             EnumSet::<$e>::from_bits(!0);
 224         }
 225
 226         #[test]
 227         fn match_const_test() {
 228             match CONST_SET {
 229                 CONST_SET => { /* ok */ }
 230                 _ => panic!("match fell through?"),
 231             }
 232         }
 233
 234         #[test]
 235         fn set_test() {
 236             const SET_TEST_A: EnumSet<$e> = enum_set!($e::A | $e::B | $e::C);
 237             const SET_TEST_B: EnumSet<$e> = enum_set!($e::A | $e::B | $e::D);
 238             const SET_TEST_C: EnumSet<$e> = enum_set!($e::A | $e::B | $e::E);
 239             const SET_TEST_D: EnumSet<$e> = enum_set!($e::A | $e::B | $e::F);
 240             const SET_TEST_E: EnumSet<$e> = enum_set!($e::A | $e::B | $e::G);
 241             macro_rules! test_set {
 242                 ($set:ident) => {{
 243                     assert!(!$set.contains(&SET_TEST_A));
 244                     assert!(!$set.contains(&SET_TEST_B));
 245                     assert!(!$set.contains(&SET_TEST_C));
 246                     assert!(!$set.contains(&SET_TEST_D));
 247                     assert!(!$set.contains(&SET_TEST_E));
 248                     $set.insert(SET_TEST_A);
 249                     $set.insert(SET_TEST_C);
 250                     assert!($set.contains(&SET_TEST_A));
 251                     assert!(!$set.contains(&SET_TEST_B));
 252                     assert!($set.contains(&SET_TEST_C));
 253                     assert!(!$set.contains(&SET_TEST_D));
 254                     assert!(!$set.contains(&SET_TEST_E));
 255                     $set.remove(&SET_TEST_C);
 256                     $set.remove(&SET_TEST_D);
 257                     assert!($set.contains(&SET_TEST_A));
 258                     assert!(!$set.contains(&SET_TEST_B));
 259                     assert!(!$set.contains(&SET_TEST_C));
 260                     assert!(!$set.contains(&SET_TEST_D));
 261                     assert!(!$set.contains(&SET_TEST_E));
 262                     $set.insert(SET_TEST_A);
 263                     $set.insert(SET_TEST_D);
 264                     assert!($set.contains(&SET_TEST_A));
 265                     assert!(!$set.contains(&SET_TEST_B));
 266                     assert!(!$set.contains(&SET_TEST_C));
 267                     assert!($set.contains(&SET_TEST_D));
 268                     assert!(!$set.contains(&SET_TEST_E));
 269                 }}
 270             }
 271
 272             let mut hash_set = HashSet::new();
 273             test_set!(hash_set);
 274
 275             let mut tree_set = BTreeSet::new();
 276             test_set!(tree_set);
 277         }
 278
 279         #[test]
 280         fn check_size() {
 281             assert_eq!(::std::mem::size_of::<EnumSet<$e>>(), $mem_size);
 282         }
 283     }
 284 }
 285 macro_rules! tests {
 286     ($m:ident, $($tt:tt)*) => { mod $m { use super::*; $($tt)*; } }
 287 }
 288
 289 tests!(small_enum, test_enum!(SmallEnum, 4));
 290 tests!(large_enum, test_enum!(LargeEnum, 16));
 291 tests!(enum8, test_enum!(Enum8, 1));
 292 tests!(enum128, test_enum!(Enum128, 16));
 293 tests!(sparse_enum, test_enum!(SparseEnum, 16));