From afb8ab448949eb19e09e1bdb4b263dc487a9be21 Mon Sep 17 00:00:00 2001 From: Igor Tolmachev Date: Fri, 21 Jun 2024 02:11:16 +0900 Subject: Implement deserialize Remove bincode crate and replace it by own written serializer --- src/structs/de.rs | 365 ++++++++++++++++++++++++++++++++++++++++++++++++ src/structs/error.rs | 12 +- src/structs/mod.rs | 1 + src/structs/ser.rs | 67 ++++----- src/structs/settings.rs | 82 ++++++----- src/structs/tests.rs | 95 ++++++++++--- 6 files changed, 530 insertions(+), 92 deletions(-) (limited to 'src/structs') diff --git a/src/structs/de.rs b/src/structs/de.rs index e69de29..9158d90 100644 --- a/src/structs/de.rs +++ b/src/structs/de.rs @@ -0,0 +1,365 @@ +use crate::structs::{Settings, StructError, StructResult}; +use crate::ArchiveError; +use serde::de; + +pub struct ArchiveDeserializer<'de> { + bytes: &'de [u8], + pointer: usize, + settings: Settings, +} + +struct SeqDeserializer<'a, 'de: 'a> { + de: &'a mut ArchiveDeserializer<'de>, + len: usize, +} + +struct EnumDeserializer<'a, 'de: 'a> { + de: &'a mut ArchiveDeserializer<'de>, +} + +impl<'de> ArchiveDeserializer<'de> { + pub fn new(bytes: &'de [u8], settings: Settings) -> Self { + Self { + bytes, + pointer: 0, + settings, + } + } + + fn take(&mut self) -> StructResult<[u8; S]> { + let bytes = self + .bytes + .get(self.pointer..self.pointer + S) + .ok_or(StructError::UnexpectedEOF)? + .try_into() + .unwrap(); + self.pointer += S; + Ok(bytes) + } + + fn take_byte(&mut self) -> StructResult { + let byte = self + .bytes + .get(self.pointer) + .ok_or(StructError::UnexpectedEOF)?; + self.pointer += 1; + Ok(*byte) + } +} + +impl<'a, 'de> SeqDeserializer<'a, 'de> { + pub fn new(de: &'a mut ArchiveDeserializer<'de>, len: usize) -> Self { + Self { de, len } + } +} + +impl<'a, 'de> EnumDeserializer<'a, 'de> { + pub fn new(de: &'a mut ArchiveDeserializer<'de>) -> Self { + Self { de } + } +} + +impl<'de> de::Deserializer<'de> for &mut ArchiveDeserializer<'de> { + type Error = ArchiveError; + + fn deserialize_any(self, _visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + Err(StructError::DeserializationNotSupported { type_name: "any" }.into()) + } + + fn deserialize_bool(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + visitor.visit_bool(self.take_byte()? != 0) + } + + fn deserialize_i8(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + visitor.visit_i8(self.take_byte()? as i8) + } + + fn deserialize_i16(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + let bytes = self.take()?; + visitor.visit_i16(self.settings.byte_order.to_i16(bytes)) + } + + fn deserialize_i32(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + let bytes = self.take()?; + visitor.visit_i32(self.settings.byte_order.to_i32(bytes)) + } + + fn deserialize_i64(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + let bytes = self.take()?; + visitor.visit_i64(self.settings.byte_order.to_i64(bytes)) + } + + fn deserialize_u8(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + visitor.visit_u8(self.take_byte()?) + } + + fn deserialize_u16(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + let bytes = self.take()?; + visitor.visit_u16(self.settings.byte_order.to_u16(bytes)) + } + + fn deserialize_u32(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + let bytes = self.take()?; + visitor.visit_u32(self.settings.byte_order.to_u32(bytes)) + } + + fn deserialize_u64(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + let bytes = self.take()?; + visitor.visit_u64(self.settings.byte_order.to_u64(bytes)) + } + + fn deserialize_f32(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + let bytes = self.take()?; + visitor.visit_f32(self.settings.byte_order.to_f32(bytes)) + } + + fn deserialize_f64(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + let bytes = self.take()?; + visitor.visit_f64(self.settings.byte_order.to_f64(bytes)) + } + + fn deserialize_char(self, _visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + Err(StructError::DeserializationNotSupported { type_name: "char" }.into()) + } + + fn deserialize_str(self, _visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + Err(StructError::DeserializationNotSupported { type_name: "str" }.into()) + } + + fn deserialize_string(self, _visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + Err(StructError::DeserializationNotSupported { + type_name: "string", + } + .into()) + } + + fn deserialize_bytes(self, _visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + Err(StructError::DeserializationNotSupported { type_name: "bytes" }.into()) + } + + fn deserialize_byte_buf(self, _visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + Err(StructError::DeserializationNotSupported { type_name: "bytes" }.into()) + } + + fn deserialize_option(self, _visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + Err(StructError::DeserializationNotSupported { + type_name: "optional", + } + .into()) + } + + fn deserialize_unit(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + visitor.visit_unit() + } + + fn deserialize_unit_struct(self, _name: &'static str, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + self.deserialize_unit(visitor) + } + + fn deserialize_newtype_struct( + self, + _name: &'static str, + visitor: V, + ) -> StructResult + where + V: de::Visitor<'de>, + { + visitor.visit_newtype_struct(self) + } + + fn deserialize_seq(self, _visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + Err(StructError::DeserializationNotSupported { type_name: "seq" }.into()) + } + + fn deserialize_tuple(self, len: usize, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + visitor.visit_seq(SeqDeserializer::new(self, len)) + } + + fn deserialize_tuple_struct( + self, + _name: &'static str, + len: usize, + visitor: V, + ) -> StructResult + where + V: de::Visitor<'de>, + { + self.deserialize_tuple(len, visitor) + } + + fn deserialize_map(self, _visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + Err(StructError::DeserializationNotSupported { type_name: "map" }.into()) + } + + fn deserialize_struct( + self, + _name: &'static str, + fields: &'static [&'static str], + visitor: V, + ) -> StructResult + where + V: de::Visitor<'de>, + { + self.deserialize_tuple(fields.len(), visitor) + } + + fn deserialize_enum( + self, + _name: &'static str, + _variants: &'static [&'static str], + visitor: V, + ) -> StructResult + where + V: de::Visitor<'de>, + { + visitor.visit_enum(EnumDeserializer::new(self)) + } + + fn deserialize_identifier(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + match self.settings.variant_index_type { + super::VariantIndexType::U8 => self.deserialize_u8(visitor), + super::VariantIndexType::U16 => self.deserialize_u16(visitor), + super::VariantIndexType::U32 => self.deserialize_u32(visitor), + super::VariantIndexType::U64 => self.deserialize_u64(visitor), + } + } + + #[inline] + fn deserialize_ignored_any(self, visitor: V) -> StructResult + where + V: de::Visitor<'de>, + { + self.deserialize_any(visitor) + } +} + +impl<'a, 'de> de::SeqAccess<'de> for SeqDeserializer<'a, 'de> { + type Error = ArchiveError; + + fn next_element_seed(&mut self, seed: T) -> Result, Self::Error> + where + T: de::DeserializeSeed<'de>, + { + if self.len == 0 { + return Ok(None); + } + seed.deserialize(&mut *self.de).map(Some) + } +} + +impl<'a, 'de> de::EnumAccess<'de> for EnumDeserializer<'a, 'de> { + type Error = ArchiveError; + type Variant = Self; + + fn variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> + where + V: de::DeserializeSeed<'de>, + { + Ok((seed.deserialize(&mut *self.de)?, self)) + } +} + +impl<'a, 'de> de::VariantAccess<'de> for EnumDeserializer<'a, 'de> { + type Error = ArchiveError; + + fn unit_variant(self) -> Result<(), Self::Error> { + Ok(()) + } + + fn newtype_variant_seed(self, seed: T) -> Result + where + T: de::DeserializeSeed<'de>, + { + seed.deserialize(&mut *self.de) + } + + fn tuple_variant(self, len: usize, visitor: V) -> Result + where + V: de::Visitor<'de>, + { + de::Deserializer::deserialize_tuple(self.de, len, visitor) + } + + fn struct_variant( + self, + fields: &'static [&'static str], + visitor: V, + ) -> Result + where + V: de::Visitor<'de>, + { + de::Deserializer::deserialize_tuple(self.de, fields.len(), visitor) + } +} diff --git a/src/structs/error.rs b/src/structs/error.rs index b9d765d..f08c9a3 100644 --- a/src/structs/error.rs +++ b/src/structs/error.rs @@ -6,7 +6,9 @@ pub type StructResult = ArchiveResult; #[derive(Debug)] pub enum StructError { - IncorrectEnumVariant, + SerializationNotSupported { type_name: &'static str }, + DeserializationNotSupported { type_name: &'static str }, + UnexpectedEOF, } impl From for ArchiveError { @@ -21,7 +23,13 @@ impl From for ArchiveError { impl Display for StructError { fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result { match self { - StructError::IncorrectEnumVariant => write!(f, "Can't cast enum variant type"), + StructError::SerializationNotSupported { type_name } => { + writeln!(f, "Serialization for type '{type_name}' not supported") + } + StructError::DeserializationNotSupported { type_name } => { + writeln!(f, "Deserialization for type '{type_name}' not supported") + } + StructError::UnexpectedEOF => writeln!(f, "Unexpected EOF"), } } } diff --git a/src/structs/mod.rs b/src/structs/mod.rs index feb37dd..36bc33e 100644 --- a/src/structs/mod.rs +++ b/src/structs/mod.rs @@ -3,6 +3,7 @@ mod error; pub mod ser; mod settings; +pub use de::ArchiveDeserializer; pub use error::{StructError, StructResult}; pub use ser::ArchiveSerializer; pub use settings::{ByteOrder, Settings, VariantIndexType}; diff --git a/src/structs/ser.rs b/src/structs/ser.rs index 8aa95a5..6833fb8 100644 --- a/src/structs/ser.rs +++ b/src/structs/ser.rs @@ -43,17 +43,17 @@ impl ser::Serializer for &mut ArchiveSerializer { } fn serialize_i16(self, v: i16) -> StructResult<()> { - self.bytes.append(&mut self.settings.byte_order.i16(v)); + self.bytes.append(&mut self.settings.byte_order.form_i16(v)); Ok(()) } fn serialize_i32(self, v: i32) -> StructResult<()> { - self.bytes.append(&mut self.settings.byte_order.i32(v)); + self.bytes.append(&mut self.settings.byte_order.form_i32(v)); Ok(()) } fn serialize_i64(self, v: i64) -> StructResult<()> { - self.bytes.append(&mut self.settings.byte_order.i64(v)); + self.bytes.append(&mut self.settings.byte_order.form_i64(v)); Ok(()) } @@ -63,54 +63,57 @@ impl ser::Serializer for &mut ArchiveSerializer { } fn serialize_u16(self, v: u16) -> StructResult<()> { - self.bytes.append(&mut self.settings.byte_order.u16(v)); + self.bytes.append(&mut self.settings.byte_order.form_u16(v)); Ok(()) } fn serialize_u32(self, v: u32) -> StructResult<()> { - self.bytes.append(&mut self.settings.byte_order.u32(v)); + self.bytes.append(&mut self.settings.byte_order.form_u32(v)); Ok(()) } fn serialize_u64(self, v: u64) -> StructResult<()> { - self.bytes.append(&mut self.settings.byte_order.u64(v)); + self.bytes.append(&mut self.settings.byte_order.form_u64(v)); Ok(()) } fn serialize_f32(self, v: f32) -> StructResult<()> { - self.bytes.append(&mut self.settings.byte_order.f32(v)); + self.bytes.append(&mut self.settings.byte_order.form_f32(v)); Ok(()) } fn serialize_f64(self, v: f64) -> StructResult<()> { - self.bytes.append(&mut self.settings.byte_order.f64(v)); + self.bytes.append(&mut self.settings.byte_order.form_f64(v)); Ok(()) } fn serialize_char(self, v: char) -> StructResult<()> { - self.bytes.push(v as u8); - Ok(()) + Err(StructError::SerializationNotSupported { type_name: "char" }.into()) } - fn serialize_str(self, v: &str) -> StructResult<()> { - self.bytes.append(&mut v.as_bytes().to_vec()); - Ok(()) + fn serialize_str(self, _v: &str) -> StructResult<()> { + Err(StructError::SerializationNotSupported { type_name: "str" }.into()) } - fn serialize_bytes(self, v: &[u8]) -> StructResult<()> { - self.bytes.append(&mut v.to_vec()); - Ok(()) + fn serialize_bytes(self, _v: &[u8]) -> StructResult<()> { + Err(StructError::SerializationNotSupported { type_name: "bytes" }.into()) } fn serialize_none(self) -> StructResult<()> { - Ok(()) + Err(StructError::SerializationNotSupported { + type_name: "optional", + } + .into()) } fn serialize_some(self, value: &T) -> StructResult<()> where T: ?Sized + Serialize, { - value.serialize(self) + Err(StructError::SerializationNotSupported { + type_name: "optional", + } + .into()) } fn serialize_unit(self) -> StructResult<()> { @@ -131,7 +134,7 @@ impl ser::Serializer for &mut ArchiveSerializer { &mut self .settings .variant_index_type - .cast(variant_index, &self.settings.byte_order)?, + .cast(variant_index, &self.settings.byte_order), ); Ok(()) } @@ -157,13 +160,13 @@ impl ser::Serializer for &mut ArchiveSerializer { &mut self .settings .variant_index_type - .cast(variant_index, &self.settings.byte_order)?, + .cast(variant_index, &self.settings.byte_order), ); value.serialize(self) } fn serialize_seq(self, _len: Option) -> StructResult { - Ok(self) + Err(StructError::SerializationNotSupported { type_name: "seq" }.into()) } fn serialize_tuple(self, _len: usize) -> StructResult { @@ -189,13 +192,13 @@ impl ser::Serializer for &mut ArchiveSerializer { &mut self .settings .variant_index_type - .cast(variant_index, &self.settings.byte_order)?, + .cast(variant_index, &self.settings.byte_order), ); Ok(self) } fn serialize_map(self, _len: Option) -> StructResult { - Ok(self) + Err(StructError::SerializationNotSupported { type_name: "map" }.into()) } fn serialize_struct( @@ -217,7 +220,7 @@ impl ser::Serializer for &mut ArchiveSerializer { &mut self .settings .variant_index_type - .cast(variant_index, &self.settings.byte_order)?, + .cast(variant_index, &self.settings.byte_order), ); Ok(self) } @@ -227,15 +230,15 @@ impl ser::SerializeSeq for &mut ArchiveSerializer { type Ok = (); type Error = ArchiveError; - fn serialize_element(&mut self, value: &T) -> StructResult<()> + fn serialize_element(&mut self, _value: &T) -> StructResult<()> where T: ?Sized + Serialize, { - value.serialize(&mut **self) + Err(StructError::SerializationNotSupported { type_name: "seq" }.into()) } fn end(self) -> StructResult<()> { - Ok(()) + Err(StructError::SerializationNotSupported { type_name: "seq" }.into()) } } @@ -291,22 +294,22 @@ impl ser::SerializeMap for &mut ArchiveSerializer { type Ok = (); type Error = ArchiveError; - fn serialize_key(&mut self, key: &T) -> StructResult<()> + fn serialize_key(&mut self, _key: &T) -> StructResult<()> where T: ?Sized + Serialize, { - key.serialize(&mut **self) + Err(StructError::SerializationNotSupported { type_name: "map" }.into()) } - fn serialize_value(&mut self, value: &T) -> StructResult<()> + fn serialize_value(&mut self, _value: &T) -> StructResult<()> where T: ?Sized + Serialize, { - value.serialize(&mut **self) + Err(StructError::SerializationNotSupported { type_name: "map" }.into()) } fn end(self) -> StructResult<()> { - Ok(()) + Err(StructError::SerializationNotSupported { type_name: "map" }.into()) } } diff --git a/src/structs/settings.rs b/src/structs/settings.rs index 63c4d3a..fce6d9e 100644 --- a/src/structs/settings.rs +++ b/src/structs/settings.rs @@ -1,5 +1,6 @@ -use crate::structs::{ArchiveSerializer, StructError, StructResult}; -use serde::Serialize; +use crate::structs::{ArchiveDeserializer, ArchiveSerializer, StructResult}; +use serde::{Deserialize, Serialize}; +use std::mem::size_of; pub enum ByteOrder { Le, @@ -12,61 +13,53 @@ pub enum VariantIndexType { U16, U32, U64, - I8, - I16, - I32, - I64, } macro_rules! impl_byte_order { - ($($n:ident),+) => { + ($($to:ident $fr:ident $n:ident),+) => { impl ByteOrder {$( - pub fn $n(&self, num: $n) -> Vec { + pub fn $fr(&self, num: $n) -> Vec { match self { ByteOrder::Le => num.to_le_bytes().to_vec(), ByteOrder::Be => num.to_be_bytes().to_vec(), ByteOrder::Ne => num.to_ne_bytes().to_vec(), } } + + pub fn $to(&self, bytes: [u8; size_of::<$n>()]) -> $n { + match self { + ByteOrder::Le => $n::from_le_bytes(bytes), + ByteOrder::Be => $n::from_be_bytes(bytes), + ByteOrder::Ne => $n::from_ne_bytes(bytes), + } + } )+} }; } -impl_byte_order!(u8, u16, u32, u64, i8, i16, i32, i64, f32, f64); + +impl_byte_order!( + to_u8 from_u8 u8, + to_u16 form_u16 u16, + to_u32 form_u32 u32, + to_u64 form_u64 u64, + + to_i8 form_i8 i8, + to_i16 form_i16 i16, + to_i32 form_i32 i32, + to_i64 form_i64 i64, + + to_f32 form_f32 f32, + to_f64 form_f64 f64 +); impl VariantIndexType { - pub fn cast(&self, num: u32, byte_order: &ByteOrder) -> StructResult> { - Ok(match self { - VariantIndexType::U8 => byte_order.u8(num - .try_into() - .map_err(|_| StructError::IncorrectEnumVariant)?), - VariantIndexType::U16 => byte_order.u16( - num.try_into() - .map_err(|_| StructError::IncorrectEnumVariant)?, - ), - VariantIndexType::U32 => byte_order.u32( - num.try_into() - .map_err(|_| StructError::IncorrectEnumVariant)?, - ), - VariantIndexType::U64 => byte_order.u64( - num.try_into() - .map_err(|_| StructError::IncorrectEnumVariant)?, - ), - VariantIndexType::I8 => byte_order.i8(num - .try_into() - .map_err(|_| StructError::IncorrectEnumVariant)?), - VariantIndexType::I16 => byte_order.i16( - num.try_into() - .map_err(|_| StructError::IncorrectEnumVariant)?, - ), - VariantIndexType::I32 => byte_order.i32( - num.try_into() - .map_err(|_| StructError::IncorrectEnumVariant)?, - ), - VariantIndexType::I64 => byte_order.i64( - num.try_into() - .map_err(|_| StructError::IncorrectEnumVariant)?, - ), - }) + pub fn cast(&self, num: u32, byte_order: &ByteOrder) -> Vec { + match self { + VariantIndexType::U8 => byte_order.from_u8(num as u8), + VariantIndexType::U16 => byte_order.form_u16(num as u16), + VariantIndexType::U32 => byte_order.form_u32(num as u32), + VariantIndexType::U64 => byte_order.form_u64(num as u64), + } } } @@ -98,6 +91,11 @@ impl Settings { object.serialize(&mut serializer)?; Ok(serializer.to_bytes()) } + + pub fn deserialize<'de, T: Deserialize<'de>>(self, object: &'de [u8]) -> StructResult { + let mut deserializer = ArchiveDeserializer::new(object, self); + Ok(T::deserialize(&mut deserializer)?) + } } impl Default for Settings { diff --git a/src/structs/tests.rs b/src/structs/tests.rs index 0fa5347..9ee7ce5 100644 --- a/src/structs/tests.rs +++ b/src/structs/tests.rs @@ -1,27 +1,26 @@ use crate::structs::{ByteOrder, Settings, VariantIndexType}; -use serde::Serialize; +use serde::{Deserialize, Serialize}; -#[derive(Serialize)] -struct Struct<'a> { +#[derive(Serialize, Deserialize, Debug, PartialEq)] +struct Struct { u8: u8, u16: u16, u32: u32, u64: u64, u8arr: [u8; 3], tuple: (u16, u8), - str: &'a str, } -#[derive(Serialize)] -enum Enum<'a> { +#[derive(Serialize, Deserialize, Debug, PartialEq)] +enum Enum { Unit, Type(u16), - Tuple(u16, &'a str), + Tuple(u16, u8), Struct { u32: u32, u64: u64 }, } #[test] -fn struct_serialize_test() { +fn struct_serialize() { let object = Struct { u8: 42, u16: 26, @@ -29,7 +28,6 @@ fn struct_serialize_test() { u64: 11, u8arr: [37, 74, 111], tuple: (24, 13), - str: "yes", }; let bytes = Settings::default() @@ -38,8 +36,7 @@ fn struct_serialize_test() { .unwrap(); assert_eq!( bytes, - //u8|-u16--|----u32-----|----------u64-----------|[0]-[1]--[2]|.0 --.1---|-y----e----s| - [42, 26, 0, 69, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 37, 74, 111, 24, 0, 13, 121, 101, 115] + [42, 26, 0, 69, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 37, 74, 111, 24, 0, 13] ); let bytes = Settings::default() @@ -48,13 +45,12 @@ fn struct_serialize_test() { .unwrap(); assert_eq!( bytes, - //u8|-u16--|----u32-----|----------u64-----------|[0]-[1]--[2]|.0 --.1---|-y----e----s| - [42, 0, 26, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 11, 37, 74, 111, 0, 24, 13, 121, 101, 115] + [42, 0, 26, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 11, 37, 74, 111, 0, 24, 13] ); } #[test] -fn enum_serialize_test() { +fn enum_serialize() { let bytes = Settings::default() .byte_order(ByteOrder::Le) .variant_index_type(VariantIndexType::U8) @@ -72,9 +68,9 @@ fn enum_serialize_test() { let bytes = Settings::default() .byte_order(ByteOrder::Le) .variant_index_type(VariantIndexType::U32) - .serialize(&Enum::Tuple(26, "yes")) + .serialize(&Enum::Tuple(26, 15)) .unwrap(); - assert_eq!(bytes, [2, 0, 0, 0, 26, 0, 121, 101, 115]); + assert_eq!(bytes, [2, 0, 0, 0, 26, 0, 15]); let bytes = Settings::default() .byte_order(ByteOrder::Be) @@ -86,3 +82,70 @@ fn enum_serialize_test() { [0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 37] ); } + +#[test] +fn struct_deserialize() { + let object = Struct { + u8: 42, + u16: 26, + u32: 69, + u64: 11, + u8arr: [37, 74, 111], + tuple: (24, 13), + }; + + assert_eq!( + Settings::default() + .byte_order(ByteOrder::Le) + .deserialize::(&[ + 42, 26, 0, 69, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 37, 74, 111, 24, 0, 13, + ]) + .unwrap(), + object + ); + assert_eq!( + Settings::default() + .byte_order(ByteOrder::Be) + .deserialize::(&[ + 42, 0, 26, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 11, 37, 74, 111, 0, 24, 13 + ]) + .unwrap(), + object + ); +} + +#[test] +fn enum_deserialize() { + assert_eq!( + Settings::default() + .byte_order(ByteOrder::Le) + .variant_index_type(VariantIndexType::U8) + .deserialize::(&[0]) + .unwrap(), + Enum::Unit + ); + assert_eq!( + Settings::default() + .byte_order(ByteOrder::Le) + .variant_index_type(VariantIndexType::U16) + .deserialize::(&[1, 0, 42, 0]) + .unwrap(), + Enum::Type(42) + ); + assert_eq!( + Settings::default() + .byte_order(ByteOrder::Le) + .variant_index_type(VariantIndexType::U32) + .deserialize::(&[2, 0, 0, 0, 26, 0, 15]) + .unwrap(), + Enum::Tuple(26, 15) + ); + assert_eq!( + Settings::default() + .byte_order(ByteOrder::Be) + .variant_index_type(VariantIndexType::U64) + .deserialize::(&[0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 69, 0, 0, 0, 0, 0, 0, 0, 37]) + .unwrap(), + Enum::Struct { u32: 69, u64: 37 } + ); +} -- cgit v1.2.3