rountrip tests

bitbuffer_derive/src/lib.rs

@@ -374,9 +374,14 @@ fn parse(data: Data, struct_name: &Ident, attrs: &[Attribute], unchecked: bool)
             }
         }
         Data::Enum(data) => {
-            let discriminant_bits: u64 = get_attribute_value(attrs, &["discriminant_bits"]).expect(
+            let discriminant_bits: u64 = match get_attribute_value(attrs, &["discriminant_bits"]) {
-                "'discriminant_bits' attribute is required when deriving `BinRead` for enums",
+                Some(attr) => attr,
-            );
+                None => {
+                    return quote! {span=>
+                        compile_error!("'discriminant_bits' attribute is required when deriving `BinRead` for enums");
+                    }
+                }
+            };
 
             let mut last_discriminant = -1;
             let match_arms = data.variants.iter().map(|variant| {
@@ -484,10 +489,15 @@ fn size(data: Data, struct_name: &Ident, attrs: &[Attribute], has_input_size: bo
             }
         }
         Data::Enum(data) => {
-            let discriminant_bits = get_attribute_value::<u64>(attrs, &["discriminant_bits"])
+            let discriminant_bits = match get_attribute_value::<u64>(attrs, &["discriminant_bits"])
-                .expect(
+            {
-                    "'discriminant_bits' attribute is required when deriving `BinRead` for enums",
+                Some(attr) => attr as usize,
-                ) as usize;
+                None => {
+                    return quote! {span=>
+                        compile_error!("'discriminant_bits' attribute is required when deriving `BinRead` for enums");
+                    }
+                }
+            };
 
             let is_unit = data
                 .variants

bitbuffer_derive/src/write.rs

@@ -137,9 +137,14 @@ fn write(data: Data, struct_name: &Ident, attrs: &[Attribute]) -> TokenStream {
             }
         }
         Data::Enum(data) => {
-            let discriminant_bits: u64 = get_attribute_value(attrs, &["discriminant_bits"]).expect(
+            let discriminant_bits: u64 = match get_attribute_value(attrs, &["discriminant_bits"]) {
-                "'discriminant_bits' attribute is required when deriving `BinRead` for enums",
+                Some(attr) => attr,
-            );
+                None => {
+                    return quote! {span=>
+                        compile_error!("'discriminant_bits' attribute is required when deriving `BinWrite` for enums");
+                    }
+                }
+            };
 
             let mut last_discriminant = -1;
 

tests/roundtrip.rs

@@ -0,0 +1,76 @@
+use bitbuffer::{
+    BigEndian, BitRead, BitReadBuffer, BitReadStream, BitWrite, BitWriteStream, LittleEndian,
+};
+use std::fmt::Debug;
+
+fn roundtrip<
+    T: BitRead<'static, BigEndian>
+        + BitWrite<BigEndian>
+        + BitRead<'static, LittleEndian>
+        + BitWrite<LittleEndian>
+        + Debug
+        + PartialEq,
+>(
+    val: T,
+) {
+    {
+        let mut stream = BitWriteStream::new(LittleEndian);
+        stream.write(&val).unwrap();
+        let size = stream.bit_len();
+        let data = stream.finish();
+        let mut read = BitReadStream::new(BitReadBuffer::new_owned(data, LittleEndian));
+        assert_eq!(val, read.read().unwrap());
+        assert_eq!(size, read.pos());
+    }
+    {
+        let mut stream = BitWriteStream::new(BigEndian);
+        stream.write(&val).unwrap();
+        let size = stream.bit_len();
+        let data = stream.finish();
+        let mut read = BitReadStream::new(BitReadBuffer::new_owned(data, BigEndian));
+        assert_eq!(val, read.read().unwrap());
+        assert_eq!(size, read.pos());
+    }
+}
+
+#[test]
+fn test_basic_struct() {
+    #[derive(Debug, PartialEq, BitRead, BitWrite)]
+    struct Foo {
+        int: u32,
+        float: f64,
+        #[size = 2]
+        smaller_int: u8,
+        signed: i32,
+        #[size = 3]
+        smaller_signed: i32,
+        dynamic_string: String,
+        #[size = 3]
+        fixed_string: String,
+    }
+    roundtrip(Foo {
+        int: 1234,
+        float: 10.2,
+        smaller_int: 3,
+        signed: -3,
+        smaller_signed: -1,
+        dynamic_string: "Foobar".to_string(),
+        fixed_string: "asd".to_string(),
+    });
+}
+
+#[test]
+fn test_bare_enum() {
+    #[derive(Debug, PartialEq, BitRead, BitWrite)]
+    #[discriminant_bits = 4]
+    enum Enum {
+        A,
+        B,
+        C,
+        D,
+    }
+    roundtrip(Enum::A);
+    roundtrip(Enum::B);
+    roundtrip(Enum::C);
+    roundtrip(Enum::D);
+}

tests/write_tests.rs

@@ -150,3 +150,19 @@ fn test_write_string_le_unaligned() {
     // 0 padded
     assert_eq!(false, read.read_bool().unwrap());
 }
+
+#[test]
+fn test_write_signed() {
+    let mut stream = BitWriteStream::new(LittleEndian);
+
+    stream.write_bool(true).unwrap();
+    stream.write_int(-17i32, 32).unwrap();
+    stream.write_int(-9i32, 8).unwrap();
+
+    let data = stream.finish();
+    let mut read = BitReadStream::from(BitReadBuffer::new(&data, LittleEndian));
+
+    assert_eq!(true, read.read_bool().unwrap());
+    assert_eq!(-17i32, read.read_int(32).unwrap());
+    assert_eq!(-9i32, read.read_int(8).unwrap());
+}