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)]
661#[allow(clippy::approx_constant)]
662mod tests {
663    use super::*;
664    use crate::{from_value, to_value};
665    use serde::{Deserialize, Serialize};
666
667    // ---------------------------------------------------------------
668    // Deserialize Value via serde (Value -> Rust types)
669    // ---------------------------------------------------------------
670
671    #[test]
672    fn deserialize_bool() {
673        let val = Value::Bool(true);
674        let result: bool = from_value(val).unwrap();
675        assert!(result);
676    }
677
678    #[test]
679    fn deserialize_u8() {
680        let val = Value::U8(42);
681        let result: u8 = from_value(val).unwrap();
682        assert_eq!(result, 42);
683    }
684
685    #[test]
686    fn deserialize_u16() {
687        let val = Value::U16(1000);
688        let result: u16 = from_value(val).unwrap();
689        assert_eq!(result, 1000);
690    }
691
692    #[test]
693    fn deserialize_u32() {
694        let val = Value::U32(100_000);
695        let result: u32 = from_value(val).unwrap();
696        assert_eq!(result, 100_000);
697    }
698
699    #[test]
700    fn deserialize_u64() {
701        let val = Value::U64(10_000_000_000);
702        let result: u64 = from_value(val).unwrap();
703        assert_eq!(result, 10_000_000_000);
704    }
705
706    #[test]
707    fn deserialize_u128() {
708        let val = Value::U128(u128::MAX);
709        let result: u128 = from_value(val).unwrap();
710        assert_eq!(result, u128::MAX);
711    }
712
713    #[test]
714    fn deserialize_i8() {
715        let val = Value::I8(-42);
716        let result: i8 = from_value(val).unwrap();
717        assert_eq!(result, -42);
718    }
719
720    #[test]
721    fn deserialize_i16() {
722        let val = Value::I16(-1000);
723        let result: i16 = from_value(val).unwrap();
724        assert_eq!(result, -1000);
725    }
726
727    #[test]
728    fn deserialize_i32() {
729        let val = Value::I32(-100_000);
730        let result: i32 = from_value(val).unwrap();
731        assert_eq!(result, -100_000);
732    }
733
734    #[test]
735    fn deserialize_i64() {
736        let val = Value::I64(-10_000_000_000);
737        let result: i64 = from_value(val).unwrap();
738        assert_eq!(result, -10_000_000_000);
739    }
740
741    #[test]
742    fn deserialize_i128() {
743        let val = Value::I128(i128::MIN);
744        let result: i128 = from_value(val).unwrap();
745        assert_eq!(result, i128::MIN);
746    }
747
748    #[test]
749    fn deserialize_f64() {
750        let val = Value::Float(3.14);
751        let result: f64 = from_value(val).unwrap();
752        assert!((result - 3.14).abs() < f64::EPSILON);
753    }
754
755    #[test]
756    fn deserialize_string() {
757        let val = Value::Text("hello".into());
758        let result: String = from_value(val).unwrap();
759        assert_eq!(result, "hello");
760    }
761
762    #[test]
763    fn deserialize_null_as_option_none() {
764        let val = Value::Null;
765        let result: Option<String> = from_value(val).unwrap();
766        assert_eq!(result, None);
767    }
768
769    #[test]
770    fn deserialize_some_as_option_some() {
771        let val = Value::Text("hi".into());
772        let result: Option<String> = from_value(val).unwrap();
773        assert_eq!(result, Some("hi".to_string()));
774    }
775
776    #[test]
777    fn deserialize_array_of_integers() {
778        let val = Value::Array(vec![Value::U32(1), Value::U32(2), Value::U32(3)]);
779        let result: Vec<u32> = from_value(val).unwrap();
780        assert_eq!(result, vec![1, 2, 3]);
781    }
782
783    #[test]
784    fn deserialize_unit_from_null() {
785        let val = Value::Null;
786        let result: () = from_value(val).unwrap();
787        assert_eq!(result, ());
788    }
789
790    #[test]
791    fn deserialize_unit_from_non_null_errors() {
792        let val = Value::U8(1);
793        let result: Result<(), Error> = from_value(val);
794        assert!(result.is_err());
795    }
796
797    #[test]
798    fn deserialize_char_from_single_char_text() {
799        let val = Value::Text("A".into());
800        let result: char = from_value(val).unwrap();
801        assert_eq!(result, 'A');
802    }
803
804    #[test]
805    fn deserialize_char_from_multi_char_text_errors() {
806        let val = Value::Text("AB".into());
807        let result: Result<char, Error> = from_value(val);
808        assert!(result.is_err());
809    }
810
811    #[test]
812    fn deserialize_struct_from_map() {
813        #[derive(Debug, PartialEq, Deserialize)]
814        struct Point {
815            x: i32,
816            y: i32,
817        }
818
819        let val = Value::Map(vec![
820            (Value::Text("x".into()), Value::I32(10)),
821            (Value::Text("y".into()), Value::I32(20)),
822        ]);
823        let result: Point = from_value(val).unwrap();
824        assert_eq!(result, Point { x: 10, y: 20 });
825    }
826
827    #[test]
828    fn deserialize_tuple_from_array() {
829        let val = Value::Array(vec![Value::U32(1), Value::U32(2)]);
830        let result: (u32, u32) = from_value(val).unwrap();
831        assert_eq!(result, (1, 2));
832    }
833
834    #[test]
835    fn deserialize_bool_type_mismatch_errors() {
836        let val = Value::U32(1);
837        let result: Result<bool, Error> = from_value(val);
838        assert!(result.is_err());
839    }
840
841    #[test]
842    fn deserialize_f64_type_mismatch_errors() {
843        let val = Value::Text("not_a_float".into());
844        let result: Result<f64, Error> = from_value(val);
845        assert!(result.is_err());
846    }
847
848    #[test]
849    fn deserialize_string_type_mismatch_errors() {
850        let val = Value::U32(42);
851        let result: Result<String, Error> = from_value(val);
852        assert!(result.is_err());
853    }
854
855    #[test]
856    fn deserialize_seq_type_mismatch_errors() {
857        let val = Value::U32(42);
858        let result: Result<Vec<u32>, Error> = from_value(val);
859        assert!(result.is_err());
860    }
861
862    #[test]
863    fn deserialize_map_type_mismatch_errors() {
864        let val = Value::U32(42);
865        let result: Result<std::collections::HashMap<String, u32>, Error> = from_value(val);
866        assert!(result.is_err());
867    }
868
869    // ---------------------------------------------------------------
870    // Round-trip serialization: Rust -> Value -> Rust
871    // ---------------------------------------------------------------
872
873    #[test]
874    fn round_trip_struct() {
875        #[derive(Debug, PartialEq, Serialize, Deserialize)]
876        struct Data {
877            name: String,
878            count: u64,
879            active: bool,
880        }
881
882        let original = Data {
883            name: "test".into(),
884            count: 42,
885            active: true,
886        };
887        let val = to_value(&original).unwrap();
888        let recovered: Data = from_value(val).unwrap();
889        assert_eq!(original, recovered);
890    }
891
892    #[test]
893    fn round_trip_vec() {
894        let original = vec![1u32, 2, 3, 4, 5];
895        let val = to_value(&original).unwrap();
896        let recovered: Vec<u32> = from_value(val).unwrap();
897        assert_eq!(original, recovered);
898    }
899
900    #[test]
901    fn round_trip_option_some() {
902        let original: Option<String> = Some("hello".into());
903        let val = to_value(&original).unwrap();
904        let recovered: Option<String> = from_value(val).unwrap();
905        assert_eq!(original, recovered);
906    }
907
908    #[test]
909    fn round_trip_option_none() {
910        let original: Option<String> = None;
911        let val = to_value(&original).unwrap();
912        let recovered: Option<String> = from_value(val).unwrap();
913        assert_eq!(original, recovered);
914    }
915
916    #[test]
917    fn round_trip_nested_struct() {
918        #[derive(Debug, PartialEq, Serialize, Deserialize)]
919        struct Inner {
920            value: i32,
921        }
922        #[derive(Debug, PartialEq, Serialize, Deserialize)]
923        struct Outer {
924            inner: Inner,
925            label: String,
926        }
927
928        let original = Outer {
929            inner: Inner { value: -5 },
930            label: "test".into(),
931        };
932        let val = to_value(&original).unwrap();
933        let recovered: Outer = from_value(val).unwrap();
934        assert_eq!(original, recovered);
935    }
936
937    #[test]
938    fn round_trip_hashmap() {
939        let mut original = std::collections::HashMap::new();
940        original.insert("a".to_string(), 1u32);
941        original.insert("b".to_string(), 2u32);
942        let val = to_value(&original).unwrap();
943        let recovered: std::collections::HashMap<String, u32> = from_value(val).unwrap();
944        assert_eq!(original, recovered);
945    }
946
947    // ---------------------------------------------------------------
948    // Value -> Value deserialization (Deserialize for Value)
949    // ---------------------------------------------------------------
950
951    #[test]
952    fn value_deserialize_preserves_bool() {
953        let val = Value::Bool(false);
954        let cloned = val.clone();
955        let result: Value = from_value(cloned).unwrap();
956        assert_eq!(result, val);
957    }
958
959    #[test]
960    fn value_deserialize_preserves_text() {
961        let val = Value::Text("test".into());
962        let cloned = val.clone();
963        let result: Value = from_value(cloned).unwrap();
964        assert_eq!(result, val);
965    }
966
967    #[test]
968    fn value_deserialize_preserves_integer_types() {
969        for val in [
970            Value::U8(1),
971            Value::I8(-1),
972            Value::U16(100),
973            Value::I16(-100),
974            Value::U32(1000),
975            Value::I32(-1000),
976            Value::U64(10000),
977            Value::I64(-10000),
978            Value::U128(100000),
979            Value::I128(-100000),
980        ] {
981            let cloned = val.clone();
982            let result: Value = from_value(cloned).unwrap();
983            assert_eq!(result, val);
984        }
985    }
986
987    #[test]
988    fn value_deserialize_preserves_float() {
989        let val = Value::Float(2.718);
990        let cloned = val.clone();
991        let result: Value = from_value(cloned).unwrap();
992        assert_eq!(result, val);
993    }
994
995    #[test]
996    fn value_deserialize_preserves_null() {
997        let val = Value::Null;
998        let cloned = val.clone();
999        let result: Value = from_value(cloned).unwrap();
1000        assert_eq!(result, val);
1001    }
1002
1003    #[test]
1004    fn value_deserialize_preserves_array() {
1005        let val = Value::Array(vec![Value::U8(1), Value::Text("hello".into())]);
1006        let cloned = val.clone();
1007        let result: Value = from_value(cloned).unwrap();
1008        assert_eq!(result, val);
1009    }
1010
1011    #[test]
1012    fn value_deserialize_preserves_map() {
1013        let val = Value::Map(vec![(Value::Text("key".into()), Value::U64(42))]);
1014        let cloned = val.clone();
1015        let result: Value = from_value(cloned).unwrap();
1016        assert_eq!(result, val);
1017    }
1018
1019    // ---------------------------------------------------------------
1020    // Bytes deserialization (non-human-readable -> visit_bytes)
1021    // ---------------------------------------------------------------
1022
1023    #[test]
1024    fn value_deserialize_bytes_as_value() {
1025        let val = Value::Bytes(vec![1, 2, 3]);
1026        let cloned = val.clone();
1027        let result: Value = from_value(cloned).unwrap();
1028        assert_eq!(result, val);
1029    }
1030
1031    #[test]
1032    fn value_deserialize_bytes32_as_value() {
1033        let val = Value::Bytes32([7u8; 32]);
1034        let cloned = val.clone();
1035        let result: Value = from_value(cloned).unwrap();
1036        // Non-human-readable: Bytes32 goes through visit_bytes which produces Value::Bytes
1037        assert_eq!(result, Value::Bytes(vec![7u8; 32]));
1038    }
1039
1040    #[test]
1041    fn value_deserialize_bytes20_as_value() {
1042        let val = Value::Bytes20([8u8; 20]);
1043        let cloned = val.clone();
1044        let result: Value = from_value(cloned).unwrap();
1045        // Non-human-readable: Bytes20 goes through visit_bytes which produces Value::Bytes
1046        assert_eq!(result, Value::Bytes(vec![8u8; 20]));
1047    }
1048
1049    #[test]
1050    fn value_deserialize_bytes36_as_value() {
1051        let val = Value::Bytes36([9u8; 36]);
1052        let cloned = val.clone();
1053        let result: Value = from_value(cloned).unwrap();
1054        // Non-human-readable: Bytes36 goes through visit_bytes which produces Value::Bytes
1055        assert_eq!(result, Value::Bytes(vec![9u8; 36]));
1056    }
1057
1058    #[test]
1059    fn value_deserialize_identifier_as_value() {
1060        let val = Value::Identifier([10u8; 32]);
1061        let cloned = val.clone();
1062        let result: Value = from_value(cloned).unwrap();
1063        // Non-human-readable: Identifier goes through visit_bytes which produces Value::Bytes
1064        assert_eq!(result, Value::Bytes(vec![10u8; 32]));
1065    }
1066
1067    // ---------------------------------------------------------------
1068    // Newtype struct deserialization
1069    // ---------------------------------------------------------------
1070
1071    #[test]
1072    fn deserialize_newtype_struct() {
1073        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1074        struct Wrapper(u32);
1075
1076        let val = Value::U32(42);
1077        let result: Wrapper = from_value(val).unwrap();
1078        assert_eq!(result, Wrapper(42));
1079    }
1080
1081    // ---------------------------------------------------------------
1082    // Unit struct deserialization
1083    // ---------------------------------------------------------------
1084
1085    #[test]
1086    fn deserialize_unit_struct_from_null() {
1087        #[derive(Debug, PartialEq, Deserialize)]
1088        struct Empty;
1089
1090        let val = Value::Null;
1091        let result: Empty = from_value(val).unwrap();
1092        assert_eq!(result, Empty);
1093    }
1094
1095    // ---------------------------------------------------------------
1096    // Bytes deserialization into byte buffers
1097    // ---------------------------------------------------------------
1098
1099    #[test]
1100    fn deserialize_bytes_from_bytes_value() {
1101        let val = Value::Bytes(vec![1, 2, 3, 4]);
1102        let result: Value = from_value(val.clone()).unwrap();
1103        assert_eq!(result, val);
1104    }
1105
1106    #[test]
1107    fn deserialize_bytes_type_mismatch_errors() {
1108        use serde::de::Deserializer as _;
1109        struct BytesVisitor;
1110        impl<'de> de::Visitor<'de> for BytesVisitor {
1111            type Value = Vec<u8>;
1112            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
1113                write!(f, "bytes")
1114            }
1115            fn visit_bytes<E: de::Error>(self, v: &[u8]) -> Result<Self::Value, E> {
1116                Ok(v.to_vec())
1117            }
1118        }
1119        let deser = Deserializer(Value::Bool(true));
1120        let result = deser.deserialize_bytes(BytesVisitor);
1121        assert!(result.is_err());
1122    }
1123
1124    // ---------------------------------------------------------------
1125    // Enum deserialization
1126    // ---------------------------------------------------------------
1127
1128    #[test]
1129    fn deserialize_unit_enum_from_text() {
1130        #[derive(Debug, PartialEq, Deserialize)]
1131        enum Color {
1132            Red,
1133            Green,
1134            Blue,
1135        }
1136        let val = Value::Text("Red".into());
1137        let result: Color = from_value(val).unwrap();
1138        assert_eq!(result, Color::Red);
1139    }
1140
1141    #[test]
1142    fn deserialize_newtype_enum_from_map() {
1143        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1144        enum Wrapper {
1145            Count(u32),
1146        }
1147        let val = Value::Map(vec![(Value::Text("Count".into()), Value::U32(42))]);
1148        let result: Wrapper = from_value(val).unwrap();
1149        assert_eq!(result, Wrapper::Count(42));
1150    }
1151
1152    #[test]
1153    fn round_trip_unit_enum() {
1154        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1155        enum Direction {
1156            Up,
1157            Down,
1158        }
1159        let original = Direction::Up;
1160        let val = to_value(&original).unwrap();
1161        let recovered: Direction = from_value(val).unwrap();
1162        assert_eq!(original, recovered);
1163    }
1164
1165    #[test]
1166    fn round_trip_newtype_enum() {
1167        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1168        enum Payload {
1169            Message(String),
1170        }
1171        let original = Payload::Message("hello".into());
1172        let val = to_value(&original).unwrap();
1173        let recovered: Payload = from_value(val).unwrap();
1174        assert_eq!(original, recovered);
1175    }
1176
1177    #[test]
1178    fn round_trip_struct_enum() {
1179        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1180        enum Shape {
1181            Circle { radius: u32 },
1182        }
1183        let original = Shape::Circle { radius: 5 };
1184        let val = to_value(&original).unwrap();
1185        let recovered: Shape = from_value(val).unwrap();
1186        assert_eq!(original, recovered);
1187    }
1188
1189    #[test]
1190    fn round_trip_tuple_enum() {
1191        #[derive(Debug, PartialEq, Serialize, Deserialize)]
1192        enum Pair {
1193            Coords(i32, i32),
1194        }
1195        let original = Pair::Coords(10, 20);
1196        let val = to_value(&original).unwrap();
1197        let recovered: Pair = from_value(val).unwrap();
1198        assert_eq!(original, recovered);
1199    }
1200}
platform_value/value_serialization/de.rs

platform_value/value_serialization/
de.rs
