enumset/tests/ops.rs

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