Added another deserializer test.

crates/node/src/main.rs

@@ -39,7 +39,6 @@ struct Certificate {
 
 #[allow(dead_code)]
 enum Hash {
-    None,
     Sha2_256([u8; 32]),
     Sha2_512([u8; 64]),
 }

crates/node/src/serde_blocktree/de.rs

@@ -4,11 +4,27 @@ use std::io::Read;
 use super::error::{Error, Result};
 use serde::de::{
     self,
+    Deserialize,
+    DeserializeOwned,
     Visitor,
     DeserializeSeed,
     IntoDeserializer
 };
 
+#[allow(dead_code)]
+pub fn from_vec<T: DeserializeOwned>(vec: &Vec<u8>) -> Result<T> {
+    let mut slice = vec.as_slice();
+    let result = from_read(&mut slice);
+    result
+}
+
+#[allow(dead_code)]
+pub fn from_read<T: DeserializeOwned, R: Read>(read: &mut R) -> Result<T> {
+    let mut de = Deserializer::new(read);
+    let result = Deserialize::deserialize(&mut de);
+    result
+}
+
 pub struct Deserializer<'de, T: Read + ?Sized> {
     input: &'de mut T,
 }
@@ -54,17 +70,17 @@ impl<'de, T: Read + ?Sized> Deserializer<'de, T> {
 
     fn read_i8(&mut self) -> Result<i8> {
         let value = self.read_u8()?;
-        try_from(value)
+        Ok(value as i8)
     }
 
     fn read_i16(&mut self) -> Result<i16> {
         let value = self.read_u16()?;
-        try_from(value)
+        Ok(value as i16)
     }
 
     fn read_i32(&mut self) -> Result<i32> {
         let value = self.read_u32()?;
-        try_from(value)
+        Ok(value as i32)
     }
 
     fn read_bool(&mut self) -> Result<bool> {
@@ -115,7 +131,7 @@ impl<'de, 'a, T: Read> de::Deserializer<'de> for &'a mut Deserializer<'de, T> {
 
     fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
         let unsigned = self.read_u64()?;
-        let signed = try_from(unsigned)?;
+        let signed = unsigned as i64;
         visitor.visit_i64(signed)
     }
 
@@ -323,7 +339,7 @@ mod test {
     #[allow(unused_imports)]
     use serde::Deserialize;
     #[allow(unused_imports)]
-    use super::{Result, Deserializer};
+    use super::{from_vec, Result, Deserializer};
     
     #[test]
     fn new() -> Result<()> {
@@ -352,11 +368,8 @@ mod test {
             0x00, 0x01,
             0xFF 
         ];
-        let mut slice = vec.as_slice();
-        let mut de = Deserializer::new(&mut slice);
-        let result = Deserialize::deserialize(&mut de);
-        let actual = result?;
-        assert_eq!(expected, actual);
+        let result = from_vec(&vec);
+        assert_eq!(expected, result?);
         Ok(())
     }
 
@@ -365,10 +378,27 @@ mod test {
         #[derive(Debug, PartialEq, Deserialize)]
         enum Emotions { Anguish, Catharsis }
         let vec: Vec<u8> = vec![0x01, 0x00];
-        let mut slice = vec.as_slice();
-        let mut de = Deserializer::new(&mut slice);
-        let value = Deserialize::deserialize(&mut de)?;
-        assert_eq!(Emotions::Catharsis, value);
+        let result = from_vec(&vec);
+        assert_eq!(Emotions::Catharsis, result?);
+        Ok(())
+    }
+
+    #[test]
+    fn deserialize_struct_variant() -> Result<()> {
+        #[derive(Debug, PartialEq, Deserialize)]
+        enum Vector {
+            Dim2(i32, i32),
+            Dim3(i32, i32, i32)
+        }
+        let expected = Vector::Dim3(1, -1, -2);
+        let vec: Vec<u8> = vec![
+            0x01, 0x00, // The variant index.
+            0x01, 0x00, 0x00, 0x00, // The first entry.
+            0xFF, 0xFF, 0xFF, 0xFF, // The second entry.
+            0xFE, 0xFF, 0xFF, 0xFF // The last entry.
+        ];
+        let result = from_vec(&vec);
+        assert_eq!(expected, result?);
         Ok(())
     }
 }