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)]
725#[allow(clippy::approx_constant)]
726mod tests {
727    use super::*;
728    use serde::{Deserialize, Serialize};
729
730    // ---------------------------------------------------------------
731    // Serialize primitives
732    // ---------------------------------------------------------------
733
734    #[test]
735    fn serialize_bool() {
736        assert_eq!(to_value(true).unwrap(), Value::Bool(true));
737        assert_eq!(to_value(false).unwrap(), Value::Bool(false));
738    }
739
740    #[test]
741    fn serialize_i8() {
742        assert_eq!(to_value(-42i8).unwrap(), Value::I8(-42));
743    }
744
745    #[test]
746    fn serialize_i16() {
747        assert_eq!(to_value(-1000i16).unwrap(), Value::I16(-1000));
748    }
749
750    #[test]
751    fn serialize_i32() {
752        assert_eq!(to_value(-100_000i32).unwrap(), Value::I32(-100_000));
753    }
754
755    #[test]
756    fn serialize_i64() {
757        assert_eq!(
758            to_value(-10_000_000_000i64).unwrap(),
759            Value::I64(-10_000_000_000)
760        );
761    }
762
763    #[test]
764    fn serialize_i128() {
765        assert_eq!(to_value(i128::MIN).unwrap(), Value::I128(i128::MIN));
766    }
767
768    #[test]
769    fn serialize_u8() {
770        assert_eq!(to_value(42u8).unwrap(), Value::U8(42));
771    }
772
773    #[test]
774    fn serialize_u16() {
775        assert_eq!(to_value(1000u16).unwrap(), Value::U16(1000));
776    }
777
778    #[test]
779    fn serialize_u32() {
780        assert_eq!(to_value(100_000u32).unwrap(), Value::U32(100_000));
781    }
782
783    #[test]
784    fn serialize_u64() {
785        assert_eq!(
786            to_value(10_000_000_000u64).unwrap(),
787            Value::U64(10_000_000_000)
788        );
789    }
790
791    #[test]
792    fn serialize_u128() {
793        assert_eq!(to_value(u128::MAX).unwrap(), Value::U128(u128::MAX));
794    }
795
796    #[test]
797    fn serialize_f32() {
798        let val = to_value(3.14f32).unwrap();
799        match val {
800            Value::Float(f) => assert!((f - 3.14f32 as f64).abs() < 1e-6),
801            _ => panic!("expected Float"),
802        }
803    }
804
805    #[test]
806    fn serialize_f64() {
807        assert_eq!(to_value(2.718f64).unwrap(), Value::Float(2.718));
808    }
809
810    #[test]
811    fn serialize_char() {
812        let val = to_value('A').unwrap();
813        assert_eq!(val, Value::Text("A".to_string()));
814    }
815
816    #[test]
817    fn serialize_str() {
818        assert_eq!(to_value("hello").unwrap(), Value::Text("hello".to_string()));
819    }
820
821    #[test]
822    fn serialize_string() {
823        assert_eq!(
824            to_value("world".to_string()).unwrap(),
825            Value::Text("world".to_string())
826        );
827    }
828
829    // ---------------------------------------------------------------
830    // Serialize unit / None / Some
831    // ---------------------------------------------------------------
832
833    #[test]
834    fn serialize_unit() {
835        assert_eq!(to_value(()).unwrap(), Value::Null);
836    }
837
838    #[test]
839    fn serialize_none() {
840        let val: Option<u32> = None;
841        assert_eq!(to_value(val).unwrap(), Value::Null);
842    }
843
844    #[test]
845    fn serialize_some() {
846        let val: Option<u32> = Some(42);
847        assert_eq!(to_value(val).unwrap(), Value::U32(42));
848    }
849
850    // ---------------------------------------------------------------
851    // Serialize sequences and tuples
852    // ---------------------------------------------------------------
853
854    #[test]
855    fn serialize_vec() {
856        let val = to_value(vec![1u32, 2, 3]).unwrap();
857        assert_eq!(
858            val,
859            Value::Array(vec![Value::U32(1), Value::U32(2), Value::U32(3)])
860        );
861    }
862
863    #[test]
864    fn serialize_empty_vec() {
865        let val = to_value(Vec::<u32>::new()).unwrap();
866        assert_eq!(val, Value::Array(vec![]));
867    }
868
869    #[test]
870    fn serialize_tuple() {
871        let val = to_value((1u32, "hello")).unwrap();
872        assert_eq!(
873            val,
874            Value::Array(vec![Value::U32(1), Value::Text("hello".into())])
875        );
876    }
877
878    // ---------------------------------------------------------------
879    // Serialize maps
880    // ---------------------------------------------------------------
881
882    #[test]
883    fn serialize_hashmap() {
884        let mut map = std::collections::HashMap::new();
885        map.insert("key", 42u32);
886        let val = to_value(map).unwrap();
887        match val {
888            Value::Map(entries) => {
889                assert_eq!(entries.len(), 1);
890                assert_eq!(entries[0].0, Value::Text("key".into()));
891                assert_eq!(entries[0].1, Value::U32(42));
892            }
893            _ => panic!("expected Map"),
894        }
895    }
896
897    // ---------------------------------------------------------------
898    // Serialize structs
899    // ---------------------------------------------------------------
900
901    #[test]
902    fn serialize_struct() {
903        #[derive(Serialize)]
904        struct Point {
905            x: i32,
906            y: i32,
907        }
908        let val = to_value(Point { x: 10, y: 20 }).unwrap();
909        match val {
910            Value::Map(entries) => {
911                assert_eq!(entries.len(), 2);
912                assert_eq!(entries[0].0, Value::Text("x".into()));
913                assert_eq!(entries[0].1, Value::I32(10));
914                assert_eq!(entries[1].0, Value::Text("y".into()));
915                assert_eq!(entries[1].1, Value::I32(20));
916            }
917            _ => panic!("expected Map"),
918        }
919    }
920
921    #[test]
922    fn serialize_unit_struct() {
923        #[derive(Serialize)]
924        struct Empty;
925        assert_eq!(to_value(Empty).unwrap(), Value::Null);
926    }
927
928    #[test]
929    fn serialize_newtype_struct() {
930        #[derive(Serialize)]
931        struct Wrapper(u32);
932        assert_eq!(to_value(Wrapper(42)).unwrap(), Value::U32(42));
933    }
934
935    #[test]
936    fn serialize_tuple_struct() {
937        #[derive(Serialize)]
938        struct Pair(u32, String);
939        let val = to_value(Pair(1, "two".into())).unwrap();
940        assert_eq!(
941            val,
942            Value::Array(vec![Value::U32(1), Value::Text("two".into())])
943        );
944    }
945
946    // ---------------------------------------------------------------
947    // Serialize enums
948    // ---------------------------------------------------------------
949
950    #[test]
951    fn serialize_unit_variant() {
952        #[derive(Serialize)]
953        enum Color {
954            Red,
955        }
956        assert_eq!(
957            to_value(Color::Red).unwrap(),
958            Value::Text("Red".to_string())
959        );
960    }
961
962    #[test]
963    fn serialize_newtype_variant() {
964        #[derive(Serialize)]
965        enum Wrapper {
966            Count(u32),
967        }
968        let val = to_value(Wrapper::Count(42)).unwrap();
969        assert_eq!(
970            val,
971            Value::Map(vec![(Value::Text("Count".into()), Value::U32(42))])
972        );
973    }
974
975    #[test]
976    fn serialize_tuple_variant() {
977        #[derive(Serialize)]
978        enum Pair {
979            Coords(i32, i32),
980        }
981        let val = to_value(Pair::Coords(10, 20)).unwrap();
982        assert_eq!(
983            val,
984            Value::Map(vec![(
985                Value::Text("Coords".into()),
986                Value::Array(vec![Value::I32(10), Value::I32(20)])
987            )])
988        );
989    }
990
991    #[test]
992    fn serialize_struct_variant() {
993        #[derive(Serialize)]
994        enum Shape {
995            Circle { radius: u32 },
996        }
997        let val = to_value(Shape::Circle { radius: 5 }).unwrap();
998        assert_eq!(
999            val,
1000            Value::Map(vec![(
1001                Value::Text("Circle".into()),
1002                Value::Map(vec![(Value::Text("radius".into()), Value::U32(5))])
1003            )])
1004        );
1005    }
1006
1007    // ---------------------------------------------------------------
1008    // Serialize bytes (non-human-readable mode)
1009    // ---------------------------------------------------------------
1010
1011    #[test]
1012    fn serialize_bytes_32_becomes_bytes32() {
1013        // Exactly 32 bytes should become Bytes32
1014        let data = [1u8; 32];
1015        use serde::Serializer;
1016        let val = Serializer.serialize_bytes(&data).unwrap();
1017        assert_eq!(val, Value::Bytes32(data));
1018    }
1019
1020    #[test]
1021    fn serialize_bytes_20_becomes_bytes20() {
1022        let data = [2u8; 20];
1023        use serde::Serializer;
1024        let val = Serializer.serialize_bytes(&data).unwrap();
1025        assert_eq!(val, Value::Bytes20(data));
1026    }
1027
1028    #[test]
1029    fn serialize_bytes_36_becomes_bytes36() {
1030        let data = [3u8; 36];
1031        use serde::Serializer;
1032        let val = Serializer.serialize_bytes(&data).unwrap();
1033        assert_eq!(val, Value::Bytes36(data));
1034    }
1035
1036    #[test]
1037    fn serialize_bytes_other_len_becomes_bytes() {
1038        let data = vec![4u8; 10];
1039        use serde::Serializer;
1040        let val = Serializer.serialize_bytes(&data).unwrap();
1041        assert_eq!(val, Value::Bytes(data));
1042    }
1043
1044    // ---------------------------------------------------------------
1045    // Serialize Value (the Serialize impl for Value)
1046    // ---------------------------------------------------------------
1047
1048    #[test]
1049    fn serialize_value_null() {
1050        let val = Value::Null;
1051        let serialized = to_value(&val).unwrap();
1052        assert_eq!(serialized, Value::Null);
1053    }
1054
1055    #[test]
1056    fn serialize_value_bool() {
1057        let val = Value::Bool(true);
1058        let serialized = to_value(&val).unwrap();
1059        assert_eq!(serialized, Value::Bool(true));
1060    }
1061
1062    #[test]
1063    fn serialize_value_integer_types() {
1064        let cases = vec![
1065            Value::U8(1),
1066            Value::I8(-1),
1067            Value::U16(100),
1068            Value::I16(-100),
1069            Value::U32(1000),
1070            Value::I32(-1000),
1071            Value::U64(10000),
1072            Value::I64(-10000),
1073            Value::U128(100000),
1074            Value::I128(-100000),
1075        ];
1076        for val in cases {
1077            let serialized = to_value(&val).unwrap();
1078            assert_eq!(serialized, val);
1079        }
1080    }
1081
1082    #[test]
1083    fn serialize_value_float() {
1084        let val = Value::Float(3.14);
1085        let serialized = to_value(&val).unwrap();
1086        assert_eq!(serialized, Value::Float(3.14));
1087    }
1088
1089    #[test]
1090    fn serialize_value_text() {
1091        let val = Value::Text("hello".into());
1092        let serialized = to_value(&val).unwrap();
1093        assert_eq!(serialized, Value::Text("hello".into()));
1094    }
1095
1096    #[test]
1097    fn serialize_value_array() {
1098        let val = Value::Array(vec![Value::U8(1), Value::U8(2)]);
1099        let serialized = to_value(&val).unwrap();
1100        assert_eq!(serialized, val);
1101    }
1102
1103    #[test]
1104    fn serialize_value_map() {
1105        let val = Value::Map(vec![(Value::Text("k".into()), Value::U32(42))]);
1106        let serialized = to_value(&val).unwrap();
1107        assert_eq!(serialized, val);
1108    }
1109
1110    #[test]
1111    fn serialize_value_bytes() {
1112        let val = Value::Bytes(vec![1, 2, 3, 4, 5]);
1113        let serialized = to_value(&val).unwrap();
1114        // Non-human-readable serializer: serialized as bytes
1115        assert_eq!(serialized, val);
1116    }
1117
1118    #[test]
1119    fn serialize_value_bytes20() {
1120        let val = Value::Bytes20([1u8; 20]);
1121        let serialized = to_value(&val).unwrap();
1122        // serialize_bytes with len=20 -> Bytes20
1123        assert_eq!(serialized, val);
1124    }
1125
1126    #[test]
1127    fn serialize_value_bytes32() {
1128        let val = Value::Bytes32([2u8; 32]);
1129        let serialized = to_value(&val).unwrap();
1130        assert_eq!(serialized, val);
1131    }
1132
1133    #[test]
1134    fn serialize_value_bytes36() {
1135        let val = Value::Bytes36([3u8; 36]);
1136        let serialized = to_value(&val).unwrap();
1137        assert_eq!(serialized, val);
1138    }
1139
1140    #[test]
1141    fn serialize_value_identifier() {
1142        let val = Value::Identifier([4u8; 32]);
1143        let serialized = to_value(&val).unwrap();
1144        // Non-human-readable: identifier serialized as bytes (32 bytes -> Bytes32)
1145        assert_eq!(serialized, Value::Bytes32([4u8; 32]));
1146    }
1147
1148    // ---------------------------------------------------------------
1149    // MapKeySerializer error cases
1150    // ---------------------------------------------------------------
1151
1152    #[test]
1153    fn map_key_bool_errors() {
1154        let mut map = std::collections::HashMap::new();
1155        map.insert(true, "value");
1156        let result = to_value(map);
1157        assert!(result.is_err());
1158    }
1159
1160    #[test]
1161    fn map_key_string_works() {
1162        let mut map = std::collections::HashMap::new();
1163        map.insert("key".to_string(), 42u32);
1164        let result = to_value(map);
1165        assert!(result.is_ok());
1166    }
1167
1168    #[test]
1169    fn map_key_integer_works() {
1170        let mut map = std::collections::HashMap::new();
1171        map.insert(42u32, "value");
1172        let result = to_value(map);
1173        assert!(result.is_ok());
1174    }
1175
1176    // ---------------------------------------------------------------
1177    // Round-trip tests: Rust -> Value -> Rust
1178    // ---------------------------------------------------------------
1179
1180    #[test]
1181    fn round_trip_complex_struct() {
1182        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1183        struct Complex {
1184            name: String,
1185            count: u64,
1186            active: bool,
1187            score: f64,
1188            tags: Vec<String>,
1189            metadata: Option<String>,
1190        }
1191
1192        let original = Complex {
1193            name: "test".into(),
1194            count: 42,
1195            active: true,
1196            score: 3.14,
1197            tags: vec!["a".into(), "b".into()],
1198            metadata: Some("info".into()),
1199        };
1200        let val = to_value(&original).unwrap();
1201        let recovered: Complex = crate::from_value(val).unwrap();
1202        assert_eq!(original, recovered);
1203    }
1204
1205    #[test]
1206    fn round_trip_nested() {
1207        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1208        struct Inner {
1209            x: i32,
1210        }
1211        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1212        struct Outer {
1213            inner: Inner,
1214        }
1215
1216        let original = Outer {
1217            inner: Inner { x: -5 },
1218        };
1219        let val = to_value(&original).unwrap();
1220        let recovered: Outer = crate::from_value(val).unwrap();
1221        assert_eq!(original, recovered);
1222    }
1223
1224    #[test]
1225    fn collect_str_produces_text() {
1226        use serde::Serializer;
1227        let val = Serializer.collect_str(&42).unwrap();
1228        assert_eq!(val, Value::Text("42".to_string()));
1229    }
1230}
platform_value/value_serialization/ser.rs

platform_value/value_serialization/
ser.rs
