123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761 |
- use crate::{
- error::{Error, Result},
- reader::{ReadAdapter, Reader, SliceAdapter},
- };
- use serde::de::{self, Deserialize, DeserializeOwned, DeserializeSeed, IntoDeserializer, Visitor};
- use std::convert::TryFrom;
- use std::io::Read;
- use std::str;
- pub fn from_vec<'de, T: Deserialize<'de>>(vec: &'de Vec<u8>) -> Result<T> {
- from_slice(vec.as_slice())
- }
- pub fn read_from<T: DeserializeOwned, R: Read>(read: &mut R) -> Result<T> {
- let mut de = Deserializer::new(ReadAdapter::new(read));
- Deserialize::deserialize(&mut de)
- }
- pub fn from_slice<'de, T: Deserialize<'de>>(slice: &'de [u8]) -> Result<T> {
- let mut de = Deserializer::new(SliceAdapter::new(slice));
- Deserialize::deserialize(&mut de)
- }
- fn try_from<TSource, TDest: TryFrom<TSource>>(value: TSource) -> Result<TDest> {
- let cast = TDest::try_from(value).map_err(|_| Error::TypeConversion)?;
- Ok(cast)
- }
- fn num_bytes_for_char(first_byte: u8) -> Result<usize> {
- if first_byte & 128u8 == 0 {
- return Ok(1);
- }
- for bit in 2..5 {
- let mask = 128u8 >> bit;
- if mask & first_byte == 0 {
- return Ok(bit);
- }
- }
- Err(Error::InvalidUtf8)
- }
- fn u32_from_utf8(buf: &[u8]) -> Result<u32> {
- const MASK: u8 = 0b0011_1111;
- fn mask(byte: u8, mask: u8) -> u32 {
- (byte & mask) as u32
- }
- fn two_bytes(buf: &[u8]) -> u32 {
- mask(buf[0], 0b0001_1111) << 6 | mask(buf[1], MASK)
- }
- fn three_bytes(buf: &[u8]) -> u32 {
- mask(buf[0], 0b0000_1111) << 12 | mask(buf[1], MASK) << 6 | mask(buf[2], MASK)
- }
- fn four_bytes(buf: &[u8]) -> u32 {
- mask(buf[0], 0b0000_0111) << 18
- | mask(buf[1], MASK) << 12
- | mask(buf[2], MASK) << 6
- | mask(buf[3], MASK)
- }
- let code_point = match buf.len() {
- 1 => Some(buf[0] as u32),
- 2 => Some(two_bytes(buf)),
- 3 => Some(three_bytes(buf)),
- 4 => Some(four_bytes(buf)),
- _ => None,
- };
- code_point.ok_or(Error::InvalidUtf8)
- }
- fn char_from_utf8(buf: &[u8]) -> Result<char> {
- let result = u32_from_utf8(buf);
- let option = char::from_u32(result?);
- option.ok_or(Error::InvalidUtf8)
- }
- pub struct Deserializer<T> {
- input: T,
- }
- impl<'de, T: Reader<'de>> Deserializer<T> {
- pub fn new(input: T) -> Self {
- Self { input }
- }
- fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
- self.input.read_exact(buf)
- }
- fn borrow_bytes(&mut self, len: usize) -> Result<&'de [u8]> {
- self.input.borrow_bytes(len)
- }
- fn read_array<const N: usize>(&mut self) -> Result<[u8; N]> {
- let mut array = [0u8; N];
- self.read_exact(array.as_mut_slice())?;
- Ok(array)
- }
- fn read_u8(&mut self) -> Result<u8> {
- let buf = self.read_array::<1>()?;
- Ok(buf[0])
- }
- fn read_u16(&mut self) -> Result<u16> {
- let buf = self.read_array()?;
- Ok(u16::from_le_bytes(buf))
- }
- fn read_u32(&mut self) -> Result<u32> {
- let buf = self.read_array()?;
- Ok(u32::from_le_bytes(buf))
- }
- fn read_u64(&mut self) -> Result<u64> {
- let buf = self.read_array()?;
- Ok(u64::from_le_bytes(buf))
- }
- fn read_u128(&mut self) -> Result<u128> {
- let buf = self.read_array()?;
- Ok(u128::from_le_bytes(buf))
- }
- fn read_i8(&mut self) -> Result<i8> {
- let value = self.read_u8()?;
- Ok(value as i8)
- }
- fn read_i16(&mut self) -> Result<i16> {
- let value = self.read_u16()?;
- Ok(value as i16)
- }
- fn read_i32(&mut self) -> Result<i32> {
- let value = self.read_u32()?;
- Ok(value as i32)
- }
- fn read_i64(&mut self) -> Result<i64> {
- let value = self.read_u64()?;
- Ok(value as i64)
- }
- fn read_i128(&mut self) -> Result<i128> {
- let value = self.read_u128()?;
- Ok(value as i128)
- }
- fn read_bool(&mut self) -> Result<bool> {
- let byte = self.read_u8()?;
- Ok(byte > 0)
- }
- fn read_vec(&mut self) -> Result<Vec<u8>> {
- let len = try_from(self.read_u32()?)?;
- let mut vec = vec![0; len];
- self.read_exact(vec.as_mut_slice())?;
- Ok(vec)
- }
- fn read_bytes(&mut self) -> Result<&'de [u8]> {
- let len = try_from(self.read_u32()?)?;
- self.borrow_bytes(len)
- }
- fn read_string(&mut self) -> Result<String> {
- let vec = self.read_vec()?;
- let value = String::from_utf8(vec).map_err(|_| Error::TypeConversion)?;
- Ok(value)
- }
- fn read_str(&mut self) -> Result<&'de str> {
- let bytes = self.read_bytes()?;
- std::str::from_utf8(bytes).map_err(|_| Error::InvalidUtf8)
- }
- }
- impl<'de, 'a, T: Reader<'de>> de::Deserializer<'de> for &'a mut Deserializer<T> {
- type Error = Error;
- fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
- Err(Error::NotSupported("deserialize_any is not supported"))
- }
- fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_bool()?;
- visitor.visit_bool(value)
- }
- fn deserialize_i8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_i8()?;
- visitor.visit_i8(value)
- }
- fn deserialize_i16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_i16()?;
- visitor.visit_i16(value)
- }
- fn deserialize_i32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_i32()?;
- visitor.visit_i32(value)
- }
- fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_i64()?;
- visitor.visit_i64(value)
- }
- fn deserialize_i128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_i128()?;
- visitor.visit_i128(value)
- }
- fn deserialize_u8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_u8()?;
- visitor.visit_u8(value)
- }
- fn deserialize_u16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_u16()?;
- visitor.visit_u16(value)
- }
- fn deserialize_u32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_u32()?;
- visitor.visit_u32(value)
- }
- fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_u64()?;
- visitor.visit_u64(value)
- }
- fn deserialize_u128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_u128()?;
- visitor.visit_u128(value)
- }
- fn deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let mut buf = [0u8; 4];
- self.read_exact(&mut buf)?;
- let value = f32::from_le_bytes(buf);
- visitor.visit_f32(value)
- }
- fn deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let mut buf = [0u8; 8];
- self.read_exact(&mut buf)?;
- let value = f64::from_le_bytes(buf);
- visitor.visit_f64(value)
- }
- fn deserialize_char<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let byte = self.read_u8()?;
- let char_len = num_bytes_for_char(byte)?;
- let mut buf = [0u8; 4];
- buf[0] = byte;
- self.read_exact(&mut buf[1..char_len])?;
- let result = char_from_utf8(&buf[..char_len]);
- visitor.visit_char(result?)
- }
- fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_str()?;
- visitor.visit_borrowed_str(value)
- }
- fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_string()?;
- visitor.visit_string(value)
- }
- fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_bytes()?;
- visitor.visit_borrowed_bytes(value)
- }
- fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let value = self.read_vec()?;
- visitor.visit_byte_buf(value)
- }
- fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let some = self.read_bool()?;
- if some {
- visitor.visit_some(self)
- } else {
- visitor.visit_none()
- }
- }
- fn deserialize_unit<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- visitor.visit_unit()
- }
- fn deserialize_unit_struct<V: Visitor<'de>>(
- self,
- _name: &'static str,
- visitor: V,
- ) -> Result<V::Value> {
- visitor.visit_unit()
- }
- fn deserialize_newtype_struct<V: Visitor<'de>>(
- self,
- _name: &'static str,
- visitor: V,
- ) -> Result<V::Value> {
- visitor.visit_newtype_struct(self)
- }
- fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let len = self.read_u32()?;
- visitor.visit_seq(SeqAccess {
- elements_left: len,
- deserializer: self,
- })
- }
- fn deserialize_tuple<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
- visitor.visit_seq(SeqAccess {
- elements_left: try_from(len)?,
- deserializer: self,
- })
- }
- fn deserialize_tuple_struct<V: Visitor<'de>>(
- self,
- _name: &'static str,
- len: usize,
- visitor: V,
- ) -> Result<V::Value> {
- self.deserialize_tuple(len, visitor)
- }
- fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
- let len = self.read_u32()?;
- visitor.visit_map(SeqAccess {
- elements_left: len,
- deserializer: self,
- })
- }
- fn deserialize_struct<V: Visitor<'de>>(
- self,
- _name: &'static str,
- fields: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value> {
- self.deserialize_tuple(fields.len(), visitor)
- }
- fn deserialize_enum<V: Visitor<'de>>(
- self,
- _name: &'static str,
- _variants: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value> {
- visitor.visit_enum(self)
- }
- fn deserialize_identifier<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
- Err(Error::NotSupported("Deserializer::deserialize_identifier"))
- }
- fn deserialize_ignored_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
- Err(Error::NotSupported("Deserializer::deserialize_ignored_any"))
- }
- fn is_human_readable(&self) -> bool {
- false
- }
- }
- struct SeqAccess<'a, T> {
- elements_left: u32,
- deserializer: &'a mut Deserializer<T>,
- }
- impl<'a, 'de, T: Reader<'de>> de::SeqAccess<'de> for SeqAccess<'a, T> {
- type Error = Error;
- fn next_element_seed<S: DeserializeSeed<'de>>(&mut self, seed: S) -> Result<Option<S::Value>> {
- if 0 == self.elements_left {
- return Ok(None);
- }
- self.elements_left -= 1;
- seed.deserialize(&mut *self.deserializer).map(Some)
- }
- }
- impl<'a, 'de, T: Reader<'de>> de::MapAccess<'de> for SeqAccess<'a, T> {
- type Error = Error;
- fn next_key_seed<S: DeserializeSeed<'de>>(&mut self, seed: S) -> Result<Option<S::Value>> {
- if 0 == self.elements_left {
- return Ok(None);
- }
- self.elements_left -= 1;
- seed.deserialize(&mut *self.deserializer).map(Some)
- }
- fn next_value_seed<U: DeserializeSeed<'de>>(&mut self, seed: U) -> Result<U::Value> {
- seed.deserialize(&mut *self.deserializer)
- }
- }
- impl<'de, T: Reader<'de>> de::VariantAccess<'de> for &mut Deserializer<T> {
- type Error = Error;
- fn unit_variant(self) -> Result<()> {
- Ok(())
- }
- fn newtype_variant_seed<S: DeserializeSeed<'de>>(self, seed: S) -> Result<S::Value> {
- seed.deserialize(self)
- }
- fn tuple_variant<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
- de::Deserializer::deserialize_tuple(self, len, visitor)
- }
- fn struct_variant<V: Visitor<'de>>(
- self,
- fields: &'static [&'static str],
- visitor: V,
- ) -> Result<V::Value> {
- de::Deserializer::deserialize_struct(self, "", fields, visitor)
- }
- }
- impl<'de, T: Reader<'de>> de::EnumAccess<'de> for &mut Deserializer<T> {
- type Error = Error;
- type Variant = Self;
- fn variant_seed<S: DeserializeSeed<'de>>(self, seed: S) -> Result<(S::Value, Self::Variant)> {
- let int = self.read_u16()?;
- let index: u32 = try_from(int)?;
- let value = seed.deserialize(index.into_deserializer())?;
- Ok((value, self))
- }
- }
- #[cfg(test)]
- mod test {
- use crate::from_slice;
- use super::{from_vec, num_bytes_for_char, Result};
- use serde::Deserialize;
- use std::collections::HashMap;
- #[test]
- fn test_num_bytes_for_char() -> Result<()> {
- fn test_case(c: char) -> Result<()> {
- let len = c.len_utf8();
- let mut buf: Vec<u8> = vec![0; len];
- c.encode_utf8(buf.as_mut_slice());
- let result = num_bytes_for_char(buf[0]);
- assert_eq!(len, result?);
- Ok(())
- }
- test_case('$')?;
- test_case('£')?;
- test_case('€')?;
- test_case('😑')?;
- 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_i128() -> Result<()> {
- let vec: Vec<u8> = vec![
- 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF,
- ];
- let result = from_vec(&vec);
- assert_eq!(-2i128, 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_u128() -> Result<()> {
- let vec: Vec<u8> = vec![
- 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF,
- ];
- let result = from_vec(&vec);
- assert_eq!(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEu128, 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<()> {
- fn test_case(c: char, vec: Vec<u8>) -> Result<()> {
- let result = from_vec(&vec);
- assert_eq!(c, result?);
- Ok(())
- }
- test_case('*', vec![0x2A])?;
- test_case('£', vec![0xC2, 0xA3])?;
- test_case('€', vec![0xE2, 0x82, 0xAC])?;
- test_case('😎', vec![0xF0, 0x9F, 0x98, 0x8E])?;
- Ok(())
- }
-
- macro_rules! input {
- ($expected:expr) => {{
- const LEN: [u8; 4] = ($expected.len() as u32).to_le_bytes();
- const INPUT_LEN: usize = LEN.len() + EXPECTED.len();
- let mut input = [0u8; INPUT_LEN];
- (&mut input[..LEN.len()]).copy_from_slice(&LEN);
- (&mut input[LEN.len()..]).copy_from_slice(&EXPECTED);
- input
- }};
- }
- #[test]
- fn deserialize_str() -> Result<()> {
- const EXPECTED: &[u8] = b"Without nature's limits, humanity's true nature was revealed.";
- let input = input!(EXPECTED);
- let actual: &str = from_slice(input.as_slice())?;
- let expected = std::str::from_utf8(EXPECTED).unwrap();
- assert_eq!(expected, actual);
- Ok(())
- }
- #[test]
- fn deserialize_string() -> Result<()> {
- let vec: Vec<u8> = vec![
- 0x06, 0x00, 0x00, 0x00, 'l' as u8, 'o' as u8, 'c' as u8, 'a' as u8, 's' as u8,
- 'h' as u8,
- ];
- let result: Result<String> = from_vec(&vec);
- assert_eq!("locash", result?);
- Ok(())
- }
- #[test]
- fn deserialize_bytes() -> Result<()> {
- const EXPECTED: &[u8] = b"I have altered the API, pray I don't alter it any further.";
- let input = input!(EXPECTED);
- let actual: &[u8] = from_slice(input.as_slice())?;
- assert_eq!(EXPECTED, actual);
- Ok(())
- }
- #[test]
- fn deserialize_byte_buf() -> Result<()> {
- let vec: Vec<u8> = vec![0x04, 0x00, 0x00, 0x00, 0x42, 0x91, 0xBE, 0xEF];
- let result: Result<Vec<u8>> = from_vec(&vec);
- assert_eq!(&vec[4..], result?);
- Ok(())
- }
- #[test]
- fn deserialize_none() -> Result<()> {
- let vec: Vec<u8> = vec![0x00];
- let result: Result<Option<u8>> = from_vec(&vec);
- assert_eq!(None, result?);
- Ok(())
- }
- #[test]
- fn deserialize_some() -> Result<()> {
- let vec: Vec<u8> = vec![0x01, 0xD5];
- let result: Result<Option<u8>> = from_vec(&vec);
- assert_eq!(Some(0xD5u8), result?);
- Ok(())
- }
- #[test]
- fn deserialize_tuple() -> Result<()> {
- let expected = ("orb".to_string(), 12u16);
- let vec: Vec<u8> = vec![
- 0x03, 0x00, 0x00, 0x00, 'o' as u8, 'r' as u8, 'b' as u8, 0x0C, 0x00,
- ];
- let result = from_vec(&vec);
- assert_eq!(expected, result?);
- Ok(())
- }
- #[test]
- fn deserialize_map() -> Result<()> {
- let expected: HashMap<String, u8> =
- HashMap::from([("blue".to_string(), 5), ("red".to_string(), 7)]);
- let vec: Vec<u8> = vec![
- 0x02, 0x00, 0x00, 0x00,
- 0x04, 0x00, 0x00, 0x00, 'b' as u8, 'l' as u8, 'u' as u8, 'e' as u8,
- 0x05,
- 0x03, 0x00, 0x00, 0x00, 'r' as u8, 'e' as u8, 'd' as u8,
- 0x07,
- ];
- let result = from_vec(&vec);
- assert_eq!(expected, result?);
- Ok(())
- }
- #[test]
- fn deserialize_struct() -> Result<()> {
- #[derive(Debug, PartialEq, Deserialize)]
- struct Order {
- customer: String,
- item_id: u16,
- quantity: u8,
- }
- let expected = Order {
- customer: "Bob".to_string(),
- item_id: 256,
- quantity: 255,
- };
- let vec: Vec<u8> = vec![
- 0x03, 0x00, 0x00, 0x00, 'B' as u8, 'o' as u8, 'b' as u8, 0x00, 0x01, 0xFF,
- ];
- let result = from_vec(&vec);
- assert_eq!(expected, result?);
- Ok(())
- }
- #[test]
- fn deserialize_enum() -> Result<()> {
- #[derive(Debug, PartialEq, Deserialize)]
- enum Emotions {
- Anguish,
- Catharsis,
- }
- let vec: Vec<u8> = vec![0x01, 0x00];
- 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,
- 0x01, 0x00, 0x00, 0x00,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFE, 0xFF, 0xFF, 0xFF,
- ];
- let result = from_vec(&vec);
- assert_eq!(expected, result?);
- Ok(())
- }
- }
|