serde_pod/
de.rs

1//! Содержит тип, реализующий простую десериализацию данных, как POD типов.
2
3use std::io::BufRead;
4use std::marker::PhantomData;
5use std::str;
6use std::string::String;
7use byteorder::{ByteOrder, ReadBytesExt};
8use serde::de::{self, Deserialize, DeserializeSeed, SeqAccess, Visitor};
9
10use error::{Error, Result};
11
12/// Структура для десериализации потока байт, практически из значений, как они хранятся
13/// в памяти, в значения Rust.
14///
15/// # Правила десериализации
16/// Все типы десериализуются максимально прямолинейно, так, как они лежат в памяти: для
17/// всех целых типов читается соответствующее их разрядности количество байт и интерпретируется
18/// в соответствии с порядком байт `BO`.
19///
20/// Для структур и кортежей рекурсивно десериализуются их поля, без разделителей между ними.
21/// Если такие разделители требуются, они должны быть внедрены непосредственно в структуру
22/// или кортеж.
23///
24/// Тип [`()`] при десериализации всегда считается присутствующим, когда запрашивается.
25///
26/// [Newtype] типы десериализуются, как оборачиваемое ими значение. Так как десериализация
27/// произвольных данных все равно не поддерживается, вызывающий код всегда будет знать, в какой
28/// именно тип он должен обернуть возвращенные данные, таким образом маркер типа даже не требуется.
29///
30/// При десериализации строк байты интерпретируются в кодировке UTF-8, являющейся нативной для Rust.
31/// В случае, если требуется читать строки в других кодировках, оберните их в структуры, для которых
32/// будет реализован типах [`Deserialize`], выполняющий чтение массива байт из потока и конвертирующий
33/// его в строку с помощью требуемой кодировки, например, используя крейт [encoding]. Чтение строки
34/// продолжается до конца потока, т.к. десериализатор не способен самостоятельно определить длину
35/// строки. В случае, если поток содержит некорректные UTF-8 данные, то возвращается ошибка
36/// [`Error::Encoding`].
37///
38/// При десериализации элемента типа `char` из потока читается требуемое количество байт (от 1 до 4-х)
39/// его UTF-8 представления; если в процессе чтения выясняется, что байты не составляют корректно
40/// кодированное значение символа в UTF-8, возвращается ошибка [`Error::Encoding`].
41///
42/// Десериализация последовательностей без определенной длины (таких, как [вектор]) осуществляется простой
43/// последовательной десериализацией их элементов до тех пор, пока в потоке остаются данные. Ни количество,
44/// ни разделители между элементами, ни какой-либо маркер конца последовательности не читаются. В случае,
45/// если они требуются для корректной десериализации, они должны быть добавлены в сериализуемые структуры
46/// вручную. Для последовательностей с известной длиной (например, массивы) читается запрошенное количество
47/// данных.
48///
49/// # Неподдерживаемые методы
50/// Для некоторых типов [модели serde] десериализация не поддержана, попытка их десериализации приводит
51/// к возврату ошибки [`Error::Unsupported`]. Также это означает, что [сериализатор] несимметричен по отношению
52/// к десериализатору: не все, что может быть закодировано, может быть раскодировано.
53///
54/// К неподдерживаемым типам модели относятся:
55/// - Оба варианта [`Option`] -- десериализатор не способен самостоятельно их различить. При необходимости
56///   десериализации типа [`Option`] можно реализовать собственную структуру, для которой реализовать
57///   типаж [`Deserialize`] и выполнить чтение маркера типа и данных `Some` варианта, если в потоке записан
58///   `Some` вариант
59/// - Перечисления. Также как и в предыдущем случае, десериализатор не способен самостоятельно определить,
60///   какой из вариантов записан в потоке. Стоит отметить, что данное ограничение применимо только к
61///   [варианту десериализации][enum] перечислений в externally tagged виде (с внешней пометкой), который
62///   является вариантом сериализации перечислений в serde по умолчанию. В остальных случаях serde десериализует
63///   перечисления, как структуры, что уже поддерживается десериализатором.
64/// - Тип `bool` также не поддерживается ввиду того, что десериализатор не знает, сколько байт читать и как
65///   их интерпретировать. Так как обычно булевы значения записываются в виде числа, не должно возникнуть
66///   проблем использовать вместо типа `bool` число, соответствующее его представлению в сериализованных данных.
67/// - Десериализация произвольных данных и отображений (map) также не поддерживается. Отображения обычно будут
68///   записаны в потоке, как список пар ключ-значение, поэтому не должно возникнуть проблем десериализовывать
69///   именно такие структуры, а затем приводить их в требуемый вид.
70///
71/// # Параметры типа
72/// - `BO`: определяет порядок байт, в котором будут записаны примитивные числовые типы:
73///         `u16`, `u32`, `u64`, `u128`, `i16`, `i32`, `i64`, `i128`, `f32` и `f64`.
74/// - `W`: определяет тип, обеспечивающих сохранение сериализуемых данных в хранилище
75///
76/// [`()`]: https://doc.rust-lang.org/std/primitive.unit.html
77/// [Newtype]: https://doc.rust-lang.org/rust-by-example/generics/new_types.html
78/// [`Deserialize`]: https://docs.serde.rs/serde/trait.Deserialize.html
79/// [encoding]: https://docs.rs/encoding/
80/// [`Error::Encoding`]: ../error/enum.Error.html#variant.Encoding
81/// [вектор]: https://doc.rust-lang.org/std/vec/struct.Vec.html
82/// [модели serde]: https://serde.rs/data-model.html
83/// [`Error::Unsupported`]: ../error/enum.Error.html#variant.Unsupported
84/// [сериализатор]: ../ser/struct.Serializer.html
85/// [`Option`]: https://doc.rust-lang.org/std/option/enum.Option.html
86/// [enum]: https://serde.rs/enum-representations.html
87pub struct Deserializer<BO, R> {
88  /// Источник данных для десериализации
89  reader: R,
90  /// Порядок байт, используемый при чтении чисел
91  _byteorder: PhantomData<BO>,
92}
93
94impl<BO, R> Deserializer<BO, R>
95  where R: BufRead,
96        BO: ByteOrder,
97{
98  /// Создает десериализатор с настройками по умолчанию. Строки кодируются в UTF-8,
99  /// если встречается непредставимый символ, декодирование прерывается и возвращается ошибка
100  ///
101  /// # Параметры
102  /// - `reader`: Поток, из которого будут читаться данные. Буферизация требуется для возможности
103  ///   определения окончания последовательностей, т.к. последовательности читаются до конца потока
104  ///   и требуется возможность определять, имеются ли в потоке еще данные или нет
105  ///
106  /// # Возвращаемое значение
107  /// Десериализатор для чтения данных из указанного потока и кодированием строк в UTF-8
108  pub fn new(reader: R) -> Self {
109    Deserializer { reader, _byteorder: PhantomData }
110  }
111  /// Читает все данные из потока в вектор и возвращает его
112  #[inline]
113  fn read_to_end(&mut self) -> Result<Vec<u8>> {
114    let mut buf = Vec::new();
115    self.reader.read_to_end(&mut buf)?;
116    Ok(buf)
117  }
118  /// Читает из потока один символ в кодировке UTF-8 (т.е. 1-4 байта для его формирования) и
119  /// возвращает его, либо возвращает ошибку, если в потоке недостаточно байт для декодирования
120  /// символа или они не представляют валидный символ в UTF-8
121  fn read_char(&mut self) -> Result<char> {
122    // Скопировано из реализации нестабильной функции core::str::utf8_char_width
123    // https://tools.ietf.org/html/rfc3629
124    static UTF8_CHAR_WIDTH: [u8; 256] = [
125      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
126      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x1F
127      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
128      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x3F
129      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
130      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x5F
131      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
132      1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1, // 0x7F
133      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
134      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0x9F
135      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
136      0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, // 0xBF
137      0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
138      2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2, // 0xDF
139      3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3, // 0xEF
140      4,4,4,4,4,0,0,0,0,0,0,0,0,0,0,0, // 0xFF
141    ];
142
143    let mut buf = [0u8; 4];
144    self.reader.read_exact(&mut buf[..1])?;// читаем 1 символ
145    let width = UTF8_CHAR_WIDTH[buf[0] as usize] as usize;
146    if width == 1 {
147      return Ok(buf[0] as char);
148    }
149    self.reader.read_exact(&mut buf[1..width])?;
150    let s = str::from_utf8(&buf[..width])?;
151    s.chars().next().ok_or_else(|| Error::Unknown("UTF-8 bytes decoded as empty string".into()))
152  }
153}
154
155/// Макрос, генерирующий код десериализации числовых типов
156macro_rules! impl_numbers {
157  ($dser_method:ident, $visitor_method:ident, $reader_method:ident) => {
158    fn $dser_method<V>(self, visitor: V) -> Result<V::Value>
159      where V: de::Visitor<'de>,
160    {
161      visitor.$visitor_method(self.reader.$reader_method::<BO>()?)
162    }
163  }
164}
165/// Макрос, генерирующий метод, возвращающий ошибку [`Error::Unsupported`]
166///
167/// [`Error::Unsupported`]: ../error/enum.Error.html#variant.Unsupported
168macro_rules! unsupported {
169  ($dser_method:ident) => {
170    /// Всегда возвращает ошибку [`Error::Unsupported`]
171    ///
172    /// [`Error::Unsupported`]: ../error/enum.Error.html#variant.Unsupported
173    fn $dser_method<V>(self, _visitor: V) -> Result<V::Value>
174      where V: Visitor<'de>,
175    {
176      Err(Error::Unsupported(concat!('`', stringify!($dser_method), "` is not supported")))
177    }
178  }
179}
180
181impl<'de, 'a, BO, R> de::Deserializer<'de> for &'a mut Deserializer<BO, R>
182  where R: BufRead,
183        BO: ByteOrder,
184{
185  type Error = Error;
186
187  /// Читает из потока 1 байт, интерпретируя его, как число со знаком
188  fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
189    where V: Visitor<'de>,
190  {
191    visitor.visit_i8(self.reader.read_i8()?)
192  }
193  /// Читает из потока 1 байт, интерпретируя его, как беззнаковое число
194  fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
195    where V: Visitor<'de>,
196  {
197    visitor.visit_u8(self.reader.read_u8()?)
198  }
199  impl_numbers!(deserialize_i16, visit_i16, read_i16);
200  impl_numbers!(deserialize_u16, visit_u16, read_u16);
201  impl_numbers!(deserialize_i32, visit_i32, read_i32);
202  impl_numbers!(deserialize_u32, visit_u32, read_u32);
203  impl_numbers!(deserialize_i64, visit_i64, read_i64);
204  impl_numbers!(deserialize_u64, visit_u64, read_u64);
205  impl_numbers!(deserialize_i128, visit_i128, read_i128);
206  impl_numbers!(deserialize_u128, visit_u128, read_u128);
207  impl_numbers!(deserialize_f32, visit_f32, read_f32);
208  impl_numbers!(deserialize_f64, visit_f64, read_f64);
209
210  fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
211    where V: Visitor<'de>,
212  {
213    visitor.visit_char(self.read_char()?)
214  }
215  #[inline]
216  fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
217    where V: Visitor<'de>,
218  {
219    self.deserialize_string(visitor)
220  }
221  /// Читает байты до конца потока, возвращает их посетителю в виде владеющего буфера.
222  /// Так как десериализатор сам не может определить, где заканчиваются данные, то для
223  /// десериализации сложных структур внешний код должен ограничить размер буфера концом
224  /// строки.
225  ///
226  /// Прочитанные байт интерпретируются, как строка в кодировке UTF-8, в случае, если это не так,
227  /// возвращается ошибка [`Error::Encoding`]
228  ///
229  /// [`Error::Encoding`]: ../error/enum.Error.html#variant.Encoding
230  fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
231    where V: Visitor<'de>,
232  {
233    let buf = self.read_to_end()?;
234    visitor.visit_string(String::from_utf8(buf)?)
235  }
236  #[inline]
237  fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
238    where V: Visitor<'de>,
239  {
240    self.deserialize_byte_buf(visitor)
241  }
242  fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
243    where V: Visitor<'de>,
244  {
245    visitor.visit_byte_buf(self.read_to_end()?)
246  }
247  /// Безусловно вызывает [`Visitor::visit_unit`]
248  ///
249  /// [`Visitor::visit_unit`]: https://docs.serde.rs/serde/de/trait.Visitor.html#method.visit_unit
250  fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
251    where V: Visitor<'de>,
252  {
253    visitor.visit_unit()
254  }
255  /// Безусловно вызывает [`Visitor::visit_unit`]. Аргумент `_name` игнорируется
256  ///
257  /// [`Visitor::visit_unit`]: https://docs.serde.rs/serde/de/trait.Visitor.html#method.visit_unit
258  fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
259    where V: Visitor<'de>,
260  {
261    visitor.visit_unit()
262  }
263  /// Безусловно вызывает [`Visitor::visit_newtype_struct`]. Аргумент `_name` игнорируется
264  ///
265  /// [`Visitor::visit_newtype_struct`]: https://docs.serde.rs/serde/de/trait.Visitor.html#method.visit_newtype_struct
266  fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
267    where V: Visitor<'de>,
268  {
269    visitor.visit_newtype_struct(self)
270  }
271  /// Десериализует последовательность, последовательно вычитывая ее элементы, пока не кончатся
272  /// данные в потоке. Элементы ничем не разделяются, никакого начального или конечного разделителя
273  /// не читается: если что-либо из этого требуется, они должны быть представлены, как читаемые
274  /// данные. Безусловно вызывает [`Visitor::visit_seq`]
275  ///
276  /// [`Visitor::visit_seq`]: https://docs.serde.rs/serde/de/trait.Visitor.html#method.visit_seq
277  fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
278    where V: Visitor<'de>,
279  {
280    visitor.visit_seq(self)
281  }
282  /// Десериализует кортеж, как последовательность его полей: безусловно вызывает
283  /// [`Visitor::visit_seq`].
284  ///
285  /// [`Visitor::visit_seq`]: https://docs.serde.rs/serde/de/trait.Visitor.html#method.visit_seq
286  fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
287    where V: Visitor<'de>,
288  {
289    visitor.visit_seq(Tuple { de: self, count: len })
290  }
291  /// Десериализует кортеж, как последовательность его полей: безусловно вызывает
292  /// [`Visitor::visit_seq`]. Аргумент `_name` игнорируется
293  ///
294  /// [`Visitor::visit_seq`]: https://docs.serde.rs/serde/de/trait.Visitor.html#method.visit_seq
295  #[inline]
296  fn deserialize_tuple_struct<V>(self, _name: &'static str, len: usize, visitor: V) -> Result<V::Value>
297    where V: Visitor<'de>,
298  {
299    self.deserialize_tuple(len, visitor)
300  }
301  /// Десериализует структуру, как последовательность ее полей: безусловно вызывает
302  /// [`Visitor::visit_seq`]. Аргумент `_name` игнорируется, в аргументе `fields` важна только его длина
303  ///
304  /// [`Visitor::visit_seq`]: https://docs.serde.rs/serde/de/trait.Visitor.html#method.visit_seq
305  #[inline]
306  fn deserialize_struct<V>(self, _name: &'static str, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
307    where V: Visitor<'de>,
308  {
309    self.deserialize_tuple(fields.len(), visitor)
310  }
311
312  unsupported!(deserialize_any);
313  unsupported!(deserialize_map);
314  unsupported!(deserialize_bool);
315  unsupported!(deserialize_option);
316  unsupported!(deserialize_identifier);
317  unsupported!(deserialize_ignored_any);
318  fn deserialize_enum<V>(self, _name: &'static str, _variants: &'static [&'static str], _visitor: V) -> Result<V::Value>
319    where V: Visitor<'de>,
320  {
321    Err(Error::Unsupported("`deserialize_enum` is not supported"))
322  }
323}
324
325/// Структура, используемая для чтения ограниченных по количеству последовательностей,
326/// таких, как массивы, структуры и кортежи
327struct Tuple<'a, BO, R> {
328  /// Объект, используемый для чтения и десериализации элементов
329  de: &'a mut Deserializer<BO, R>,
330  /// Количество элементов, которое осталось прочитать
331  count: usize,
332}
333impl<'a, 'de, BO, R> SeqAccess<'de> for Tuple<'a, BO, R>
334  where R: BufRead,
335        BO: ByteOrder,
336{
337  type Error = Error;
338
339  fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
340    where T: DeserializeSeed<'de>,
341  {
342    // Если еще есть элементы для чтения, вытаскиваем их
343    if self.count > 0 {
344      self.count -= 1;
345      return seed.deserialize(&mut *self.de).map(Some);
346    }
347    return Ok(None);
348  }
349
350  fn size_hint(&self) -> Option<usize> { Some(self.count) }
351}
352
353impl<'a, 'de, BO, R> SeqAccess<'de> for &'a mut Deserializer<BO, R>
354  where R: BufRead,
355        BO: ByteOrder,
356{
357  type Error = Error;
358
359  fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
360    where T: DeserializeSeed<'de>,
361  {
362    // Если данные закончились, прекращаем итерации
363    if self.reader.fill_buf()?.is_empty() {
364      return Ok(None);
365    }
366    seed.deserialize(&mut **self).map(Some)
367  }
368}
369
370/// Десериализует значение заданного типа из массива байт.
371///
372/// # Параметры
373/// - `storage`: Массив байт, содержащий сериализованное значение
374///
375/// # Параметры типа
376/// - `BO`: Порядок байт, в котором читать данные из потока
377/// - `T`: Десериализуемый тип
378///
379/// # Возвращаемое значение
380/// Прочитанное значение
381///
382/// # Ошибки
383/// Возможны 2 причины, по которым данный метод вернет ошибку:
384/// - Реализация `Deserialize` для типа `T` вернет ошибку
385/// - [`Error::Encoding`]: Десериализуемый тип содержит [строки], и в десериализуемых
386///   данных они не содержат корректных UTF-8 последовательностей
387///
388/// [`Error::Encoding`]: ../error/enum.Error.html#variant.Encoding
389/// [строки]: https://doc.rust-lang.org/std/string/struct.String.html
390pub fn from_bytes<'a, BO, T>(storage: &'a [u8]) -> Result<T>
391  where T: Deserialize<'a>,
392        BO: ByteOrder,
393{
394  let mut deserializer: Deserializer<BO, _> = Deserializer::new(storage);
395  T::deserialize(&mut deserializer)
396}
397
398////////////////////////////////////////////////////////////////////////////////
399
400#[cfg(test)]
401mod integers {
402  use super::from_bytes;
403  use byteorder::{BE, LE};
404
405  #[test]
406  fn test_u8() {
407    let test: u8 = 0x12;
408    assert_eq!(from_bytes::<BE, u8>(&[0x12]).unwrap(), test);
409    assert_eq!(from_bytes::<LE, u8>(&[0x12]).unwrap(), test);
410  }
411  #[test]
412  fn test_i8() {
413    let test: i8 = 0x12;
414    assert_eq!(from_bytes::<BE, i8>(&[0x12]).unwrap(), test);
415    assert_eq!(from_bytes::<LE, i8>(&[0x12]).unwrap(), test);
416  }
417
418  #[test]
419  fn test_u16() {
420    let test: u16 = 0x1234;
421    assert_eq!(from_bytes::<BE, u16>(&[0x12, 0x34]).unwrap(), test);
422    assert_eq!(from_bytes::<LE, u16>(&[0x34, 0x12]).unwrap(), test);
423  }
424  #[test]
425  fn test_i16() {
426    let test: i16 = 0x1234;
427    assert_eq!(from_bytes::<BE, i16>(&[0x12, 0x34]).unwrap(), test);
428    assert_eq!(from_bytes::<LE, i16>(&[0x34, 0x12]).unwrap(), test);
429  }
430
431  #[test]
432  fn test_u32() {
433    let test: u32 = 0x12345678;
434    assert_eq!(from_bytes::<BE, u32>(&[0x12, 0x34, 0x56, 0x78]).unwrap(), test);
435    assert_eq!(from_bytes::<LE, u32>(&[0x78, 0x56, 0x34, 0x12]).unwrap(), test);
436  }
437  #[test]
438  fn test_i32() {
439    let test: i32 = 0x12345678;
440    assert_eq!(from_bytes::<BE, i32>(&[0x12, 0x34, 0x56, 0x78]).unwrap(), test);
441    assert_eq!(from_bytes::<LE, i32>(&[0x78, 0x56, 0x34, 0x12]).unwrap(), test);
442  }
443
444  #[test]
445  fn test_u64() {
446    let test: u64 = 0x12345678_90ABCDEF;
447    assert_eq!(from_bytes::<BE, u64>(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]).unwrap(), test);
448    assert_eq!(from_bytes::<LE, u64>(&[0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12]).unwrap(), test);
449  }
450  #[test]
451  fn test_i64() {
452    let test: i64 = 0x12345678_90ABCDEF;
453    assert_eq!(from_bytes::<BE, i64>(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]).unwrap(), test);
454    assert_eq!(from_bytes::<LE, i64>(&[0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12]).unwrap(), test);
455  }
456
457  #[test]
458  fn test_u128() {
459    let test: u128 = 0x12345678_90ABCDEF_12345678_90ABCDEF;
460    assert_eq!(from_bytes::<BE, u128>(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]).unwrap(), test);
461    assert_eq!(from_bytes::<LE, u128>(&[0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12]).unwrap(), test);
462  }
463  #[test]
464  fn test_i128() {
465    let test: i128 = 0x12345678_90ABCDEF_12345678_90ABCDEF;
466    assert_eq!(from_bytes::<BE, i128>(&[0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF, 0x12, 0x34, 0x56, 0x78, 0x90, 0xAB, 0xCD, 0xEF]).unwrap(), test);
467    assert_eq!(from_bytes::<LE, i128>(&[0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12, 0xEF, 0xCD, 0xAB, 0x90, 0x78, 0x56, 0x34, 0x12]).unwrap(), test);
468  }
469}
470#[cfg(test)]
471mod floats {
472  use super::from_bytes;
473  use byteorder::{ByteOrder, BE, LE};
474
475  macro_rules! float_test {
476    ($name:ident, $BO:ident :: $write:ident, $type:ty) => (
477      quickcheck! {
478        fn $name(test: $type) -> bool {
479          let mut buf = [0; std::mem::size_of::<$type>()];
480          $BO::$write(&mut buf, test);
481          from_bytes::<$BO, $type>(&buf).unwrap() == test
482        }
483      }
484    );
485  }
486
487  float_test!(test_f32_be, BE::write_f32, f32);
488  float_test!(test_f32_le, LE::write_f32, f32);
489
490  float_test!(test_f64_be, BE::write_f64, f64);
491  float_test!(test_f64_le, LE::write_f64, f64);
492}
493#[cfg(test)]
494mod complex {
495  use super::from_bytes;
496  use byteorder::{BE, LE};
497
498  quickcheck! {
499    #[should_panic]
500    fn test_bool(byte: u8) -> bool {
501      from_bytes::<BE, bool>(&[byte]).unwrap()
502    }
503  }
504  /// При десериализации ничего не читает из потока
505  #[test]
506  fn test_unit() {
507    #[derive(Debug, Deserialize, PartialEq)]
508    struct Test;
509
510    let test = Test;
511    assert_eq!(from_bytes::<BE, Test>(&[]).unwrap(), test);
512    assert_eq!(from_bytes::<LE, Test>(&[]).unwrap(), test);
513  }
514
515  /// При десериализации читает из потока нижележащий тип
516  #[test]
517  fn test_newtype() {
518    #[derive(Debug, Deserialize, PartialEq)]
519    struct Test(u32);
520
521    let test = Test(0x12345678);
522    assert_eq!(from_bytes::<BE, Test>(&[0x12, 0x34, 0x56, 0x78]).unwrap(), test);
523    assert_eq!(from_bytes::<LE, Test>(&[0x78, 0x56, 0x34, 0x12]).unwrap(), test);
524  }
525
526  /// Поля в кортеже записываются подряд, в порядке следования, без пробелов и дополнительных данных.
527  /// Порядок байт переворачивается для каждого поля независимо.
528  #[test]
529  fn test_tuple() {
530    #[derive(Debug, Deserialize, PartialEq)]
531    struct Test(u32, u16);
532
533    let test = Test(0x12345678, 0xABCD);
534    assert_eq!(from_bytes::<BE, Test>(&[0x12, 0x34, 0x56, 0x78,   0xAB, 0xCD]).unwrap(), test);
535    assert_eq!(from_bytes::<LE, Test>(&[0x78, 0x56, 0x34, 0x12,   0xCD, 0xAB]).unwrap(), test);
536  }
537
538  /// Поля в структуре записываются подряд, в порядке следования, без пробелов и дополнительных данных.
539  /// Порядок байт переворачивается для каждого поля независимо.
540  #[test]
541  fn test_struct() {
542    #[derive(Debug, Deserialize, PartialEq)]
543    struct Test {
544      int1: u32,
545      int2: u16,
546    }
547
548    let test = Test { int1: 0x12345678, int2: 0xABCD };
549    assert_eq!(from_bytes::<BE, Test>(&[0x12, 0x34, 0x56, 0x78,   0xAB, 0xCD]).unwrap(), test);
550    assert_eq!(from_bytes::<LE, Test>(&[0x78, 0x56, 0x34, 0x12,   0xCD, 0xAB]).unwrap(), test);
551  }
552
553  /// Десериализатор не в состоянии различить `Some` и `None` -- для десериализации нужно
554  /// вручную прочитать (или определить) маркер, и прочитать значение, если маркер говорит,
555  /// что оно есть
556  #[test]
557  #[should_panic]
558  fn test_option_be() {
559    from_bytes::<BE, Option<u16>>(&[0x12, 0x34]).unwrap();
560  }
561  #[test]
562  #[should_panic]
563  fn test_option_le() {
564    from_bytes::<LE, Option<u16>>(&[0x12, 0x34]).unwrap();
565  }
566
567  /// Записывает все элементы последовательности подряд, без разделителей, заголовочной или
568  /// конечной информации, либо какой-либо информации о количестве элементов.
569  /// Порядок байт переворачивается для каждого поля независимо.
570  #[test]
571  fn test_seq() {
572    let test = [0x12, 0x34,   0x56, 0x78,   0xAB, 0xCD];
573    assert_eq!(from_bytes::<BE, Vec<u16>>(&test).unwrap(), vec![0x1234, 0x5678, 0xABCD]);
574    assert_eq!(from_bytes::<LE, Vec<u16>>(&test).unwrap(), vec![0x3412, 0x7856, 0xCDAB]);
575  }
576
577  /// Возврат срезов строки не поддерживается, т.к. десериализатор всегда выдает новую строку
578  #[test]
579  #[should_panic]
580  fn test_str_be() {
581    from_bytes::<BE, &str>("test".as_bytes()).unwrap();
582  }
583  #[test]
584  #[should_panic]
585  fn test_str_le() {
586    from_bytes::<LE, &str>("test".as_bytes()).unwrap();
587  }
588  #[test]
589  fn test_string() {
590    let test = "тест";
591    assert_eq!(from_bytes::<BE, String>(test.as_bytes()).unwrap(), test);
592    assert_eq!(from_bytes::<LE, String>(test.as_bytes()).unwrap(), test);
593  }
594
595  #[test]
596  fn test_array_empty() {
597    assert_eq!(from_bytes::<BE, [u16; 0]>(&[]).unwrap(), []);
598    assert_eq!(from_bytes::<LE, [u16; 0]>(&[]).unwrap(), []);
599  }
600  #[test]
601  fn test_array() {
602    let test = [0x12, 0x34, 0x56, 0x78, 0xAB, 0xCD];
603    assert_eq!(from_bytes::<BE, [u16; 3]>(&test).unwrap(), [0x1234, 0x5678, 0xABCD]);
604    assert_eq!(from_bytes::<LE, [u16; 3]>(&test).unwrap(), [0x3412, 0x7856, 0xCDAB]);
605  }
606  #[test]
607  #[should_panic]
608  fn test_array_no_data_be() {
609    let test = [0x12, 0x34, 0x56, 0x78, 0xAB];
610    from_bytes::<BE, [u16; 3]>(&test).unwrap();
611  }
612  #[test]
613  #[should_panic]
614  fn test_array_no_data_le() {
615    let test = [0x12, 0x34, 0x56, 0x78, 0xAB];
616    from_bytes::<LE, [u16; 3]>(&test).unwrap();
617  }
618  #[test]
619  fn test_vec() {
620    let test = [0x12, 0x34, 0x56, 0x78, 0xAB, 0xCD];
621    assert_eq!(from_bytes::<BE, Vec<u16>>(&test).unwrap(), vec![0x1234, 0x5678, 0xABCD]);
622    assert_eq!(from_bytes::<LE, Vec<u16>>(&test).unwrap(), vec![0x3412, 0x7856, 0xCDAB]);
623  }
624  #[test]
625  #[should_panic]
626  fn test_vec_no_data_be() {
627    let test = [0x12, 0x34, 0x56, 0x78, 0xAB];
628    from_bytes::<BE, Vec<u16>>(&test).unwrap();
629  }
630  #[test]
631  #[should_panic]
632  fn test_vec_no_data_le() {
633    let test = [0x12, 0x34, 0x56, 0x78, 0xAB];
634    from_bytes::<LE, Vec<u16>>(&test).unwrap();
635  }
636}
serde_pod/de.rs

serde_pod/
de.rs
