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);