Add tests

sdk/program/src/borsh.rs

@@ -67,3 +67,86 @@ pub fn try_from_slice_unchecked<T: BorshDeserialize>(data: &[u8]) -> Result<T, E
     let result = T::deserialize(&mut data_mut)?;
     Ok(result)
 }
+
+#[cfg(test)]
+mod tests {
+    use {
+        super::*,
+        borsh::{maybestd::io::ErrorKind, BorshSchema, BorshSerialize},
+        std::mem::size_of,
+    };
+
+    #[derive(BorshSerialize, BorshDeserialize, BorshSchema)]
+    enum TestEnum {
+        NoValue,
+        Value(u32),
+        StructValue {
+            #[allow(dead_code)]
+            number: u64,
+            #[allow(dead_code)]
+            array: [u8; 8],
+        },
+    }
+
+    #[derive(BorshSerialize, BorshDeserialize, BorshSchema)]
+    struct TestStruct {
+        pub array: [u64; 16],
+        pub number: u128,
+        pub tuple: (u8, u16),
+        pub enumeration: TestEnum,
+    }
+
+    #[derive(Debug, PartialEq, BorshSerialize, BorshDeserialize, BorshSchema)]
+    struct Child {
+        pub data: [u8; 64],
+    }
+
+    #[derive(Debug, PartialEq, BorshSerialize, BorshDeserialize, BorshSchema)]
+    struct Parent {
+        pub data: Vec<Child>,
+    }
+
+    #[test]
+    fn unchecked_deserialization() {
+        let data = vec![
+            Child { data: [0u8; 64] },
+            Child { data: [1u8; 64] },
+            Child { data: [2u8; 64] },
+        ];
+        let parent = Parent { data };
+
+        // exact size, both work
+        let mut byte_vec = vec![0u8; 4 + get_packed_len::<Child>() * 3];
+        let mut bytes = byte_vec.as_mut_slice();
+        parent.serialize(&mut bytes).unwrap();
+        let deserialized = Parent::try_from_slice(&byte_vec).unwrap();
+        assert_eq!(deserialized, parent);
+        let deserialized = try_from_slice_unchecked::<Parent>(&byte_vec).unwrap();
+        assert_eq!(deserialized, parent);
+
+        // too big, only unchecked works
+        let mut byte_vec = vec![0u8; 4 + get_packed_len::<Child>() * 10];
+        let mut bytes = byte_vec.as_mut_slice();
+        parent.serialize(&mut bytes).unwrap();
+        let err = Parent::try_from_slice(&byte_vec).unwrap_err();
+        assert_eq!(err.kind(), ErrorKind::InvalidData);
+        let deserialized = try_from_slice_unchecked::<Parent>(&byte_vec).unwrap();
+        assert_eq!(deserialized, parent);
+    }
+
+    #[test]
+    fn packed_len() {
+        assert_eq!(
+            get_packed_len::<TestEnum>(),
+            size_of::<u8>() + size_of::<u64>() + size_of::<u8>() * 8
+        );
+        assert_eq!(
+            get_packed_len::<TestStruct>(),
+            size_of::<u64>() * 16
+                + size_of::<u128>()
+                + size_of::<u8>()
+                + size_of::<u16>()
+                + get_packed_len::<TestEnum>()
+        );
+    }
+}