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 #[repr(u32)]
  52 #[derive(EnumSetType, Debug)]
  53 pub enum ReprEnum {
  54     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,
  55 }
  56 #[repr(u64)]
  57 #[derive(EnumSetType, Debug)]
  58 pub enum ReprEnum2 {
  59     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,
  60 }
  61 #[repr(isize)]
  62 #[derive(EnumSetType, Debug)]
  63 pub enum ReprEnum3 {
  64     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,
  65 }
  66 #[repr(C)]
  67 #[derive(EnumSetType, Debug)]
  68 pub enum ReprEnum4 {
  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
  72 macro_rules! test_variants {
  73     ($enum_name:ident $all_empty_test:ident $($variant:ident,)*) => {
  74         #[test]
  75         fn $all_empty_test() {
  76             let all = EnumSet::<$enum_name>::all();
  77             let empty = EnumSet::<$enum_name>::empty();
  78
  79             $(
  80                 assert!(!empty.contains($enum_name::$variant));
  81                 assert!(all.contains($enum_name::$variant));
  82             )*
  83         }
  84     }
  85 }
  86 test_variants! { SmallEnum small_enum_all_empty
  87     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,
  88 }
  89 test_variants! { LargeEnum large_enum_all_empty
  90     _00,  _01,  _02,  _03,  _04,  _05,  _06,  _07,
  91     _10,  _11,  _12,  _13,  _14,  _15,  _16,  _17,
  92     _20,  _21,  _22,  _23,  _24,  _25,  _26,  _27,
  93     _30,  _31,  _32,  _33,  _34,  _35,  _36,  _37,
  94     _40,  _41,  _42,  _43,  _44,  _45,  _46,  _47,
  95     _50,  _51,  _52,  _53,  _54,  _55,  _56,  _57,
  96     _60,  _61,  _62,  _63,  _64,  _65,  _66,  _67,
  97     _70,  _71,  _72,  _73,  _74,  _75,  _76,  _77,
  98     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,
  99 }
 100 test_variants! { SparseEnum sparse_enum_all_empty
 101     A, B, C, D, E, F, G,
 102 }
 103
 104 macro_rules! test_enum {
 105     ($e:ident, $mem_size:expr) => {
 106         const CONST_SET: EnumSet<$e> = enum_set!($e::A | $e::C);
 107         const CONST_1_SET: EnumSet<$e> = enum_set!($e::A);
 108         const EMPTY_SET: EnumSet<$e> = enum_set!();
 109         #[test]
 110         fn const_set() {
 111             assert_eq!(CONST_SET.len(), 2);
 112             assert_eq!(CONST_1_SET.len(), 1);
 113             assert!(CONST_SET.contains($e::A));
 114             assert!(CONST_SET.contains($e::C));
 115             assert!(EMPTY_SET.is_empty());
 116         }
 117
 118         #[test]
 119         fn basic_add_remove() {
 120             let mut set = EnumSet::new();
 121             set.insert($e::A);
 122             set.insert($e::B);
 123             set.insert($e::C);
 124             assert_eq!(set, $e::A | $e::B | $e::C);
 125             set.remove($e::B);
 126             assert_eq!(set, $e::A | $e::C);
 127             set.insert($e::D);
 128             assert_eq!(set, $e::A | $e::C | $e::D);
 129             set.insert_all($e::F | $e::E | $e::G);
 130             assert_eq!(set, $e::A | $e::C | $e::D | $e::F | $e::E | $e::G);
 131             set.remove_all($e::A | $e::D | $e::G);
 132             assert_eq!(set, $e::C | $e::F | $e::E);
 133             assert!(!set.is_empty());
 134             set.clear();
 135             assert!(set.is_empty());
 136         }
 137
 138         #[test]
 139         fn already_present_element() {
 140             let mut set = EnumSet::new();
 141             assert!(set.insert($e::A));
 142             assert!(!set.insert($e::A));
 143             set.remove($e::A);
 144             assert!(set.insert($e::A));
 145         }
 146
 147         #[test]
 148         fn empty_is_empty() {
 149             assert_eq!(EnumSet::<$e>::empty().len(), 0)
 150         }
 151
 152         #[test]
 153         fn all_len() {
 154             assert_eq!(EnumSet::<$e>::all().len(), EnumSet::<$e>::variant_count() as usize)
 155         }
 156
 157         #[test]
 158         fn iter_test() {
 159             let mut set = EnumSet::new();
 160             set.insert($e::A);
 161             set.insert($e::B);
 162             set.extend($e::C | $e::E);
 163
 164             let mut set_2 = EnumSet::new();
 165             let vec: Vec<_> = set.iter().collect();
 166             for val in vec {
 167                 assert!(!set_2.contains(val));
 168                 set_2.insert(val);
 169             }
 170             assert_eq!(set, set_2);
 171
 172             let mut set_3 = EnumSet::new();
 173             for val in set {
 174                 assert!(!set_3.contains(val));
 175                 set_3.insert(val);
 176             }
 177             assert_eq!(set, set_3);
 178
 179             let mut set_4 = EnumSet::new();
 180             let vec: EnumSet<_> = set.into_iter().map(EnumSet::only).collect();
 181             for val in vec {
 182                 assert!(!set_4.contains(val));
 183                 set_4.insert(val);
 184             }
 185             assert_eq!(set, set_4);
 186
 187             let mut set_5 = EnumSet::new();
 188             let vec: EnumSet<_> = set.iter().collect();
 189             for val in vec {
 190                 assert!(!set_5.contains(val));
 191                 set_5.insert(val);
 192             }
 193             assert_eq!(set, set_5);
 194         }
 195
 196         fn check_iter_size_hint(set: EnumSet<$e>) {
 197             let count = set.len();
 198             let mut itr = set.iter();
 199             for idx in 0 .. count {
 200                 assert_eq!(itr.size_hint(), (count-idx, Some(count-idx)));
 201                 assert_eq!(itr.len(), count-idx);
 202                 assert!(itr.next().is_some());
 203             }
 204             assert_eq!(itr.size_hint(), (0, Some(0)));
 205             assert_eq!(itr.len(), 0);
 206         }
 207         #[test]
 208         fn test_iter_size_hint() {
 209             check_iter_size_hint(EnumSet::<$e>::all());
 210             let mut set = EnumSet::new();
 211             set.insert($e::A);
 212             set.insert($e::C);
 213             set.insert($e::E);
 214             check_iter_size_hint(set);
 215         }
 216
 217         #[test]
 218         fn iter_ops_test() {
 219             let set = $e::A | $e::B | $e::C | $e::E;
 220             let set2 = set.iter().filter(|&v| v != $e::B).collect::<EnumSet<_>>();
 221             assert_eq!(set2, $e::A | $e::C | $e::E);
 222         }
 223
 224         #[test]
 225         fn basic_ops_test() {
 226             assert_eq!(($e::A | $e::B) | ($e::B | $e::C), $e::A | $e::B | $e::C);
 227             assert_eq!(($e::A | $e::B) & ($e::B | $e::C), $e::B);
 228             assert_eq!(($e::A | $e::B) ^ ($e::B | $e::C), $e::A | $e::C);
 229             assert_eq!(($e::A | $e::B) - ($e::B | $e::C), $e::A);
 230             assert_eq!($e::A | !$e::A, EnumSet::<$e>::all());
 231         }
 232
 233         #[test]
 234         fn mutable_ops_test() {
 235             let mut set = $e::A | $e::B;
 236             assert_eq!(set, $e::A | $e::B);
 237             set |= $e::C | $e::D;
 238             assert_eq!(set, $e::A | $e::B | $e::C | $e::D);
 239             set -= $e::C;
 240             assert_eq!(set, $e::A | $e::B | $e::D);
 241             set ^= $e::B | $e::E;
 242             assert_eq!(set, $e::A | $e::D | $e::E);
 243             set &= $e::A | $e::E | $e::F;
 244             assert_eq!(set, $e::A | $e::E);
 245         }
 246
 247         #[test]
 248         fn basic_set_status() {
 249             assert!(($e::A | $e::B | $e::C).is_disjoint($e::D | $e::E | $e::F));
 250             assert!(!($e::A | $e::B | $e::C | $e::D).is_disjoint($e::D | $e::E | $e::F));
 251             assert!(($e::A | $e::B).is_subset($e::A | $e::B | $e::C));
 252             assert!(!($e::A | $e::D).is_subset($e::A | $e::B | $e::C));
 253         }
 254
 255         #[test]
 256         fn debug_impl() {
 257             assert_eq!(format!("{:?}", $e::A | $e::B | $e::D), "EnumSet(A | B | D)");
 258         }
 259
 260         #[test]
 261         fn to_from_bits() {
 262             let value = $e::A | $e::C | $e::D | $e::F | $e::E | $e::G;
 263             assert_eq!(EnumSet::from_u128(value.as_u128()), value);
 264         }
 265
 266         #[test]
 267         #[should_panic]
 268         fn too_many_bits() {
 269             if EnumSet::<$e>::variant_count() == 128 {
 270                 panic!("(test skipped)")
 271             }
 272             EnumSet::<$e>::from_u128(!0);
 273         }
 274
 275         #[test]
 276         fn match_const_test() {
 277             match CONST_SET {
 278                 CONST_SET => { /* ok */ }
 279                 _ => panic!("match fell through?"),
 280             }
 281         }
 282
 283         #[test]
 284         fn set_test() {
 285             const SET_TEST_A: EnumSet<$e> = enum_set!($e::A | $e::B | $e::C);
 286             const SET_TEST_B: EnumSet<$e> = enum_set!($e::A | $e::B | $e::D);
 287             const SET_TEST_C: EnumSet<$e> = enum_set!($e::A | $e::B | $e::E);
 288             const SET_TEST_D: EnumSet<$e> = enum_set!($e::A | $e::B | $e::F);
 289             const SET_TEST_E: EnumSet<$e> = enum_set!($e::A | $e::B | $e::G);
 290             macro_rules! test_set {
 291                 ($set:ident) => {{
 292                     assert!(!$set.contains(&SET_TEST_A));
 293                     assert!(!$set.contains(&SET_TEST_B));
 294                     assert!(!$set.contains(&SET_TEST_C));
 295                     assert!(!$set.contains(&SET_TEST_D));
 296                     assert!(!$set.contains(&SET_TEST_E));
 297                     $set.insert(SET_TEST_A);
 298                     $set.insert(SET_TEST_C);
 299                     assert!($set.contains(&SET_TEST_A));
 300                     assert!(!$set.contains(&SET_TEST_B));
 301                     assert!($set.contains(&SET_TEST_C));
 302                     assert!(!$set.contains(&SET_TEST_D));
 303                     assert!(!$set.contains(&SET_TEST_E));
 304                     $set.remove(&SET_TEST_C);
 305                     $set.remove(&SET_TEST_D);
 306                     assert!($set.contains(&SET_TEST_A));
 307                     assert!(!$set.contains(&SET_TEST_B));
 308                     assert!(!$set.contains(&SET_TEST_C));
 309                     assert!(!$set.contains(&SET_TEST_D));
 310                     assert!(!$set.contains(&SET_TEST_E));
 311                     $set.insert(SET_TEST_A);
 312                     $set.insert(SET_TEST_D);
 313                     assert!($set.contains(&SET_TEST_A));
 314                     assert!(!$set.contains(&SET_TEST_B));
 315                     assert!(!$set.contains(&SET_TEST_C));
 316                     assert!($set.contains(&SET_TEST_D));
 317                     assert!(!$set.contains(&SET_TEST_E));
 318                 }}
 319             }
 320
 321             let mut hash_set = HashSet::new();
 322             test_set!(hash_set);
 323
 324             let mut tree_set = BTreeSet::new();
 325             test_set!(tree_set);
 326         }
 327
 328         #[test]
 329         fn sum_test() {
 330             let target = $e::A | $e::B | $e::D | $e::E | $e::G | $e::H;
 331
 332             let list_a = [$e::A | $e::B, $e::D | $e::E, $e::G | $e::H];
 333             let sum_a: EnumSet<$e> = list_a.iter().map(|x| *x).sum();
 334             assert_eq!(target, sum_a);
 335             let sum_b: EnumSet<$e> = list_a.iter().sum();
 336             assert_eq!(target, sum_b);
 337
 338             let list_b = [$e::A, $e::B, $e::D, $e::E, $e::G, $e::H];
 339             let sum_c: EnumSet<$e> = list_b.iter().map(|x| *x).sum();
 340             assert_eq!(target, sum_c);
 341             let sum_d: EnumSet<$e> = list_b.iter().sum();
 342             assert_eq!(target, sum_d);
 343         }
 344
 345         #[test]
 346         fn check_size() {
 347             assert_eq!(::std::mem::size_of::<EnumSet<$e>>(), $mem_size);
 348         }
 349     }
 350 }
 351 macro_rules! tests {
 352     ($m:ident, $($tt:tt)*) => { mod $m { use super::*; $($tt)*; } }
 353 }
 354
 355 tests!(small_enum, test_enum!(SmallEnum, 4));
 356 tests!(large_enum, test_enum!(LargeEnum, 16));
 357 tests!(enum8, test_enum!(Enum8, 1));
 358 tests!(enum128, test_enum!(Enum128, 16));
 359 tests!(sparse_enum, test_enum!(SparseEnum, 16));
 360 tests!(repr_enum_u32, test_enum!(ReprEnum, 4));
 361 tests!(repr_enum_u64, test_enum!(ReprEnum2, 4));
 362 tests!(repr_enum_isize, test_enum!(ReprEnum3, 4));
 363 tests!(repr_enum_c, test_enum!(ReprEnum4, 4));
 364
 365 #[derive(EnumSetType, Debug)]
 366 pub enum ThresholdEnum {
 367     A = 1, B, C, D,
 368     U8 = 0, U16 = 8, U32 = 16, U64 = 32, U128 = 64,
 369 }
 370 macro_rules! bits_tests {
 371     (
 372         $mod_name:ident, $threshold_expr:expr, ($($too_big_expr:expr),*), $ty:ty,
 373         $to:ident $try_to:ident $to_truncated:ident
 374         $from:ident $try_from:ident $from_truncated:ident
 375     ) => {
 376         mod $mod_name {
 377             use super::*;
 378             use crate::ThresholdEnum::*;
 379
 380             #[test]
 381             fn to_from_basic() {
 382                 for &mask in &[
 383                     $threshold_expr | B | C | D,
 384                     $threshold_expr | A | D,
 385                     $threshold_expr | B | C,
 386                 ] {
 387                     assert_eq!(mask, EnumSet::<ThresholdEnum>::$from(mask.$to()));
 388                     assert_eq!(mask.$to_truncated(), mask.$to());
 389                     assert_eq!(Some(mask.$to()), mask.$try_to())
 390                 }
 391             }
 392
 393             #[test]
 394             #[should_panic]
 395             fn from_invalid() {
 396                 let invalid_mask: $ty = 0x80;
 397                 EnumSet::<ThresholdEnum>::$from(invalid_mask);
 398             }
 399
 400             #[test]
 401             fn try_from_invalid() {
 402                 assert!(EnumSet::<ThresholdEnum>::$try_from(0xFF).is_none());
 403             }
 404
 405             $(
 406                 #[test]
 407                 fn try_to_overflow() {
 408                         let set: EnumSet<ThresholdEnum> = $too_big_expr.into();
 409                         assert!(set.$try_to().is_none());
 410                 }
 411             )*
 412
 413             #[test]
 414             fn truncated_overflow() {
 415                 let trunc_invalid = EnumSet::<ThresholdEnum>::$from_truncated(0xFE);
 416                 assert_eq!(A | B | C | D, trunc_invalid);
 417                 $(
 418                     let set: EnumSet<ThresholdEnum> = $too_big_expr | A;
 419                     assert_eq!(2, set.$to_truncated());
 420                 )*
 421             }
 422         }
 423     }
 424 }
 425
 426 bits_tests!(test_u8_bits, U8, (U16), u8,
 427             as_u8 try_as_u8 as_u8_truncated from_u8 try_from_u8 from_u8_truncated);
 428 bits_tests!(test_u16_bits, U16, (U32), u16,
 429             as_u16 try_as_u16 as_u16_truncated from_u16 try_from_u16 from_u16_truncated);
 430 bits_tests!(test_u32_bits, U32, (U64), u32,
 431             as_u32 try_as_u32 as_u32_truncated from_u32 try_from_u32 from_u32_truncated);
 432 bits_tests!(test_u64_bits, U64, (U128), u64,
 433             as_u64 try_as_u64 as_u64_truncated from_u64 try_from_u64 from_u64_truncated);
 434 bits_tests!(test_u128_bits, U128, (), u128,
 435             as_u128 try_as_u128 as_u128_truncated from_u128 try_from_u128 from_u128_truncated);
 436 bits_tests!(test_uize_bits, U32, (U128), usize,
 437             as_usize try_as_usize as_usize_truncated
 438             from_usize try_from_usize from_usize_truncated);