Add `no_super_impls` option to `EnumSetType` derive.

[enumset.git] / enumset / tests / ops.rs

diff --git a/enumset/tests/ops.rs b/enumset/tests/ops.rs
index aa7019b8c3334d8d8c5bf48da393d60fe0a009fa..b76881e3df25b8d5f2edec352c7475f4ceeadd13 100644 (file)
--- a/enumset/tests/ops.rs
+++ b/enumset/tests/ops.rs
@@ -15,6 +15,11 @@ pub enum Enum1 {
 pub enum SmallEnum {
     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,
 }
+#[derive(Clone, Copy, Debug, EnumSetType, Eq, PartialEq)]
+#[enumset(no_super_impls)]
+pub enum SmallEnumExplicitDerive {
+    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,
+}
 #[derive(EnumSetType, Debug)]
 pub enum LargeEnum {
     _00,  _01,  _02,  _03,  _04,  _05,  _06,  _07,
@@ -86,6 +91,9 @@ macro_rules! test_variants {
 test_variants! { SmallEnum small_enum_all_empty
     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,
 }
+test_variants! { SmallEnumExplicitDerive small_enum_explicit_derive_all_empty
+    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,
+}
 test_variants! { LargeEnum large_enum_all_empty
     _00,  _01,  _02,  _03,  _04,  _05,  _06,  _07,
     _10,  _11,  _12,  _13,  _14,  _15,  _16,  _17,
@@ -104,10 +112,12 @@ test_variants! { SparseEnum sparse_enum_all_empty
 macro_rules! test_enum {
     ($e:ident, $mem_size:expr) => {
         const CONST_SET: EnumSet<$e> = enum_set!($e::A | $e::C);
+        const CONST_1_SET: EnumSet<$e> = enum_set!($e::A);
         const EMPTY_SET: EnumSet<$e> = enum_set!();
         #[test]
         fn const_set() {
             assert_eq!(CONST_SET.len(), 2);
+            assert_eq!(CONST_1_SET.len(), 1);
             assert!(CONST_SET.contains($e::A));
             assert!(CONST_SET.contains($e::C));
             assert!(EMPTY_SET.is_empty());
@@ -315,14 +325,31 @@ macro_rules! test_enum {
                     assert!(!$set.contains(&SET_TEST_E));
                 }}
             }
-            
+
             let mut hash_set = HashSet::new();
             test_set!(hash_set);
-            
+
             let mut tree_set = BTreeSet::new();
             test_set!(tree_set);
         }
 
+        #[test]
+        fn sum_test() {
+            let target = $e::A | $e::B | $e::D | $e::E | $e::G | $e::H;
+
+            let list_a = [$e::A | $e::B, $e::D | $e::E, $e::G | $e::H];
+            let sum_a: EnumSet<$e> = list_a.iter().map(|x| *x).sum();
+            assert_eq!(target, sum_a);
+            let sum_b: EnumSet<$e> = list_a.iter().sum();
+            assert_eq!(target, sum_b);
+
+            let list_b = [$e::A, $e::B, $e::D, $e::E, $e::G, $e::H];
+            let sum_c: EnumSet<$e> = list_b.iter().map(|x| *x).sum();
+            assert_eq!(target, sum_c);
+            let sum_d: EnumSet<$e> = list_b.iter().sum();
+            assert_eq!(target, sum_d);
+        }
+
         #[test]
         fn check_size() {
             assert_eq!(::std::mem::size_of::<EnumSet<$e>>(), $mem_size);
@@ -334,6 +361,7 @@ macro_rules! tests {
 }
 
 tests!(small_enum, test_enum!(SmallEnum, 4));
+tests!(small_enum_explicit_derive, test_enum!(SmallEnumExplicitDerive, 4));
 tests!(large_enum, test_enum!(LargeEnum, 16));
 tests!(enum8, test_enum!(Enum8, 1));
 tests!(enum128, test_enum!(Enum128, 16));