fifthtry_serde_sqlite_jsonb/
de.rs

1// Copyright 2018 Serde Developers
2//
3// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
4// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
5// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
6// option. This file may not be copied, modified, or distributed
7// except according to those terms.
8
9use crate::error::{Error, Result};
10use crate::header::{ElementType, Header};
11use serde::de::{self, Deserialize, IntoDeserializer, SeqAccess, Visitor};
12use std::convert::Infallible;
13use std::io::Read;
14
15/// A structure that deserializes SQLite JSONB data into Rust values.
16pub struct Deserializer<R: Read> {
17    /// The reader that the deserializer reads from.
18    reader: R,
19}
20
21impl<'a> Deserializer<&'a [u8]> {
22    /// Deserialize an instance of type `T` from a byte slice of SQLite JSONB data.
23    #[allow(clippy::should_implement_trait)]
24    pub fn from_bytes(input: &'a [u8]) -> Self {
25        Deserializer { reader: input }
26    }
27}
28
29/// Deserialize an instance of type `T` from a byte slice of SQLite JSONB data.
30pub fn from_slice<'a, T>(s: &'a [u8]) -> Result<T>
31where
32    T: Deserialize<'a>,
33{
34    let mut deserializer = Deserializer::from_bytes(s);
35    let t = T::deserialize(&mut deserializer)?;
36    if deserializer.reader.is_empty() {
37        Ok(t)
38    } else {
39        Err(Error::TrailingCharacters)
40    }
41}
42
43/// Deserialize an instance of type `T` from a byte slice of SQLite JSONB data.
44pub fn from_reader<'a, R: Read, T>(reader: R) -> Result<T>
45where
46    T: Deserialize<'a>,
47{
48    let mut deserializer = Deserializer { reader };
49    let t = T::deserialize(&mut deserializer)?;
50    let Deserializer { mut reader } = deserializer;
51    if reader.read(&mut [0])? == 0 {
52        Ok(t)
53    } else {
54        Err(Error::TrailingCharacters)
55    }
56}
57
58impl<R: Read> Deserializer<R> {
59    fn with_header(&mut self, header: Header) -> Deserializer<impl Read + '_> {
60        // a little bit of a hack to "unread" a header that was already read
61        let header_bytes = std::io::Cursor::new(header.serialize());
62        let reader = header_bytes.chain(&mut self.reader);
63        Deserializer { reader }
64    }
65
66    fn read_header(&mut self) -> Result<Header> {
67        /*  The upper four bits of the first byte of the header determine
68          - size of the header
69          - and possibly also the size of the payload.
70        */
71        let mut header_0 = [0u8; 1];
72        if self.reader.read(&mut header_0)? == 0 {
73            return Err(Error::Empty);
74        }
75        let first_byte = header_0[0];
76        let upper_four_bits = first_byte >> 4;
77        /*
78         If the upper four bits have a value between 0 and 11,
79        then the header is exactly one byte in size and the payload size is determined by those upper four bits.
80
81        If the upper four bits have a value between 12 and 15,
82        that means that the total header size is 2, 3, 5, or 9 bytes and the payload size is unsigned big-endian integer that is contained in the subsequent bytes.
83
84        The size integer is
85          - the one byte that following the initial header byte if the upper four bits are 12,
86          - two bytes if the upper bits are 13,
87          - four bytes if the upper bits are 14,
88          - and eight bytes if the upper bits are 15.
89        */
90        let bytes_to_read = match upper_four_bits {
91            0..=11 => 0,
92            12 => 1,
93            13 => 2,
94            14 => 4,
95            15 => 8,
96            n => unreachable!("{n} does not fit in four bits"),
97        };
98        let payload_size: u64 = if bytes_to_read == 0 {
99            u64::from(upper_four_bits)
100        } else {
101            let mut buf = [0u8; 8];
102            let start = 8 - bytes_to_read;
103            self.reader.read_exact(&mut buf[start..8])?;
104            u64::from_be_bytes(buf)
105        };
106        Ok(Header {
107            element_type: ElementType::from(first_byte),
108            payload_size,
109        })
110    }
111
112    fn read_payload_string(&mut self, header: Header) -> Result<String> {
113        let mut str = String::with_capacity(header.payload_size as usize);
114        let read = self.reader_with_limit(header)?.read_to_string(&mut str)?;
115        assert_eq!(read, header.payload_size as usize);
116        Ok(str)
117    }
118
119    fn drop_payload(&mut self, header: Header) -> Result<ElementType> {
120        let mut remaining = header.payload_size;
121        while remaining > 0 {
122            let mut buf = [0u8; 256];
123            let len = buf.len().min(remaining as usize);
124            self.reader.read_exact(&mut buf[..len])?;
125            remaining -= len as u64;
126        }
127        Ok(header.element_type)
128    }
129
130    fn read_bool(&mut self, header: Header) -> Result<bool> {
131        self.drop_payload(header)?;
132        match header.element_type {
133            ElementType::True => Ok(true),
134            ElementType::False => Ok(false),
135            t => Err(Error::UnexpectedType(t)),
136        }
137    }
138
139    fn read_null(&mut self, header: Header) -> Result<()> {
140        self.drop_payload(header)?;
141        match header.element_type {
142            ElementType::Null => Ok(()),
143            t => Err(Error::UnexpectedType(t)),
144        }
145    }
146
147    fn reader_with_limit(&mut self, header: Header) -> Result<impl Read + '_> {
148        let limit =
149            u64::try_from(header.payload_size).map_err(u64_conversion)?;
150        Ok((&mut self.reader).take(limit))
151    }
152
153    fn read_json_compatible<T>(&mut self, header: Header) -> Result<T>
154    where
155        for<'a> T: Deserialize<'a>,
156    {
157        if header.payload_size <= 8 {
158            // micro-optimization: read small payloads into a stack buffer
159            let mut buf = [0u8; 8];
160            let smallbuf = &mut buf[..header.payload_size as usize];
161            self.reader.read_exact(smallbuf)?;
162            Ok(crate::json::parse_json_slice(smallbuf)?)
163        } else {
164            let mut reader = self.reader_with_limit(header)?;
165            Ok(crate::json::parse_json(&mut reader)?)
166        }
167    }
168
169    fn read_json5_compatible<T>(&mut self, header: Header) -> Result<T>
170    where
171        for<'a> T: Deserialize<'a>,
172    {
173        let mut reader = self.reader_with_limit(header)?;
174        Ok(crate::json::parse_json5(&mut reader)?)
175    }
176
177    fn read_json_compatible_string(
178        &mut self,
179        header: Header,
180    ) -> Result<String> {
181        let mut reader = read_with_quotes(self.reader_with_limit(header)?);
182        Ok(crate::json::parse_json(&mut reader)?)
183    }
184
185    fn read_json5_compatible_string(
186        &mut self,
187        header: Header,
188    ) -> Result<String> {
189        let mut reader = read_with_quotes(self.reader_with_limit(header)?);
190        Ok(crate::json::parse_json5(&mut reader)?)
191    }
192
193    fn read_integer<T>(&mut self, header: Header) -> Result<T>
194    where
195        for<'a> T: Deserialize<'a>,
196    {
197        match header.element_type {
198            ElementType::Int => self.read_json_compatible(header),
199            ElementType::Int5 => self.read_json5_compatible(header),
200            t => Err(Error::UnexpectedType(t)),
201        }
202    }
203
204    fn read_string(&mut self, header: Header) -> Result<String> {
205        match header.element_type {
206            ElementType::Text | ElementType::TextRaw => {
207                self.read_payload_string(header)
208            }
209            ElementType::TextJ => self.read_json_compatible_string(header),
210            ElementType::Text5 => self.read_json5_compatible_string(header),
211            t => Err(Error::UnexpectedType(t)),
212        }
213    }
214
215    fn read_float<T>(&mut self, header: Header) -> Result<T>
216    where
217        for<'a> T: Deserialize<'a>,
218    {
219        match header.element_type {
220            ElementType::Int => self.read_json_compatible(header),
221            ElementType::Int5 => self.read_json5_compatible(header),
222            ElementType::Float => self.read_json_compatible(header),
223            ElementType::Float5 => self.read_json5_compatible(header),
224            t => Err(Error::UnexpectedType(t)),
225        }
226    }
227
228    fn deserialize_any_with_header<'de, V>(
229        &mut self,
230        header: Header,
231        visitor: V,
232    ) -> Result<V::Value>
233    where
234        V: Visitor<'de>,
235    {
236        match header.element_type {
237            ElementType::Null => {
238                self.read_null(header)?;
239                visitor.visit_unit()
240            }
241            ElementType::True | ElementType::False => {
242                visitor.visit_bool(self.read_bool(header)?)
243            }
244            ElementType::Float | ElementType::Float5 => {
245                visitor.visit_f64(self.read_float(header)?)
246            }
247            ElementType::Int | ElementType::Int5 => {
248                let i: i64 = self.read_integer(header)?;
249                if let Ok(x) = u8::try_from(i) {
250                    visitor.visit_u8(x)
251                } else if let Ok(x) = i8::try_from(i) {
252                    visitor.visit_i8(x)
253                } else if let Ok(x) = u16::try_from(i) {
254                    visitor.visit_u16(x)
255                } else if let Ok(x) = i16::try_from(i) {
256                    visitor.visit_i16(x)
257                } else if let Ok(x) = u32::try_from(i) {
258                    visitor.visit_u32(x)
259                } else if let Ok(x) = i32::try_from(i) {
260                    visitor.visit_i32(x)
261                } else if let Ok(x) = u64::try_from(i) {
262                    visitor.visit_u64(x)
263                } else {
264                    visitor.visit_i64(i)
265                }
266            }
267            ElementType::Array => visitor.visit_seq(self),
268            ElementType::Object => visitor.visit_map(self),
269            ElementType::Text
270            | ElementType::TextJ
271            | ElementType::Text5
272            | ElementType::TextRaw => {
273                visitor.visit_string(self.read_string(header)?)
274            }
275            ElementType::Reserved13
276            | ElementType::Reserved14
277            | ElementType::Reserved15 => {
278                Err(Error::UnexpectedType(header.element_type))
279            }
280        }
281    }
282}
283
284fn read_with_quotes(r: impl Read) -> impl Read {
285    b"\"".chain(r).chain(&b"\""[..])
286}
287
288fn u64_conversion(e: Infallible) -> Error {
289    Error::Io(std::io::Error::new(std::io::ErrorKind::InvalidData, e))
290}
291
292impl<'de, 'a, R: Read> de::Deserializer<'de> for &'a mut Deserializer<R> {
293    type Error = Error;
294
295    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
296    where
297        V: Visitor<'de>,
298    {
299        let header = self.read_header()?;
300        self.deserialize_any_with_header(header, visitor)
301    }
302
303    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
304    where
305        V: Visitor<'de>,
306    {
307        let header = self.read_header()?;
308        visitor.visit_bool(self.read_bool(header)?)
309    }
310
311    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
312    where
313        V: Visitor<'de>,
314    {
315        let header = self.read_header()?;
316        visitor.visit_i8(self.read_integer(header)?)
317    }
318
319    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
320    where
321        V: Visitor<'de>,
322    {
323        let header = self.read_header()?;
324        visitor.visit_i16(self.read_integer(header)?)
325    }
326
327    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
328    where
329        V: Visitor<'de>,
330    {
331        let header = self.read_header()?;
332        visitor.visit_i32(self.read_integer(header)?)
333    }
334
335    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
336    where
337        V: Visitor<'de>,
338    {
339        let header = self.read_header()?;
340        visitor.visit_i64(self.read_integer(header)?)
341    }
342
343    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
344    where
345        V: Visitor<'de>,
346    {
347        let header = self.read_header()?;
348        visitor.visit_u8(self.read_integer(header)?)
349    }
350
351    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
352    where
353        V: Visitor<'de>,
354    {
355        let header = self.read_header()?;
356        visitor.visit_u16(self.read_integer(header)?)
357    }
358
359    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
360    where
361        V: Visitor<'de>,
362    {
363        let header = self.read_header()?;
364        visitor.visit_u32(self.read_integer(header)?)
365    }
366
367    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
368    where
369        V: Visitor<'de>,
370    {
371        let header = self.read_header()?;
372        visitor.visit_u64(self.read_integer(header)?)
373    }
374
375    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
376    where
377        V: Visitor<'de>,
378    {
379        let header = self.read_header()?;
380        if header.element_type == ElementType::Null {
381            visitor.visit_none()
382        } else {
383            let mut deser = self.with_header(header);
384            visitor.visit_some(&mut deser)
385        }
386    }
387
388    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
389    where
390        V: Visitor<'de>,
391    {
392        let header = self.read_header()?;
393        self.read_null(header)?;
394        visitor.visit_unit()
395    }
396
397    fn deserialize_unit_struct<V>(
398        self,
399        _name: &'static str,
400        visitor: V,
401    ) -> Result<V::Value>
402    where
403        V: Visitor<'de>,
404    {
405        self.deserialize_unit(visitor)
406    }
407
408    fn deserialize_newtype_struct<V>(
409        self,
410        _name: &'static str,
411        visitor: V,
412    ) -> Result<V::Value>
413    where
414        V: Visitor<'de>,
415    {
416        visitor.visit_newtype_struct(self)
417    }
418
419    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
420    where
421        V: Visitor<'de>,
422    {
423        let head = self.read_header()?;
424        let reader = self.reader_with_limit(head)?;
425        let mut seq_deser = Deserializer { reader };
426        visitor.visit_seq(&mut seq_deser)
427    }
428
429    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
430    where
431        V: Visitor<'de>,
432    {
433        self.deserialize_seq(visitor)
434    }
435
436    fn deserialize_tuple_struct<V>(
437        self,
438        _name: &'static str,
439        _len: usize,
440        visitor: V,
441    ) -> Result<V::Value>
442    where
443        V: Visitor<'de>,
444    {
445        self.deserialize_seq(visitor)
446    }
447
448    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
449    where
450        V: Visitor<'de>,
451    {
452        let head = self.read_header()?;
453        let reader = self.reader_with_limit(head)?;
454        let mut seq_deser = Deserializer { reader };
455        visitor.visit_map(&mut seq_deser)
456    }
457
458    fn deserialize_struct<V>(
459        self,
460        _name: &'static str,
461        _fields: &'static [&'static str],
462        visitor: V,
463    ) -> Result<V::Value>
464    where
465        V: Visitor<'de>,
466    {
467        self.deserialize_map(visitor)
468    }
469
470    fn deserialize_enum<V>(
471        self,
472        _name: &'static str,
473        _variants: &'static [&'static str],
474        visitor: V,
475    ) -> Result<V::Value>
476    where
477        V: Visitor<'de>,
478    {
479        let header = self.read_header()?;
480        match header.element_type {
481            ElementType::Text
482            | ElementType::TextJ
483            | ElementType::Text5
484            | ElementType::TextRaw => {
485                let s = self.read_string(header)?;
486                visitor.visit_enum(s.into_deserializer())
487            }
488            ElementType::Object => {
489                let reader = self.reader_with_limit(header)?;
490                let mut de = Deserializer { reader };
491                let r = visitor.visit_enum(&mut de);
492                if de.reader.read(&mut [0])? == 0 {
493                    r
494                } else {
495                    Err(Error::TrailingCharacters)
496                }
497            }
498            other => Err(Error::UnexpectedType(other)),
499        }
500    }
501
502    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
503    where
504        V: Visitor<'de>,
505    {
506        self.deserialize_str(visitor)
507    }
508
509    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
510    where
511        V: Visitor<'de>,
512    {
513        let header = self.read_header()?;
514        self.drop_payload(header)?;
515        visitor.visit_unit()
516    }
517
518    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
519    where
520        V: Visitor<'de>,
521    {
522        let header = self.read_header()?;
523        visitor.visit_f32(self.read_float(header)?)
524    }
525
526    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
527    where
528        V: Visitor<'de>,
529    {
530        let header = self.read_header()?;
531        visitor.visit_f64(self.read_float(header)?)
532    }
533
534    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
535    where
536        V: Visitor<'de>,
537    {
538        let header = self.read_header()?;
539        let s = self.read_string(header)?;
540        if s.len() != 1 {
541            return Err(Error::Message(
542                "invalid string length for char".into(),
543            ));
544        }
545        visitor.visit_char(s.chars().next().unwrap())
546    }
547
548    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
549    where
550        V: Visitor<'de>,
551    {
552        // Borrowed string deserialization is not supported
553        self.deserialize_string(visitor)
554    }
555
556    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
557    where
558        V: Visitor<'de>,
559    {
560        let header = self.read_header()?;
561        visitor.visit_string(self.read_string(header)?)
562    }
563
564    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
565    where
566        V: Visitor<'de>,
567    {
568        self.deserialize_seq(visitor)
569    }
570
571    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
572    where
573        V: Visitor<'de>,
574    {
575        self.deserialize_seq(visitor)
576    }
577}
578
579impl<'de, 'a, R: Read> de::SeqAccess<'de> for &'a mut Deserializer<R> {
580    type Error = Error;
581
582    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
583    where
584        T: de::DeserializeSeed<'de>,
585    {
586        match seed.deserialize(&mut **self) {
587            Ok(v) => Ok(Some(v)),
588            Err(Error::Empty) => Ok(None),
589            Err(e) => Err(e),
590        }
591    }
592}
593
594impl<'de, 'a, R: Read> de::MapAccess<'de> for &'a mut Deserializer<R> {
595    type Error = Error;
596
597    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
598    where
599        K: de::DeserializeSeed<'de>,
600    {
601        self.next_element_seed(seed)
602    }
603
604    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
605    where
606        V: de::DeserializeSeed<'de>,
607    {
608        self.next_element_seed(seed)
609            .and_then(|opt| opt.ok_or_else(|| Error::Empty))
610    }
611}
612
613impl<'de, 'a, R: Read> de::EnumAccess<'de> for &'a mut Deserializer<R> {
614    type Error = Error;
615    type Variant = Self;
616
617    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
618    where
619        V: de::DeserializeSeed<'de>,
620    {
621        let val = seed.deserialize(&mut *self)?;
622        Ok((val, self))
623    }
624}
625
626impl<'de, 'a, R: Read> de::VariantAccess<'de> for &'a mut Deserializer<R> {
627    type Error = Error;
628
629    fn unit_variant(self) -> Result<()> {
630        Ok(())
631    }
632
633    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
634    where
635        T: de::DeserializeSeed<'de>,
636    {
637        seed.deserialize(self)
638    }
639
640    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
641    where
642        V: Visitor<'de>,
643    {
644        de::Deserializer::deserialize_seq(self, visitor)
645    }
646
647    fn struct_variant<V>(
648        self,
649        _fields: &'static [&'static str],
650        visitor: V,
651    ) -> Result<V::Value>
652    where
653        V: Visitor<'de>,
654    {
655        de::Deserializer::deserialize_map(self, visitor)
656    }
657}
658#[cfg(test)]
659mod tests {
660    use super::*;
661
662    fn assert_header(bytes: &[u8], expected: Header) {
663        let mut de = Deserializer::from_bytes(bytes);
664        let header = de.read_header().unwrap();
665        assert_eq!(header, expected);
666    }
667
668    #[test]
669    fn test_read_header() {
670        assert_header(
671            &[0b_0000_0000],
672            Header {
673                element_type: ElementType::Null,
674                payload_size: 0,
675            },
676        );
677        assert_header(
678            &[0b_0000_0001],
679            Header {
680                element_type: ElementType::True,
681                payload_size: 0,
682            },
683        );
684        assert_header(
685            &[0b_0000_0010],
686            Header {
687                element_type: ElementType::False,
688                payload_size: 0,
689            },
690        );
691        assert_header(
692            &[0b_1100_0011, 0xFA],
693            Header {
694                element_type: ElementType::Int,
695                payload_size: 0xFA,
696            },
697        );
698        assert_header(
699            b"\xf3\x00\x00\x00\x00\x00\x00\x00\x01",
700            Header {
701                element_type: ElementType::Int,
702                payload_size: 1,
703            },
704        );
705        assert_header(
706            b"\xbb",
707            Header {
708                element_type: ElementType::Array,
709                payload_size: 11,
710            },
711        );
712    }
713
714    fn assert_all_int_types_eq(encoded: &[u8], expected: i64) {
715        // unsigned
716        assert_eq!(
717            from_slice::<i8>(encoded).unwrap(),
718            expected as i8,
719            "parsing {encoded:?} as i8"
720        );
721        assert_eq!(from_slice::<i16>(encoded).unwrap(), expected as i16);
722        assert_eq!(from_slice::<i32>(encoded).unwrap(), expected as i32);
723        assert_eq!(from_slice::<i64>(encoded).unwrap(), expected);
724        // signed
725        assert_eq!(from_slice::<u8>(encoded).unwrap(), expected as u8);
726        assert_eq!(from_slice::<u16>(encoded).unwrap(), expected as u16);
727        assert_eq!(from_slice::<u32>(encoded).unwrap(), expected as u32);
728        assert_eq!(from_slice::<u64>(encoded).unwrap(), expected as u64);
729    }
730
731    #[test]
732    fn test_decoding_1() {
733        /* From the spec:
734        The header for an element does not need to be in its simplest form. For example, consider the JSON numeric value "1". That element can be encode in five different ways:
735           0x13 0x31
736           0xc3 0x01 0x31
737           0xd3 0x00 0x01 0x31
738           0xe3 0x00 0x00 0x00 0x01 0x31
739           0xf3 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x01 0x31
740        */
741        assert_all_int_types_eq(b"\x13\x31", 1);
742        assert_all_int_types_eq(b"\xc3\x01\x31", 1);
743        assert_all_int_types_eq(b"\xd3\x00\x01\x31", 1);
744        assert_all_int_types_eq(b"\xe3\x00\x00\x00\x01\x31", 1);
745        assert_all_int_types_eq(b"\xf3\x00\x00\x00\x00\x00\x00\x00\x01\x31", 1);
746        assert_all_int_types_eq(b"\xc3\x03127", 127);
747    }
748
749    #[test]
750    fn test_decoding_large_int() {
751        assert_eq!(
752            from_slice::<u64>(b"\xc3\xf418446744073709551615").unwrap(),
753            18446744073709551615
754        );
755        // large negative i64
756        assert_eq!(
757            from_slice::<i64>(b"\xc3\xf5-9223372036854775808").unwrap(),
758            -9223372036854775808
759        );
760    }
761
762    #[test]
763    fn test_decoding_large_float() {
764        // large negative i64
765        assert_eq!(
766            from_slice::<f64>(b"\xc5\x0c-0.123456789").unwrap(),
767            -0.123456789
768        );
769    }
770
771    #[test]
772    fn test_decoding_int_as_float() {
773        // large negative i64
774        assert_eq!(from_slice::<f32>(b"\xc3\x0512345").unwrap(), 12345.);
775    }
776
777    #[test]
778    fn test_null() {
779        from_slice::<()>(b"\x00").unwrap();
780    }
781
782    #[test]
783    fn test_option() {
784        assert_eq!(from_slice::<Option<u64>>(b"\x00").unwrap(), None);
785        assert_eq!(from_slice::<Option<Vec<u8>>>(b"\x00").unwrap(), None);
786        assert_eq!(from_slice::<Option<u8>>(b"\x2342").unwrap(), Some(42));
787    }
788
789    #[test]
790    fn test_string_noescape() {
791        assert_eq!(from_slice::<String>(b"\x57hello").unwrap(), "hello");
792    }
793
794    #[test]
795    fn test_string_json_escape() {
796        assert_eq!(from_slice::<String>(b"\x28\\n").unwrap(), "\n");
797    }
798
799    #[test]
800    #[cfg(feature = "serde_json5")]
801    fn test_string_json5_escape() {
802        assert_eq!(from_slice::<String>(b"\x49\\x0A").unwrap(), "\n");
803    }
804
805    #[test]
806    fn test_tuple() {
807        assert_eq!(
808            from_slice::<(u8, i64, char)>(b"\x6b\x131\x132\x18x").unwrap(),
809            (1, 2, 'x')
810        );
811    }
812
813    #[test]
814    fn test_tuple_struct() {
815        #[derive(Debug, PartialEq, serde_derive::Deserialize)]
816        struct Test(Option<String>, bool, bool);
817        assert_eq!(
818            from_slice::<Test>(b"\x3b\x00\x01\x02").unwrap(),
819            Test(None, true, false)
820        );
821    }
822
823    #[test]
824    fn test_vec() {
825        assert_eq!(from_slice::<Vec<()>>(b"\x0b").unwrap(), vec![]);
826        assert_eq!(
827            from_slice::<Vec<u8>>(b"\x4b\x131\x132").unwrap(),
828            vec![1, 2]
829        );
830    }
831
832    #[test]
833    fn test_vec_opts() {
834        assert_eq!(
835            from_slice::<Vec<Option<String>>>(b"\xbb\x471234\x00\x475678")
836                .unwrap(),
837            vec![Some("1234".to_string()), None, Some("5678".to_string())]
838        );
839    }
840
841    #[test]
842    fn test_vec_with_reader() {
843        assert_eq!(from_reader::<_, Vec<()>>(&b"\x0b"[..]).unwrap(), vec![]);
844    }
845
846    #[test]
847    fn test_vec_of_vecs() {
848        assert_eq!(
849            from_slice::<Vec<Vec<i16>>>(
850                b"\xcb\x0a\x4b\x131\x132\x4b\x133\x134"
851            )
852            .unwrap(),
853            vec![vec![1, 2], vec![3, 4]]
854        );
855    }
856
857    #[test]
858    fn test_hashmap() {
859        use std::collections::HashMap;
860        let actual =
861            from_slice::<HashMap<String, bool>>(b"\x6c\x17a\x02\x17b\x01")
862                .unwrap();
863        let expected = [("a".into(), false), ("b".into(), true)]
864            .into_iter()
865            .collect();
866        assert_eq!(actual, expected);
867    }
868
869    #[test]
870    fn test_struct() {
871        #[derive(Debug, PartialEq, serde_derive::Deserialize)]
872        struct Test {
873            a: bool,
874            b: bool,
875        }
876        let actual = from_slice::<Test>(b"\x6c\x17a\x02\x17b\x01").unwrap();
877        let expected = Test { a: false, b: true };
878        assert_eq!(actual, expected);
879    }
880
881    #[test]
882    fn test_complex_struct() {
883        let bytes = b"\xcc\x3a\x27id\x131\x47name\x87John Doe\xc7\x0dphone_numbers\xbb\x471234\x00\x475678\x47data\x6b\x131\x132\x133";
884        let mut deser = Deserializer::from_bytes(bytes);
885        #[derive(Debug, PartialEq, serde_derive::Deserialize)]
886        struct Person {
887            id: i32,
888            name: String,
889            phone_numbers: Vec<Option<String>>,
890            data: Vec<u8>,
891        }
892        let person: Person = Person::deserialize(&mut deser).unwrap();
893        assert_eq!(
894            person,
895            Person {
896                id: 1,
897                name: "John Doe".to_string(),
898                phone_numbers: vec![
899                    Some("1234".to_string()),
900                    None,
901                    Some("5678".to_string())
902                ],
903                data: vec![1, 2, 3]
904            }
905        );
906    }
907
908    #[test]
909    fn test_basic_enum() {
910        #[derive(Debug, PartialEq, serde_derive::Deserialize)]
911        enum Test {
912            X,
913            Y,
914        }
915        let actual: Vec<Test> = from_slice(b"\x4b\x18X\x18Y").unwrap();
916        let expected = vec![Test::X, Test::Y];
917        assert_eq!(actual, expected);
918    }
919
920    #[test]
921    fn test_externally_tagged_enum() {
922        #[derive(Debug, PartialEq, serde_derive::Deserialize)]
923        enum Test {
924            X(String),
925            Y(bool),
926        }
927        // {"X": "Y"}
928        let actual: Test = from_slice(b"\x4c\x18X\x18Y").unwrap();
929        let expected = Test::X("Y".to_string());
930        assert_eq!(actual, expected);
931    }
932
933    #[test]
934    fn test_externally_tagged_enum_too_large() {
935        #[derive(Debug, PartialEq, serde_derive::Deserialize)]
936        enum Test {
937            X(char),
938            Y(char),
939        }
940        assert_eq!(
941            from_slice::<Vec<Test>>(b"\x9b\x8c\x18X\x18Y\x18Y\x18A")
942                .unwrap_err()
943                .to_string(),
944            Error::TrailingCharacters.to_string()
945        );
946    }
947}
fifthtry_serde_sqlite_jsonb/de.rs

fifthtry_serde_sqlite_jsonb/
de.rs
