Merge pull request #3 from hashmismatch/fuzz

Additional fuzz tests for the byte-copying code generator

Author: rudib

packed_struct/src/types_num.rs

@@ -650,6 +650,18 @@ fn test_packed_int_msb() {
     assert_eq!(val, **unpacked);
 }
 
+#[test]
+fn test_packed_int_partial() {
+    let val = 0b10_10101010;
+    let typed: Integer<u16, Bits10> = val.into();
+    let endian = typed.as_packed_msb();
+    let packed = endian.pack();
+    assert_eq!([0b00000010, 0b10101010], packed);
+    
+    let unpacked: MsbInteger<_, _, Integer<u16, Bits10>> = MsbInteger::unpack(&packed).unwrap();
+    assert_eq!(val, **unpacked);
+}
+
 #[test]
 fn test_packed_int_lsb() {
     let val = 0xAABBCCDD;

packed_struct_codegen/src/pack_codegen.rs

@@ -188,10 +188,9 @@ fn pack_bits(field: &FieldRegular) -> PackBitsCopy {
         }
     } else {
         let packed_field_len = (field.bit_width as f32 / 8.0).ceil() as usize; 
+        let start_byte = (field.bit_range_rust.start as f32 / 8.0).floor() as usize;
+        let shift = ((packed_field_len as isize*8) - (field.bit_width as isize)) - (field.bit_range_rust.start as isize - (start_byte as isize * 8));
 
-        let start_byte = field.bit_range_rust.start / 8;
-        let shift = (8 - (field.bit_width as isize)) % 8 - (field.bit_range_rust.start as isize - (start_byte as isize * 8));
-        
         let emit_shift = |s: isize| {
             if s == 0 {
                 quote! {}
@@ -203,43 +202,65 @@ fn pack_bits(field: &FieldRegular) -> PackBitsCopy {
             }
         };
 
-        let mut l = field.bit_range_rust.len() as isize;
+        let mut l = 8 - ((packed_field_len as isize*8) - field.bit_width as isize);
         let mut dst_byte = start_byte;
 
         let mut pack = vec![];
         let mut unpack = vec![];
 
+        let mut bits_to_pack = field.bit_width;
+        let mut target_bit = field.bit_range.start as usize;
+
         for i in 0..packed_field_len {
-            let src_mask = ones_u8(l as u8);
-            
+            let src_mask = ones_u8(l as u8);                        
             let bit_shift = emit_shift(shift);
             pack.push(quote! {
+                let _a = #i;
                 target[#dst_byte] |= (packed[#i] & #src_mask) #bit_shift;  
             });
 
             let bit_shift = emit_shift(-shift);
             unpack.push(quote! {
+                let _a = #i;
                 b[#i] |= (src[#dst_byte] #bit_shift) & #src_mask;
             });
 
-            if shift < 0 {
-                let shift = shift + 8;
+            if shift < 0 && (dst_byte - start_byte) <= packed_field_len {
+                let shift = (8+shift);
+                let src_mask = ones_u8(8-shift as u8);
 
                 let bit_shift = emit_shift(shift);                
                 pack.push(quote! {
+                    let _b = #i;
                     target[#dst_byte + 1] |= (((packed[#i] & #src_mask) as u16) #bit_shift) as u8;  
                 });
 
                 let bit_shift = emit_shift(-shift);
                 unpack.push(quote! {
+                    let _b = #i;
                     b[#i] |= (((src[#dst_byte + 1] as u16) #bit_shift) & #src_mask as u16) as u8;
                 });
+            } else if shift > 0 && (dst_byte - start_byte) <= packed_field_len && i < packed_field_len - 1 {
+                let shift = -(8-shift);
+                let bit_shift = emit_shift(shift);
+                let src_mask = !ones_u8(-shift as u8);
+
+                pack.push(quote! {
+                    let _c = #i;
+                    target[#dst_byte] |= (((packed[#i + 1] & #src_mask) as u16) #bit_shift) as u8;  
+                });
+
+                let bit_shift = emit_shift(-shift);
+                unpack.push(quote! {
+                    let _c = #i;
+                    b[#i + 1] |= (((src[#dst_byte] as u16) #bit_shift) & #src_mask as u16) as u8;
+                });
             }
 
             dst_byte += 1;
-            l -= 8;                
+            l += 8;                
         }
-
+        
         PackBitsCopy {
             pack: quote! {
                 #(#pack)*

packed_struct_tests/tests/packing_bit_positioning.rs

@@ -29,19 +29,18 @@ fn test_packing_bit_positions() {
     };
 
     let packed = a.pack();
-    println!("packed: {:?}", packed);
+    assert_eq!([255], packed);
 
     let unpacked = SmallInts::unpack(&packed).unwrap();
     assert_eq!(a, unpacked);
 }
 
 
-/*
 #[derive(PackedStruct, PartialEq, Debug)]
 #[packed_struct(size_bytes="1", bit_numbering="lsb0")]
 pub struct SmallIntsLsb {    
     #[packed_field(bits="2..0")]
-    pub val1: UIntBits3,
+    pub val1: Integer<u8, packed_bits::Bits3>,
     #[packed_field(bits="6")]
     pub val2: bool
 }
@@ -54,7 +53,6 @@ fn test_packing_bit_positions_lsb() {
     };
 
     let packed = a.pack();
-    println!("packed: {:?}", packed);
     assert_eq!(&[0b01000111], &packed);
 
     let unpacked = SmallIntsLsb::unpack(&packed).unwrap();
@@ -89,4 +87,3 @@ fn test_packing_byte_position() {
 
     assert_eq!(b, unpacked);
 }
-*/

packed_struct_tests/tests/test_usb_pd.rs

@@ -0,0 +1,49 @@
+extern crate packed_struct;
+#[macro_use]
+extern crate packed_struct_codegen;
+
+use packed_struct::prelude::*;
+
+#[test]
+fn test_serialization_codegen() {
+
+
+
+    #[derive(PackedStruct, Debug, Default, Copy, Clone)]
+    #[packed_struct(size_bytes="4", bit_numbering="lsb0", endian="msb")]
+    pub struct PowerDataObjectFixed {
+        #[packed_field(bits="31..30")]
+        pub supply: Integer<u8, packed_bits::Bits2>,
+        #[packed_field(bits="29")]
+        pub dual_role_power: bool,
+        #[packed_field(bits="28")]
+        pub usb_suspend_supported: bool,
+        #[packed_field(bits="27")]
+        pub unconstrained_power: bool,
+        #[packed_field(bits="26")]
+        pub usb_communications_capable: bool,
+        #[packed_field(bits="25")]
+        pub dual_role_data: bool,
+        #[packed_field(bits="21..20")]
+        pub peak_current: Integer<u8, packed_bits::Bits2>,
+        #[packed_field(bits="19..10")]
+        pub voltage: Integer<u16, packed_bits::Bits10>,
+        #[packed_field(bits="9..0")]
+        pub maximum_current: Integer<u16, packed_bits::Bits10>
+    }
+
+
+    let mut p: PowerDataObjectFixed = Default::default();
+    p.dual_role_data = true;
+    p.voltage = 0b10_11111111.into();
+    p.maximum_current = 0b10_10101010.into();
+        
+    let packed = p.pack();
+    assert_eq!([0b00000010, 0b0000_1011, 0b111111_10, 0b10101010], packed);
+
+    let unpacked = PowerDataObjectFixed::unpack(&packed).unwrap();
+    assert_eq!(unpacked.dual_role_data, true);
+    assert_eq!(*unpacked.voltage, *p.voltage);
+    assert_eq!(*unpacked.maximum_current, *p.maximum_current);
+
+}

packed_struct_tests/tests/test_wide_ints_14.rs

@@ -0,0 +1,62 @@
+extern crate packed_struct;
+#[macro_use]
+extern crate packed_struct_codegen;
+
+use packed_struct::prelude::*;
+
+macro_rules! test_int_14 {
+    ($f: ident, $fi: tt) => {
+        #[test]
+        fn $f() {
+
+            #[derive(PackedStruct, Debug, Default, Copy, Clone, PartialEq)]
+            #[packed_struct(bit_numbering="msb0", endian="msb")]
+            pub struct Test {
+                #[packed_field(bits= $fi )]
+                pub int1: Integer<u16, packed_bits::Bits14>
+            }
+
+            let roundtrip = |x: u16| {
+                let mut t: Test = Default::default();
+                t.int1 = x.into();
+                let packed = t.pack();
+
+                let unpacked = Test::unpack(&packed).unwrap();
+                assert_eq!(unpacked, t);
+            };
+
+            roundtrip(0b00_101010_10101010);
+            roundtrip(0b00_010101_01010101);
+            roundtrip(0b00_111111_11111111);
+            roundtrip(0b00_111111_01111111);
+            roundtrip(0b00_111110_11111111);
+            roundtrip(0b00_111110_01111111);
+            roundtrip(0b00_100000_00000001);
+        }
+    };
+}
+
+
+test_int_14!(test_10_0, "0..");
+test_int_14!(test_10_1, "1..");
+test_int_14!(test_10_2, "2..");
+test_int_14!(test_10_3, "3..");
+test_int_14!(test_10_4, "4..");
+test_int_14!(test_10_5, "5..");
+test_int_14!(test_10_6, "6..");
+test_int_14!(test_10_7, "7..");
+test_int_14!(test_10_8, "8..");
+test_int_14!(test_10_9, "9..");
+test_int_14!(test_10_10, "10..");
+test_int_14!(test_10_11, "11..");
+test_int_14!(test_10_12, "12..");
+test_int_14!(test_10_13, "13..");
+test_int_14!(test_10_14, "14..");
+test_int_14!(test_10_15, "15..");
+test_int_14!(test_10_16, "16..");
+test_int_14!(test_10_17, "17..");
+test_int_14!(test_10_18, "18..");
+test_int_14!(test_10_19, "19..");
+
+
+test_int_14!(test_10_100, "100..");

packed_struct_tests/tests/test_wide_ints_50.rs

@@ -0,0 +1,64 @@
+extern crate packed_struct;
+#[macro_use]
+extern crate packed_struct_codegen;
+
+use packed_struct::prelude::*;
+
+macro_rules! test_int_50 {
+    ($f: ident, $fi: tt) => {
+        #[test]
+        fn $f() {
+
+            #[derive(PackedStruct, Debug, Default, Copy, Clone, PartialEq)]
+            #[packed_struct(bit_numbering="msb0", endian="msb")]
+            pub struct Test {
+                #[packed_field(bits= $fi )]
+                pub int1: Integer<u64, packed_bits::Bits50>
+            }
+
+            let roundtrip = |x: u64| {
+                let mut t: Test = Default::default();
+                t.int1 = x.into();
+                let packed = t.pack();
+
+                let unpacked = Test::unpack(&packed).unwrap();
+                assert_eq!(unpacked, t);
+            };
+
+            roundtrip(0b00_101010_10101010);
+            roundtrip(0b00_010101_01010101);
+            roundtrip(0b00_111111_11111111);
+            roundtrip(0b00_111111_01111111);
+            roundtrip(0b00_111110_11111111);
+            roundtrip(0b00_111110_01111111);
+            roundtrip(0b00_100000_00000001);
+        }
+    };
+}
+
+
+test_int_50!(test_50_0, "0..");
+test_int_50!(test_50_1, "1..");
+test_int_50!(test_50_2, "2..");
+test_int_50!(test_50_3, "3..");
+test_int_50!(test_50_4, "4..");
+test_int_50!(test_50_5, "5..");
+test_int_50!(test_50_6, "6..");
+test_int_50!(test_50_7, "7..");
+test_int_50!(test_50_8, "8..");
+test_int_50!(test_50_9, "9..");
+test_int_50!(test_50_10, "10..");
+test_int_50!(test_50_11, "11..");
+test_int_50!(test_50_12, "12..");
+test_int_50!(test_50_13, "13..");
+test_int_50!(test_50_14, "14..");
+test_int_50!(test_50_15, "15..");
+test_int_50!(test_50_16, "16..");
+test_int_50!(test_50_17, "17..");
+test_int_50!(test_50_18, "18..");
+test_int_50!(test_50_19, "19..");
+
+
+
+
+test_int_50!(test_50_100, "100..");