enumset/tests/ops.rs

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