platform_value/value_serialization/
ser.rs

1use crate::error::Error;
2use crate::value_map::ValueMap;
3use crate::{to_value, Value};
4use base64::prelude::BASE64_STANDARD;
5use base64::Engine;
6use serde::ser::{Impossible, Serialize};
7use std::fmt::Display;
8
9// We only use our own error type; no need for From conversions provided by the
10// standard library's try! macro. This reduces lines of LLVM IR by 4%.
11macro_rules! tri {
12    ($e:expr $(,)?) => {
13        match $e {
14            core::result::Result::Ok(val) => val,
15            core::result::Result::Err(err) => return core::result::Result::Err(err),
16        }
17    };
18}
19
20impl Serialize for Value {
21    #[inline]
22    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
23    where
24        S: ::serde::Serializer,
25    {
26        match self {
27            Value::Null => serializer.serialize_unit(),
28            Value::Bool(b) => serializer.serialize_bool(*b),
29            Value::Array(v) => v.serialize(serializer),
30            Value::Map(m) => {
31                use serde::ser::SerializeMap;
32                let mut map = tri!(serializer.serialize_map(Some(m.len())));
33                for (k, v) in m {
34                    tri!(map.serialize_entry(k, v));
35                }
36                map.end()
37            }
38            Value::U128(i) => serializer.serialize_u128(*i),
39            Value::I128(i) => serializer.serialize_i128(*i),
40            Value::U64(i) => serializer.serialize_u64(*i),
41            Value::I64(i) => serializer.serialize_i64(*i),
42            Value::U32(i) => serializer.serialize_u32(*i),
43            Value::I32(i) => serializer.serialize_i32(*i),
44            Value::U16(i) => serializer.serialize_u16(*i),
45            Value::I16(i) => serializer.serialize_i16(*i),
46            Value::U8(i) => serializer.serialize_u8(*i),
47            Value::I8(i) => serializer.serialize_i8(*i),
48            Value::Bytes(bytes) => {
49                if serializer.is_human_readable() {
50                    serializer.serialize_str(BASE64_STANDARD.encode(bytes).as_str())
51                } else {
52                    serializer.serialize_bytes(bytes)
53                }
54            }
55            Value::Bytes20(bytes) => {
56                if serializer.is_human_readable() {
57                    serializer.serialize_str(BASE64_STANDARD.encode(bytes).as_str())
58                } else {
59                    serializer.serialize_bytes(bytes)
60                }
61            }
62            Value::Bytes32(bytes) => {
63                if serializer.is_human_readable() {
64                    serializer.serialize_str(BASE64_STANDARD.encode(bytes).as_str())
65                } else {
66                    serializer.serialize_bytes(bytes)
67                }
68            }
69            Value::Bytes36(bytes) => {
70                if serializer.is_human_readable() {
71                    serializer.serialize_str(BASE64_STANDARD.encode(bytes).as_str())
72                } else {
73                    serializer.serialize_bytes(bytes)
74                }
75            }
76            Value::Identifier(bytes) => {
77                if serializer.is_human_readable() {
78                    serializer.serialize_str(bs58::encode(bytes).into_string().as_str())
79                } else {
80                    serializer.serialize_bytes(bytes)
81                }
82            }
83            Value::Float(f64) => serializer.serialize_f64(*f64),
84            Value::Text(string) => serializer.serialize_str(string),
85            Value::EnumU8(_x) => todo!(),
86            Value::EnumString(_x) => todo!(),
87        }
88    }
89}
90
91/// Serializer whose output is a `Value`.
92///
93/// This is the serializer that backs [`platform_value::to_value`][crate::to_value].
94/// Unlike the main platform_value serializer which goes from some serializable
95/// value of type `T` to JSON text, this one goes from `T` to
96/// `platform_value::Value`.
97///
98/// The `to_value` function is implementable as:
99///
100/// ```
101/// use serde::Serialize;
102/// use serde_json::{Error, Value};
103///
104/// pub fn to_value<T>(input: T) -> Result<Value, Error>
105/// where
106///     T: Serialize,
107/// {
108///     input.serialize(serde_json::value::Serializer)
109/// }
110/// ```
111pub struct Serializer;
112
113impl serde::Serializer for Serializer {
114    type Ok = Value;
115    type Error = Error;
116
117    type SerializeSeq = SerializeVec;
118    type SerializeTuple = SerializeVec;
119    type SerializeTupleStruct = SerializeVec;
120    type SerializeTupleVariant = SerializeTupleVariant;
121    type SerializeMap = SerializeMap;
122    type SerializeStruct = SerializeMap;
123    type SerializeStructVariant = SerializeStructVariant;
124
125    #[inline]
126    fn serialize_bool(self, value: bool) -> Result<Value, Error> {
127        Ok(Value::Bool(value))
128    }
129
130    #[inline]
131    fn serialize_i8(self, value: i8) -> Result<Value, Error> {
132        Ok(Value::I8(value))
133    }
134
135    #[inline]
136    fn serialize_i16(self, value: i16) -> Result<Value, Error> {
137        Ok(Value::I16(value))
138    }
139
140    #[inline]
141    fn serialize_i32(self, value: i32) -> Result<Value, Error> {
142        Ok(Value::I32(value))
143    }
144
145    #[inline]
146    fn serialize_i64(self, value: i64) -> Result<Value, Error> {
147        Ok(Value::I64(value))
148    }
149
150    #[inline]
151    fn serialize_i128(self, value: i128) -> Result<Value, Error> {
152        Ok(Value::I128(value))
153    }
154
155    #[inline]
156    fn serialize_u8(self, value: u8) -> Result<Value, Error> {
157        Ok(Value::U8(value))
158    }
159
160    #[inline]
161    fn serialize_u16(self, value: u16) -> Result<Value, Error> {
162        Ok(Value::U16(value))
163    }
164
165    #[inline]
166    fn serialize_u32(self, value: u32) -> Result<Value, Error> {
167        Ok(Value::U32(value))
168    }
169
170    #[inline]
171    fn serialize_u64(self, value: u64) -> Result<Value, Error> {
172        Ok(Value::U64(value))
173    }
174
175    #[inline]
176    fn serialize_u128(self, value: u128) -> Result<Value, Error> {
177        Ok(Value::U128(value))
178    }
179
180    #[inline]
181    fn serialize_f32(self, value: f32) -> Result<Value, Error> {
182        self.serialize_f64(value as f64)
183    }
184
185    #[inline]
186    fn serialize_f64(self, value: f64) -> Result<Value, Error> {
187        Ok(Value::Float(value))
188    }
189
190    #[inline]
191    fn serialize_char(self, value: char) -> Result<Value, Error> {
192        let mut s = String::new();
193        s.push(value);
194        Ok(Value::Text(s))
195    }
196
197    #[inline]
198    fn serialize_str(self, value: &str) -> Result<Value, Error> {
199        Ok(Value::Text(value.to_owned()))
200    }
201
202    #[inline]
203    fn serialize_bytes(self, value: &[u8]) -> Result<Value, Error> {
204        Ok(match value.len() {
205            32 => Value::Bytes32(value.try_into().unwrap()),
206            36 => Value::Bytes36(value.try_into().unwrap()),
207            20 => Value::Bytes20(value.try_into().unwrap()),
208            _ => Value::Bytes(value.to_vec()),
209        })
210    }
211
212    #[inline]
213    fn serialize_unit(self) -> Result<Value, Error> {
214        Ok(Value::Null)
215    }
216
217    #[inline]
218    fn serialize_unit_struct(self, _name: &'static str) -> Result<Value, Error> {
219        self.serialize_unit()
220    }
221
222    #[inline]
223    fn serialize_unit_variant(
224        self,
225        _name: &'static str,
226        _variant_index: u32,
227        variant: &'static str,
228    ) -> Result<Value, Error> {
229        self.serialize_str(variant)
230    }
231
232    #[inline]
233    fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Value, Error>
234    where
235        T: ?Sized + Serialize,
236    {
237        match name {
238            "Identifier" => match value.serialize(self)? {
239                Value::Bytes32(b) => Ok(Value::Identifier(b)),
240                data => {
241                    panic!("expected Value::Bytes32, got: {data:#?}")
242                }
243            },
244            _ => value.serialize(self),
245        }
246    }
247
248    fn serialize_newtype_variant<T>(
249        self,
250        _name: &'static str,
251        _variant_index: u32,
252        variant: &'static str,
253        value: &T,
254    ) -> Result<Value, Error>
255    where
256        T: ?Sized + Serialize,
257    {
258        Ok(Value::Map(vec![(
259            Value::Text(String::from(variant)),
260            tri!(to_value(value)),
261        )]))
262    }
263
264    #[inline]
265    fn serialize_none(self) -> Result<Value, Error> {
266        self.serialize_unit()
267    }
268
269    #[inline]
270    fn serialize_some<T>(self, value: &T) -> Result<Value, Error>
271    where
272        T: ?Sized + Serialize,
273    {
274        value.serialize(self)
275    }
276
277    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
278        Ok(SerializeVec {
279            vec: Vec::with_capacity(len.unwrap_or(0)),
280        })
281    }
282
283    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Error> {
284        self.serialize_seq(Some(len))
285    }
286
287    fn serialize_tuple_struct(
288        self,
289        _name: &'static str,
290        len: usize,
291    ) -> Result<Self::SerializeTupleStruct, Error> {
292        self.serialize_seq(Some(len))
293    }
294
295    fn serialize_tuple_variant(
296        self,
297        _name: &'static str,
298        _variant_index: u32,
299        variant: &'static str,
300        len: usize,
301    ) -> Result<Self::SerializeTupleVariant, Error> {
302        Ok(SerializeTupleVariant {
303            name: String::from(variant),
304            vec: Vec::with_capacity(len),
305        })
306    }
307
308    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
309        Ok(SerializeMap::Map {
310            map: Vec::new(),
311            next_key: None,
312        })
313    }
314
315    fn serialize_struct(
316        self,
317        _name: &'static str,
318        len: usize,
319    ) -> Result<Self::SerializeStruct, Error> {
320        self.serialize_map(Some(len))
321    }
322
323    fn serialize_struct_variant(
324        self,
325        _name: &'static str,
326        _variant_index: u32,
327        variant: &'static str,
328        _len: usize,
329    ) -> Result<Self::SerializeStructVariant, Error> {
330        Ok(SerializeStructVariant {
331            name: String::from(variant),
332            map: Vec::new(),
333        })
334    }
335
336    fn collect_str<T>(self, value: &T) -> Result<Value, Error>
337    where
338        T: ?Sized + Display,
339    {
340        Ok(Value::Text(value.to_string()))
341    }
342
343    fn is_human_readable(&self) -> bool {
344        false
345    }
346}
347
348pub struct SerializeVec {
349    vec: Vec<Value>,
350}
351
352pub struct SerializeTupleVariant {
353    name: String,
354    vec: Vec<Value>,
355}
356
357pub enum SerializeMap {
358    Map {
359        map: ValueMap,
360        next_key: Option<String>,
361    },
362}
363
364pub struct SerializeStructVariant {
365    name: String,
366    map: ValueMap,
367}
368
369impl serde::ser::SerializeSeq for SerializeVec {
370    type Ok = Value;
371    type Error = Error;
372
373    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
374    where
375        T: ?Sized + Serialize,
376    {
377        self.vec.push(tri!(to_value(value)));
378        Ok(())
379    }
380
381    fn end(self) -> Result<Value, Error> {
382        Ok(Value::Array(self.vec))
383    }
384}
385
386impl serde::ser::SerializeTuple for SerializeVec {
387    type Ok = Value;
388    type Error = Error;
389
390    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
391    where
392        T: ?Sized + Serialize,
393    {
394        serde::ser::SerializeSeq::serialize_element(self, value)
395    }
396
397    fn end(self) -> Result<Value, Error> {
398        serde::ser::SerializeSeq::end(self)
399    }
400}
401
402// impl serde::ser::SerializeTuple for SerializeSizedVec {
403//     type Ok = Value;
404//     type Error = Error;
405//
406//     fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
407//         where
408//             T: ?Sized + Serialize,
409//     {
410//         serde::ser::SerializeSeq::serialize_element(self, value)
411//     }
412//
413//     fn end(self) -> Result<Value, Error> {
414//         if self.size == 32 {
415//             Ok(Value::Bytes32(self.vec))
416//         } else {
417//             serde::ser::SerializeSeq::end(self)
418//         }
419//     }
420// }
421
422impl serde::ser::SerializeTupleStruct for SerializeVec {
423    type Ok = Value;
424    type Error = Error;
425
426    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
427    where
428        T: ?Sized + Serialize,
429    {
430        serde::ser::SerializeSeq::serialize_element(self, value)
431    }
432
433    fn end(self) -> Result<Value, Error> {
434        serde::ser::SerializeSeq::end(self)
435    }
436}
437
438impl serde::ser::SerializeTupleVariant for SerializeTupleVariant {
439    type Ok = Value;
440    type Error = Error;
441
442    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
443    where
444        T: ?Sized + Serialize,
445    {
446        self.vec.push(tri!(to_value(value)));
447        Ok(())
448    }
449
450    fn end(self) -> Result<Value, Error> {
451        Ok(Value::Map(vec![(
452            Value::Text(self.name),
453            Value::Array(self.vec),
454        )]))
455    }
456}
457
458impl serde::ser::SerializeMap for SerializeMap {
459    type Ok = Value;
460    type Error = Error;
461
462    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error>
463    where
464        T: ?Sized + Serialize,
465    {
466        match self {
467            SerializeMap::Map { next_key, .. } => {
468                *next_key = Some(tri!(key.serialize(MapKeySerializer)));
469                Ok(())
470            }
471        }
472    }
473
474    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
475    where
476        T: ?Sized + Serialize,
477    {
478        match self {
479            SerializeMap::Map { map, next_key } => {
480                let key = next_key.take();
481                // Panic because this indicates a bug in the program rather than an
482                // expected failure.
483                let key = key.expect("serialize_value called before serialize_key");
484                map.push((Value::Text(key), tri!(to_value(value))));
485                Ok(())
486            }
487        }
488    }
489
490    fn end(self) -> Result<Value, Error> {
491        match self {
492            SerializeMap::Map { map, .. } => Ok(Value::Map(map)),
493        }
494    }
495}
496
497struct MapKeySerializer;
498
499fn key_must_be_a_string() -> Error {
500    Error::KeyMustBeAString
501}
502
503impl serde::Serializer for MapKeySerializer {
504    type Ok = String;
505    type Error = Error;
506
507    type SerializeSeq = Impossible<String, Error>;
508    type SerializeTuple = Impossible<String, Error>;
509    type SerializeTupleStruct = Impossible<String, Error>;
510    type SerializeTupleVariant = Impossible<String, Error>;
511    type SerializeMap = Impossible<String, Error>;
512    type SerializeStruct = Impossible<String, Error>;
513    type SerializeStructVariant = Impossible<String, Error>;
514
515    #[inline]
516    fn serialize_unit_variant(
517        self,
518        _name: &'static str,
519        _variant_index: u32,
520        variant: &'static str,
521    ) -> Result<String, Error> {
522        Ok(variant.to_owned())
523    }
524
525    #[inline]
526    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<String, Error>
527    where
528        T: ?Sized + Serialize,
529    {
530        value.serialize(self)
531    }
532
533    fn serialize_bool(self, _value: bool) -> Result<String, Error> {
534        Err(key_must_be_a_string())
535    }
536
537    fn serialize_i8(self, value: i8) -> Result<String, Error> {
538        Ok(value.to_string())
539    }
540
541    fn serialize_i16(self, value: i16) -> Result<String, Error> {
542        Ok(value.to_string())
543    }
544
545    fn serialize_i32(self, value: i32) -> Result<String, Error> {
546        Ok(value.to_string())
547    }
548
549    fn serialize_i64(self, value: i64) -> Result<String, Error> {
550        Ok(value.to_string())
551    }
552
553    fn serialize_u8(self, value: u8) -> Result<String, Error> {
554        Ok(value.to_string())
555    }
556
557    fn serialize_u16(self, value: u16) -> Result<String, Error> {
558        Ok(value.to_string())
559    }
560
561    fn serialize_u32(self, value: u32) -> Result<String, Error> {
562        Ok(value.to_string())
563    }
564
565    fn serialize_u64(self, value: u64) -> Result<String, Error> {
566        Ok(value.to_string())
567    }
568
569    fn serialize_f32(self, _value: f32) -> Result<String, Error> {
570        Err(key_must_be_a_string())
571    }
572
573    fn serialize_f64(self, _value: f64) -> Result<String, Error> {
574        Err(key_must_be_a_string())
575    }
576
577    #[inline]
578    fn serialize_char(self, value: char) -> Result<String, Error> {
579        Ok({
580            let mut s = String::new();
581            s.push(value);
582            s
583        })
584    }
585
586    #[inline]
587    fn serialize_str(self, value: &str) -> Result<String, Error> {
588        Ok(value.to_owned())
589    }
590
591    fn serialize_bytes(self, _value: &[u8]) -> Result<String, Error> {
592        Err(key_must_be_a_string())
593    }
594
595    fn serialize_unit(self) -> Result<String, Error> {
596        Err(key_must_be_a_string())
597    }
598
599    fn serialize_unit_struct(self, _name: &'static str) -> Result<String, Error> {
600        Err(key_must_be_a_string())
601    }
602
603    fn serialize_newtype_variant<T>(
604        self,
605        _name: &'static str,
606        _variant_index: u32,
607        _variant: &'static str,
608        _value: &T,
609    ) -> Result<String, Error>
610    where
611        T: ?Sized + Serialize,
612    {
613        Err(key_must_be_a_string())
614    }
615
616    fn serialize_none(self) -> Result<String, Error> {
617        Err(key_must_be_a_string())
618    }
619
620    fn serialize_some<T>(self, _value: &T) -> Result<String, Error>
621    where
622        T: ?Sized + Serialize,
623    {
624        Err(key_must_be_a_string())
625    }
626
627    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Error> {
628        Err(key_must_be_a_string())
629    }
630
631    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Error> {
632        Err(key_must_be_a_string())
633    }
634
635    fn serialize_tuple_struct(
636        self,
637        _name: &'static str,
638        _len: usize,
639    ) -> Result<Self::SerializeTupleStruct, Error> {
640        Err(key_must_be_a_string())
641    }
642
643    fn serialize_tuple_variant(
644        self,
645        _name: &'static str,
646        _variant_index: u32,
647        _variant: &'static str,
648        _len: usize,
649    ) -> Result<Self::SerializeTupleVariant, Error> {
650        Err(key_must_be_a_string())
651    }
652
653    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Error> {
654        Err(key_must_be_a_string())
655    }
656
657    fn serialize_struct(
658        self,
659        _name: &'static str,
660        _len: usize,
661    ) -> Result<Self::SerializeStruct, Error> {
662        Err(key_must_be_a_string())
663    }
664
665    fn serialize_struct_variant(
666        self,
667        _name: &'static str,
668        _variant_index: u32,
669        _variant: &'static str,
670        _len: usize,
671    ) -> Result<Self::SerializeStructVariant, Error> {
672        Err(key_must_be_a_string())
673    }
674
675    fn collect_str<T>(self, value: &T) -> Result<String, Error>
676    where
677        T: ?Sized + Display,
678    {
679        Ok(value.to_string())
680    }
681}
682
683impl serde::ser::SerializeStruct for SerializeMap {
684    type Ok = Value;
685    type Error = Error;
686
687    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
688    where
689        T: ?Sized + Serialize,
690    {
691        match self {
692            SerializeMap::Map { .. } => serde::ser::SerializeMap::serialize_entry(self, key, value),
693        }
694    }
695
696    fn end(self) -> Result<Value, Error> {
697        match self {
698            SerializeMap::Map { .. } => serde::ser::SerializeMap::end(self),
699        }
700    }
701}
702
703impl serde::ser::SerializeStructVariant for SerializeStructVariant {
704    type Ok = Value;
705    type Error = Error;
706
707    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
708    where
709        T: ?Sized + Serialize,
710    {
711        self.map
712            .push((Value::Text(String::from(key)), tri!(to_value(value))));
713        Ok(())
714    }
715
716    fn end(self) -> Result<Value, Error> {
717        Ok(Value::Map(vec![(
718            Value::Text(self.name),
719            Value::Map(self.map),
720        )]))
721    }
722}
723
724#[cfg(test)]
725mod tests {
726    use super::*;
727    use serde::{Deserialize, Serialize};
728
729    // ---------------------------------------------------------------
730    // Serialize primitives
731    // ---------------------------------------------------------------
732
733    #[test]
734    fn serialize_bool() {
735        assert_eq!(to_value(true).unwrap(), Value::Bool(true));
736        assert_eq!(to_value(false).unwrap(), Value::Bool(false));
737    }
738
739    #[test]
740    fn serialize_i8() {
741        assert_eq!(to_value(-42i8).unwrap(), Value::I8(-42));
742    }
743
744    #[test]
745    fn serialize_i16() {
746        assert_eq!(to_value(-1000i16).unwrap(), Value::I16(-1000));
747    }
748
749    #[test]
750    fn serialize_i32() {
751        assert_eq!(to_value(-100_000i32).unwrap(), Value::I32(-100_000));
752    }
753
754    #[test]
755    fn serialize_i64() {
756        assert_eq!(
757            to_value(-10_000_000_000i64).unwrap(),
758            Value::I64(-10_000_000_000)
759        );
760    }
761
762    #[test]
763    fn serialize_i128() {
764        assert_eq!(to_value(i128::MIN).unwrap(), Value::I128(i128::MIN));
765    }
766
767    #[test]
768    fn serialize_u8() {
769        assert_eq!(to_value(42u8).unwrap(), Value::U8(42));
770    }
771
772    #[test]
773    fn serialize_u16() {
774        assert_eq!(to_value(1000u16).unwrap(), Value::U16(1000));
775    }
776
777    #[test]
778    fn serialize_u32() {
779        assert_eq!(to_value(100_000u32).unwrap(), Value::U32(100_000));
780    }
781
782    #[test]
783    fn serialize_u64() {
784        assert_eq!(
785            to_value(10_000_000_000u64).unwrap(),
786            Value::U64(10_000_000_000)
787        );
788    }
789
790    #[test]
791    fn serialize_u128() {
792        assert_eq!(to_value(u128::MAX).unwrap(), Value::U128(u128::MAX));
793    }
794
795    #[test]
796    fn serialize_f32() {
797        let val = to_value(3.14f32).unwrap();
798        match val {
799            Value::Float(f) => assert!((f - 3.14f32 as f64).abs() < 1e-6),
800            _ => panic!("expected Float"),
801        }
802    }
803
804    #[test]
805    fn serialize_f64() {
806        assert_eq!(to_value(2.718f64).unwrap(), Value::Float(2.718));
807    }
808
809    #[test]
810    fn serialize_char() {
811        let val = to_value('A').unwrap();
812        assert_eq!(val, Value::Text("A".to_string()));
813    }
814
815    #[test]
816    fn serialize_str() {
817        assert_eq!(to_value("hello").unwrap(), Value::Text("hello".to_string()));
818    }
819
820    #[test]
821    fn serialize_string() {
822        assert_eq!(
823            to_value("world".to_string()).unwrap(),
824            Value::Text("world".to_string())
825        );
826    }
827
828    // ---------------------------------------------------------------
829    // Serialize unit / None / Some
830    // ---------------------------------------------------------------
831
832    #[test]
833    fn serialize_unit() {
834        assert_eq!(to_value(()).unwrap(), Value::Null);
835    }
836
837    #[test]
838    fn serialize_none() {
839        let val: Option<u32> = None;
840        assert_eq!(to_value(val).unwrap(), Value::Null);
841    }
842
843    #[test]
844    fn serialize_some() {
845        let val: Option<u32> = Some(42);
846        assert_eq!(to_value(val).unwrap(), Value::U32(42));
847    }
848
849    // ---------------------------------------------------------------
850    // Serialize sequences and tuples
851    // ---------------------------------------------------------------
852
853    #[test]
854    fn serialize_vec() {
855        let val = to_value(vec![1u32, 2, 3]).unwrap();
856        assert_eq!(
857            val,
858            Value::Array(vec![Value::U32(1), Value::U32(2), Value::U32(3)])
859        );
860    }
861
862    #[test]
863    fn serialize_empty_vec() {
864        let val = to_value(Vec::<u32>::new()).unwrap();
865        assert_eq!(val, Value::Array(vec![]));
866    }
867
868    #[test]
869    fn serialize_tuple() {
870        let val = to_value((1u32, "hello")).unwrap();
871        assert_eq!(
872            val,
873            Value::Array(vec![Value::U32(1), Value::Text("hello".into())])
874        );
875    }
876
877    // ---------------------------------------------------------------
878    // Serialize maps
879    // ---------------------------------------------------------------
880
881    #[test]
882    fn serialize_hashmap() {
883        let mut map = std::collections::HashMap::new();
884        map.insert("key", 42u32);
885        let val = to_value(map).unwrap();
886        match val {
887            Value::Map(entries) => {
888                assert_eq!(entries.len(), 1);
889                assert_eq!(entries[0].0, Value::Text("key".into()));
890                assert_eq!(entries[0].1, Value::U32(42));
891            }
892            _ => panic!("expected Map"),
893        }
894    }
895
896    // ---------------------------------------------------------------
897    // Serialize structs
898    // ---------------------------------------------------------------
899
900    #[test]
901    fn serialize_struct() {
902        #[derive(Serialize)]
903        struct Point {
904            x: i32,
905            y: i32,
906        }
907        let val = to_value(Point { x: 10, y: 20 }).unwrap();
908        match val {
909            Value::Map(entries) => {
910                assert_eq!(entries.len(), 2);
911                assert_eq!(entries[0].0, Value::Text("x".into()));
912                assert_eq!(entries[0].1, Value::I32(10));
913                assert_eq!(entries[1].0, Value::Text("y".into()));
914                assert_eq!(entries[1].1, Value::I32(20));
915            }
916            _ => panic!("expected Map"),
917        }
918    }
919
920    #[test]
921    fn serialize_unit_struct() {
922        #[derive(Serialize)]
923        struct Empty;
924        assert_eq!(to_value(Empty).unwrap(), Value::Null);
925    }
926
927    #[test]
928    fn serialize_newtype_struct() {
929        #[derive(Serialize)]
930        struct Wrapper(u32);
931        assert_eq!(to_value(Wrapper(42)).unwrap(), Value::U32(42));
932    }
933
934    #[test]
935    fn serialize_tuple_struct() {
936        #[derive(Serialize)]
937        struct Pair(u32, String);
938        let val = to_value(Pair(1, "two".into())).unwrap();
939        assert_eq!(
940            val,
941            Value::Array(vec![Value::U32(1), Value::Text("two".into())])
942        );
943    }
944
945    // ---------------------------------------------------------------
946    // Serialize enums
947    // ---------------------------------------------------------------
948
949    #[test]
950    fn serialize_unit_variant() {
951        #[derive(Serialize)]
952        enum Color {
953            Red,
954        }
955        assert_eq!(
956            to_value(Color::Red).unwrap(),
957            Value::Text("Red".to_string())
958        );
959    }
960
961    #[test]
962    fn serialize_newtype_variant() {
963        #[derive(Serialize)]
964        enum Wrapper {
965            Count(u32),
966        }
967        let val = to_value(Wrapper::Count(42)).unwrap();
968        assert_eq!(
969            val,
970            Value::Map(vec![(Value::Text("Count".into()), Value::U32(42))])
971        );
972    }
973
974    #[test]
975    fn serialize_tuple_variant() {
976        #[derive(Serialize)]
977        enum Pair {
978            Coords(i32, i32),
979        }
980        let val = to_value(Pair::Coords(10, 20)).unwrap();
981        assert_eq!(
982            val,
983            Value::Map(vec![(
984                Value::Text("Coords".into()),
985                Value::Array(vec![Value::I32(10), Value::I32(20)])
986            )])
987        );
988    }
989
990    #[test]
991    fn serialize_struct_variant() {
992        #[derive(Serialize)]
993        enum Shape {
994            Circle { radius: u32 },
995        }
996        let val = to_value(Shape::Circle { radius: 5 }).unwrap();
997        assert_eq!(
998            val,
999            Value::Map(vec![(
1000                Value::Text("Circle".into()),
1001                Value::Map(vec![(Value::Text("radius".into()), Value::U32(5))])
1002            )])
1003        );
1004    }
1005
1006    // ---------------------------------------------------------------
1007    // Serialize bytes (non-human-readable mode)
1008    // ---------------------------------------------------------------
1009
1010    #[test]
1011    fn serialize_bytes_32_becomes_bytes32() {
1012        // Exactly 32 bytes should become Bytes32
1013        let data = [1u8; 32];
1014        use serde::Serializer;
1015        let val = Serializer.serialize_bytes(&data).unwrap();
1016        assert_eq!(val, Value::Bytes32(data));
1017    }
1018
1019    #[test]
1020    fn serialize_bytes_20_becomes_bytes20() {
1021        let data = [2u8; 20];
1022        use serde::Serializer;
1023        let val = Serializer.serialize_bytes(&data).unwrap();
1024        assert_eq!(val, Value::Bytes20(data));
1025    }
1026
1027    #[test]
1028    fn serialize_bytes_36_becomes_bytes36() {
1029        let data = [3u8; 36];
1030        use serde::Serializer;
1031        let val = Serializer.serialize_bytes(&data).unwrap();
1032        assert_eq!(val, Value::Bytes36(data));
1033    }
1034
1035    #[test]
1036    fn serialize_bytes_other_len_becomes_bytes() {
1037        let data = vec![4u8; 10];
1038        use serde::Serializer;
1039        let val = Serializer.serialize_bytes(&data).unwrap();
1040        assert_eq!(val, Value::Bytes(data));
1041    }
1042
1043    // ---------------------------------------------------------------
1044    // Serialize Value (the Serialize impl for Value)
1045    // ---------------------------------------------------------------
1046
1047    #[test]
1048    fn serialize_value_null() {
1049        let val = Value::Null;
1050        let serialized = to_value(&val).unwrap();
1051        assert_eq!(serialized, Value::Null);
1052    }
1053
1054    #[test]
1055    fn serialize_value_bool() {
1056        let val = Value::Bool(true);
1057        let serialized = to_value(&val).unwrap();
1058        assert_eq!(serialized, Value::Bool(true));
1059    }
1060
1061    #[test]
1062    fn serialize_value_integer_types() {
1063        let cases = vec![
1064            Value::U8(1),
1065            Value::I8(-1),
1066            Value::U16(100),
1067            Value::I16(-100),
1068            Value::U32(1000),
1069            Value::I32(-1000),
1070            Value::U64(10000),
1071            Value::I64(-10000),
1072            Value::U128(100000),
1073            Value::I128(-100000),
1074        ];
1075        for val in cases {
1076            let serialized = to_value(&val).unwrap();
1077            assert_eq!(serialized, val);
1078        }
1079    }
1080
1081    #[test]
1082    fn serialize_value_float() {
1083        let val = Value::Float(3.14);
1084        let serialized = to_value(&val).unwrap();
1085        assert_eq!(serialized, Value::Float(3.14));
1086    }
1087
1088    #[test]
1089    fn serialize_value_text() {
1090        let val = Value::Text("hello".into());
1091        let serialized = to_value(&val).unwrap();
1092        assert_eq!(serialized, Value::Text("hello".into()));
1093    }
1094
1095    #[test]
1096    fn serialize_value_array() {
1097        let val = Value::Array(vec![Value::U8(1), Value::U8(2)]);
1098        let serialized = to_value(&val).unwrap();
1099        assert_eq!(serialized, val);
1100    }
1101
1102    #[test]
1103    fn serialize_value_map() {
1104        let val = Value::Map(vec![(Value::Text("k".into()), Value::U32(42))]);
1105        let serialized = to_value(&val).unwrap();
1106        assert_eq!(serialized, val);
1107    }
1108
1109    #[test]
1110    fn serialize_value_bytes() {
1111        let val = Value::Bytes(vec![1, 2, 3, 4, 5]);
1112        let serialized = to_value(&val).unwrap();
1113        // Non-human-readable serializer: serialized as bytes
1114        assert_eq!(serialized, val);
1115    }
1116
1117    #[test]
1118    fn serialize_value_bytes20() {
1119        let val = Value::Bytes20([1u8; 20]);
1120        let serialized = to_value(&val).unwrap();
1121        // serialize_bytes with len=20 -> Bytes20
1122        assert_eq!(serialized, val);
1123    }
1124
1125    #[test]
1126    fn serialize_value_bytes32() {
1127        let val = Value::Bytes32([2u8; 32]);
1128        let serialized = to_value(&val).unwrap();
1129        assert_eq!(serialized, val);
1130    }
1131
1132    #[test]
1133    fn serialize_value_bytes36() {
1134        let val = Value::Bytes36([3u8; 36]);
1135        let serialized = to_value(&val).unwrap();
1136        assert_eq!(serialized, val);
1137    }
1138
1139    #[test]
1140    fn serialize_value_identifier() {
1141        let val = Value::Identifier([4u8; 32]);
1142        let serialized = to_value(&val).unwrap();
1143        // Non-human-readable: identifier serialized as bytes (32 bytes -> Bytes32)
1144        assert_eq!(serialized, Value::Bytes32([4u8; 32]));
1145    }
1146
1147    // ---------------------------------------------------------------
1148    // MapKeySerializer error cases
1149    // ---------------------------------------------------------------
1150
1151    #[test]
1152    fn map_key_bool_errors() {
1153        let mut map = std::collections::HashMap::new();
1154        map.insert(true, "value");
1155        let result = to_value(map);
1156        assert!(result.is_err());
1157    }
1158
1159    #[test]
1160    fn map_key_string_works() {
1161        let mut map = std::collections::HashMap::new();
1162        map.insert("key".to_string(), 42u32);
1163        let result = to_value(map);
1164        assert!(result.is_ok());
1165    }
1166
1167    #[test]
1168    fn map_key_integer_works() {
1169        let mut map = std::collections::HashMap::new();
1170        map.insert(42u32, "value");
1171        let result = to_value(map);
1172        assert!(result.is_ok());
1173    }
1174
1175    // ---------------------------------------------------------------
1176    // Round-trip tests: Rust -> Value -> Rust
1177    // ---------------------------------------------------------------
1178
1179    #[test]
1180    fn round_trip_complex_struct() {
1181        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1182        struct Complex {
1183            name: String,
1184            count: u64,
1185            active: bool,
1186            score: f64,
1187            tags: Vec<String>,
1188            metadata: Option<String>,
1189        }
1190
1191        let original = Complex {
1192            name: "test".into(),
1193            count: 42,
1194            active: true,
1195            score: 3.14,
1196            tags: vec!["a".into(), "b".into()],
1197            metadata: Some("info".into()),
1198        };
1199        let val = to_value(&original).unwrap();
1200        let recovered: Complex = crate::from_value(val).unwrap();
1201        assert_eq!(original, recovered);
1202    }
1203
1204    #[test]
1205    fn round_trip_nested() {
1206        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1207        struct Inner {
1208            x: i32,
1209        }
1210        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1211        struct Outer {
1212            inner: Inner,
1213        }
1214
1215        let original = Outer {
1216            inner: Inner { x: -5 },
1217        };
1218        let val = to_value(&original).unwrap();
1219        let recovered: Outer = crate::from_value(val).unwrap();
1220        assert_eq!(original, recovered);
1221    }
1222
1223    #[test]
1224    fn collect_str_produces_text() {
1225        use serde::Serializer;
1226        let val = Serializer.collect_str(&42).unwrap();
1227        assert_eq!(val, Value::Text("42".to_string()));
1228    }
1229}
platform_value/value_serialization/ser.rs

platform_value/value_serialization/
ser.rs
