dlhn/
ser.rs

1use crate::{PrefixVarint, ZigZag};
2use serde::{
3    ser::{self, Impossible},
4    Serialize,
5};
6use std::{
7    fmt::{self, Display},
8    io::Write,
9};
10
11#[derive(Clone, Debug, PartialEq)]
12pub enum Error {
13    Write,
14    UnsupportedKeyType,
15    Message(String),
16}
17
18impl ser::Error for Error {
19    fn custom<T: Display>(msg: T) -> Self {
20        Error::Message(msg.to_string())
21    }
22}
23
24impl Display for Error {
25    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
26        match self {
27            Error::Write => formatter.write_str("write error"),
28            Error::UnsupportedKeyType => formatter.write_str("unsupported key type"),
29            Error::Message(message) => formatter.write_str(message),
30        }
31    }
32}
33
34impl std::error::Error for Error {}
35
36pub struct Serializer<W: Write> {
37    output: W,
38}
39
40impl<W: Write> Serializer<W> {
41    pub fn new(output: W) -> Self {
42        Self { output }
43    }
44}
45
46impl<'a, W: Write> ser::Serializer for &'a mut Serializer<W> {
47    type Ok = ();
48    type Error = Error;
49    type SerializeSeq = Self;
50    type SerializeTuple = Self;
51    type SerializeTupleStruct = Self;
52    type SerializeTupleVariant = Self;
53    type SerializeMap = Self;
54    type SerializeStruct = Self;
55    type SerializeStructVariant = Self;
56
57    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
58        if v {
59            self.output.write_all(&[1]).or(Err(Error::Write))
60        } else {
61            self.output.write_all(&[0]).or(Err(Error::Write))
62        }
63    }
64
65    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
66        self.output
67            .write_all(&v.to_le_bytes())
68            .or(Err(Error::Write))
69    }
70
71    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
72        let mut buf = [0u8; u16::PREFIX_VARINT_BUF_SIZE];
73        let size = v.encode_zigzag().encode_prefix_varint(&mut buf);
74        self.output.write_all(&buf[..size]).or(Err(Error::Write))
75    }
76
77    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
78        let mut buf = [0u8; u32::PREFIX_VARINT_BUF_SIZE];
79        let size = v.encode_zigzag().encode_prefix_varint(&mut buf);
80        self.output.write_all(&buf[..size]).or(Err(Error::Write))
81    }
82
83    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
84        let mut buf = [0u8; u64::PREFIX_VARINT_BUF_SIZE];
85        let size = v.encode_zigzag().encode_prefix_varint(&mut buf);
86        self.output.write_all(&buf[..size]).or(Err(Error::Write))
87    }
88
89    // fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
90    //     let mut buf = [0u8; u128::LEB128_BUF_SIZE];
91    //     let size = v.encode_zigzag().encode_leb128(&mut buf);
92    //     self.output.write_all(&buf[..size]).or(Err(Error::Write))
93    // }
94
95    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
96        self.output
97            .write_all(&v.to_le_bytes())
98            .or(Err(Error::Write))
99    }
100
101    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
102        let mut buf = [0u8; u16::PREFIX_VARINT_BUF_SIZE];
103        let size = v.encode_prefix_varint(&mut buf);
104        self.output.write_all(&buf[..size]).or(Err(Error::Write))
105    }
106
107    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
108        let mut buf = [0u8; u32::PREFIX_VARINT_BUF_SIZE];
109        let size = v.encode_prefix_varint(&mut buf);
110        self.output.write_all(&buf[..size]).or(Err(Error::Write))
111    }
112
113    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
114        let mut buf = [0u8; u64::PREFIX_VARINT_BUF_SIZE];
115        let size = v.encode_prefix_varint(&mut buf);
116        self.output.write_all(&buf[..size]).or(Err(Error::Write))
117    }
118
119    // fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
120    //     let mut buf = [0u8; u128::LEB128_BUF_SIZE];
121    //     let size = v.encode_leb128(&mut buf);
122    //     self.output.write_all(&buf[..size]).or(Err(Error::Write))
123    // }
124
125    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
126        self.output
127            .write_all(&v.to_le_bytes())
128            .or(Err(Error::Write))
129    }
130
131    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
132        self.output
133            .write_all(&v.to_le_bytes())
134            .or(Err(Error::Write))
135    }
136
137    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
138        v.to_string().serialize(self)
139    }
140
141    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
142        (v.len() as u64).serialize(&mut *self)?;
143        self.output.write_all(v.as_bytes()).or(Err(Error::Write))
144    }
145
146    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
147        (v.len() as u64).serialize(&mut *self)?;
148        self.output.write_all(v).or(Err(Error::Write))
149    }
150
151    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
152        self.output.write_all(&[0u8]).or(Err(Error::Write))
153    }
154
155    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
156    where
157        T: serde::Serialize,
158    {
159        self.output.write_all(&[1u8]).or(Err(Error::Write))?;
160        value.serialize(self)
161    }
162
163    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
164        Ok(())
165    }
166
167    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
168        Ok(())
169    }
170
171    fn serialize_unit_variant(
172        self,
173        _name: &'static str,
174        variant_index: u32,
175        _variant: &'static str,
176    ) -> Result<Self::Ok, Self::Error> {
177        variant_index.serialize(self)
178    }
179
180    fn serialize_newtype_struct<T: ?Sized>(
181        self,
182        _name: &'static str,
183        value: &T,
184    ) -> Result<Self::Ok, Self::Error>
185    where
186        T: serde::Serialize,
187    {
188        value.serialize(self)
189    }
190
191    fn serialize_newtype_variant<T: ?Sized>(
192        self,
193        _name: &'static str,
194        variant_index: u32,
195        _variant: &'static str,
196        value: &T,
197    ) -> Result<Self::Ok, Self::Error>
198    where
199        T: serde::Serialize,
200    {
201        variant_index.serialize(&mut *self)?;
202        value.serialize(self)
203    }
204
205    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
206        if let Some(len) = len {
207            len.serialize(&mut *self)?;
208        }
209        Ok(self)
210    }
211
212    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
213        Ok(self)
214    }
215
216    fn serialize_tuple_struct(
217        self,
218        _name: &'static str,
219        _len: usize,
220    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
221        Ok(self)
222    }
223
224    fn serialize_tuple_variant(
225        self,
226        _name: &'static str,
227        variant_index: u32,
228        _variant: &'static str,
229        _len: usize,
230    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
231        variant_index.serialize(&mut *self)?;
232        Ok(self)
233    }
234
235    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
236        if let Some(len) = len {
237            len.serialize(&mut *self)?;
238        }
239        Ok(self)
240    }
241
242    #[inline]
243    fn serialize_struct(
244        self,
245        _name: &'static str,
246        _len: usize,
247    ) -> Result<Self::SerializeStruct, Self::Error> {
248        Ok(self)
249    }
250
251    fn serialize_struct_variant(
252        self,
253        _name: &'static str,
254        variant_index: u32,
255        _variant: &'static str,
256        _len: usize,
257    ) -> Result<Self::SerializeStructVariant, Self::Error> {
258        variant_index.serialize(&mut *self)?;
259        Ok(self)
260    }
261
262    #[inline]
263    fn is_human_readable(&self) -> bool {
264        false
265    }
266}
267
268impl<'a, W: Write> ser::SerializeSeq for &'a mut Serializer<W> {
269    type Ok = ();
270
271    type Error = Error;
272
273    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
274    where
275        T: serde::Serialize,
276    {
277        value.serialize(&mut **self)
278    }
279
280    fn end(self) -> Result<Self::Ok, Self::Error> {
281        Ok(())
282    }
283}
284
285impl<'a, W: Write> ser::SerializeTuple for &'a mut Serializer<W> {
286    type Ok = ();
287
288    type Error = Error;
289
290    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
291    where
292        T: serde::Serialize,
293    {
294        value.serialize(&mut **self)
295    }
296
297    fn end(self) -> Result<Self::Ok, Self::Error> {
298        Ok(())
299    }
300}
301
302impl<'a, W: Write> ser::SerializeTupleStruct for &'a mut Serializer<W> {
303    type Ok = ();
304
305    type Error = Error;
306
307    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
308    where
309        T: serde::Serialize,
310    {
311        value.serialize(&mut **self)
312    }
313
314    fn end(self) -> Result<Self::Ok, Self::Error> {
315        Ok(())
316    }
317}
318
319impl<'a, W: Write> ser::SerializeTupleVariant for &'a mut Serializer<W> {
320    type Ok = ();
321
322    type Error = Error;
323
324    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
325    where
326        T: serde::Serialize,
327    {
328        value.serialize(&mut **self)
329    }
330
331    fn end(self) -> Result<Self::Ok, Self::Error> {
332        Ok(())
333    }
334}
335
336impl<'a, W: Write> ser::SerializeMap for &'a mut Serializer<W> {
337    type Ok = ();
338    type Error = Error;
339
340    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
341    where
342        T: serde::Serialize,
343    {
344        key.serialize(MapKeySerializer::new(self))
345    }
346
347    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
348    where
349        T: serde::Serialize,
350    {
351        value.serialize(&mut **self)
352    }
353
354    fn end(self) -> Result<Self::Ok, Self::Error> {
355        Ok(())
356    }
357}
358
359impl<'a, W: Write> ser::SerializeStruct for &'a mut Serializer<W> {
360    type Ok = ();
361    type Error = Error;
362
363    fn serialize_field<T: ?Sized>(
364        &mut self,
365        _key: &'static str,
366        value: &T,
367    ) -> Result<(), Self::Error>
368    where
369        T: Serialize,
370    {
371        value.serialize(&mut **self)
372    }
373
374    fn end(self) -> Result<Self::Ok, Self::Error> {
375        Ok(())
376    }
377}
378
379impl<'a, W: Write> ser::SerializeStructVariant for &'a mut Serializer<W> {
380    type Ok = ();
381    type Error = Error;
382
383    fn serialize_field<T: ?Sized>(
384        &mut self,
385        _key: &'static str,
386        value: &T,
387    ) -> Result<(), Self::Error>
388    where
389        T: serde::Serialize,
390    {
391        value.serialize(&mut **self)
392    }
393
394    fn end(self) -> Result<Self::Ok, Self::Error> {
395        Ok(())
396    }
397}
398
399struct MapKeySerializer<'a, W: Write> {
400    ser: &'a mut Serializer<W>,
401}
402
403impl<'a, W: 'a + Write> MapKeySerializer<'a, W> {
404    fn new(ser: &'a mut Serializer<W>) -> Self {
405        Self { ser }
406    }
407}
408
409impl<'a, W: Write> ser::Serializer for MapKeySerializer<'a, W> {
410    type Ok = ();
411    type Error = Error;
412    type SerializeSeq = Impossible<(), Error>;
413    type SerializeTuple = Impossible<(), Error>;
414    type SerializeTupleStruct = Impossible<(), Error>;
415    type SerializeTupleVariant = Impossible<(), Error>;
416    type SerializeMap = Impossible<(), Error>;
417    type SerializeStruct = Impossible<(), Error>;
418    type SerializeStructVariant = Impossible<(), Error>;
419
420    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
421        Err(Error::UnsupportedKeyType)
422    }
423
424    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
425        Err(Error::UnsupportedKeyType)
426    }
427
428    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
429        Err(Error::UnsupportedKeyType)
430    }
431
432    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
433        Err(Error::UnsupportedKeyType)
434    }
435
436    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
437        Err(Error::UnsupportedKeyType)
438    }
439
440    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
441        Err(Error::UnsupportedKeyType)
442    }
443
444    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
445        Err(Error::UnsupportedKeyType)
446    }
447
448    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
449        Err(Error::UnsupportedKeyType)
450    }
451
452    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
453        Err(Error::UnsupportedKeyType)
454    }
455
456    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
457        Err(Error::UnsupportedKeyType)
458    }
459
460    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
461        Err(Error::UnsupportedKeyType)
462    }
463
464    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
465        Err(Error::UnsupportedKeyType)
466    }
467
468    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
469        self.ser.serialize_str(v)
470    }
471
472    fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
473        Err(Error::UnsupportedKeyType)
474    }
475
476    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
477        Err(Error::UnsupportedKeyType)
478    }
479
480    fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
481    where
482        T: Serialize,
483    {
484        Err(Error::UnsupportedKeyType)
485    }
486
487    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
488        Err(Error::UnsupportedKeyType)
489    }
490
491    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
492        Err(Error::UnsupportedKeyType)
493    }
494
495    fn serialize_unit_variant(
496        self,
497        _: &'static str,
498        _: u32,
499        _: &'static str,
500    ) -> Result<Self::Ok, Self::Error> {
501        Err(Error::UnsupportedKeyType)
502    }
503
504    fn serialize_newtype_struct<T: ?Sized>(
505        self,
506        _: &'static str,
507        _: &T,
508    ) -> Result<Self::Ok, Self::Error>
509    where
510        T: Serialize,
511    {
512        Err(Error::UnsupportedKeyType)
513    }
514
515    fn serialize_newtype_variant<T: ?Sized>(
516        self,
517        _: &'static str,
518        _: u32,
519        _: &'static str,
520        _: &T,
521    ) -> Result<Self::Ok, Self::Error>
522    where
523        T: Serialize,
524    {
525        Err(Error::UnsupportedKeyType)
526    }
527
528    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
529        Err(Error::UnsupportedKeyType)
530    }
531
532    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
533        Err(Error::UnsupportedKeyType)
534    }
535
536    fn serialize_tuple_struct(
537        self,
538        _: &'static str,
539        _: usize,
540    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
541        Err(Error::UnsupportedKeyType)
542    }
543
544    fn serialize_tuple_variant(
545        self,
546        _: &'static str,
547        _: u32,
548        _: &'static str,
549        _: usize,
550    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
551        Err(Error::UnsupportedKeyType)
552    }
553
554    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
555        Err(Error::UnsupportedKeyType)
556    }
557
558    fn serialize_struct(
559        self,
560        _: &'static str,
561        _: usize,
562    ) -> Result<Self::SerializeStruct, Self::Error> {
563        Err(Error::UnsupportedKeyType)
564    }
565
566    fn serialize_struct_variant(
567        self,
568        _: &'static str,
569        _: u32,
570        _: &'static str,
571        _: usize,
572    ) -> Result<Self::SerializeStructVariant, Self::Error> {
573        Err(Error::UnsupportedKeyType)
574    }
575}
576
577#[cfg(test)]
578mod tests {
579    use super::Serializer;
580    use crate::{ser::Error, PrefixVarint, ZigZag};
581    use serde::Serialize;
582    use serde_bytes::Bytes;
583    use std::collections::BTreeMap;
584
585    #[test]
586    fn serialize_bool() {
587        {
588            let mut buf = Vec::new();
589            let mut serializer = Serializer::new(&mut buf);
590
591            let body = true;
592            body.serialize(&mut serializer).unwrap();
593            assert_eq!(buf, [1]);
594        }
595
596        {
597            let mut buf = Vec::new();
598            let mut serializer = Serializer::new(&mut buf);
599
600            let body = false;
601            body.serialize(&mut serializer).unwrap();
602            assert_eq!(buf, [0]);
603        }
604    }
605
606    #[test]
607    fn serialize_i8() {
608        {
609            let mut buf = Vec::new();
610            let mut serializer = Serializer::new(&mut buf);
611            let body = i8::MIN;
612            body.serialize(&mut serializer).unwrap();
613            assert_eq!(buf, i8::MIN.to_le_bytes());
614        }
615
616        {
617            let mut buf = Vec::new();
618            let mut serializer = Serializer::new(&mut buf);
619            let body = 0i8;
620            body.serialize(&mut serializer).unwrap();
621            assert_eq!(buf, [0]);
622        }
623
624        {
625            let mut buf = Vec::new();
626            let mut serializer = Serializer::new(&mut buf);
627            let body = i8::MAX;
628            body.serialize(&mut serializer).unwrap();
629            assert_eq!(buf, i8::MAX.to_le_bytes());
630        }
631    }
632
633    #[test]
634    fn serialize_i16() {
635        {
636            let mut buf = Vec::new();
637            let mut serializer = Serializer::new(&mut buf);
638            let body = i16::MIN;
639            body.serialize(&mut serializer).unwrap();
640            assert_eq!(buf, i16::MIN.encode_zigzag().encode_prefix_varint_vec());
641        }
642
643        {
644            let mut buf = Vec::new();
645            let mut serializer = Serializer::new(&mut buf);
646            let body = 0i16;
647            body.serialize(&mut serializer).unwrap();
648            assert_eq!(buf, [0]);
649        }
650
651        {
652            let mut buf = Vec::new();
653            let mut serializer = Serializer::new(&mut buf);
654            let body = i16::MAX;
655            body.serialize(&mut serializer).unwrap();
656            assert_eq!(buf, i16::MAX.encode_zigzag().encode_prefix_varint_vec());
657        }
658    }
659
660    #[test]
661    fn serialize_i32() {
662        {
663            let mut buf = Vec::new();
664            let mut serializer = Serializer::new(&mut buf);
665            let body = i32::MIN;
666            body.serialize(&mut serializer).unwrap();
667            assert_eq!(buf, i32::MIN.encode_zigzag().encode_prefix_varint_vec());
668        }
669
670        {
671            let mut buf = Vec::new();
672            let mut serializer = Serializer::new(&mut buf);
673            let body = 0i32;
674            body.serialize(&mut serializer).unwrap();
675            assert_eq!(buf, [0]);
676        }
677
678        {
679            let mut buf = Vec::new();
680            let mut serializer = Serializer::new(&mut buf);
681            let body = i32::MAX;
682            body.serialize(&mut serializer).unwrap();
683            assert_eq!(buf, i32::MAX.encode_zigzag().encode_prefix_varint_vec());
684        }
685    }
686
687    #[test]
688    fn serialize_i64() {
689        {
690            let mut buf = Vec::new();
691            let mut serializer = Serializer::new(&mut buf);
692            let body = i64::MIN;
693            body.serialize(&mut serializer).unwrap();
694            assert_eq!(buf, i64::MIN.encode_zigzag().encode_prefix_varint_vec());
695        }
696
697        {
698            let mut buf = Vec::new();
699            let mut serializer = Serializer::new(&mut buf);
700            let body = 0i64;
701            body.serialize(&mut serializer).unwrap();
702            assert_eq!(buf, [0]);
703        }
704
705        {
706            let mut buf = Vec::new();
707            let mut serializer = Serializer::new(&mut buf);
708            let body = i64::MAX;
709            body.serialize(&mut serializer).unwrap();
710            assert_eq!(buf, i64::MAX.encode_zigzag().encode_prefix_varint_vec());
711        }
712    }
713
714    // #[test]
715    // fn serialize_i128() {
716    //     {
717    //         let mut buf = Vec::new();
718    //         let mut serializer = Serializer::new(&mut buf);
719    //         let body = i128::MIN;
720    //         body.serialize(&mut serializer).unwrap();
721    //         assert_eq!(buf, i128::MIN.encode_zigzag().encode_leb128_vec());
722    //     }
723
724    //     {
725    //         let mut buf = Vec::new();
726    //         let mut serializer = Serializer::new(&mut buf);
727    //         let body = i128::MAX;
728    //         body.serialize(&mut serializer).unwrap();
729    //         assert_eq!(buf, i128::MAX.encode_zigzag().encode_leb128_vec());
730    //     }
731    // }
732
733    #[test]
734    fn serialize_u8() {
735        {
736            let mut buf = Vec::new();
737            let mut serializer = Serializer::new(&mut buf);
738            let body = u8::MIN;
739            body.serialize(&mut serializer).unwrap();
740            assert_eq!(buf, u8::MIN.to_le_bytes());
741        }
742
743        {
744            let mut buf = Vec::new();
745            let mut serializer = Serializer::new(&mut buf);
746            let body = u8::MAX;
747            body.serialize(&mut serializer).unwrap();
748            assert_eq!(buf, u8::MAX.to_le_bytes());
749        }
750    }
751
752    #[test]
753    fn serialize_u16() {
754        {
755            let mut buf = Vec::new();
756            let mut serializer = Serializer::new(&mut buf);
757            let body = u16::MIN;
758            body.serialize(&mut serializer).unwrap();
759            assert_eq!(buf, u16::MIN.encode_prefix_varint_vec());
760        }
761
762        {
763            let mut buf = Vec::new();
764            let mut serializer = Serializer::new(&mut buf);
765            let body = u16::MAX;
766            body.serialize(&mut serializer).unwrap();
767            assert_eq!(buf, u16::MAX.encode_prefix_varint_vec());
768        }
769    }
770
771    #[test]
772    fn serialize_u32() {
773        {
774            let mut buf = Vec::new();
775            let mut serializer = Serializer::new(&mut buf);
776            let body = u32::MIN;
777            body.serialize(&mut serializer).unwrap();
778            assert_eq!(buf, u32::MIN.encode_prefix_varint_vec());
779        }
780
781        {
782            let mut buf = Vec::new();
783            let mut serializer = Serializer::new(&mut buf);
784            let body = u32::MAX;
785            body.serialize(&mut serializer).unwrap();
786            assert_eq!(buf, u32::MAX.encode_prefix_varint_vec());
787        }
788    }
789
790    #[test]
791    fn serialize_u64() {
792        {
793            let mut buf = Vec::new();
794            let mut serializer = Serializer::new(&mut buf);
795            let body = u64::MIN;
796            body.serialize(&mut serializer).unwrap();
797            assert_eq!(buf, u64::MIN.encode_prefix_varint_vec());
798        }
799
800        {
801            let mut buf = Vec::new();
802            let mut serializer = Serializer::new(&mut buf);
803            let body = u64::MAX;
804            body.serialize(&mut serializer).unwrap();
805            assert_eq!(buf, u64::MAX.encode_prefix_varint_vec());
806        }
807    }
808
809    // #[test]
810    // fn serialize_u128() {
811    //     {
812    //         let mut buf = Vec::new();
813    //         let mut serializer = Serializer::new(&mut buf);
814    //         let body = u128::MIN;
815    //         body.serialize(&mut serializer).unwrap();
816    //         assert_eq!(buf, u128::MIN.encode_leb128_vec());
817    //     }
818
819    //     {
820    //         let mut buf = Vec::new();
821    //         let mut serializer = Serializer::new(&mut buf);
822    //         let body = u128::MAX;
823    //         body.serialize(&mut serializer).unwrap();
824    //         assert_eq!(buf, u128::MAX.encode_leb128_vec());
825    //     }
826    // }
827
828    #[test]
829    fn serialize_f32() {
830        {
831            let mut buf = Vec::new();
832            let mut serializer = Serializer::new(&mut buf);
833            let body = 0f32;
834            body.serialize(&mut serializer).unwrap();
835            assert_eq!(buf, 0f32.to_le_bytes());
836        }
837
838        {
839            let mut buf = Vec::new();
840            let mut serializer = Serializer::new(&mut buf);
841            let body = 1.1f32;
842            body.serialize(&mut serializer).unwrap();
843            assert_eq!(buf, 1.1f32.to_le_bytes());
844        }
845
846        {
847            let mut buf = Vec::new();
848            let mut serializer = Serializer::new(&mut buf);
849            let body = -1.1f32;
850            body.serialize(&mut serializer).unwrap();
851            assert_eq!(buf, (-1.1f32).to_le_bytes());
852        }
853
854        {
855            let mut buf = Vec::new();
856            let mut serializer = Serializer::new(&mut buf);
857            let body = f32::INFINITY;
858            body.serialize(&mut serializer).unwrap();
859            assert_eq!(buf, f32::INFINITY.to_le_bytes());
860        }
861
862        {
863            let mut buf = Vec::new();
864            let mut serializer = Serializer::new(&mut buf);
865            let body = -f32::INFINITY;
866            body.serialize(&mut serializer).unwrap();
867            assert_eq!(buf, (-f32::INFINITY).to_le_bytes());
868        }
869
870        {
871            let mut buf = Vec::new();
872            let mut serializer = Serializer::new(&mut buf);
873            let body = f32::NAN;
874            body.serialize(&mut serializer).unwrap();
875            assert_eq!(buf, f32::NAN.to_le_bytes());
876        }
877
878        {
879            let mut buf = Vec::new();
880            let mut serializer = Serializer::new(&mut buf);
881            let body = -f32::NAN;
882            body.serialize(&mut serializer).unwrap();
883            assert_eq!(buf, (-f32::NAN).to_le_bytes());
884        }
885    }
886
887    #[test]
888    fn serialize_f64() {
889        {
890            let mut buf = Vec::new();
891            let mut serializer = Serializer::new(&mut buf);
892            let body = 0f64;
893            body.serialize(&mut serializer).unwrap();
894            assert_eq!(buf, 0f64.to_le_bytes());
895        }
896
897        {
898            let mut buf = Vec::new();
899            let mut serializer = Serializer::new(&mut buf);
900            let body = 1.1f64;
901            body.serialize(&mut serializer).unwrap();
902            assert_eq!(buf, 1.1f64.to_le_bytes());
903        }
904
905        {
906            let mut buf = Vec::new();
907            let mut serializer = Serializer::new(&mut buf);
908            let body = -1.1f64;
909            body.serialize(&mut serializer).unwrap();
910            assert_eq!(buf, (-1.1f64).to_le_bytes());
911        }
912
913        {
914            let mut buf = Vec::new();
915            let mut serializer = Serializer::new(&mut buf);
916            let body = f64::INFINITY;
917            body.serialize(&mut serializer).unwrap();
918            assert_eq!(buf, f64::INFINITY.to_le_bytes());
919        }
920
921        {
922            let mut buf = Vec::new();
923            let mut serializer = Serializer::new(&mut buf);
924            let body = -f64::INFINITY;
925            body.serialize(&mut serializer).unwrap();
926            assert_eq!(buf, (-f64::INFINITY).to_le_bytes());
927        }
928    }
929
930    #[test]
931    fn serialize_char() {
932        {
933            let mut buf = Vec::new();
934            let mut serializer = Serializer::new(&mut buf);
935            let body = 'a';
936            body.serialize(&mut serializer).unwrap();
937            assert_eq!(
938                buf,
939                [
940                    ("a".as_bytes().len() as u64)
941                        .encode_prefix_varint_vec()
942                        .as_slice(),
943                    "a".as_bytes()
944                ]
945                .concat()
946            );
947        }
948
949        {
950            let mut buf = Vec::new();
951            let mut serializer = Serializer::new(&mut buf);
952            let body = 'あ';
953            body.serialize(&mut serializer).unwrap();
954            assert_eq!(
955                buf,
956                [
957                    ("あ".as_bytes().len() as u64)
958                        .encode_prefix_varint_vec()
959                        .as_slice(),
960                    "あ".as_bytes()
961                ]
962                .concat()
963            );
964        }
965    }
966
967    #[test]
968    fn serialize_str() {
969        {
970            let mut buf = Vec::new();
971            let mut serializer = Serializer::new(&mut buf);
972            let body = "";
973            body.serialize(&mut serializer).unwrap();
974            assert_eq!(
975                buf,
976                [
977                    ("".len() as u64).encode_prefix_varint_vec().as_slice(),
978                    "".as_bytes()
979                ]
980                .concat()
981            );
982        }
983
984        {
985            let mut buf = Vec::new();
986            let mut serializer = Serializer::new(&mut buf);
987            let body = "test";
988            body.serialize(&mut serializer).unwrap();
989            assert_eq!(
990                buf,
991                [
992                    ("test".as_bytes().len() as u64)
993                        .encode_prefix_varint_vec()
994                        .as_slice(),
995                    "test".as_bytes()
996                ]
997                .concat()
998            );
999        }
1000    }
1001
1002    #[test]
1003    fn serialize_none() {
1004        let mut buf = Vec::new();
1005        let mut serializer = Serializer::new(&mut buf);
1006        let body: Option<bool> = None;
1007        body.serialize(&mut serializer).unwrap();
1008        assert_eq!(buf, [0]);
1009    }
1010
1011    #[test]
1012    fn serialize_some() {
1013        let mut buf = Vec::new();
1014        let mut serializer = Serializer::new(&mut buf);
1015        let body = Some(123u8);
1016        body.serialize(&mut serializer).unwrap();
1017        assert_eq!(buf, [1, 123]);
1018    }
1019
1020    #[test]
1021    fn serialize_unit() {
1022        let mut buf = Vec::new();
1023        let mut serializer = Serializer::new(&mut buf);
1024        let body = ();
1025        body.serialize(&mut serializer).unwrap();
1026        assert_eq!(buf, []);
1027    }
1028
1029    #[test]
1030    fn serialize_unit_struct() {
1031        #[derive(Debug, PartialEq, Serialize)]
1032        struct Test;
1033
1034        let mut buf = Vec::new();
1035        let mut serializer = Serializer::new(&mut buf);
1036        let body = Test;
1037        body.serialize(&mut serializer).unwrap();
1038        assert_eq!(buf, []);
1039    }
1040
1041    #[test]
1042    fn serialize_unit_variant() {
1043        #[derive(Debug, PartialEq, Serialize)]
1044        enum Test {
1045            A,
1046        }
1047
1048        let mut buf = Vec::new();
1049        let mut serializer = Serializer::new(&mut buf);
1050        let body = Test::A;
1051        body.serialize(&mut serializer).unwrap();
1052        assert_eq!(buf, [0]);
1053    }
1054
1055    #[test]
1056    fn serialize_newtype_struct() {
1057        {
1058            #[derive(Debug, PartialEq, Serialize)]
1059            struct Inner {
1060                c: String,
1061                a: bool,
1062                b: u8,
1063            }
1064            #[derive(Debug, PartialEq, Serialize)]
1065            struct Test(Inner);
1066
1067            let mut buf = Vec::new();
1068            let mut serializer = Serializer::new(&mut buf);
1069            Test(Inner {
1070                c: "test".to_string(),
1071                a: true,
1072                b: 123,
1073            })
1074            .serialize(&mut serializer)
1075            .unwrap();
1076
1077            assert_eq!(
1078                buf,
1079                [
1080                    [4].as_ref(),
1081                    "test".as_bytes(),
1082                    [1].as_ref(),
1083                    [123].as_ref()
1084                ]
1085                .concat()
1086            );
1087        }
1088
1089        {
1090            #[derive(Debug, PartialEq, Serialize)]
1091            struct Inner(u8);
1092            #[derive(Debug, PartialEq, Serialize)]
1093            struct Test {
1094                c: String,
1095                a: bool,
1096                b: Inner,
1097            }
1098
1099            let mut buf = Vec::new();
1100            let mut serializer = Serializer::new(&mut buf);
1101            Test {
1102                c: "test".to_string(),
1103                a: true,
1104                b: Inner(123),
1105            }
1106            .serialize(&mut serializer)
1107            .unwrap();
1108
1109            assert_eq!(
1110                buf,
1111                [
1112                    [4].as_ref(),
1113                    "test".as_bytes(),
1114                    [1].as_ref(),
1115                    [123].as_ref()
1116                ]
1117                .concat()
1118            );
1119        }
1120    }
1121
1122    #[test]
1123    fn serialize_newtype_variant() {
1124        #[allow(dead_code)]
1125        #[derive(Serialize)]
1126        enum Test {
1127            A,
1128            B(String),
1129            C,
1130        }
1131
1132        let mut buf = Vec::new();
1133        let mut serializer = Serializer::new(&mut buf);
1134        let body = Test::B("test".to_string());
1135        body.serialize(&mut serializer).unwrap();
1136        assert_eq!(
1137            buf,
1138            [[1u8].as_ref(), [4u8].as_ref(), "test".as_bytes()].concat()
1139        );
1140    }
1141
1142    #[test]
1143    fn serialize_seq() {
1144        {
1145            let mut buf = Vec::new();
1146            let mut serializer = Serializer::new(&mut buf);
1147            let body: Vec<u8> = Vec::new();
1148            body.serialize(&mut serializer).unwrap();
1149            assert_eq!(buf, [0]);
1150        }
1151
1152        {
1153            let mut buf = Vec::new();
1154            let mut serializer = Serializer::new(&mut buf);
1155            let body = vec![123u8];
1156            body.serialize(&mut serializer).unwrap();
1157            assert_eq!(buf, [1, 123]);
1158        }
1159
1160        {
1161            let mut buf = Vec::new();
1162            let mut serializer = Serializer::new(&mut buf);
1163            let body = [1u8].repeat(128);
1164            body.serialize(&mut serializer).unwrap();
1165            assert_eq!(
1166                buf,
1167                [128u64.encode_prefix_varint_vec(), [1u8].repeat(128)].concat()
1168            );
1169        }
1170
1171        {
1172            let mut buf = Vec::new();
1173            let mut serializer = Serializer::new(&mut buf);
1174            let body = vec![true, false, true];
1175            body.serialize(&mut serializer).unwrap();
1176            assert_eq!(buf, [3, 1, 0, 1]);
1177        }
1178    }
1179
1180    #[test]
1181    fn serialize_tuple() {
1182        let mut buf = Vec::new();
1183        let mut serializer = Serializer::new(&mut buf);
1184        let body = (true, 123u8, "test");
1185        body.serialize(&mut serializer).unwrap();
1186        assert_eq!(
1187            buf,
1188            [
1189                &[1],
1190                &[123],
1191                ("test".len() as u64).encode_prefix_varint_vec().as_slice(),
1192                "test".as_bytes()
1193            ]
1194            .concat()
1195        );
1196    }
1197
1198    #[test]
1199    fn serialize_tuple_struct() {
1200        #[derive(Serialize)]
1201        struct Test(bool, u8, String);
1202
1203        let mut buf = Vec::new();
1204        let mut serializer = Serializer::new(&mut buf);
1205        let body = Test(true, 123u8, "test".to_string());
1206        body.serialize(&mut serializer).unwrap();
1207        assert_eq!(
1208            buf,
1209            [
1210                &[1],
1211                &[123],
1212                ("test".len() as u64).encode_prefix_varint_vec().as_slice(),
1213                "test".as_bytes()
1214            ]
1215            .concat()
1216        );
1217    }
1218
1219    #[test]
1220    fn serialize_tuple_variant() {
1221        #[allow(dead_code)]
1222        #[derive(Serialize)]
1223        enum Test {
1224            A,
1225            B(bool, u8, String),
1226            C,
1227        }
1228
1229        let mut buf = Vec::new();
1230        let mut serializer = Serializer::new(&mut buf);
1231        let body = Test::B(true, 123, "test".to_string());
1232        body.serialize(&mut serializer).unwrap();
1233        assert_eq!(
1234            buf,
1235            [
1236                [1u8].as_ref(),
1237                [1].as_ref(),
1238                [123].as_ref(),
1239                [4u8].as_ref(),
1240                "test".as_bytes()
1241            ]
1242            .concat()
1243        );
1244    }
1245
1246    #[test]
1247    fn serialize_struct() {
1248        #[derive(Serialize)]
1249        struct Test {
1250            c: String,
1251            a: bool,
1252            b: u8,
1253        }
1254
1255        let mut buf = Vec::new();
1256        let mut serializer = Serializer::new(&mut buf);
1257        let body = Test {
1258            c: "test".to_string(),
1259            a: true,
1260            b: 123,
1261        };
1262        body.serialize(&mut serializer).unwrap();
1263
1264        assert_eq!(
1265            buf,
1266            [
1267                [4].as_ref(),
1268                "test".as_bytes(),
1269                [1].as_ref(),
1270                [123].as_ref()
1271            ]
1272            .concat()
1273        );
1274    }
1275
1276    #[test]
1277    fn serialize_struct_variant() {
1278        #[allow(dead_code)]
1279        #[derive(Serialize)]
1280        enum Test {
1281            A,
1282            B { a: bool, b: u8, c: String },
1283            C,
1284        }
1285
1286        let mut buf = Vec::new();
1287        let mut serializer = Serializer::new(&mut buf);
1288        let body = Test::B {
1289            a: true,
1290            b: 123,
1291            c: "test".to_string(),
1292        };
1293        body.serialize(&mut serializer).unwrap();
1294
1295        assert_eq!(buf, [[1, 1, 123, 4].as_ref(), "test".as_bytes()].concat());
1296    }
1297
1298    #[test]
1299    fn serialize_map() {
1300        {
1301            let mut buf = Vec::new();
1302            let mut serializer = Serializer::new(&mut buf);
1303            let body = {
1304                let mut map = BTreeMap::new();
1305                map.insert("a".to_string(), 0u8);
1306                map.insert("b".to_string(), 123u8);
1307                map.insert("c".to_string(), 255u8);
1308                map
1309            };
1310            body.serialize(&mut serializer).unwrap();
1311
1312            assert_eq!(
1313                buf,
1314                [
1315                    &[3],
1316                    &[1],
1317                    "a".as_bytes(),
1318                    &[0],
1319                    &[1],
1320                    "b".as_bytes(),
1321                    &[123],
1322                    &[1],
1323                    "c".as_bytes(),
1324                    &[255]
1325                ]
1326                .concat()
1327            );
1328        }
1329
1330        {
1331            let mut buf = Vec::new();
1332            let mut serializer = Serializer::new(&mut buf);
1333            let body = {
1334                let mut map = BTreeMap::new();
1335                map.insert(1, 0u8);
1336                map.insert(2, 123u8);
1337                map.insert(3, 255u8);
1338                map
1339            };
1340
1341            assert_eq!(
1342                body.serialize(&mut serializer),
1343                Err(Error::UnsupportedKeyType)
1344            );
1345        }
1346    }
1347
1348    #[test]
1349    fn serialize_bytes() {
1350        let mut buf = Vec::new();
1351        let mut serializer = Serializer::new(&mut buf);
1352        let body = Bytes::new(&[0u8, 1, 2, 3, 255]);
1353        body.serialize(&mut serializer).unwrap();
1354        assert_eq!(buf, [5, 0, 1, 2, 3, 255]);
1355    }
1356}
dlhn/ser.rs

dlhn/
ser.rs
