messagepack_serde/value/
ser.rs

1use super::Value;
2use alloc::{vec, vec::Vec};
3use serde::ser::{self};
4
5type Error = crate::ser::Error<core::convert::Infallible>;
6
7/// Convert `T` to [crate::value::Value]
8pub fn to_value<T>(value: T) -> Result<Value, Error>
9where
10    T: ser::Serialize,
11{
12    value.serialize(Serializer)
13}
14
15struct Serializer;
16
17impl ser::Serializer for Serializer {
18    type Ok = Value;
19    type Error = Error;
20    type SerializeSeq = SerializeSeq;
21    type SerializeTuple = SerializeSeq;
22    type SerializeTupleStruct = SerializeSeq;
23    type SerializeTupleVariant = SerializeTupleVariant;
24    type SerializeMap = SerializeMap;
25    type SerializeStruct = SerializeMap;
26    type SerializeStructVariant = SerializeStructVariant;
27
28    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
29        Ok(Value::from(v))
30    }
31
32    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
33        Ok(Value::from(v))
34    }
35
36    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
37        Ok(Value::from(v))
38    }
39
40    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
41        Ok(Value::from(v))
42    }
43
44    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
45        Ok(Value::from(v))
46    }
47
48    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
49        Ok(Value::from(v))
50    }
51
52    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
53        Ok(Value::from(v))
54    }
55
56    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
57        Ok(Value::from(v))
58    }
59
60    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
61        Ok(Value::from(v))
62    }
63
64    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
65        Ok(Value::from(v))
66    }
67
68    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
69        Ok(Value::from(v))
70    }
71
72    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
73        use crate::alloc::string::ToString;
74        Ok(Value::String(v.to_string()))
75    }
76
77    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
78        Ok(Value::from(v))
79    }
80
81    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
82        Ok(Value::from(v))
83    }
84
85    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
86        Ok(Value::Nil)
87    }
88
89    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
90    where
91        T: ?Sized + ser::Serialize,
92    {
93        value.serialize(self)
94    }
95
96    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
97        self.serialize_none()
98    }
99
100    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
101        self.serialize_none()
102    }
103
104    fn serialize_unit_variant(
105        self,
106        _name: &'static str,
107        _variant_index: u32,
108        variant: &'static str,
109    ) -> Result<Self::Ok, Self::Error> {
110        self.serialize_str(variant)
111    }
112
113    fn serialize_newtype_struct<T>(
114        self,
115        name: &'static str,
116        value: &T,
117    ) -> Result<Self::Ok, Self::Error>
118    where
119        T: ?Sized + ser::Serialize,
120    {
121        match name {
122            crate::extension::EXTENSION_STRUCT_NAME => {
123                let mut ser = SerializeExt::new();
124                value.serialize(&mut ser)?;
125                ser.into_value()
126            }
127            _ => value.serialize(self),
128        }
129    }
130
131    fn serialize_newtype_variant<T>(
132        self,
133        _name: &'static str,
134        _variant_index: u32,
135        variant: &'static str,
136        value: &T,
137    ) -> Result<Self::Ok, Self::Error>
138    where
139        T: ?Sized + ser::Serialize,
140    {
141        let val = value.serialize(self)?;
142        let key = Value::from(variant);
143        Ok(Value::Map(vec![(key, val)]))
144    }
145
146    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
147        Ok(SerializeSeq::with_capacity(len))
148    }
149
150    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
151        self.serialize_seq(Some(len))
152    }
153
154    fn serialize_tuple_struct(
155        self,
156        _name: &'static str,
157        len: usize,
158    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
159        self.serialize_seq(Some(len))
160    }
161
162    fn serialize_tuple_variant(
163        self,
164        _name: &'static str,
165        _variant_index: u32,
166        variant: &'static str,
167        len: usize,
168    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
169        Ok(SerializeTupleVariant::with_capacity(variant, len))
170    }
171
172    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
173        Ok(SerializeMap::with_capacity(len))
174    }
175
176    fn serialize_struct(
177        self,
178        _name: &'static str,
179        len: usize,
180    ) -> Result<Self::SerializeStruct, Self::Error> {
181        self.serialize_map(Some(len))
182    }
183
184    fn serialize_struct_variant(
185        self,
186        _name: &'static str,
187        _variant_index: u32,
188        variant: &'static str,
189        len: usize,
190    ) -> Result<Self::SerializeStructVariant, Self::Error> {
191        Ok(SerializeStructVariant::with_capacity(variant, len))
192    }
193}
194
195struct SerializeSeq {
196    values: Vec<Value>,
197}
198
199impl SerializeSeq {
200    fn with_capacity(len: Option<usize>) -> Self {
201        Self {
202            values: len.map(Vec::with_capacity).unwrap_or_default(),
203        }
204    }
205}
206
207impl ser::SerializeSeq for SerializeSeq {
208    type Ok = Value;
209    type Error = Error;
210
211    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
212    where
213        T: ?Sized + ser::Serialize,
214    {
215        let val = value.serialize(Serializer)?;
216        self.values.push(val);
217        Ok(())
218    }
219
220    fn end(self) -> Result<Self::Ok, Self::Error> {
221        Ok(Value::Array(self.values))
222    }
223}
224
225impl ser::SerializeTuple for SerializeSeq {
226    type Ok = Value;
227    type Error = Error;
228
229    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
230    where
231        T: ?Sized + ser::Serialize,
232    {
233        ser::SerializeSeq::serialize_element(self, value)
234    }
235
236    fn end(self) -> Result<Self::Ok, Self::Error> {
237        ser::SerializeSeq::end(self)
238    }
239}
240
241impl ser::SerializeTupleStruct for SerializeSeq {
242    type Ok = Value;
243    type Error = Error;
244
245    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
246    where
247        T: ?Sized + ser::Serialize,
248    {
249        ser::SerializeSeq::serialize_element(self, value)
250    }
251
252    fn end(self) -> Result<Self::Ok, Self::Error> {
253        ser::SerializeSeq::end(self)
254    }
255}
256
257struct SerializeTupleVariant {
258    variant_name: &'static str,
259    seq: SerializeSeq,
260}
261
262impl SerializeTupleVariant {
263    fn with_capacity(name: &'static str, len: usize) -> Self {
264        Self {
265            variant_name: name,
266            seq: SerializeSeq::with_capacity(Some(len)),
267        }
268    }
269}
270
271impl ser::SerializeTupleVariant for SerializeTupleVariant {
272    type Ok = Value;
273    type Error = Error;
274
275    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
276    where
277        T: ?Sized + ser::Serialize,
278    {
279        ser::SerializeSeq::serialize_element(&mut self.seq, value)?;
280        Ok(())
281    }
282
283    fn end(self) -> Result<Self::Ok, Self::Error> {
284        let array = ser::SerializeSeq::end(self.seq)?;
285        let key = Value::from(self.variant_name);
286        Ok(Value::Map(vec![(key, array)]))
287    }
288}
289
290struct SerializeMap {
291    key: Option<Value>,
292    items: Vec<(Value, Value)>,
293}
294
295impl SerializeMap {
296    fn with_capacity(len: Option<usize>) -> Self {
297        Self {
298            items: len.map(Vec::with_capacity).unwrap_or_default(),
299            key: None,
300        }
301    }
302}
303
304impl ser::SerializeMap for SerializeMap {
305    type Ok = Value;
306    type Error = Error;
307
308    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
309    where
310        T: ?Sized + ser::Serialize,
311    {
312        let key = key.serialize(Serializer)?;
313        self.key = Some(key);
314        Ok(())
315    }
316
317    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
318    where
319        T: ?Sized + ser::Serialize,
320    {
321        let key = self
322            .key
323            .take()
324            .ok_or(<Error as ser::Error>::custom("missing map key"))?;
325        let val = value.serialize(Serializer)?;
326        self.items.push((key, val));
327        Ok(())
328    }
329
330    fn end(self) -> Result<Self::Ok, Self::Error> {
331        Ok(Value::Map(self.items))
332    }
333}
334
335impl ser::SerializeStruct for SerializeMap {
336    type Ok = Value;
337    type Error = Error;
338
339    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
340    where
341        T: ?Sized + ser::Serialize,
342    {
343        ser::SerializeMap::serialize_key(self, key)?;
344        ser::SerializeMap::serialize_value(self, value)?;
345        Ok(())
346    }
347    fn end(self) -> Result<Self::Ok, Self::Error> {
348        ser::SerializeMap::end(self)
349    }
350}
351
352struct SerializeStructVariant {
353    variant_name: &'static str,
354    map: SerializeMap,
355}
356
357impl SerializeStructVariant {
358    fn with_capacity(name: &'static str, len: usize) -> Self {
359        Self {
360            variant_name: name,
361            map: SerializeMap::with_capacity(Some(len)),
362        }
363    }
364}
365
366impl ser::SerializeStructVariant for SerializeStructVariant {
367    type Ok = Value;
368    type Error = Error;
369    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
370    where
371        T: ?Sized + ser::Serialize,
372    {
373        ser::SerializeStruct::serialize_field(&mut self.map, key, value)
374    }
375    fn end(self) -> Result<Self::Ok, Self::Error> {
376        let map = ser::SerializeStruct::end(self.map)?;
377        let key = Value::from(self.variant_name);
378        Ok(Value::Map(vec![(key, map)]))
379    }
380}
381
382struct SerializeExt {
383    format_seen: bool,
384    data_length: Option<u32>,
385    kind: Option<i8>,
386    data: Option<Vec<u8>>,
387}
388
389impl SerializeExt {
390    fn new() -> Self {
391        Self {
392            format_seen: false,
393            data_length: None,
394            kind: None,
395            data: None,
396        }
397    }
398
399    fn into_value(self) -> Result<Value, Error> {
400        let Self {
401            format_seen: _,
402            data_length: _,
403            kind,
404            data,
405        } = self;
406
407        let Some(kind) = kind else {
408            return Err(ser::Error::custom("extension type not found"));
409        };
410        let Some(data) = data else {
411            return Err(ser::Error::custom("extension data not found"));
412        };
413        let ext = messagepack_core::extension::ExtensionOwned::new(kind, data);
414        Ok(Value::from(ext))
415    }
416
417    fn unsupported_type() -> Error {
418        ser::Error::custom("support only `i8`, `u8`, `u16`, `u32`, `bytes` and `seq`")
419    }
420}
421
422impl AsMut<Self> for SerializeExt {
423    fn as_mut(&mut self) -> &mut Self {
424        self
425    }
426}
427
428impl<'a> ser::Serializer for &'a mut SerializeExt {
429    type Ok = ();
430    type Error = Error;
431
432    type SerializeSeq = SerializeExtSeq<'a>;
433    type SerializeTuple = serde::ser::Impossible<Self::Ok, Self::Error>;
434    type SerializeTupleStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
435    type SerializeTupleVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
436    type SerializeMap = serde::ser::Impossible<Self::Ok, Self::Error>;
437    type SerializeStruct = serde::ser::Impossible<Self::Ok, Self::Error>;
438    type SerializeStructVariant = serde::ser::Impossible<Self::Ok, Self::Error>;
439
440    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
441        self.kind = Some(v);
442        Ok(())
443    }
444
445    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
446        self.data_length = Some(u32::from(v));
447        Ok(())
448    }
449    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
450        self.data_length = Some(u32::from(v));
451        Ok(())
452    }
453    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
454        self.data_length = Some(v);
455        Ok(())
456    }
457
458    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
459        // first time
460        if !self.format_seen {
461            self.format_seen = true;
462            return Ok(());
463        };
464
465        self.data = Some(v.to_vec());
466        Ok(())
467    }
468
469    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
470        let seq = SerializeExtSeq { ser: self };
471        Ok(seq)
472    }
473
474    fn serialize_newtype_struct<T>(
475        self,
476        _name: &'static str,
477        value: &T,
478    ) -> Result<Self::Ok, Self::Error>
479    where
480        T: ?Sized + ser::Serialize,
481    {
482        value.serialize(self)
483    }
484
485    fn serialize_bool(self, _v: bool) -> Result<Self::Ok, Self::Error> {
486        Err(SerializeExt::unsupported_type())
487    }
488
489    fn serialize_i16(self, _v: i16) -> Result<Self::Ok, Self::Error> {
490        Err(SerializeExt::unsupported_type())
491    }
492
493    fn serialize_i32(self, _v: i32) -> Result<Self::Ok, Self::Error> {
494        Err(SerializeExt::unsupported_type())
495    }
496
497    fn serialize_i64(self, _v: i64) -> Result<Self::Ok, Self::Error> {
498        Err(SerializeExt::unsupported_type())
499    }
500
501    fn serialize_u64(self, _v: u64) -> Result<Self::Ok, Self::Error> {
502        Err(SerializeExt::unsupported_type())
503    }
504
505    fn serialize_f32(self, _v: f32) -> Result<Self::Ok, Self::Error> {
506        Err(SerializeExt::unsupported_type())
507    }
508
509    fn serialize_f64(self, _v: f64) -> Result<Self::Ok, Self::Error> {
510        Err(SerializeExt::unsupported_type())
511    }
512
513    fn serialize_char(self, _v: char) -> Result<Self::Ok, Self::Error> {
514        Err(SerializeExt::unsupported_type())
515    }
516
517    fn serialize_str(self, _v: &str) -> Result<Self::Ok, Self::Error> {
518        Err(SerializeExt::unsupported_type())
519    }
520
521    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
522        Err(SerializeExt::unsupported_type())
523    }
524
525    fn serialize_some<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
526    where
527        T: ?Sized + ser::Serialize,
528    {
529        Err(SerializeExt::unsupported_type())
530    }
531
532    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
533        Err(SerializeExt::unsupported_type())
534    }
535
536    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
537        Err(SerializeExt::unsupported_type())
538    }
539
540    fn serialize_unit_variant(
541        self,
542        _name: &'static str,
543        _variant_index: u32,
544        _variant: &'static str,
545    ) -> Result<Self::Ok, Self::Error> {
546        Err(SerializeExt::unsupported_type())
547    }
548
549    fn serialize_newtype_variant<T>(
550        self,
551        _name: &'static str,
552        _variant_index: u32,
553        _variant: &'static str,
554        _value: &T,
555    ) -> Result<Self::Ok, Self::Error>
556    where
557        T: ?Sized + ser::Serialize,
558    {
559        Err(SerializeExt::unsupported_type())
560    }
561
562    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
563        Err(SerializeExt::unsupported_type())
564    }
565
566    fn serialize_tuple_struct(
567        self,
568        _name: &'static str,
569        _len: usize,
570    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
571        Err(SerializeExt::unsupported_type())
572    }
573
574    fn serialize_tuple_variant(
575        self,
576        _name: &'static str,
577        _variant_index: u32,
578        _variant: &'static str,
579        _len: usize,
580    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
581        Err(SerializeExt::unsupported_type())
582    }
583
584    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
585        Err(SerializeExt::unsupported_type())
586    }
587
588    fn serialize_struct(
589        self,
590        _name: &'static str,
591        _len: usize,
592    ) -> Result<Self::SerializeStruct, Self::Error> {
593        Err(SerializeExt::unsupported_type())
594    }
595
596    fn serialize_struct_variant(
597        self,
598        _name: &'static str,
599        _variant_index: u32,
600        _variant: &'static str,
601        _len: usize,
602    ) -> Result<Self::SerializeStructVariant, Self::Error> {
603        Err(SerializeExt::unsupported_type())
604    }
605}
606
607struct SerializeExtSeq<'a> {
608    ser: &'a mut SerializeExt,
609}
610
611impl<'a> ser::SerializeSeq for SerializeExtSeq<'a> {
612    type Ok = ();
613    type Error = Error;
614    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
615    where
616        T: ?Sized + ser::Serialize,
617    {
618        value.serialize(self.ser.as_mut())
619    }
620
621    fn end(self) -> Result<Self::Ok, Self::Error> {
622        Ok(())
623    }
624}
625
626#[cfg(test)]
627mod tests {
628    use super::*;
629    use rstest::rstest;
630    use serde::Serialize;
631    use serde_bytes::ByteBuf;
632
633    #[derive(Serialize)]
634    enum Kind<'a> {
635        Unit,
636        New(u8),
637        Tup(u8, u16),
638        Str { a: bool, b: &'a str },
639    }
640
641    #[rstest]
642    #[case(Kind::Unit, Value::from("Unit"))]
643    #[case(Kind::New(5), Value::Map(
644        vec![(Value::from("New"), Value::from(5))]
645    ))]
646    #[case(Kind::Tup(1,2), Value::Map(
647        vec![(
648                Value::from("Tup"),
649                Value::Array(vec![Value::from(1), Value::from(2)])
650            )]
651    ))]
652    #[case(
653        Kind::Str { a: false, b: "hi" },
654        Value::Map(vec![(
655                Value::from("Str"),
656                Value::Map(vec![
657                    (Value::from("a"), Value::from(false)),
658                    (Value::from("b"), Value::from("hi")),
659                ]),
660        ),])
661    )]
662    fn serialize_enum(#[case] val: Kind, #[case] expected: Value) {
663        let serialized = val.serialize(Serializer).unwrap();
664        assert_eq!(serialized, expected);
665    }
666    #[derive(Debug, Serialize)]
667    struct WrappedRef(
668        #[serde(with = "crate::extension::ext_ref")]
669        messagepack_core::extension::ExtensionRef<'static>,
670    );
671
672    impl WrappedRef {
673        fn new(kind: i8, data: &'static [u8]) -> Self {
674            Self(messagepack_core::extension::ExtensionRef::new(kind, data))
675        }
676    }
677
678    #[rstest]
679    fn serialize_extension() {
680        let val = WrappedRef::new(8, &[1, 2, 3, 4]);
681        let serialized = val.serialize(Serializer).unwrap();
682
683        let expected = Value::Extension(messagepack_core::extension::ExtensionOwned::new(
684            8,
685            vec![1, 2, 3, 4],
686        ));
687
688        assert_eq!(serialized, expected);
689    }
690
691    // primitives and simple composites
692    #[rstest]
693    #[case(true)]
694    #[case(false)]
695    fn serialize_bool_primitives(#[case] v: bool) {
696        let serialized = v.serialize(Serializer).unwrap();
697        assert_eq!(serialized, Value::from(v));
698    }
699
700    #[rstest]
701    #[case(0i8)]
702    #[case(-1)]
703    #[case(127)]
704    fn serialize_i8_numbers(#[case] v: i8) {
705        let serialized = v.serialize(Serializer).unwrap();
706        assert_eq!(serialized, Value::from(v));
707    }
708
709    #[rstest]
710    #[case(0i16)]
711    #[case(-128)]
712    #[case(1024)]
713    fn serialize_i16_numbers(#[case] v: i16) {
714        let serialized = v.serialize(Serializer).unwrap();
715        assert_eq!(serialized, Value::from(v));
716    }
717
718    #[rstest]
719    #[case(0i32)]
720    #[case(-32768)]
721    #[case(1_000_000)]
722    fn serialize_i32_numbers(#[case] v: i32) {
723        let serialized = v.serialize(Serializer).unwrap();
724        assert_eq!(serialized, Value::from(v));
725    }
726
727    #[rstest]
728    #[case(0i64)]
729    #[case(-2147483648)]
730    #[case(9_223_372_036_854_775_807i64)]
731    fn serialize_i64_numbers(#[case] v: i64) {
732        let serialized = v.serialize(Serializer).unwrap();
733        assert_eq!(serialized, Value::from(v));
734    }
735
736    #[rstest]
737    #[case(0u8)]
738    #[case(255)]
739    fn serialize_u8_numbers(#[case] v: u8) {
740        let serialized = v.serialize(Serializer).unwrap();
741        assert_eq!(serialized, Value::from(v));
742    }
743
744    #[rstest]
745    #[case(0u16)]
746    #[case(65_535)]
747    fn serialize_u16_numbers(#[case] v: u16) {
748        let serialized = v.serialize(Serializer).unwrap();
749        assert_eq!(serialized, Value::from(v));
750    }
751
752    #[rstest]
753    #[case(0u32)]
754    #[case(4_294_967_295)]
755    fn serialize_u32_numbers(#[case] v: u32) {
756        let serialized = v.serialize(Serializer).unwrap();
757        assert_eq!(serialized, Value::from(v));
758    }
759
760    #[rstest]
761    #[case(0u64)]
762    #[case(18_446_744_073_709_551_615u64)]
763    fn serialize_u64_numbers(#[case] v: u64) {
764        let serialized = v.serialize(Serializer).unwrap();
765        assert_eq!(serialized, Value::from(v));
766    }
767
768    #[rstest]
769    #[case(0.0f32)]
770    #[case(-0.0)]
771    #[case(1.5)]
772    fn serialize_f32_numbers(#[case] v: f32) {
773        let serialized = v.serialize(Serializer).unwrap();
774        assert_eq!(serialized, Value::from(v));
775    }
776
777    #[rstest]
778    #[case(0.0f64)]
779    #[case(-0.0)]
780    #[case(1.5)]
781    fn serialize_f64_numbers(#[case] v: f64) {
782        let serialized = v.serialize(Serializer).unwrap();
783        assert_eq!(serialized, Value::from(v));
784    }
785
786    #[rstest]
787    #[case('a', Value::String("a".to_string()))]
788    #[case('😀', Value::String("😀".to_string()))]
789    fn serialize_char_as_string(#[case] ch: char, #[case] expected: Value) {
790        let serialized = ch.serialize(Serializer).unwrap();
791        assert_eq!(serialized, expected);
792    }
793
794    #[rstest]
795    #[case("")]
796    #[case("hello")]
797    fn serialize_strs(#[case] s: &str) {
798        let serialized = s.serialize(Serializer).unwrap();
799        assert_eq!(serialized, Value::from(s));
800    }
801
802    #[rstest]
803    #[case(vec![])]
804    #[case(vec![9u8, 8, 7, 6])]
805    fn serialize_bytes_via_bytebuf(#[case] data: Vec<u8>) {
806        let bb = ByteBuf::from(data.clone());
807        let serialized = bb.serialize(Serializer).unwrap();
808        assert_eq!(serialized, Value::Bin(data));
809    }
810
811    #[rstest]
812    #[case(vec![])]
813    #[case(vec![1u8, 2, 3])]
814    fn serialize_slice_u8_as_array(#[case] data: Vec<u8>) {
815        let s: &[u8] = &data;
816        let serialized = s.serialize(Serializer).unwrap();
817        assert_eq!(
818            serialized,
819            Value::Array(data.into_iter().map(Value::from).collect())
820        );
821    }
822
823    #[rstest]
824    #[case(vec![])]
825    #[case(vec![1u8, 2, 3])]
826    fn serialize_vec_u8_as_array(#[case] data: Vec<u8>) {
827        let serialized = data.serialize(Serializer).unwrap();
828        assert_eq!(
829            serialized,
830            Value::Array(data.into_iter().map(Value::from).collect())
831        );
832    }
833
834    #[rstest]
835    #[case(vec![])]
836    #[case(vec![1u8, 2, 3])]
837    fn serialize_bytes_via_bytes_wrapper(#[case] data: Vec<u8>) {
838        let bytes = serde_bytes::Bytes::new(&data);
839        let serialized = bytes.serialize(Serializer).unwrap();
840        assert_eq!(serialized, Value::Bin(data));
841    }
842
843    #[derive(Serialize)]
844    struct U;
845
846    #[rstest]
847    #[case(U)]
848    #[case(())]
849    #[case(Option::<u8>::None)]
850    fn serialize_option_unit_and_unit_struct<V>(#[case] val: V)
851    where
852        V: Serialize,
853    {
854        assert_eq!(val.serialize(Serializer).unwrap(), Value::Nil)
855    }
856
857    #[rstest]
858    fn serialize_newtype_struct_plain() {
859        #[derive(Serialize)]
860        struct Wrapper(u16);
861        let v = Wrapper(7);
862        // Should delegate to inner
863        assert_eq!(v.serialize(Serializer).unwrap(), Value::from(7));
864    }
865
866    #[derive(Serialize)]
867    struct Tup(u8, i16);
868
869    #[rstest]
870    #[case(
871        (1u8, 2u16, 3i32),
872        Value::Array(vec![Value::from(1), Value::from(2), Value::from(3)])
873    )]
874    #[case(
875        Tup(1, -2),
876        Value::Array(vec![Value::from(1), Value::from(-2)])
877    )]
878    fn serialize_tuple_and_tuple_struct<V>(#[case] val: V, #[case] expected: Value)
879    where
880        V: Serialize,
881    {
882        assert_eq!(val.serialize(Serializer).unwrap(), expected)
883    }
884
885    #[rstest]
886    fn serialize_struct_to_map() {
887        #[derive(Serialize)]
888        struct S<'a> {
889            a: u8,
890            #[serde(rename = "msg")]
891            b: &'a str,
892        }
893        let v = S { a: 7, b: "hi" };
894        let s = v.serialize(Serializer).unwrap();
895        assert_eq!(
896            s,
897            Value::Map(vec![
898                (Value::from("a"), Value::from(7u8)),
899                (Value::from("msg"), Value::from("hi")),
900            ])
901        );
902    }
903
904    #[test]
905    fn serialize_seq_and_map_with_unknown_len() {
906        // Serialize a seq with None length
907        struct DynSeq;
908        impl Serialize for DynSeq {
909            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
910            where
911                S: serde::Serializer,
912            {
913                use serde::ser::SerializeSeq;
914                let mut seq = serializer.serialize_seq(None)?;
915                seq.serialize_element(&1u8)?;
916                seq.serialize_element(&2u16)?;
917                seq.serialize_element(&3i32)?;
918                seq.end()
919            }
920        }
921        let seq_val = DynSeq.serialize(Serializer).unwrap();
922        assert_eq!(
923            seq_val,
924            Value::Array(vec![Value::from(1u8), Value::from(2u16), Value::from(3i32)])
925        );
926
927        // Serialize a map with None length
928        struct DynMap;
929        impl Serialize for DynMap {
930            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
931            where
932                S: serde::Serializer,
933            {
934                use serde::ser::SerializeMap;
935                let mut map = serializer.serialize_map(None)?;
936                map.serialize_entry(&"k1", &10u8)?;
937                map.serialize_entry(&2u8, &"v2")?;
938                map.end()
939            }
940        }
941        let map_val = DynMap.serialize(Serializer).unwrap();
942        assert_eq!(
943            map_val,
944            Value::Map(vec![
945                (Value::from("k1"), Value::from(10u8)),
946                (Value::from(2u8), Value::from("v2")),
947            ])
948        );
949    }
950}
messagepack_serde/value/ser.rs

messagepack_serde/value/
ser.rs
