platform_value/value_serialization/
de.rs

1use base64::prelude::BASE64_STANDARD;
2use base64::Engine;
3use core::{fmt, slice};
4use std::iter::Peekable;
5
6use serde::de::value::SeqDeserializer;
7use serde::de::{self, Deserializer as _, IntoDeserializer};
8
9use crate::{Error, Value};
10
11impl<'a> From<&'a Value> for de::Unexpected<'a> {
12    fn from(value: &'a Value) -> Self {
13        match value {
14            Value::Bool(x) => Self::Bool(*x),
15            Value::Float(x) => Self::Float(*x),
16            Value::Bytes(x) => Self::Bytes(x),
17            Value::Text(x) => Self::Str(x),
18            Value::Array(..) => Self::Seq,
19            Value::Map(..) => Self::Map,
20            Value::Null => Self::Other("null"),
21            Value::U128(_x) => todo!(), // TODO: it seems serde is not happy about u128
22            Value::I128(_x) => todo!(), // TODO: ... and for i128 either
23            Value::U64(x) => Self::Unsigned(*x),
24            Value::I64(x) => Self::Signed(*x),
25            Value::U32(x) => Self::Unsigned(*x as u64),
26            Value::I32(x) => Self::Signed(*x as i64),
27            Value::U16(x) => Self::Unsigned(*x as u64),
28            Value::I16(x) => Self::Signed(*x as i64),
29            Value::U8(x) => Self::Unsigned(*x as u64),
30            Value::I8(x) => Self::Signed(*x as i64),
31            Value::Bytes20(x) => Self::Bytes(x),
32            Value::Bytes32(x) => Self::Bytes(x),
33            Value::Bytes36(x) => Self::Bytes(x),
34            Value::EnumU8(_x) => todo!(),
35            Value::EnumString(_x) => todo!(),
36            Value::Identifier(x) => Self::Bytes(x),
37        }
38    }
39}
40
41macro_rules! mkvisit {
42    ($($f:ident($v:ty)),+ $(,)?) => {
43        $(
44                        fn $f<E: de::Error>(self, v: $v) -> Result<Self::Value, E> {
45                Ok(v.into())
46            }
47        )+
48    };
49}
50
51struct Visitor;
52
53impl<'de> de::Visitor<'de> for Visitor {
54    type Value = Value;
55
56    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
57        write!(formatter, "a valid platform value item")
58    }
59
60    mkvisit! {
61        visit_bool(bool),
62        visit_f32(f32),
63        visit_f64(f64),
64
65        visit_i8(i8),
66        visit_i16(i16),
67        visit_i32(i32),
68        visit_i64(i64),
69        visit_i128(i128),
70
71        visit_u8(u8),
72        visit_u16(u16),
73        visit_u32(u32),
74        visit_u64(u64),
75        visit_u128(u128),
76
77        visit_char(char),
78        visit_str(&str),
79        visit_borrowed_str(&'de str),
80        visit_string(String),
81
82        visit_bytes(&[u8]),
83        visit_borrowed_bytes(&'de [u8]),
84        visit_byte_buf(Vec<u8>),
85    }
86
87    fn visit_none<E: de::Error>(self) -> Result<Self::Value, E> {
88        Ok(Value::Null)
89    }
90
91    fn visit_some<D: de::Deserializer<'de>>(
92        self,
93        deserializer: D,
94    ) -> Result<Self::Value, D::Error> {
95        deserializer.deserialize_any(self)
96    }
97
98    fn visit_unit<E: de::Error>(self) -> Result<Self::Value, E> {
99        Ok(Value::Null)
100    }
101
102    fn visit_newtype_struct<D: de::Deserializer<'de>>(
103        self,
104        deserializer: D,
105    ) -> Result<Self::Value, D::Error> {
106        deserializer.deserialize_any(self)
107    }
108
109    fn visit_seq<A: de::SeqAccess<'de>>(self, mut acc: A) -> Result<Self::Value, A::Error> {
110        let mut seq = Vec::new();
111
112        while let Some(elem) = acc.next_element()? {
113            seq.push(elem);
114        }
115
116        Ok(Value::Array(seq))
117    }
118
119    fn visit_map<A: de::MapAccess<'de>>(self, mut acc: A) -> Result<Self::Value, A::Error> {
120        let mut map = Vec::<(Value, Value)>::new();
121
122        while let Some(kv) = acc.next_entry()? {
123            map.push(kv);
124        }
125
126        Ok(Value::Map(map))
127    }
128
129    fn visit_enum<A: de::EnumAccess<'de>>(self, acc: A) -> Result<Self::Value, A::Error> {
130        use serde::de::VariantAccess;
131        struct Inner;
132        impl<'de> de::Visitor<'de> for Inner {
133            type Value = Value;
134            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
135                write!(formatter, "a valid CBOR item")
136            }
137            fn visit_seq<A: de::SeqAccess<'de>>(self, mut acc: A) -> Result<Self::Value, A::Error> {
138                match acc.size_hint() {
139                    Some(1) => {
140                        let tag: u8 = acc
141                            .next_element()?
142                            .ok_or_else(|| de::Error::custom("expected tag"))?;
143                        Ok(Value::EnumU8(vec![tag]))
144                    }
145                    _ => {
146                        let val: Vec<String> = de::Deserialize::deserialize(
147                            de::value::SeqAccessDeserializer::new(acc),
148                        )?;
149                        Ok(Value::EnumString(val))
150                    }
151                }
152            }
153        }
154        let (name, data): (String, _) = acc.variant()?;
155        if name == "@@TAGGED@@" {
156            data.tuple_variant(2, Inner)
157        } else {
158            Err(de::Error::custom(format!(
159                "Unexpected variant name: {}",
160                name
161            )))
162        }
163    }
164}
165
166impl<'de> de::Deserialize<'de> for Value {
167    fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
168        deserializer.deserialize_any(Visitor)
169    }
170}
171
172pub(crate) struct Deserializer<T>(pub(crate) T);
173
174impl<'de> de::Deserializer<'de> for Deserializer<Value> {
175    type Error = Error;
176
177    fn deserialize_any<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
178        let human_readable = self.is_human_readable();
179        match self.0 {
180            Value::Bytes(x) => {
181                if human_readable {
182                    visitor.visit_str(BASE64_STANDARD.encode(x).as_str())
183                } else {
184                    visitor.visit_bytes(&x)
185                }
186            }
187            Value::Text(x) => visitor.visit_str(&x),
188            Value::Array(x) => visitor.visit_seq(ArrayDeserializer(x.iter())),
189            Value::Map(x) => visitor.visit_map(ValueMapDeserializer(x.iter().peekable())),
190            Value::Bool(x) => visitor.visit_bool(x),
191            Value::Null => visitor.visit_none(),
192            Value::Float(x) => visitor.visit_f64(x),
193            Value::U128(x) => visitor.visit_u128(x),
194            Value::I128(x) => visitor.visit_i128(x),
195            Value::U64(x) => visitor.visit_u64(x),
196            Value::I64(x) => visitor.visit_i64(x),
197            Value::U32(x) => visitor.visit_u32(x),
198            Value::I32(x) => visitor.visit_i32(x),
199            Value::U16(x) => visitor.visit_u16(x),
200            Value::I16(x) => visitor.visit_i16(x),
201            Value::U8(x) => visitor.visit_u8(x),
202            Value::I8(x) => visitor.visit_i8(x),
203            Value::Bytes20(x) => {
204                if human_readable {
205                    visitor.visit_str(BASE64_STANDARD.encode(x).as_str())
206                } else {
207                    visitor.visit_bytes(&x)
208                }
209            }
210            Value::Bytes32(x) => {
211                if human_readable {
212                    visitor.visit_str(BASE64_STANDARD.encode(x).as_str())
213                } else {
214                    visitor.visit_bytes(&x)
215                }
216            }
217            Value::Bytes36(x) => {
218                if human_readable {
219                    visitor.visit_str(BASE64_STANDARD.encode(x).as_str())
220                } else {
221                    visitor.visit_bytes(&x)
222                }
223            }
224            Value::EnumU8(x) => visitor.visit_seq(SeqDeserializer::new(x.into_iter())),
225            Value::EnumString(x) => visitor.visit_seq(SeqDeserializer::new(x.into_iter())),
226            Value::Identifier(x) => {
227                if human_readable {
228                    visitor.visit_str(bs58::encode(x).into_string().as_str())
229                } else {
230                    visitor.visit_bytes(&x)
231                }
232            }
233        }
234    }
235
236    fn deserialize_bool<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
237        let value = self.0;
238
239        match value {
240            Value::Bool(x) => visitor.visit_bool(x),
241            _ => Err(de::Error::invalid_type((&value).into(), &"bool")),
242        }
243    }
244
245    fn deserialize_f32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
246        self.deserialize_f64(visitor)
247    }
248
249    fn deserialize_f64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
250        let value = self.0;
251
252        match value {
253            Value::Float(x) => visitor.visit_f64(x),
254            _ => Err(de::Error::invalid_type((&value).into(), &"f64")),
255        }
256    }
257
258    fn deserialize_i8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
259        let value = self.0;
260        visitor.visit_i8(value.to_integer()?)
261    }
262
263    fn deserialize_i16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
264        let value = self.0;
265        visitor.visit_i16(value.to_integer()?)
266    }
267
268    fn deserialize_i32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
269        let value = self.0;
270        visitor.visit_i32(value.to_integer()?)
271    }
272
273    fn deserialize_i64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
274        let value = self.0;
275        visitor.visit_i64(value.to_integer()?)
276    }
277
278    fn deserialize_i128<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
279        let value = self.0;
280        visitor.visit_i128(value.to_integer()?)
281    }
282
283    fn deserialize_u8<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
284        let value = self.0;
285        visitor.visit_u8(value.to_integer()?)
286    }
287
288    fn deserialize_u16<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
289        let value = self.0;
290        visitor.visit_u16(value.to_integer()?)
291    }
292
293    fn deserialize_u32<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
294        let value = self.0;
295        visitor.visit_u32(value.to_integer()?)
296    }
297
298    fn deserialize_u64<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
299        let value = self.0;
300        visitor.visit_u64(value.to_integer()?)
301    }
302
303    fn deserialize_u128<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
304        let value = self.0;
305        visitor.visit_u128(value.to_integer()?)
306    }
307
308    fn deserialize_char<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
309        let value = self.0;
310
311        match value {
312            Value::Text(ref x) => match x.chars().count() {
313                1 => visitor.visit_char(x.chars().next().unwrap()),
314                _ => Err(de::Error::invalid_type((&value).into(), &"char")),
315            },
316
317            _ => Err(de::Error::invalid_type((&value).into(), &"char")),
318        }
319    }
320
321    fn deserialize_str<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
322        let value = self.0;
323
324        match value {
325            Value::Text(x) => visitor.visit_str(&x),
326            _ => Err(de::Error::invalid_type((&value).into(), &"str")),
327        }
328    }
329
330    fn deserialize_string<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
331        self.deserialize_str(visitor)
332    }
333
334    fn deserialize_bytes<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
335        let value = self.0;
336
337        match value {
338            Value::Bytes(x) => visitor.visit_bytes(&x),
339            Value::Bytes20(x) => visitor.visit_bytes(x.as_slice()),
340            Value::Bytes32(x) => visitor.visit_bytes(x.as_slice()),
341            Value::Bytes36(x) => visitor.visit_bytes(x.as_slice()),
342            Value::Identifier(x) => visitor.visit_bytes(x.as_slice()),
343            _ => Err(de::Error::invalid_type((&value).into(), &"bytes")),
344        }
345    }
346
347    fn deserialize_byte_buf<V: de::Visitor<'de>>(
348        self,
349        visitor: V,
350    ) -> Result<V::Value, Self::Error> {
351        self.deserialize_bytes(visitor)
352    }
353
354    fn deserialize_seq<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
355        let value = self.0;
356
357        match value {
358            Value::Array(x) => visitor.visit_seq(ArrayDeserializer(x.iter())),
359            _ => Err(de::Error::invalid_type((&value).into(), &"array")),
360        }
361    }
362
363    fn deserialize_map<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
364        let value = self.0;
365
366        match value {
367            Value::Map(x) => visitor.visit_map(ValueMapDeserializer(x.iter().peekable())),
368            _ => Err(de::Error::invalid_type((&value).into(), &"map")),
369        }
370    }
371
372    fn deserialize_struct<V: de::Visitor<'de>>(
373        self,
374        _name: &'static str,
375        _fields: &'static [&'static str],
376        visitor: V,
377    ) -> Result<V::Value, Self::Error> {
378        self.deserialize_map(visitor)
379    }
380
381    fn deserialize_tuple<V: de::Visitor<'de>>(
382        self,
383        _len: usize,
384        visitor: V,
385    ) -> Result<V::Value, Self::Error> {
386        self.deserialize_seq(visitor)
387    }
388
389    fn deserialize_tuple_struct<V: de::Visitor<'de>>(
390        self,
391        _name: &'static str,
392        _len: usize,
393        visitor: V,
394    ) -> Result<V::Value, Self::Error> {
395        self.deserialize_seq(visitor)
396    }
397
398    fn deserialize_identifier<V: de::Visitor<'de>>(
399        self,
400        visitor: V,
401    ) -> Result<V::Value, Self::Error> {
402        self.deserialize_str(visitor)
403    }
404
405    fn deserialize_ignored_any<V: de::Visitor<'de>>(
406        self,
407        visitor: V,
408    ) -> Result<V::Value, Self::Error> {
409        self.deserialize_any(visitor)
410    }
411
412    fn deserialize_option<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
413        match self.0 {
414            Value::Null => visitor.visit_none(),
415            x => visitor.visit_some(Self(x)),
416        }
417    }
418
419    fn deserialize_unit<V: de::Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
420        match self.0 {
421            Value::Null => visitor.visit_unit(),
422            _ => Err(de::Error::invalid_type((&self.0).into(), &"null")),
423        }
424    }
425
426    fn deserialize_unit_struct<V: de::Visitor<'de>>(
427        self,
428        _name: &'static str,
429        visitor: V,
430    ) -> Result<V::Value, Self::Error> {
431        self.deserialize_unit(visitor)
432    }
433
434    fn deserialize_newtype_struct<V: de::Visitor<'de>>(
435        self,
436        _name: &'static str,
437        visitor: V,
438    ) -> Result<V::Value, Self::Error> {
439        visitor.visit_newtype_struct(self)
440    }
441
442    fn deserialize_enum<V: de::Visitor<'de>>(
443        self,
444        _name: &'static str,
445        _variants: &'static [&'static str],
446        visitor: V,
447    ) -> Result<V::Value, Self::Error> {
448        match self.0 {
449            // Existing CBOR enum types — keep for backward compatibility
450            Value::EnumU8(x) => {
451                let enum_variant = x.first().ok_or_else(|| {
452                    de::Error::invalid_length(0, &"at least one variant expected")
453                })?;
454                let variant_name = format!("Variant{}", enum_variant);
455                visitor.visit_enum(variant_name.into_deserializer())
456            }
457            Value::EnumString(x) => {
458                let variant_name = x
459                    .first()
460                    .ok_or_else(|| de::Error::invalid_length(0, &"at least one variant expected"))?
461                    .clone();
462                visitor.visit_enum(variant_name.into_deserializer())
463            }
464
465            // String → unit variant (e.g., "Abstain", "Lock", "NoWinner")
466            Value::Text(variant) => visitor.visit_enum(ValueEnumDeserializer {
467                variant,
468                value: None,
469            }),
470
471            // Single-key map → externally tagged variant
472            // e.g., {"TowardsIdentity": <data>} or {"ResourceVote": {...}}
473            Value::Map(entries) if entries.len() == 1 => {
474                let (key, value) = entries
475                    .into_iter()
476                    .next()
477                    .expect("guard guarantees len == 1");
478                let variant = match key {
479                    Value::Text(s) => s,
480                    other => {
481                        return Err(de::Error::invalid_type(
482                            (&other).into(),
483                            &"string variant name",
484                        ))
485                    }
486                };
487                visitor.visit_enum(ValueEnumDeserializer {
488                    variant,
489                    value: Some(value),
490                })
491            }
492
493            other => Err(de::Error::invalid_type((&other).into(), &"enum")),
494        }
495    }
496
497    fn is_human_readable(&self) -> bool {
498        false
499    }
500}
501
502struct ArrayDeserializer<'a>(slice::Iter<'a, Value>);
503
504impl<'de> de::SeqAccess<'de> for ArrayDeserializer<'_> {
505    type Error = Error;
506
507    fn next_element_seed<U: de::DeserializeSeed<'de>>(
508        &mut self,
509        seed: U,
510    ) -> Result<Option<U::Value>, Self::Error> {
511        self.0
512            .next()
513            .map(|x| seed.deserialize(Deserializer(x.clone())))
514            .transpose() // TODO
515    }
516}
517
518struct ValueMapDeserializer<'a>(Peekable<slice::Iter<'a, (Value, Value)>>);
519
520impl<'de> de::MapAccess<'de> for ValueMapDeserializer<'_> {
521    type Error = Error;
522
523    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
524    where
525        K: de::DeserializeSeed<'de>,
526    {
527        // Serde expect `key` call to go first, thus it should not move iterator
528        // as `value` call should follow
529        self.0
530            .peek()
531            .map(|x| seed.deserialize(Deserializer(x.0.clone()))) // TODO
532            .transpose()
533    }
534
535    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
536    where
537        V: de::DeserializeSeed<'de>,
538    {
539        let map_value = self
540            .0
541            .next()
542            .expect("`next_key_seed` must be called first")
543            .1
544            .clone(); // TODO
545        seed.deserialize(Deserializer(map_value))
546    }
547}
548
549/// EnumAccess for deserializing externally-tagged enums from Value.
550struct ValueEnumDeserializer {
551    variant: String,
552    value: Option<Value>,
553}
554
555impl<'de> de::EnumAccess<'de> for ValueEnumDeserializer {
556    type Error = Error;
557    type Variant = ValueVariantDeserializer;
558
559    fn variant_seed<V: de::DeserializeSeed<'de>>(
560        self,
561        seed: V,
562    ) -> Result<(V::Value, Self::Variant), Self::Error> {
563        let variant = seed.deserialize(self.variant.into_deserializer())?;
564        Ok((variant, ValueVariantDeserializer { value: self.value }))
565    }
566}
567
568/// VariantAccess that delegates to Deserializer<Value> for variant data.
569struct ValueVariantDeserializer {
570    value: Option<Value>,
571}
572
573impl<'de> de::VariantAccess<'de> for ValueVariantDeserializer {
574    type Error = Error;
575
576    fn unit_variant(self) -> Result<(), Self::Error> {
577        match self.value {
578            None => Ok(()),
579            Some(Value::Null) => Ok(()),
580            Some(other) => Err(de::Error::invalid_type((&other).into(), &"unit variant")),
581        }
582    }
583
584    fn newtype_variant_seed<T: de::DeserializeSeed<'de>>(
585        self,
586        seed: T,
587    ) -> Result<T::Value, Self::Error> {
588        match self.value {
589            Some(value) => seed.deserialize(Deserializer(value)),
590            None => Err(de::Error::invalid_type(
591                de::Unexpected::UnitVariant,
592                &"newtype variant",
593            )),
594        }
595    }
596
597    fn tuple_variant<V: de::Visitor<'de>>(
598        self,
599        _len: usize,
600        visitor: V,
601    ) -> Result<V::Value, Self::Error> {
602        match self.value {
603            Some(value) => Deserializer(value).deserialize_seq(visitor),
604            None => Err(de::Error::invalid_type(
605                de::Unexpected::UnitVariant,
606                &"tuple variant",
607            )),
608        }
609    }
610
611    fn struct_variant<V: de::Visitor<'de>>(
612        self,
613        _fields: &'static [&'static str],
614        visitor: V,
615    ) -> Result<V::Value, Self::Error> {
616        match self.value {
617            Some(value) => Deserializer(value).deserialize_map(visitor),
618            None => Err(de::Error::invalid_type(
619                de::Unexpected::UnitVariant,
620                &"struct variant",
621            )),
622        }
623    }
624}
625
626impl<'de> de::VariantAccess<'de> for Deserializer<Value> {
627    type Error = Error;
628
629    fn unit_variant(self) -> Result<(), Self::Error> {
630        match self.0 {
631            Value::Null => Ok(()),
632            v => Err(de::Error::invalid_type((&v).into(), &"unit")),
633        }
634    }
635
636    fn newtype_variant_seed<U: de::DeserializeSeed<'de>>(
637        self,
638        seed: U,
639    ) -> Result<U::Value, Self::Error> {
640        seed.deserialize(self)
641    }
642
643    fn tuple_variant<V: de::Visitor<'de>>(
644        self,
645        _len: usize,
646        visitor: V,
647    ) -> Result<V::Value, Self::Error> {
648        self.deserialize_seq(visitor)
649    }
650
651    fn struct_variant<V: de::Visitor<'de>>(
652        self,
653        _fields: &'static [&'static str],
654        visitor: V,
655    ) -> Result<V::Value, Self::Error> {
656        self.deserialize_map(visitor)
657    }
658}
659
660#[cfg(test)]
661mod tests {
662    use super::*;
663    use crate::{from_value, to_value};
664    use serde::{Deserialize, Serialize};
665
666    // ---------------------------------------------------------------
667    // Deserialize Value via serde (Value -> Rust types)
668    // ---------------------------------------------------------------
669
670    #[test]
671    fn deserialize_bool() {
672        let val = Value::Bool(true);
673        let result: bool = from_value(val).unwrap();
674        assert!(result);
675    }
676
677    #[test]
678    fn deserialize_u8() {
679        let val = Value::U8(42);
680        let result: u8 = from_value(val).unwrap();
681        assert_eq!(result, 42);
682    }
683
684    #[test]
685    fn deserialize_u16() {
686        let val = Value::U16(1000);
687        let result: u16 = from_value(val).unwrap();
688        assert_eq!(result, 1000);
689    }
690
691    #[test]
692    fn deserialize_u32() {
693        let val = Value::U32(100_000);
694        let result: u32 = from_value(val).unwrap();
695        assert_eq!(result, 100_000);
696    }
697
698    #[test]
699    fn deserialize_u64() {
700        let val = Value::U64(10_000_000_000);
701        let result: u64 = from_value(val).unwrap();
702        assert_eq!(result, 10_000_000_000);
703    }
704
705    #[test]
706    fn deserialize_u128() {
707        let val = Value::U128(u128::MAX);
708        let result: u128 = from_value(val).unwrap();
709        assert_eq!(result, u128::MAX);
710    }
711
712    #[test]
713    fn deserialize_i8() {
714        let val = Value::I8(-42);
715        let result: i8 = from_value(val).unwrap();
716        assert_eq!(result, -42);
717    }
718
719    #[test]
720    fn deserialize_i16() {
721        let val = Value::I16(-1000);
722        let result: i16 = from_value(val).unwrap();
723        assert_eq!(result, -1000);
724    }
725
726    #[test]
727    fn deserialize_i32() {
728        let val = Value::I32(-100_000);
729        let result: i32 = from_value(val).unwrap();
730        assert_eq!(result, -100_000);
731    }
732
733    #[test]
734    fn deserialize_i64() {
735        let val = Value::I64(-10_000_000_000);
736        let result: i64 = from_value(val).unwrap();
737        assert_eq!(result, -10_000_000_000);
738    }
739
740    #[test]
741    fn deserialize_i128() {
742        let val = Value::I128(i128::MIN);
743        let result: i128 = from_value(val).unwrap();
744        assert_eq!(result, i128::MIN);
745    }
746
747    #[test]
748    fn deserialize_f64() {
749        let val = Value::Float(3.14);
750        let result: f64 = from_value(val).unwrap();
751        assert!((result - 3.14).abs() < f64::EPSILON);
752    }
753
754    #[test]
755    fn deserialize_string() {
756        let val = Value::Text("hello".into());
757        let result: String = from_value(val).unwrap();
758        assert_eq!(result, "hello");
759    }
760
761    #[test]
762    fn deserialize_null_as_option_none() {
763        let val = Value::Null;
764        let result: Option<String> = from_value(val).unwrap();
765        assert_eq!(result, None);
766    }
767
768    #[test]
769    fn deserialize_some_as_option_some() {
770        let val = Value::Text("hi".into());
771        let result: Option<String> = from_value(val).unwrap();
772        assert_eq!(result, Some("hi".to_string()));
773    }
774
775    #[test]
776    fn deserialize_array_of_integers() {
777        let val = Value::Array(vec![Value::U32(1), Value::U32(2), Value::U32(3)]);
778        let result: Vec<u32> = from_value(val).unwrap();
779        assert_eq!(result, vec![1, 2, 3]);
780    }
781
782    #[test]
783    fn deserialize_unit_from_null() {
784        let val = Value::Null;
785        let result: () = from_value(val).unwrap();
786        assert_eq!(result, ());
787    }
788
789    #[test]
790    fn deserialize_unit_from_non_null_errors() {
791        let val = Value::U8(1);
792        let result: Result<(), Error> = from_value(val);
793        assert!(result.is_err());
794    }
795
796    #[test]
797    fn deserialize_char_from_single_char_text() {
798        let val = Value::Text("A".into());
799        let result: char = from_value(val).unwrap();
800        assert_eq!(result, 'A');
801    }
802
803    #[test]
804    fn deserialize_char_from_multi_char_text_errors() {
805        let val = Value::Text("AB".into());
806        let result: Result<char, Error> = from_value(val);
807        assert!(result.is_err());
808    }
809
810    #[test]
811    fn deserialize_struct_from_map() {
812        #[derive(Debug, PartialEq, Deserialize)]
813        struct Point {
814            x: i32,
815            y: i32,
816        }
817
818        let val = Value::Map(vec![
819            (Value::Text("x".into()), Value::I32(10)),
820            (Value::Text("y".into()), Value::I32(20)),
821        ]);
822        let result: Point = from_value(val).unwrap();
823        assert_eq!(result, Point { x: 10, y: 20 });
824    }
825
826    #[test]
827    fn deserialize_tuple_from_array() {
828        let val = Value::Array(vec![Value::U32(1), Value::U32(2)]);
829        let result: (u32, u32) = from_value(val).unwrap();
830        assert_eq!(result, (1, 2));
831    }
832
833    #[test]
834    fn deserialize_bool_type_mismatch_errors() {
835        let val = Value::U32(1);
836        let result: Result<bool, Error> = from_value(val);
837        assert!(result.is_err());
838    }
839
840    #[test]
841    fn deserialize_f64_type_mismatch_errors() {
842        let val = Value::Text("not_a_float".into());
843        let result: Result<f64, Error> = from_value(val);
844        assert!(result.is_err());
845    }
846
847    #[test]
848    fn deserialize_string_type_mismatch_errors() {
849        let val = Value::U32(42);
850        let result: Result<String, Error> = from_value(val);
851        assert!(result.is_err());
852    }
853
854    #[test]
855    fn deserialize_seq_type_mismatch_errors() {
856        let val = Value::U32(42);
857        let result: Result<Vec<u32>, Error> = from_value(val);
858        assert!(result.is_err());
859    }
860
861    #[test]
862    fn deserialize_map_type_mismatch_errors() {
863        let val = Value::U32(42);
864        let result: Result<std::collections::HashMap<String, u32>, Error> = from_value(val);
865        assert!(result.is_err());
866    }
867
868    // ---------------------------------------------------------------
869    // Round-trip serialization: Rust -> Value -> Rust
870    // ---------------------------------------------------------------
871
872    #[test]
873    fn round_trip_struct() {
874        #[derive(Debug, PartialEq, Serialize, Deserialize)]
875        struct Data {
876            name: String,
877            count: u64,
878            active: bool,
879        }
880
881        let original = Data {
882            name: "test".into(),
883            count: 42,
884            active: true,
885        };
886        let val = to_value(&original).unwrap();
887        let recovered: Data = from_value(val).unwrap();
888        assert_eq!(original, recovered);
889    }
890
891    #[test]
892    fn round_trip_vec() {
893        let original = vec![1u32, 2, 3, 4, 5];
894        let val = to_value(&original).unwrap();
895        let recovered: Vec<u32> = from_value(val).unwrap();
896        assert_eq!(original, recovered);
897    }
898
899    #[test]
900    fn round_trip_option_some() {
901        let original: Option<String> = Some("hello".into());
902        let val = to_value(&original).unwrap();
903        let recovered: Option<String> = from_value(val).unwrap();
904        assert_eq!(original, recovered);
905    }
906
907    #[test]
908    fn round_trip_option_none() {
909        let original: Option<String> = None;
910        let val = to_value(&original).unwrap();
911        let recovered: Option<String> = from_value(val).unwrap();
912        assert_eq!(original, recovered);
913    }
914
915    #[test]
916    fn round_trip_nested_struct() {
917        #[derive(Debug, PartialEq, Serialize, Deserialize)]
918        struct Inner {
919            value: i32,
920        }
921        #[derive(Debug, PartialEq, Serialize, Deserialize)]
922        struct Outer {
923            inner: Inner,
924            label: String,
925        }
926
927        let original = Outer {
928            inner: Inner { value: -5 },
929            label: "test".into(),
930        };
931        let val = to_value(&original).unwrap();
932        let recovered: Outer = from_value(val).unwrap();
933        assert_eq!(original, recovered);
934    }
935
936    #[test]
937    fn round_trip_hashmap() {
938        let mut original = std::collections::HashMap::new();
939        original.insert("a".to_string(), 1u32);
940        original.insert("b".to_string(), 2u32);
941        let val = to_value(&original).unwrap();
942        let recovered: std::collections::HashMap<String, u32> = from_value(val).unwrap();
943        assert_eq!(original, recovered);
944    }
945
946    // ---------------------------------------------------------------
947    // Value -> Value deserialization (Deserialize for Value)
948    // ---------------------------------------------------------------
949
950    #[test]
951    fn value_deserialize_preserves_bool() {
952        let val = Value::Bool(false);
953        let cloned = val.clone();
954        let result: Value = from_value(cloned).unwrap();
955        assert_eq!(result, val);
956    }
957
958    #[test]
959    fn value_deserialize_preserves_text() {
960        let val = Value::Text("test".into());
961        let cloned = val.clone();
962        let result: Value = from_value(cloned).unwrap();
963        assert_eq!(result, val);
964    }
965
966    #[test]
967    fn value_deserialize_preserves_integer_types() {
968        for val in [
969            Value::U8(1),
970            Value::I8(-1),
971            Value::U16(100),
972            Value::I16(-100),
973            Value::U32(1000),
974            Value::I32(-1000),
975            Value::U64(10000),
976            Value::I64(-10000),
977            Value::U128(100000),
978            Value::I128(-100000),
979        ] {
980            let cloned = val.clone();
981            let result: Value = from_value(cloned).unwrap();
982            assert_eq!(result, val);
983        }
984    }
985
986    #[test]
987    fn value_deserialize_preserves_float() {
988        let val = Value::Float(2.718);
989        let cloned = val.clone();
990        let result: Value = from_value(cloned).unwrap();
991        assert_eq!(result, val);
992    }
993
994    #[test]
995    fn value_deserialize_preserves_null() {
996        let val = Value::Null;
997        let cloned = val.clone();
998        let result: Value = from_value(cloned).unwrap();
999        assert_eq!(result, val);
1000    }
1001
1002    #[test]
1003    fn value_deserialize_preserves_array() {
1004        let val = Value::Array(vec![Value::U8(1), Value::Text("hello".into())]);
1005        let cloned = val.clone();
1006        let result: Value = from_value(cloned).unwrap();
1007        assert_eq!(result, val);
1008    }
1009
1010    #[test]
1011    fn value_deserialize_preserves_map() {
1012        let val = Value::Map(vec![(Value::Text("key".into()), Value::U64(42))]);
1013        let cloned = val.clone();
1014        let result: Value = from_value(cloned).unwrap();
1015        assert_eq!(result, val);
1016    }
1017
1018    // ---------------------------------------------------------------
1019    // Bytes deserialization (non-human-readable -> visit_bytes)
1020    // ---------------------------------------------------------------
1021
1022    #[test]
1023    fn value_deserialize_bytes_as_value() {
1024        let val = Value::Bytes(vec![1, 2, 3]);
1025        let cloned = val.clone();
1026        let result: Value = from_value(cloned).unwrap();
1027        assert_eq!(result, val);
1028    }
1029
1030    #[test]
1031    fn value_deserialize_bytes32_as_value() {
1032        let val = Value::Bytes32([7u8; 32]);
1033        let cloned = val.clone();
1034        let result: Value = from_value(cloned).unwrap();
1035        // Non-human-readable: Bytes32 goes through visit_bytes which produces Value::Bytes
1036        assert_eq!(result, Value::Bytes(vec![7u8; 32]));
1037    }
1038
1039    #[test]
1040    fn value_deserialize_bytes20_as_value() {
1041        let val = Value::Bytes20([8u8; 20]);
1042        let cloned = val.clone();
1043        let result: Value = from_value(cloned).unwrap();
1044        // Non-human-readable: Bytes20 goes through visit_bytes which produces Value::Bytes
1045        assert_eq!(result, Value::Bytes(vec![8u8; 20]));
1046    }
1047
1048    #[test]
1049    fn value_deserialize_bytes36_as_value() {
1050        let val = Value::Bytes36([9u8; 36]);
1051        let cloned = val.clone();
1052        let result: Value = from_value(cloned).unwrap();
1053        // Non-human-readable: Bytes36 goes through visit_bytes which produces Value::Bytes
1054        assert_eq!(result, Value::Bytes(vec![9u8; 36]));
1055    }
1056
1057    #[test]
1058    fn value_deserialize_identifier_as_value() {
1059        let val = Value::Identifier([10u8; 32]);
1060        let cloned = val.clone();
1061        let result: Value = from_value(cloned).unwrap();
1062        // Non-human-readable: Identifier goes through visit_bytes which produces Value::Bytes
1063        assert_eq!(result, Value::Bytes(vec![10u8; 32]));
1064    }
1065
1066    // ---------------------------------------------------------------
1067    // Newtype struct deserialization
1068    // ---------------------------------------------------------------
1069
1070    #[test]
1071    fn deserialize_newtype_struct() {
1072        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1073        struct Wrapper(u32);
1074
1075        let val = Value::U32(42);
1076        let result: Wrapper = from_value(val).unwrap();
1077        assert_eq!(result, Wrapper(42));
1078    }
1079
1080    // ---------------------------------------------------------------
1081    // Unit struct deserialization
1082    // ---------------------------------------------------------------
1083
1084    #[test]
1085    fn deserialize_unit_struct_from_null() {
1086        #[derive(Debug, PartialEq, Deserialize)]
1087        struct Empty;
1088
1089        let val = Value::Null;
1090        let result: Empty = from_value(val).unwrap();
1091        assert_eq!(result, Empty);
1092    }
1093
1094    // ---------------------------------------------------------------
1095    // Bytes deserialization into byte buffers
1096    // ---------------------------------------------------------------
1097
1098    #[test]
1099    fn deserialize_bytes_from_bytes_value() {
1100        let val = Value::Bytes(vec![1, 2, 3, 4]);
1101        let result: Value = from_value(val.clone()).unwrap();
1102        assert_eq!(result, val);
1103    }
1104
1105    #[test]
1106    fn deserialize_bytes_type_mismatch_errors() {
1107        use serde::de::Deserializer as _;
1108        struct BytesVisitor;
1109        impl<'de> de::Visitor<'de> for BytesVisitor {
1110            type Value = Vec<u8>;
1111            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1112                write!(f, "bytes")
1113            }
1114            fn visit_bytes<E: de::Error>(self, v: &[u8]) -> Result<Self::Value, E> {
1115                Ok(v.to_vec())
1116            }
1117        }
1118        let deser = Deserializer(Value::Bool(true));
1119        let result = deser.deserialize_bytes(BytesVisitor);
1120        assert!(result.is_err());
1121    }
1122
1123    // ---------------------------------------------------------------
1124    // Enum deserialization
1125    // ---------------------------------------------------------------
1126
1127    #[test]
1128    fn deserialize_unit_enum_from_text() {
1129        #[derive(Debug, PartialEq, Deserialize)]
1130        enum Color {
1131            Red,
1132            Green,
1133            Blue,
1134        }
1135        let val = Value::Text("Red".into());
1136        let result: Color = from_value(val).unwrap();
1137        assert_eq!(result, Color::Red);
1138    }
1139
1140    #[test]
1141    fn deserialize_newtype_enum_from_map() {
1142        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1143        enum Wrapper {
1144            Count(u32),
1145        }
1146        let val = Value::Map(vec![(Value::Text("Count".into()), Value::U32(42))]);
1147        let result: Wrapper = from_value(val).unwrap();
1148        assert_eq!(result, Wrapper::Count(42));
1149    }
1150
1151    #[test]
1152    fn round_trip_unit_enum() {
1153        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1154        enum Direction {
1155            Up,
1156            Down,
1157        }
1158        let original = Direction::Up;
1159        let val = to_value(&original).unwrap();
1160        let recovered: Direction = from_value(val).unwrap();
1161        assert_eq!(original, recovered);
1162    }
1163
1164    #[test]
1165    fn round_trip_newtype_enum() {
1166        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1167        enum Payload {
1168            Message(String),
1169        }
1170        let original = Payload::Message("hello".into());
1171        let val = to_value(&original).unwrap();
1172        let recovered: Payload = from_value(val).unwrap();
1173        assert_eq!(original, recovered);
1174    }
1175
1176    #[test]
1177    fn round_trip_struct_enum() {
1178        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1179        enum Shape {
1180            Circle { radius: u32 },
1181        }
1182        let original = Shape::Circle { radius: 5 };
1183        let val = to_value(&original).unwrap();
1184        let recovered: Shape = from_value(val).unwrap();
1185        assert_eq!(original, recovered);
1186    }
1187
1188    #[test]
1189    fn round_trip_tuple_enum() {
1190        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1191        enum Pair {
1192            Coords(i32, i32),
1193        }
1194        let original = Pair::Coords(10, 20);
1195        let val = to_value(&original).unwrap();
1196        let recovered: Pair = from_value(val).unwrap();
1197        assert_eq!(original, recovered);
1198    }
1199}
platform_value/value_serialization/de.rs

platform_value/value_serialization/
de.rs
