de.rs 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761
  1. use crate::{
  2. error::{Error, Result},
  3. reader::{ReadAdapter, Reader, SliceAdapter},
  4. };
  5. use serde::de::{self, Deserialize, DeserializeOwned, DeserializeSeed, IntoDeserializer, Visitor};
  6. use std::convert::TryFrom;
  7. use std::io::Read;
  8. use std::str;
  9. pub fn from_vec<'de, T: Deserialize<'de>>(vec: &'de Vec<u8>) -> Result<T> {
  10. from_slice(vec.as_slice())
  11. }
  12. pub fn read_from<T: DeserializeOwned, R: Read>(read: &mut R) -> Result<T> {
  13. let mut de = Deserializer::new(ReadAdapter::new(read));
  14. Deserialize::deserialize(&mut de)
  15. }
  16. pub fn from_slice<'de, T: Deserialize<'de>>(slice: &'de [u8]) -> Result<T> {
  17. let mut de = Deserializer::new(SliceAdapter::new(slice));
  18. Deserialize::deserialize(&mut de)
  19. }
  20. fn try_from<TSource, TDest: TryFrom<TSource>>(value: TSource) -> Result<TDest> {
  21. let cast = TDest::try_from(value).map_err(|_| Error::TypeConversion)?;
  22. Ok(cast)
  23. }
  24. /// Returns the number of bytes needed to store the unicode character in UTF-8 whose
  25. /// encoding begins with the given byte. If the given byte is not valid as the first byte
  26. /// for any character, then a failed result with Error::InvalidUtf8Char is returned.
  27. fn num_bytes_for_char(first_byte: u8) -> Result<usize> {
  28. if first_byte & 128u8 == 0 {
  29. return Ok(1);
  30. }
  31. for bit in 2..5 {
  32. let mask = 128u8 >> bit;
  33. if mask & first_byte == 0 {
  34. return Ok(bit);
  35. }
  36. }
  37. Err(Error::InvalidUtf8)
  38. }
  39. /// Returns the unicode code point of the character that is encoded in UTF-8 in the given buffer
  40. /// as a u32. If the given buffer is not of a valid length then a failed result is returned.
  41. /// No other verification is performed.
  42. fn u32_from_utf8(buf: &[u8]) -> Result<u32> {
  43. const MASK: u8 = 0b0011_1111;
  44. fn mask(byte: u8, mask: u8) -> u32 {
  45. (byte & mask) as u32
  46. }
  47. fn two_bytes(buf: &[u8]) -> u32 {
  48. mask(buf[0], 0b0001_1111) << 6 | mask(buf[1], MASK)
  49. }
  50. fn three_bytes(buf: &[u8]) -> u32 {
  51. mask(buf[0], 0b0000_1111) << 12 | mask(buf[1], MASK) << 6 | mask(buf[2], MASK)
  52. }
  53. fn four_bytes(buf: &[u8]) -> u32 {
  54. mask(buf[0], 0b0000_0111) << 18
  55. | mask(buf[1], MASK) << 12
  56. | mask(buf[2], MASK) << 6
  57. | mask(buf[3], MASK)
  58. }
  59. let code_point = match buf.len() {
  60. 1 => Some(buf[0] as u32),
  61. 2 => Some(two_bytes(buf)),
  62. 3 => Some(three_bytes(buf)),
  63. 4 => Some(four_bytes(buf)),
  64. _ => None,
  65. };
  66. code_point.ok_or(Error::InvalidUtf8)
  67. }
  68. fn char_from_utf8(buf: &[u8]) -> Result<char> {
  69. let result = u32_from_utf8(buf);
  70. let option = char::from_u32(result?);
  71. option.ok_or(Error::InvalidUtf8)
  72. }
  73. pub struct Deserializer<T> {
  74. input: T,
  75. }
  76. impl<'de, T: Reader<'de>> Deserializer<T> {
  77. pub fn new(input: T) -> Self {
  78. Self { input }
  79. }
  80. fn read_exact(&mut self, buf: &mut [u8]) -> Result<()> {
  81. self.input.read_exact(buf)
  82. }
  83. fn borrow_bytes(&mut self, len: usize) -> Result<&'de [u8]> {
  84. self.input.borrow_bytes(len)
  85. }
  86. fn read_array<const N: usize>(&mut self) -> Result<[u8; N]> {
  87. let mut array = [0u8; N];
  88. self.read_exact(array.as_mut_slice())?;
  89. Ok(array)
  90. }
  91. fn read_u8(&mut self) -> Result<u8> {
  92. let buf = self.read_array::<1>()?;
  93. Ok(buf[0])
  94. }
  95. fn read_u16(&mut self) -> Result<u16> {
  96. let buf = self.read_array()?;
  97. Ok(u16::from_le_bytes(buf))
  98. }
  99. fn read_u32(&mut self) -> Result<u32> {
  100. let buf = self.read_array()?;
  101. Ok(u32::from_le_bytes(buf))
  102. }
  103. fn read_u64(&mut self) -> Result<u64> {
  104. let buf = self.read_array()?;
  105. Ok(u64::from_le_bytes(buf))
  106. }
  107. fn read_u128(&mut self) -> Result<u128> {
  108. let buf = self.read_array()?;
  109. Ok(u128::from_le_bytes(buf))
  110. }
  111. fn read_i8(&mut self) -> Result<i8> {
  112. let value = self.read_u8()?;
  113. Ok(value as i8)
  114. }
  115. fn read_i16(&mut self) -> Result<i16> {
  116. let value = self.read_u16()?;
  117. Ok(value as i16)
  118. }
  119. fn read_i32(&mut self) -> Result<i32> {
  120. let value = self.read_u32()?;
  121. Ok(value as i32)
  122. }
  123. fn read_i64(&mut self) -> Result<i64> {
  124. let value = self.read_u64()?;
  125. Ok(value as i64)
  126. }
  127. fn read_i128(&mut self) -> Result<i128> {
  128. let value = self.read_u128()?;
  129. Ok(value as i128)
  130. }
  131. fn read_bool(&mut self) -> Result<bool> {
  132. let byte = self.read_u8()?;
  133. Ok(byte > 0)
  134. }
  135. fn read_vec(&mut self) -> Result<Vec<u8>> {
  136. let len = try_from(self.read_u32()?)?;
  137. let mut vec = vec![0; len];
  138. self.read_exact(vec.as_mut_slice())?;
  139. Ok(vec)
  140. }
  141. fn read_bytes(&mut self) -> Result<&'de [u8]> {
  142. let len = try_from(self.read_u32()?)?;
  143. self.borrow_bytes(len)
  144. }
  145. fn read_string(&mut self) -> Result<String> {
  146. let vec = self.read_vec()?;
  147. let value = String::from_utf8(vec).map_err(|_| Error::TypeConversion)?;
  148. Ok(value)
  149. }
  150. fn read_str(&mut self) -> Result<&'de str> {
  151. let bytes = self.read_bytes()?;
  152. std::str::from_utf8(bytes).map_err(|_| Error::InvalidUtf8)
  153. }
  154. }
  155. impl<'de, 'a, T: Reader<'de>> de::Deserializer<'de> for &'a mut Deserializer<T> {
  156. type Error = Error;
  157. fn deserialize_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
  158. Err(Error::NotSupported("deserialize_any is not supported"))
  159. }
  160. fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  161. let value = self.read_bool()?;
  162. visitor.visit_bool(value)
  163. }
  164. fn deserialize_i8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  165. let value = self.read_i8()?;
  166. visitor.visit_i8(value)
  167. }
  168. fn deserialize_i16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  169. let value = self.read_i16()?;
  170. visitor.visit_i16(value)
  171. }
  172. fn deserialize_i32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  173. let value = self.read_i32()?;
  174. visitor.visit_i32(value)
  175. }
  176. fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  177. let value = self.read_i64()?;
  178. visitor.visit_i64(value)
  179. }
  180. fn deserialize_i128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  181. let value = self.read_i128()?;
  182. visitor.visit_i128(value)
  183. }
  184. fn deserialize_u8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  185. let value = self.read_u8()?;
  186. visitor.visit_u8(value)
  187. }
  188. fn deserialize_u16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  189. let value = self.read_u16()?;
  190. visitor.visit_u16(value)
  191. }
  192. fn deserialize_u32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  193. let value = self.read_u32()?;
  194. visitor.visit_u32(value)
  195. }
  196. fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  197. let value = self.read_u64()?;
  198. visitor.visit_u64(value)
  199. }
  200. fn deserialize_u128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  201. let value = self.read_u128()?;
  202. visitor.visit_u128(value)
  203. }
  204. fn deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  205. let mut buf = [0u8; 4];
  206. self.read_exact(&mut buf)?;
  207. let value = f32::from_le_bytes(buf);
  208. visitor.visit_f32(value)
  209. }
  210. fn deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  211. let mut buf = [0u8; 8];
  212. self.read_exact(&mut buf)?;
  213. let value = f64::from_le_bytes(buf);
  214. visitor.visit_f64(value)
  215. }
  216. fn deserialize_char<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  217. let byte = self.read_u8()?;
  218. let char_len = num_bytes_for_char(byte)?;
  219. let mut buf = [0u8; 4];
  220. buf[0] = byte;
  221. self.read_exact(&mut buf[1..char_len])?;
  222. let result = char_from_utf8(&buf[..char_len]);
  223. visitor.visit_char(result?)
  224. }
  225. fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  226. let value = self.read_str()?;
  227. visitor.visit_borrowed_str(value)
  228. }
  229. fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  230. let value = self.read_string()?;
  231. visitor.visit_string(value)
  232. }
  233. fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  234. let value = self.read_bytes()?;
  235. visitor.visit_borrowed_bytes(value)
  236. }
  237. fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  238. let value = self.read_vec()?;
  239. visitor.visit_byte_buf(value)
  240. }
  241. fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  242. let some = self.read_bool()?;
  243. if some {
  244. visitor.visit_some(self)
  245. } else {
  246. visitor.visit_none()
  247. }
  248. }
  249. fn deserialize_unit<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  250. visitor.visit_unit()
  251. }
  252. fn deserialize_unit_struct<V: Visitor<'de>>(
  253. self,
  254. _name: &'static str,
  255. visitor: V,
  256. ) -> Result<V::Value> {
  257. visitor.visit_unit()
  258. }
  259. fn deserialize_newtype_struct<V: Visitor<'de>>(
  260. self,
  261. _name: &'static str,
  262. visitor: V,
  263. ) -> Result<V::Value> {
  264. visitor.visit_newtype_struct(self)
  265. }
  266. fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  267. let len = self.read_u32()?;
  268. visitor.visit_seq(SeqAccess {
  269. elements_left: len,
  270. deserializer: self,
  271. })
  272. }
  273. fn deserialize_tuple<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
  274. visitor.visit_seq(SeqAccess {
  275. elements_left: try_from(len)?,
  276. deserializer: self,
  277. })
  278. }
  279. fn deserialize_tuple_struct<V: Visitor<'de>>(
  280. self,
  281. _name: &'static str,
  282. len: usize,
  283. visitor: V,
  284. ) -> Result<V::Value> {
  285. self.deserialize_tuple(len, visitor)
  286. }
  287. fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value> {
  288. let len = self.read_u32()?;
  289. visitor.visit_map(SeqAccess {
  290. elements_left: len,
  291. deserializer: self,
  292. })
  293. }
  294. fn deserialize_struct<V: Visitor<'de>>(
  295. self,
  296. _name: &'static str,
  297. fields: &'static [&'static str],
  298. visitor: V,
  299. ) -> Result<V::Value> {
  300. self.deserialize_tuple(fields.len(), visitor)
  301. }
  302. fn deserialize_enum<V: Visitor<'de>>(
  303. self,
  304. _name: &'static str,
  305. _variants: &'static [&'static str],
  306. visitor: V,
  307. ) -> Result<V::Value> {
  308. visitor.visit_enum(self)
  309. }
  310. fn deserialize_identifier<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
  311. Err(Error::NotSupported("Deserializer::deserialize_identifier"))
  312. }
  313. fn deserialize_ignored_any<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value> {
  314. Err(Error::NotSupported("Deserializer::deserialize_ignored_any"))
  315. }
  316. fn is_human_readable(&self) -> bool {
  317. false
  318. }
  319. }
  320. struct SeqAccess<'a, T> {
  321. elements_left: u32,
  322. deserializer: &'a mut Deserializer<T>,
  323. }
  324. impl<'a, 'de, T: Reader<'de>> de::SeqAccess<'de> for SeqAccess<'a, T> {
  325. type Error = Error;
  326. fn next_element_seed<S: DeserializeSeed<'de>>(&mut self, seed: S) -> Result<Option<S::Value>> {
  327. if 0 == self.elements_left {
  328. return Ok(None);
  329. }
  330. self.elements_left -= 1;
  331. seed.deserialize(&mut *self.deserializer).map(Some)
  332. }
  333. }
  334. impl<'a, 'de, T: Reader<'de>> de::MapAccess<'de> for SeqAccess<'a, T> {
  335. type Error = Error;
  336. fn next_key_seed<S: DeserializeSeed<'de>>(&mut self, seed: S) -> Result<Option<S::Value>> {
  337. if 0 == self.elements_left {
  338. return Ok(None);
  339. }
  340. self.elements_left -= 1;
  341. seed.deserialize(&mut *self.deserializer).map(Some)
  342. }
  343. fn next_value_seed<U: DeserializeSeed<'de>>(&mut self, seed: U) -> Result<U::Value> {
  344. seed.deserialize(&mut *self.deserializer)
  345. }
  346. }
  347. impl<'de, T: Reader<'de>> de::VariantAccess<'de> for &mut Deserializer<T> {
  348. type Error = Error;
  349. fn unit_variant(self) -> Result<()> {
  350. Ok(())
  351. }
  352. fn newtype_variant_seed<S: DeserializeSeed<'de>>(self, seed: S) -> Result<S::Value> {
  353. seed.deserialize(self)
  354. }
  355. fn tuple_variant<V: Visitor<'de>>(self, len: usize, visitor: V) -> Result<V::Value> {
  356. de::Deserializer::deserialize_tuple(self, len, visitor)
  357. }
  358. fn struct_variant<V: Visitor<'de>>(
  359. self,
  360. fields: &'static [&'static str],
  361. visitor: V,
  362. ) -> Result<V::Value> {
  363. de::Deserializer::deserialize_struct(self, "", fields, visitor)
  364. }
  365. }
  366. impl<'de, T: Reader<'de>> de::EnumAccess<'de> for &mut Deserializer<T> {
  367. type Error = Error;
  368. type Variant = Self;
  369. fn variant_seed<S: DeserializeSeed<'de>>(self, seed: S) -> Result<(S::Value, Self::Variant)> {
  370. let int = self.read_u16()?;
  371. let index: u32 = try_from(int)?;
  372. let value = seed.deserialize(index.into_deserializer())?;
  373. Ok((value, self))
  374. }
  375. }
  376. #[cfg(test)]
  377. mod test {
  378. use crate::from_slice;
  379. use super::{from_vec, num_bytes_for_char, Result};
  380. use serde::Deserialize;
  381. use std::collections::HashMap;
  382. #[test]
  383. fn test_num_bytes_for_char() -> Result<()> {
  384. fn test_case(c: char) -> Result<()> {
  385. let len = c.len_utf8();
  386. let mut buf: Vec<u8> = vec![0; len];
  387. c.encode_utf8(buf.as_mut_slice());
  388. let result = num_bytes_for_char(buf[0]);
  389. assert_eq!(len, result?);
  390. Ok(())
  391. }
  392. test_case('$')?;
  393. test_case('£')?;
  394. test_case('€')?;
  395. test_case('😑')?;
  396. Ok(())
  397. }
  398. #[test]
  399. fn deserialize_false() -> Result<()> {
  400. let vec: Vec<u8> = vec![0x00];
  401. let result = from_vec(&vec);
  402. assert_eq!(false, result?);
  403. Ok(())
  404. }
  405. #[test]
  406. fn deserialize_true() -> Result<()> {
  407. let vec: Vec<u8> = vec![0x01];
  408. let result = from_vec(&vec);
  409. assert_eq!(true, result?);
  410. Ok(())
  411. }
  412. #[test]
  413. fn deserialize_i8() -> Result<()> {
  414. let vec: Vec<u8> = vec![0xFE];
  415. let result = from_vec(&vec);
  416. assert_eq!(-2i8, result?);
  417. Ok(())
  418. }
  419. #[test]
  420. fn deserialize_i16() -> Result<()> {
  421. let vec: Vec<u8> = vec![0xFD, 0xFF];
  422. let result = from_vec(&vec);
  423. assert_eq!(-3i16, result?);
  424. Ok(())
  425. }
  426. #[test]
  427. fn deserialize_i32() -> Result<()> {
  428. let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF];
  429. let result = from_vec(&vec);
  430. assert_eq!(-2i32, result?);
  431. Ok(())
  432. }
  433. #[test]
  434. fn deserialize_i64() -> Result<()> {
  435. let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
  436. let result = from_vec(&vec);
  437. assert_eq!(-2i64, result?);
  438. Ok(())
  439. }
  440. #[test]
  441. fn deserialize_i128() -> Result<()> {
  442. let vec: Vec<u8> = vec![
  443. 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  444. 0xFF, 0xFF,
  445. ];
  446. let result = from_vec(&vec);
  447. assert_eq!(-2i128, result?);
  448. Ok(())
  449. }
  450. #[test]
  451. fn deserialize_u8() -> Result<()> {
  452. let vec: Vec<u8> = vec![0xFF];
  453. let result = from_vec(&vec);
  454. assert_eq!(255u8, result?);
  455. Ok(())
  456. }
  457. #[test]
  458. fn deserialize_u16() -> Result<()> {
  459. let vec: Vec<u8> = vec![0xFE, 0xFF];
  460. let result = from_vec(&vec);
  461. assert_eq!(0xFFFEu16, result?);
  462. Ok(())
  463. }
  464. #[test]
  465. fn deserialize_u32() -> Result<()> {
  466. let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF];
  467. let result = from_vec(&vec);
  468. assert_eq!(0xFFFFFFFEu32, result?);
  469. Ok(())
  470. }
  471. #[test]
  472. fn deserialize_u64() -> Result<()> {
  473. let vec: Vec<u8> = vec![0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF];
  474. let result = from_vec(&vec);
  475. assert_eq!(0xFFFFFFFFFFFFFFFEu64, result?);
  476. Ok(())
  477. }
  478. #[test]
  479. fn deserialize_u128() -> Result<()> {
  480. let vec: Vec<u8> = vec![
  481. 0xFE, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
  482. 0xFF, 0xFF,
  483. ];
  484. let result = from_vec(&vec);
  485. assert_eq!(0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEu128, result?);
  486. Ok(())
  487. }
  488. #[test]
  489. fn deserialize_f32() -> Result<()> {
  490. let vec: Vec<u8> = vec![0x00, 0x00, 0x20, 0x3E];
  491. let result = from_vec(&vec);
  492. assert_eq!(0.15625f32, result?);
  493. Ok(())
  494. }
  495. #[test]
  496. fn deserialize_f64() -> Result<()> {
  497. let vec: Vec<u8> = vec![0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x3F];
  498. let result = from_vec(&vec);
  499. assert_eq!(1f64, result?);
  500. Ok(())
  501. }
  502. #[test]
  503. fn deserialize_char() -> Result<()> {
  504. fn test_case(c: char, vec: Vec<u8>) -> Result<()> {
  505. let result = from_vec(&vec);
  506. assert_eq!(c, result?);
  507. Ok(())
  508. }
  509. test_case('*', vec![0x2A])?;
  510. test_case('£', vec![0xC2, 0xA3])?;
  511. test_case('€', vec![0xE2, 0x82, 0xAC])?;
  512. test_case('😎', vec![0xF0, 0x9F, 0x98, 0x8E])?;
  513. Ok(())
  514. }
  515. /// Returns the bytes that would be returned if the given data were serialized.
  516. macro_rules! input {
  517. ($expected:expr) => {{
  518. const LEN: [u8; 4] = ($expected.len() as u32).to_le_bytes();
  519. const INPUT_LEN: usize = LEN.len() + EXPECTED.len();
  520. let mut input = [0u8; INPUT_LEN];
  521. (&mut input[..LEN.len()]).copy_from_slice(&LEN);
  522. (&mut input[LEN.len()..]).copy_from_slice(&EXPECTED);
  523. input
  524. }};
  525. }
  526. #[test]
  527. fn deserialize_str() -> Result<()> {
  528. const EXPECTED: &[u8] = b"Without nature's limits, humanity's true nature was revealed.";
  529. let input = input!(EXPECTED);
  530. let actual: &str = from_slice(input.as_slice())?;
  531. let expected = std::str::from_utf8(EXPECTED).unwrap();
  532. assert_eq!(expected, actual);
  533. Ok(())
  534. }
  535. #[test]
  536. fn deserialize_string() -> Result<()> {
  537. let vec: Vec<u8> = vec![
  538. 0x06, 0x00, 0x00, 0x00, 'l' as u8, 'o' as u8, 'c' as u8, 'a' as u8, 's' as u8,
  539. 'h' as u8,
  540. ];
  541. let result: Result<String> = from_vec(&vec);
  542. assert_eq!("locash", result?);
  543. Ok(())
  544. }
  545. #[test]
  546. fn deserialize_bytes() -> Result<()> {
  547. const EXPECTED: &[u8] = b"I have altered the API, pray I don't alter it any further.";
  548. let input = input!(EXPECTED);
  549. let actual: &[u8] = from_slice(input.as_slice())?;
  550. assert_eq!(EXPECTED, actual);
  551. Ok(())
  552. }
  553. #[test]
  554. fn deserialize_byte_buf() -> Result<()> {
  555. let vec: Vec<u8> = vec![0x04, 0x00, 0x00, 0x00, 0x42, 0x91, 0xBE, 0xEF];
  556. let result: Result<Vec<u8>> = from_vec(&vec);
  557. assert_eq!(&vec[4..], result?);
  558. Ok(())
  559. }
  560. #[test]
  561. fn deserialize_none() -> Result<()> {
  562. let vec: Vec<u8> = vec![0x00];
  563. let result: Result<Option<u8>> = from_vec(&vec);
  564. assert_eq!(None, result?);
  565. Ok(())
  566. }
  567. #[test]
  568. fn deserialize_some() -> Result<()> {
  569. let vec: Vec<u8> = vec![0x01, 0xD5];
  570. let result: Result<Option<u8>> = from_vec(&vec);
  571. assert_eq!(Some(0xD5u8), result?);
  572. Ok(())
  573. }
  574. #[test]
  575. fn deserialize_tuple() -> Result<()> {
  576. let expected = ("orb".to_string(), 12u16);
  577. let vec: Vec<u8> = vec![
  578. 0x03, 0x00, 0x00, 0x00, 'o' as u8, 'r' as u8, 'b' as u8, 0x0C, 0x00,
  579. ];
  580. let result = from_vec(&vec);
  581. assert_eq!(expected, result?);
  582. Ok(())
  583. }
  584. #[test]
  585. fn deserialize_map() -> Result<()> {
  586. let expected: HashMap<String, u8> =
  587. HashMap::from([("blue".to_string(), 5), ("red".to_string(), 7)]);
  588. let vec: Vec<u8> = vec![
  589. 0x02, 0x00, 0x00, 0x00, // Number of entries in the map.
  590. 0x04, 0x00, 0x00, 0x00, 'b' as u8, 'l' as u8, 'u' as u8, 'e' as u8, // First key.
  591. 0x05, // First value.
  592. 0x03, 0x00, 0x00, 0x00, 'r' as u8, 'e' as u8, 'd' as u8, // Second key.
  593. 0x07, // Second value.
  594. ];
  595. let result = from_vec(&vec);
  596. assert_eq!(expected, result?);
  597. Ok(())
  598. }
  599. #[test]
  600. fn deserialize_struct() -> Result<()> {
  601. #[derive(Debug, PartialEq, Deserialize)]
  602. struct Order {
  603. customer: String,
  604. item_id: u16,
  605. quantity: u8,
  606. }
  607. let expected = Order {
  608. customer: "Bob".to_string(),
  609. item_id: 256,
  610. quantity: 255,
  611. };
  612. let vec: Vec<u8> = vec![
  613. 0x03, 0x00, 0x00, 0x00, 'B' as u8, 'o' as u8, 'b' as u8, 0x00, 0x01, 0xFF,
  614. ];
  615. let result = from_vec(&vec);
  616. assert_eq!(expected, result?);
  617. Ok(())
  618. }
  619. #[test]
  620. fn deserialize_enum() -> Result<()> {
  621. #[derive(Debug, PartialEq, Deserialize)]
  622. enum Emotions {
  623. Anguish,
  624. Catharsis,
  625. }
  626. let vec: Vec<u8> = vec![0x01, 0x00];
  627. let result = from_vec(&vec);
  628. assert_eq!(Emotions::Catharsis, result?);
  629. Ok(())
  630. }
  631. #[test]
  632. fn deserialize_struct_variant() -> Result<()> {
  633. #[derive(Debug, PartialEq, Deserialize)]
  634. enum Vector {
  635. Dim2(i32, i32),
  636. Dim3(i32, i32, i32),
  637. }
  638. let expected = Vector::Dim3(1, -1, -2);
  639. let vec: Vec<u8> = vec![
  640. 0x01, 0x00, // The variant index.
  641. 0x01, 0x00, 0x00, 0x00, // The first entry.
  642. 0xFF, 0xFF, 0xFF, 0xFF, // The second entry.
  643. 0xFE, 0xFF, 0xFF, 0xFF, // The last entry.
  644. ];
  645. let result = from_vec(&vec);
  646. assert_eq!(expected, result?);
  647. Ok(())
  648. }
  649. }