enumset/tests/ops.rs

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