4 use std::collections::{HashSet, BTreeSet};
6 #[derive(EnumSetType, Debug)]
9 #[derive(EnumSetType, Debug)]
14 #[derive(EnumSetType, Debug)]
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,
18 #[derive(EnumSetType, Debug)]
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,
30 #[derive(EnumSetType, Debug)]
32 A, B, C, D, E, F, G, H,
34 #[derive(EnumSetType, Debug)]
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,
46 #[derive(EnumSetType, Debug)]
48 A = 0xA, B = 20, C = 30, D = 40, E = 50, F = 60, G = 70, H = 80,
52 #[derive(EnumSetType, Debug)]
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,
57 #[derive(EnumSetType, Debug)]
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,
62 #[derive(EnumSetType, Debug)]
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,
67 #[derive(EnumSetType, Debug)]
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,
72 macro_rules! test_variants {
73 ($enum_name:ident $all_empty_test:ident $($variant:ident,)*) => {
75 fn $all_empty_test() {
76 let all = EnumSet::<$enum_name>::all();
77 let empty = EnumSet::<$enum_name>::empty();
80 assert!(!empty.contains($enum_name::$variant));
81 assert!(all.contains($enum_name::$variant));
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,
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,
100 test_variants! { SparseEnum sparse_enum_all_empty
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 EMPTY_SET: EnumSet<$e> = enum_set!();
110 assert_eq!(CONST_SET.len(), 2);
111 assert!(CONST_SET.contains($e::A));
112 assert!(CONST_SET.contains($e::C));
113 assert!(EMPTY_SET.is_empty());
117 fn basic_add_remove() {
118 let mut set = EnumSet::new();
122 assert_eq!(set, $e::A | $e::B | $e::C);
124 assert_eq!(set, $e::A | $e::C);
126 assert_eq!(set, $e::A | $e::C | $e::D);
127 set.insert_all($e::F | $e::E | $e::G);
128 assert_eq!(set, $e::A | $e::C | $e::D | $e::F | $e::E | $e::G);
129 set.remove_all($e::A | $e::D | $e::G);
130 assert_eq!(set, $e::C | $e::F | $e::E);
131 assert!(!set.is_empty());
133 assert!(set.is_empty());
137 fn already_present_element() {
138 let mut set = EnumSet::new();
139 assert!(set.insert($e::A));
140 assert!(!set.insert($e::A));
142 assert!(set.insert($e::A));
146 fn empty_is_empty() {
147 assert_eq!(EnumSet::<$e>::empty().len(), 0)
152 assert_eq!(EnumSet::<$e>::all().len(), EnumSet::<$e>::variant_count() as usize)
157 let mut set = EnumSet::new();
160 set.extend($e::C | $e::E);
162 let mut set_2 = EnumSet::new();
163 let vec: Vec<_> = set.iter().collect();
165 assert!(!set_2.contains(val));
168 assert_eq!(set, set_2);
170 let mut set_3 = EnumSet::new();
172 assert!(!set_3.contains(val));
175 assert_eq!(set, set_3);
177 let mut set_4 = EnumSet::new();
178 let vec: EnumSet<_> = set.into_iter().map(EnumSet::only).collect();
180 assert!(!set_4.contains(val));
183 assert_eq!(set, set_4);
185 let mut set_5 = EnumSet::new();
186 let vec: EnumSet<_> = set.iter().collect();
188 assert!(!set_5.contains(val));
191 assert_eq!(set, set_5);
194 fn check_iter_size_hint(set: EnumSet<$e>) {
195 let count = set.len();
196 let mut itr = set.iter();
197 for idx in 0 .. count {
198 assert_eq!(itr.size_hint(), (count-idx, Some(count-idx)));
199 assert!(itr.next().is_some());
201 assert_eq!(itr.size_hint(), (0, Some(0)));
204 fn test_iter_size_hint() {
205 check_iter_size_hint(EnumSet::<$e>::all());
206 let mut set = EnumSet::new();
210 check_iter_size_hint(set);
215 let set = $e::A | $e::B | $e::C | $e::E;
216 let set2 = set.iter().filter(|&v| v != $e::B).collect::<EnumSet<_>>();
217 assert_eq!(set2, $e::A | $e::C | $e::E);
221 fn basic_ops_test() {
222 assert_eq!(($e::A | $e::B) | ($e::B | $e::C), $e::A | $e::B | $e::C);
223 assert_eq!(($e::A | $e::B) & ($e::B | $e::C), $e::B);
224 assert_eq!(($e::A | $e::B) ^ ($e::B | $e::C), $e::A | $e::C);
225 assert_eq!(($e::A | $e::B) - ($e::B | $e::C), $e::A);
226 assert_eq!($e::A | !$e::A, EnumSet::<$e>::all());
230 fn mutable_ops_test() {
231 let mut set = $e::A | $e::B;
232 assert_eq!(set, $e::A | $e::B);
233 set |= $e::C | $e::D;
234 assert_eq!(set, $e::A | $e::B | $e::C | $e::D);
236 assert_eq!(set, $e::A | $e::B | $e::D);
237 set ^= $e::B | $e::E;
238 assert_eq!(set, $e::A | $e::D | $e::E);
239 set &= $e::A | $e::E | $e::F;
240 assert_eq!(set, $e::A | $e::E);
244 fn basic_set_status() {
245 assert!(($e::A | $e::B | $e::C).is_disjoint($e::D | $e::E | $e::F));
246 assert!(!($e::A | $e::B | $e::C | $e::D).is_disjoint($e::D | $e::E | $e::F));
247 assert!(($e::A | $e::B).is_subset($e::A | $e::B | $e::C));
248 assert!(!($e::A | $e::D).is_subset($e::A | $e::B | $e::C));
253 assert_eq!(format!("{:?}", $e::A | $e::B | $e::D), "EnumSet(A | B | D)");
258 let value = $e::A | $e::C | $e::D | $e::F | $e::E | $e::G;
259 assert_eq!(EnumSet::from_u128(value.as_u128()), value);
265 if EnumSet::<$e>::variant_count() == 128 {
266 panic!("(test skipped)")
268 EnumSet::<$e>::from_u128(!0);
272 fn match_const_test() {
274 CONST_SET => { /* ok */ }
275 _ => panic!("match fell through?"),
281 const SET_TEST_A: EnumSet<$e> = enum_set!($e::A | $e::B | $e::C);
282 const SET_TEST_B: EnumSet<$e> = enum_set!($e::A | $e::B | $e::D);
283 const SET_TEST_C: EnumSet<$e> = enum_set!($e::A | $e::B | $e::E);
284 const SET_TEST_D: EnumSet<$e> = enum_set!($e::A | $e::B | $e::F);
285 const SET_TEST_E: EnumSet<$e> = enum_set!($e::A | $e::B | $e::G);
286 macro_rules! test_set {
288 assert!(!$set.contains(&SET_TEST_A));
289 assert!(!$set.contains(&SET_TEST_B));
290 assert!(!$set.contains(&SET_TEST_C));
291 assert!(!$set.contains(&SET_TEST_D));
292 assert!(!$set.contains(&SET_TEST_E));
293 $set.insert(SET_TEST_A);
294 $set.insert(SET_TEST_C);
295 assert!($set.contains(&SET_TEST_A));
296 assert!(!$set.contains(&SET_TEST_B));
297 assert!($set.contains(&SET_TEST_C));
298 assert!(!$set.contains(&SET_TEST_D));
299 assert!(!$set.contains(&SET_TEST_E));
300 $set.remove(&SET_TEST_C);
301 $set.remove(&SET_TEST_D);
302 assert!($set.contains(&SET_TEST_A));
303 assert!(!$set.contains(&SET_TEST_B));
304 assert!(!$set.contains(&SET_TEST_C));
305 assert!(!$set.contains(&SET_TEST_D));
306 assert!(!$set.contains(&SET_TEST_E));
307 $set.insert(SET_TEST_A);
308 $set.insert(SET_TEST_D);
309 assert!($set.contains(&SET_TEST_A));
310 assert!(!$set.contains(&SET_TEST_B));
311 assert!(!$set.contains(&SET_TEST_C));
312 assert!($set.contains(&SET_TEST_D));
313 assert!(!$set.contains(&SET_TEST_E));
317 let mut hash_set = HashSet::new();
320 let mut tree_set = BTreeSet::new();
326 assert_eq!(::std::mem::size_of::<EnumSet<$e>>(), $mem_size);
331 ($m:ident, $($tt:tt)*) => { mod $m { use super::*; $($tt)*; } }
334 tests!(small_enum, test_enum!(SmallEnum, 4));
335 tests!(large_enum, test_enum!(LargeEnum, 16));
336 tests!(enum8, test_enum!(Enum8, 1));
337 tests!(enum128, test_enum!(Enum128, 16));
338 tests!(sparse_enum, test_enum!(SparseEnum, 16));
339 tests!(repr_enum_u32, test_enum!(ReprEnum, 4));
340 tests!(repr_enum_u64, test_enum!(ReprEnum2, 4));
341 tests!(repr_enum_isize, test_enum!(ReprEnum3, 4));
342 tests!(repr_enum_c, test_enum!(ReprEnum4, 4));
344 #[derive(EnumSetType, Debug)]
345 pub enum ThresholdEnum {
347 U8 = 0, U16 = 8, U32 = 16, U64 = 32, U128 = 64,
349 macro_rules! bits_tests {
351 $mod_name:ident, $threshold_expr:expr, ($($too_big_expr:expr),*), $ty:ty,
352 $to:ident $try_to:ident $to_truncated:ident
353 $from:ident $try_from:ident $from_truncated:ident
357 use crate::ThresholdEnum::*;
362 $threshold_expr | B | C | D,
363 $threshold_expr | A | D,
364 $threshold_expr | B | C,
366 assert_eq!(mask, EnumSet::<ThresholdEnum>::$from(mask.$to()));
367 assert_eq!(mask.$to_truncated(), mask.$to());
368 assert_eq!(Some(mask.$to()), mask.$try_to())
375 let invalid_mask: $ty = 0x80;
376 EnumSet::<ThresholdEnum>::$from(invalid_mask);
380 fn try_from_invalid() {
381 assert!(EnumSet::<ThresholdEnum>::$try_from(0xFF).is_none());
386 fn try_to_overflow() {
387 let set: EnumSet<ThresholdEnum> = $too_big_expr.into();
388 assert!(set.$try_to().is_none());
393 fn truncated_overflow() {
394 let trunc_invalid = EnumSet::<ThresholdEnum>::$from_truncated(0xFE);
395 assert_eq!(A | B | C | D, trunc_invalid);
397 let set: EnumSet<ThresholdEnum> = $too_big_expr | A;
398 assert_eq!(2, set.$to_truncated());
405 bits_tests!(test_u8_bits, U8, (U16), u8,
406 as_u8 try_as_u8 as_u8_truncated from_u8 try_from_u8 from_u8_truncated);
407 bits_tests!(test_u16_bits, U16, (U32), u16,
408 as_u16 try_as_u16 as_u16_truncated from_u16 try_from_u16 from_u16_truncated);
409 bits_tests!(test_u32_bits, U32, (U64), u32,
410 as_u32 try_as_u32 as_u32_truncated from_u32 try_from_u32 from_u32_truncated);
411 bits_tests!(test_u64_bits, U64, (U128), u64,
412 as_u64 try_as_u64 as_u64_truncated from_u64 try_from_u64 from_u64_truncated);
413 bits_tests!(test_u128_bits, U128, (), u128,
414 as_u128 try_as_u128 as_u128_truncated from_u128 try_from_u128 from_u128_truncated);
415 bits_tests!(test_uize_bits, U32, (U128), usize,
416 as_usize try_as_usize as_usize_truncated
417 from_usize try_from_usize from_usize_truncated);