Added serde-big-array.

crates/serde_block_tree/Cargo.lock

@@ -29,11 +29,21 @@ dependencies = [
  "serde_derive",
 ]
 
+[[package]]
+name = "serde-big-array"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3323f09a748af288c3dc2474ea6803ee81f118321775bffa3ac8f7e65c5e90e7"
+dependencies = [
+ "serde",
+]
+
 [[package]]
 name = "serde_block_tree"
 version = "0.1.0"
 dependencies = [
  "serde",
+ "serde-big-array",
 ]
 
 [[package]]

crates/serde_block_tree/Cargo.toml

@@ -8,3 +8,4 @@ edition = "2021"
 
 [dependencies]
 serde = { version = "1.0.136", features = ["derive"] }
+serde-big-array = { version = "0.4.1" }

crates/serde_block_tree/src/de.rs

@@ -11,14 +11,12 @@ use serde::de::{
     IntoDeserializer
 };
 
-#[allow(dead_code)]
 pub fn from_vec<T: DeserializeOwned>(vec: &Vec<u8>) -> Result<T> {
     let mut slice = vec.as_slice();
     let result = read_from(&mut slice);
     result
 }
 
-#[allow(dead_code)]
 pub fn read_from<T: DeserializeOwned, R: Read>(read: &mut R) -> Result<T> {
     let mut de = Deserializer::new(read);
     let result = Deserialize::deserialize(&mut de);
@@ -394,17 +392,15 @@ impl<'a, 'de, T: Read> de::EnumAccess<'de> for &mut Deserializer<'de, T> {
     }
 }
 
+#[cfg(test)]
 mod test {
-    #[allow(unused_imports)]
     use serde::Deserialize;
-    #[allow(unused_imports)]
     use super::{
         from_vec,
         num_bytes_for_char,
         Result,
         Deserializer
     };
-    #[allow(unused_imports)]
     use std::collections::HashMap;
     
     #[test]

crates/serde_block_tree/src/dependency_tests.rs

@@ -0,0 +1,56 @@
+use super::{to_vec, from_vec, Result};
+use serde::{Serialize, Deserialize};
+use serde_big_array::BigArray;
+
+#[test]
+fn test_empty_array_deserialization() -> Result<()> {
+    #[derive(Deserialize, Debug, PartialEq)]
+    struct Vacuous {
+        // Of course you would never actually do this, but it should handle it properly regardless.
+        #[serde(with = "BigArray")]
+        nothing: [u8; 0]
+    }
+    let expected = Vacuous { nothing: [0u8; 0] };
+    let vec = vec![];
+    let result = from_vec(&vec);
+    assert_eq!(expected, result?);
+    Ok(())
+}
+
+#[derive(Serialize, Deserialize, Debug, PartialEq)]
+struct S {
+    #[serde(with = "BigArray")]
+    array: [u8; 0x40]
+}
+
+#[test]
+fn test_big_array_deserialization() -> Result<()> {
+    let expected = S {  array: [
+        0x81, 0xc0, 0xf, 0x3e, 0x2f, 0x11, 0xae, 0xc9, 0x48, 0x68, 0xc4, 0x66, 0x67, 0x1e, 0xda,
+        0x4e, 0xde, 0xf, 0x84, 0x23, 0x4d, 0x24, 0x0, 0x23, 0xe8, 0x84, 0xac, 0xc6, 0x7c, 0xb0,
+        0x34, 0x5, 0xa3, 0xc3, 0x4b, 0x59, 0xaa, 0x96, 0x9f, 0xc6, 0x2d, 0x31, 0x5a, 0xb5, 0x61,
+        0xfd, 0xad, 0x9b, 0x7a, 0xf8, 0xf3, 0xd7, 0xee, 0x4a, 0x86, 0xd7, 0x87, 0x20, 0x33, 0x32,
+        0x12, 0xc9, 0x55, 0x1e
+    ] };
+    let mut vec = vec![0; 0x40];
+    vec.copy_from_slice(expected.array.as_slice());
+    let result = from_vec(&vec);
+    assert_eq!(expected, result?);
+    Ok(())
+}
+
+#[test]
+fn test_big_array_serialization() -> Result<()> {
+    let value = S {  array: [
+        0x81, 0xc0, 0xf, 0x3e, 0x2f, 0x11, 0xae, 0xc9, 0x48, 0x68, 0xc4, 0x66, 0x67, 0x1e, 0xda,
+        0x4e, 0xde, 0xf, 0x84, 0x23, 0x4d, 0x24, 0x0, 0x23, 0xe8, 0x84, 0xac, 0xc6, 0x7c, 0xb0,
+        0x34, 0x5, 0xa3, 0xc3, 0x4b, 0x59, 0xaa, 0x96, 0x9f, 0xc6, 0x2d, 0x31, 0x5a, 0xb5, 0x61,
+        0xfd, 0xad, 0x9b, 0x7a, 0xf8, 0xf3, 0xd7, 0xee, 0x4a, 0x86, 0xd7, 0x87, 0x20, 0x33, 0x32,
+        0x12, 0xc9, 0x55, 0x1e
+    ] };
+    let mut expected = vec![0; 0x40];
+    expected.copy_from_slice(value.array.as_slice());
+    let result = to_vec(&value);
+    assert_eq!(expected, result?);
+    Ok(())
+}

crates/serde_block_tree/src/lib.rs

@@ -4,6 +4,9 @@ mod error;
 mod ser;
 mod de;
 
+#[cfg(test)]
+mod dependency_tests;
+
 pub use error::{Error, Result};
 
 pub use ser::{to_vec, write_to, Serializer};

crates/serde_block_tree/src/ser.rs

@@ -28,7 +28,6 @@ impl<'w, W: Write> Serializer<'w, W> {
     }
 }
 
-#[allow(dead_code)]
 pub fn to_vec<T: Serialize + ?Sized>(value: &T) -> Result<Vec<u8>> {
     let mut vec = Vec::new();
     let result = write_to(value, &mut vec);
@@ -36,7 +35,6 @@ pub fn to_vec<T: Serialize + ?Sized>(value: &T) -> Result<Vec<u8>> {
     Ok(vec)
 }
 
-#[allow(dead_code)]
 pub fn write_to<T: Serialize + ?Sized, W: Write>(value: &T, write: &mut W) -> Result<()> {
     let mut serializer = Serializer::new(write);
     let result = value.serialize(&mut serializer);
@@ -385,13 +383,11 @@ impl<'a, 'w, W: Write> SerializeStructVariant for &'a mut Serializer<'w, W> {
     }
 }
 
-#[allow(dead_code)]
+#[cfg(test)]
 mod test {
     // This is actually used in every method below.
-    #[allow(unused_imports)]
     use super::Result;
     // This is also used in several methods below.
-    #[allow(unused_imports)]
     use serde::Serialize;
 
     #[test]
@@ -594,6 +590,7 @@ mod test {
     #[test]
     fn serialize_unit_variant() -> Result<()> {
         #[derive(Serialize)]
+        #[allow(dead_code)]
         enum Matter {
             Condensate,
             Solid,
@@ -621,6 +618,7 @@ mod test {
     #[test]
     fn serialize_newtype_variant() -> Result<()> {
         #[derive(Serialize)]
+        #[allow(dead_code)]
         enum Currency {
             Usd(i32),
             Btc(i32),
@@ -640,6 +638,7 @@ mod test {
     #[test]
     fn serialize_unit_struct_variant() -> Result<()> {
         #[derive(Serialize)]
+        #[allow(dead_code)]
         enum UnitStructVariant {
             Zeroth {},
             First {},
@@ -678,6 +677,7 @@ mod test {
     #[test]
     fn serialize_tuple_variant() -> Result<()> {
         #[derive(Serialize)]
+        #[allow(dead_code)]
         enum ByteVector {
             Dim2(u8, u8),
             Dim3(u8, u8, u8),
@@ -738,6 +738,7 @@ mod test {
     #[test]
     fn serialize_struct_variant() -> Result<()> {
         #[derive(Serialize)]
+        #[allow(dead_code)]
         enum Shape {
             Rectangle { upper_left_corner: (u16, u16), width: u16, height: u16 },
             Circle { center: (u16, u16), radius: u16 },