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         #[test]
 141         fn basic_ops_test() {
 142             assert_eq!(($e::A | $e::B) | ($e::B | $e::C), $e::A | $e::B | $e::C);
 143             assert_eq!(($e::A | $e::B) & ($e::B | $e::C), $e::B);
 144             assert_eq!(($e::A | $e::B) ^ ($e::B | $e::C), $e::A | $e::C);
 145             assert_eq!(($e::A | $e::B) - ($e::B | $e::C), $e::A);
 146         }
 147
 148         #[test]
 149         fn basic_set_status() {
 150             assert!(($e::A | $e::B | $e::C).is_disjoint($e::D | $e::E | $e::F));
 151             assert!(!($e::A | $e::B | $e::C | $e::D).is_disjoint($e::D | $e::E | $e::F));
 152             assert!(($e::A | $e::B).is_subset($e::A | $e::B | $e::C));
 153             assert!(!($e::A | $e::D).is_subset($e::A | $e::B | $e::C));
 154         }
 155
 156         #[test]
 157         fn debug_impl() {
 158             assert_eq!(format!("{:?}", $e::A | $e::B | $e::D), "EnumSet(A | B | D)");
 159         }
 160
 161         #[test]
 162         fn to_from_bits() {
 163             let value = $e::A | $e::C | $e::D | $e::F | $e::E | $e::G;
 164             assert_eq!(EnumSet::from_bits(value.to_bits()), value);
 165         }
 166
 167         #[test]
 168         #[should_panic]
 169         fn too_many_bits() {
 170             if EnumSet::<$e>::variant_count() == 128 {
 171                 panic!("(test skipped)")
 172             }
 173             EnumSet::<$e>::from_bits(!0);
 174         }
 175
 176         #[test]
 177         fn match_const_test() {
 178             match CONST_SET {
 179                 CONST_SET => { /* ok */ }
 180                 _ => panic!("match fell through?"),
 181             }
 182         }
 183
 184         #[test]
 185         fn check_size() {
 186             assert_eq!(::std::mem::size_of::<EnumSet<$e>>(), $mem_size);
 187         }
 188     }
 189 }
 190 macro_rules! tests {
 191     ($m:ident, $($tt:tt)*) => { mod $m { use super::*; $($tt)*; } }
 192 }
 193
 194 tests!(small_enum, test_enum!(SmallEnum, 4));
 195 tests!(large_enum, test_enum!(LargeEnum, 16));
 196 tests!(enum8, test_enum!(Enum8, 1));
 197 tests!(enum128, test_enum!(Enum128, 16));
 198 tests!(sparse_enum, test_enum!(SparseEnum, 16));