Add tests validating the width of all possible types

Author: winstonallo

macros/src/generator.rs

@@ -26,16 +26,8 @@ pub fn expand_bitmap(input: BitmapInput) -> syn::Result<TokenStream2> {
         bit_index += ident.size;
         let setter_name = Ident::new(&format!("set_{}", ident.name), ident.name.span());
         let name = ident.name.to_owned();
-        let mask = match ident.size {
-            1 => quote! { 0b1 as #storage_ty },
-            2 => quote! { 0b11 as #storage_ty },
-            3 => quote! { 0b111 as #storage_ty },
-            4 => quote! { 0b1111 as #storage_ty },
-            5 => quote! { 0b11111 as #storage_ty },
-            6 => quote! { 0b111111 as #storage_ty },
-            7 => quote! { 0b1111111 as #storage_ty },
-            _ => unreachable!(),
-        };
+        let size = ident.size;
+        let mask = quote! { ((0b1 << #size) - 1) as #storage_ty };
         quote! {
             pub fn #name(&self) -> #storage_ty {
                 (self.0 >> #index) & #mask

src/lib.rs

@@ -5,45 +5,69 @@ use macros::bitmap;
 fn one_bit() {
     bitmap!(
         struct Bits {
-            field0: u1,
+            a: u1,
         }
     );
     let mut bits = Bits(0b0);
-    bits.set_field0(0b1);
-    assert!(bits.field0() == 0b1);
+    bits.set_a(0b1);
+    assert_eq!(bits.a(), 0b1);
 }
 
 #[test]
 fn two_bits() {
     bitmap!(
         struct Bits {
-            field0: u1,
-            field1: u1,
+            a: u1,
+            b: u1,
         }
     );
     let mut bits = Bits(0b10);
-    bits.set_field0(0b1);
-    bits.set_field1(0b0);
-    assert!(bits.0 == 0b01);
+    bits.set_a(0b1);
+    bits.set_b(0b0);
+    assert_eq!(bits.0, 0b01);
 }
 
 #[test]
 fn sixty_four_bits() {
     bitmap!(
         struct Bits {
-            field0: u1,
-            field1: u7,
-            field2: u7,
-            field3: u7,
-            field4: u7,
-            field5: u7,
-            field6: u7,
-            field7: u7,
-            field8: u7,
-            field9: u7,
+            a: u1,
+            b: u7,
+            c: u7,
+            d: u7,
+            e: u7,
+            f: u7,
+            g: u7,
+            h: u7,
+            i: u7,
+            j: u7,
         }
     );
     let mut bits = Bits(0xFF00FF00FF00FF00);
-    bits.set_field9(0b0000000);
-    assert!(bits.0 == 0x0100FF00FF00FF00);
+    bits.set_j(0b0000000);
+    assert_eq!(bits.0, 0x0100FF00FF00FF00);
 }
+
+macro_rules! test_width {
+    ($name:ident, $val:literal) => {
+        #[test]
+        fn $name() {
+            bitmap!(
+                struct Bits {
+                    field: $name,
+                }
+            );
+            let mut bits = Bits(0);
+            bits.set_field($val);
+            assert_eq!(bits.field(), $val);
+        }
+    };
+}
+
+test_width!(u1, 1);
+test_width!(u2, 3);
+test_width!(u3, 7);
+test_width!(u4, 15);
+test_width!(u5, 31);
+test_width!(u6, 63);
+test_width!(u7, 127);