Implemented more deserialization tests.

crates/node/src/serde_blocktree/de.rs

@@ -170,6 +170,7 @@ impl<'de, 'a, T: Read> de::Deserializer<'de> for &'a mut Deserializer<'de, T> {
     }
 
     fn deserialize_char<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
+        // TODO: UTF-8 is a multi-byte encoding. I need to read the correct number of bytes here.
         let byte = self.read_u8()?;
         let value = try_from(byte)?;
         visitor.visit_char(value)
@@ -373,6 +374,110 @@ mod test {
         Ok(())
     }
 
+    #[test]
+    fn deserialize_false() -> Result<()> {
+        let vec: Vec<u8> = vec![0x00];
+        let result = from_vec(&vec);
+        assert_eq!(false, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_true() -> Result<()> {
+        let vec: Vec<u8> = vec![0x01];
+        let result = from_vec(&vec);
+        assert_eq!(true, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_i8() -> Result<()> {
+        let vec: Vec<u8> = vec![0xFE];
+        let result = from_vec(&vec);
+        assert_eq!(-2i8, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_i16() -> Result<()> {
+        let vec: Vec<u8> = vec![0xFD, 0xFF];
+        let result = from_vec(&vec);
+        assert_eq!(-3i16, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_i32() -> Result<()> {
+        let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF];
+        let result = from_vec(&vec);
+        assert_eq!(-2i32, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_i64() -> Result<()> {
+        let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+        let result = from_vec(&vec);
+        assert_eq!(-2i64, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_u8() -> Result<()> {
+        let vec: Vec<u8> = vec![0xFF];
+        let result = from_vec(&vec);
+        assert_eq!(255u8, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_u16() -> Result<()> {
+        let vec: Vec<u8> = vec![0xFE, 0xFF];
+        let result = from_vec(&vec);
+        assert_eq!(0xFFFEu16, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_u32() -> Result<()> {
+        let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF];
+        let result = from_vec(&vec);
+        assert_eq!(0xFFFFFFFEu32, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_u64() -> Result<()> {
+        let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
+        let result = from_vec(&vec);
+        assert_eq!(0xFFFFFFFFFFFFFFFEu64, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_f32() -> Result<()> {
+        let vec: Vec<u8> = vec![0x00, 0x00, 0x20, 0x3E];
+        let result = from_vec(&vec);
+        assert_eq!(0.15625f32, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_f64() -> Result<()> {
+        let vec: Vec<u8> = vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F];
+        let result = from_vec(&vec);
+        assert_eq!(1f64, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_char() -> Result<()> {
+        let vec: Vec<u8> = vec![0xF0, 0x9F, 0x98, 0x8E];
+        let result = from_vec(&vec);
+        assert_eq!('😎', result?);
+        Ok(())
+    }
+
     #[test]
     fn deserialize_enum() -> Result<()> {
         #[derive(Debug, PartialEq, Deserialize)]

crates/node/src/serde_blocktree/ser.rs

@@ -379,16 +379,6 @@ mod test {
     // This is also used in several methods below.
     #[allow(unused_imports)]
     use serde::Serialize;
-    //use super::super::super::{
-    //    VersionedBlock,
-    //    Block,
-    //    ReadCap,
-    //    WriteCap,
-    //    Certificate,
-    //    Hash,
-    //    Signature,
-    //    EnvelopedKey
-    //};
 
     #[test]
     fn serialize_bool() -> Result<()> {