playwright/imp/core/message/
de.rs

1use serde::{
2    de,
3    de::{IntoDeserializer, Visitor}
4};
5use serde_json::value::{Map, Value};
6use std::convert::TryFrom;
7
8#[derive(Debug, thiserror::Error)]
9pub enum Error {
10    #[error("{0:}")]
11    Msg(String),
12    #[error("Not be able to deserialize from blank")]
13    Blank,
14    #[error("Incorrect type")]
15    TypeMismatch,
16    #[error("{0:} isn't supported")]
17    NotSupported(&'static str),
18    #[error(transparent)]
19    Serde(#[from] serde_json::Error)
20}
21
22impl de::Error for Error {
23    fn custom<T>(msg: T) -> Self
24    where
25        T: std::fmt::Display
26    {
27        Self::Msg(msg.to_string())
28    }
29}
30
31pub(crate) struct Deserializer<'de> {
32    stack: Vec<&'de Value>
33}
34
35impl<'de> Deserializer<'de> {
36    fn new(v: &'de Value) -> Self {
37        let stack = vec![v];
38        Self { stack }
39    }
40
41    fn pop(&mut self) -> Result<&'de Value, Error> { self.stack.pop().ok_or(Error::Blank) }
42}
43
44pub(crate) fn from_value<T>(v: &Value) -> Result<T, Error>
45where
46    T: de::DeserializeOwned
47{
48    let mut deserializer = Deserializer::new(v);
49    let t = T::deserialize(&mut deserializer)?;
50    Ok(t)
51}
52
53macro_rules! int {
54    ($t:ty, $base:ty) => {
55        paste::paste! {
56            fn [<deserialize_$t>]<V>(self, visitor: V) -> Result<V::Value, Self::Error>
57            where
58                V: Visitor<'de>
59            {
60                let v = self.pop()?;
61                let i1 = v.as_object()
62                    .and_then(|m| m.get("n"))
63                    .and_then(|v| v.[<as_$base>]())
64                    .ok_or(Error::TypeMismatch);
65                let i2 = v.[<as_$base>]().ok_or(Error::TypeMismatch);
66                let i = i1.or(i2)?;
67                let i = $t::try_from(i).map_err(|_| Error::TypeMismatch)?;
68                visitor.[<visit_$t>](i)
69            }
70        }
71    };
72}
73
74impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
75    type Error = Error;
76
77    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
78    where
79        V: Visitor<'de>
80    {
81        log::trace!("any {:?}", self.stack);
82        let v = *self.stack.last().ok_or(Error::Blank)?;
83        match v {
84            Value::Null => self.deserialize_unit(visitor),
85            Value::Bool(_) => self.deserialize_bool(visitor),
86            Value::Number(x) if x.is_u64() => self.deserialize_u64(visitor),
87            Value::Number(x) if x.is_i64() => self.deserialize_i64(visitor),
88            Value::Number(x) if x.is_f64() => self.deserialize_f64(visitor),
89            Value::Number(_) => unreachable!(),
90            Value::String(_) => self.deserialize_str(visitor),
91            Value::Array(_) => self.deserialize_seq(visitor),
92            Value::Object(m) => {
93                if let Some(v) = m.get("v") {
94                    match v.as_str() {
95                        Some("Infinity") | Some("-Infinity") | Some("-0") | Some("NaN") => {
96                            self.deserialize_f64(visitor)
97                        }
98                        Some("undefined") | Some("null") => self.deserialize_unit(visitor),
99                        _ => {
100                            let _ = self.pop()?;
101                            self.stack.push(v);
102                            self.deserialize_any(visitor)
103                        }
104                    }
105                } else if let Some(_a) = m.get("a") {
106                    self.deserialize_seq(visitor)
107                } else if let Some(_o) = m.get("o") {
108                    self.deserialize_map(visitor)
109                } else if let Some(n) = m.get("n") {
110                    match n {
111                        Value::Number(x) if x.is_u64() => self.deserialize_u64(visitor),
112                        Value::Number(x) if x.is_i64() => self.deserialize_i64(visitor),
113                        Value::Number(x) if x.is_f64() => self.deserialize_f64(visitor),
114                        _ => {
115                            log::error!("{:?}", n);
116                            Err(Error::TypeMismatch)
117                        }
118                    }
119                } else if let Some(_s) = m.get("s") {
120                    self.deserialize_str(visitor)
121                } else if let Some(_b) = m.get("b") {
122                    self.deserialize_bool(visitor)
123                } else {
124                    self.deserialize_map(visitor)
125                }
126            }
127        }
128    }
129
130    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
131    where
132        V: Visitor<'de>
133    {
134        let v = self.pop()?;
135        let b1 = v
136            .as_object()
137            .and_then(|m| m.get("b"))
138            .and_then(|v| v.as_bool())
139            .ok_or(Error::TypeMismatch);
140        let b2 = v.as_bool().ok_or(Error::TypeMismatch);
141        let b = b1.or(b2)?;
142        visitor.visit_bool(b)
143    }
144
145    int! {i8, i64}
146    int! {i16, i64}
147    int! {i32, i64}
148    int! {i64, i64}
149    int! {u8, u64}
150    int! {u16, u64}
151    int! {u32, u64}
152    int! {u64, u64}
153
154    fn deserialize_char<V>(self, _: V) -> Result<V::Value, Self::Error>
155    where
156        V: Visitor<'de>
157    {
158        Err(Error::NotSupported("deserialize_char"))
159    }
160
161    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
162    where
163        V: Visitor<'de>
164    {
165        Err(Error::NotSupported("deserialize_bytes"))
166    }
167
168    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
169    where
170        V: Visitor<'de>
171    {
172        Err(Error::NotSupported("deserialize_byte_buf"))
173    }
174
175    fn deserialize_f32<V>(self, _: V) -> Result<V::Value, Self::Error>
176    where
177        V: Visitor<'de>
178    {
179        Err(Error::NotSupported("deserialize_f32"))
180    }
181
182    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
183    where
184        V: Visitor<'de>
185    {
186        let v = self.pop()?;
187        let f1 = v
188            .as_object()
189            .and_then(|m| m.get("n"))
190            .and_then(|v| v.as_f64())
191            .ok_or(Error::TypeMismatch);
192        let f2 = v.as_f64().ok_or(Error::TypeMismatch);
193        let f3 = v
194            .as_object()
195            .and_then(|m| m.get("v"))
196            .and_then(|v| v.as_str())
197            .and_then(|s| match s {
198                "Infinity" => Some(f64::INFINITY),
199                "-Infinity" => Some(f64::NEG_INFINITY),
200                "-0" => Some(-0.0),
201                "NaN" => Some(f64::NAN),
202                _ => None
203            })
204            .ok_or(Error::TypeMismatch);
205        let f = f1.or(f2).or(f3)?;
206        visitor.visit_f64(f)
207    }
208
209    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
210    where
211        V: Visitor<'de>
212    {
213        log::trace!("str {:?}", self.stack);
214        let v = self.pop()?;
215        let s1 = v
216            .as_object()
217            .and_then(|m| m.get("s"))
218            .and_then(|v| v.as_str())
219            .ok_or(Error::TypeMismatch);
220        let s2 = v.as_str().ok_or(Error::TypeMismatch);
221        let s = s1.or(s2)?;
222        visitor.visit_borrowed_str(s)
223    }
224
225    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
226    where
227        V: Visitor<'de>
228    {
229        self.deserialize_str(visitor)
230    }
231
232    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
233    where
234        V: Visitor<'de>
235    {
236        let v = self.pop()?;
237        let n1 = v
238            .as_object()
239            .and_then(|m| m.get("v"))
240            .and_then(|v| v.as_str())
241            .and_then(|s| match s {
242                "undefined" => Some(()),
243                "null" => Some(()),
244                _ => None
245            });
246        let n2 = v.as_null();
247        let is_null = n1.or(n2).is_some();
248        if is_null {
249            visitor.visit_none()
250        } else {
251            self.stack.push(v);
252            visitor.visit_some(self)
253        }
254    }
255
256    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
257    where
258        V: Visitor<'de>
259    {
260        log::trace!("unit {:?}", self.stack);
261        let v = self.pop()?;
262        let n1 = v
263            .as_object()
264            .and_then(|m| m.get("v"))
265            .and_then(|v| v.as_str())
266            .and_then(|s| match s {
267                "undefined" => Some(()),
268                "null" => Some(()),
269                _ => None
270            });
271        let n2 = v.as_null();
272        let _ = n1.or(n2).ok_or(Error::TypeMismatch)?;
273        visitor.visit_unit()
274    }
275
276    fn deserialize_unit_struct<V>(
277        self,
278        _name: &'static str,
279        visitor: V
280    ) -> Result<V::Value, Self::Error>
281    where
282        V: Visitor<'de>
283    {
284        self.deserialize_unit(visitor)
285    }
286
287    fn deserialize_newtype_struct<V>(
288        self,
289        _name: &'static str,
290        visitor: V
291    ) -> Result<V::Value, Self::Error>
292    where
293        V: Visitor<'de>
294    {
295        visitor.visit_newtype_struct(self)
296    }
297
298    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
299    where
300        V: Visitor<'de>
301    {
302        let v = self.pop()?;
303        let a1 = v
304            .as_object()
305            .and_then(|m| m.get("a"))
306            .and_then(|v| v.as_array())
307            .ok_or(Error::TypeMismatch);
308        let a2 = v.as_array().ok_or(Error::TypeMismatch);
309        let a = a1.or(a2)?;
310        visitor.visit_seq(Array::new(&mut self, a))
311    }
312
313    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
314    where
315        V: Visitor<'de>
316    {
317        self.deserialize_seq(visitor)
318    }
319
320    fn deserialize_tuple_struct<V>(
321        self,
322        _name: &'static str,
323        _len: usize,
324        visitor: V
325    ) -> Result<V::Value, Self::Error>
326    where
327        V: Visitor<'de>
328    {
329        self.deserialize_seq(visitor)
330    }
331
332    // TODO: datetime
333    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
334    where
335        V: Visitor<'de>
336    {
337        let v = self.pop()?;
338        let m = v.as_object().ok_or(Error::TypeMismatch)?;
339        let o1 = m
340            .get("o")
341            .and_then(|v| v.as_array())
342            .ok_or(Error::TypeMismatch);
343        if m.contains_key("v") || m.contains_key("a") {
344            Err(Error::TypeMismatch)
345        } else if m.contains_key("d") {
346            visitor.visit_map(Object::new(&mut self, m))
347        } else if m.contains_key("o") {
348            visitor.visit_map(ObjectArr::new(&mut self, o1?))
349        } else if m.contains_key("n") || m.contains_key("s") || m.contains_key("b") {
350            Err(Error::TypeMismatch)
351        } else {
352            visitor.visit_map(Object::new(&mut self, m))
353        }
354    }
355
356    fn deserialize_struct<V>(
357        self,
358        _name: &'static str,
359        _fields: &'static [&'static str],
360        visitor: V
361    ) -> Result<V::Value, Self::Error>
362    where
363        V: Visitor<'de>
364    {
365        self.deserialize_map(visitor)
366    }
367
368    fn deserialize_enum<V>(
369        self,
370        _name: &'static str,
371        _variants: &'static [&'static str],
372        visitor: V
373    ) -> Result<V::Value, Self::Error>
374    where
375        V: Visitor<'de>
376    {
377        log::trace!("enum {:?}", self.stack);
378        let v = self.pop()?;
379        match v {
380            Value::String(s) => visitor.visit_enum(s.as_str().into_deserializer()),
381            Value::Object(m) => {
382                if let Some(s) = m.get("s") {
383                    let s = s.as_str().ok_or(Error::TypeMismatch)?;
384                    return visitor.visit_enum(s.into_deserializer());
385                }
386                visitor.visit_enum(Enum::new(self, m))
387            }
388            _ => Err(Error::TypeMismatch)
389        }
390    }
391
392    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
393    where
394        V: Visitor<'de>
395    {
396        self.deserialize_str(visitor)
397    }
398
399    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
400    where
401        V: Visitor<'de>
402    {
403        self.deserialize_any(visitor)
404    }
405}
406
407struct Array<'a, 'de: 'a> {
408    prime: &'a mut Deserializer<'de>,
409    data: std::slice::Iter<'de, Value>
410}
411
412impl<'a, 'de> Array<'a, 'de> {
413    fn new(prime: &'a mut Deserializer<'de>, arr: &'de [Value]) -> Self {
414        Array {
415            prime,
416            data: arr.iter()
417        }
418    }
419}
420
421impl<'de, 'a> de::SeqAccess<'de> for Array<'a, 'de> {
422    type Error = Error;
423
424    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
425    where
426        T: de::DeserializeSeed<'de>
427    {
428        let data = match self.data.next() {
429            Some(x) => x,
430            None => return Ok(None)
431        };
432        self.prime.stack.push(data);
433        seed.deserialize(&mut *self.prime).map(Some)
434    }
435}
436
437struct Object<'a, 'de: 'a> {
438    prime: &'a mut Deserializer<'de>,
439    keys: serde_json::map::Keys<'de>,
440    values: serde_json::map::Values<'de>
441}
442
443impl<'a, 'de> Object<'a, 'de> {
444    fn new(prime: &'a mut Deserializer<'de>, obj: &'de Map<String, Value>) -> Self {
445        Self {
446            prime,
447            keys: obj.keys(),
448            values: obj.values()
449        }
450    }
451}
452
453impl<'de, 'a> de::MapAccess<'de> for Object<'a, 'de> {
454    type Error = Error;
455
456    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
457    where
458        K: de::DeserializeSeed<'de>
459    {
460        let s = match self.keys.next() {
461            Some(x) => x,
462            None => return Ok(None)
463        };
464        let mut d = KeyDeserializer {
465            prime: &mut *self.prime,
466            s
467        };
468        Ok(Some(seed.deserialize(&mut d)?))
469    }
470
471    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
472    where
473        V: de::DeserializeSeed<'de>
474    {
475        let data = self.values.next().ok_or(Error::Blank)?;
476        self.prime.stack.push(data);
477        seed.deserialize(&mut *self.prime)
478    }
479}
480
481struct ObjectArr<'a, 'de: 'a> {
482    prime: &'a mut Deserializer<'de>,
483    arr: &'de [Value],
484    idx: usize
485}
486
487impl<'a, 'de> ObjectArr<'a, 'de> {
488    fn new(prime: &'a mut Deserializer<'de>, arr: &'de [Value]) -> Self {
489        Self { prime, arr, idx: 0 }
490    }
491}
492
493impl<'de, 'a> de::MapAccess<'de> for ObjectArr<'a, 'de> {
494    type Error = Error;
495
496    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
497    where
498        K: de::DeserializeSeed<'de>
499    {
500        let data = if self.idx < self.arr.len() {
501            self.idx += 1;
502            self.arr[self.idx - 1]
503                .as_object()
504                .and_then(|m| m.get("k"))
505                .ok_or(Error::Blank)?
506        } else {
507            return Ok(None);
508        };
509        let s = data.as_str().ok_or(Error::TypeMismatch)?;
510        let mut d = KeyDeserializer {
511            prime: &mut *self.prime,
512            s
513        };
514        Ok(Some(seed.deserialize(&mut d)?))
515    }
516
517    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
518    where
519        V: de::DeserializeSeed<'de>
520    {
521        let data = self.arr[self.idx - 1]
522            .as_object()
523            .and_then(|m| m.get("v"))
524            .ok_or(Error::Blank)?;
525        self.prime.stack.push(data);
526        seed.deserialize(&mut *self.prime)
527    }
528}
529
530struct KeyDeserializer<'a, 'de: 'a> {
531    prime: &'a mut Deserializer<'de>,
532    s: &'de str
533}
534
535macro_rules! key_int {
536    ($t:ty, $base:ty) => {
537        paste::paste! {
538            fn [<deserialize_$t>]<V>(self, visitor: V) -> Result<V::Value, Self::Error>
539            where
540                V: Visitor<'de>
541            {
542                let i: $t = serde_json::from_str(self.s)?;
543                visitor.[<visit_$t>](i)
544            }
545        }
546    };
547}
548
549impl<'de, 'a> de::Deserializer<'de> for &'a mut KeyDeserializer<'a, 'de> {
550    type Error = Error;
551
552    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
553    where
554        V: Visitor<'de>
555    {
556        visitor.visit_str(self.s)
557    }
558
559    forward_to_deserialize_any! {
560        bool f32 f64 char str string unit unit_struct seq tuple tuple_struct map
561        struct identifier ignored_any
562    }
563
564    key_int! {i8, i64}
565    key_int! {i16, i64}
566    key_int! {i32, i64}
567    key_int! {i64, i64}
568    key_int! {u8, u64}
569    key_int! {u16, u64}
570    key_int! {u32, u64}
571    key_int! {u64, u64}
572
573    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
574    where
575        V: Visitor<'de>
576    {
577        Err(Error::NotSupported("deserialize_bytes"))
578    }
579
580    fn deserialize_byte_buf<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
581    where
582        V: Visitor<'de>
583    {
584        Err(Error::NotSupported("deserialize_byte_buf"))
585    }
586
587    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
588    where
589        V: Visitor<'de>
590    {
591        visitor.visit_some(self)
592    }
593
594    fn deserialize_newtype_struct<V>(
595        self,
596        _name: &'static str,
597        visitor: V
598    ) -> Result<V::Value, Self::Error>
599    where
600        V: Visitor<'de>
601    {
602        visitor.visit_newtype_struct(self)
603    }
604
605    fn deserialize_enum<V>(
606        self,
607        name: &'static str,
608        variants: &'static [&'static str],
609        visitor: V
610    ) -> Result<V::Value, Self::Error>
611    where
612        V: Visitor<'de>
613    {
614        self.prime.deserialize_enum(name, variants, visitor)
615    }
616}
617
618struct Enum<'a, 'de: 'a> {
619    prime: &'a mut Deserializer<'de>,
620    map: &'de Map<String, Value>
621}
622
623impl<'a, 'de> Enum<'a, 'de> {
624    fn new(prime: &'a mut Deserializer<'de>, map: &'de Map<String, Value>) -> Self {
625        Enum { prime, map }
626    }
627}
628
629impl<'de, 'a> de::EnumAccess<'de> for Enum<'a, 'de> {
630    type Error = Error;
631    type Variant = Self;
632
633    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
634    where
635        V: de::DeserializeSeed<'de>
636    {
637        log::trace!("variant_seed {:?}", self.map);
638        if let Some(a) = self.map.get("o") {
639            let a = a.as_array().ok_or(Error::Blank)?;
640            if a.len() == 1 {
641                let key = a[0].get("k").ok_or(Error::Blank)?;
642                self.prime.stack.push(key);
643                let v = seed.deserialize(&mut *self.prime)?;
644                self.prime.stack.push(a[0].get("v").ok_or(Error::Blank)?);
645                Ok((v, self))
646            } else {
647                Err(Error::TypeMismatch)
648            }
649        } else {
650            Err(Error::TypeMismatch)
651        }
652    }
653}
654
655impl<'de, 'a> de::VariantAccess<'de> for Enum<'a, 'de> {
656    type Error = Error;
657
658    fn unit_variant(self) -> Result<(), Self::Error> {
659        let v = self.prime.pop()?;
660        if v.is_null() {
661            Ok(())
662        } else {
663            Err(Error::TypeMismatch)
664        }
665    }
666
667    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
668    where
669        T: de::DeserializeSeed<'de>
670    {
671        seed.deserialize(self.prime)
672    }
673
674    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
675    where
676        V: Visitor<'de>
677    {
678        de::Deserializer::deserialize_seq(self.prime, visitor)
679    }
680
681    fn struct_variant<V>(
682        self,
683        _fields: &'static [&'static str],
684        visitor: V
685    ) -> Result<V::Value, Self::Error>
686    where
687        V: Visitor<'de>
688    {
689        de::Deserializer::deserialize_map(self.prime, visitor)
690    }
691}
692
693#[cfg(test)]
694mod tests {
695    use super::*;
696    use std::collections::HashMap;
697
698    #[test]
699    fn r#struct() {
700        env_logger::builder().is_test(true).try_init().ok();
701        #[derive(Debug, Deserialize, PartialEq)]
702        struct Test {
703            a: i32,
704            b: Option<i32>,
705            c: Option<String>,
706            d: f64,
707            e: Vec<Value>,
708            mi: HashMap<i32, String>,
709            ms: HashMap<String, String>
710        }
711        let v = serde_json::from_str(
712            r#"{ "o": [
713            { "k": "a", "v": { "n": 3 } },
714            {"k":"c","v":{"s":"sdf"}},
715            {"k":"d","v":{"v":"Infinity"}},
716            {"k": "e", "v": {"a": [{"n": 2.0}, {"b": false}]}},
717            {"k": "ms", "v": {"o": [{"k": "2", "v": "as"}]}},
718            {"k": "mi", "v": {"o": [{"k": "2", "v": "as"}]}}
719            ] }"#
720        )
721        .unwrap();
722        let de: Test = from_value(&v).unwrap();
723        let mi = {
724            let mut m = HashMap::new();
725            m.insert(2, "as".into());
726            m
727        };
728        let ms = {
729            let mut m = HashMap::new();
730            m.insert("2".into(), "as".into());
731            m
732        };
733        assert_eq!(
734            de,
735            Test {
736                a: 3,
737                b: None,
738                c: Some("sdf".into()),
739                d: f64::INFINITY,
740                e: vec![Value::from(2.0f64), Value::from(false)],
741                mi,
742                ms
743            }
744        );
745        let v = serde_json::from_str(r#"{"v": "null"}"#).unwrap();
746        let de: Option<String> = from_value(&v).unwrap();
747        assert_eq!(de, None);
748    }
749
750    #[test]
751    fn r#enum() {
752        env_logger::builder().is_test(true).try_init().ok();
753        #[derive(Debug, Deserialize, PartialEq)]
754        enum Test {
755            A,
756            B(i32),
757            Tuple(u32, u32),
758            Struct { a: u32 }
759        }
760        let v = serde_json::from_str(r#"{"s": "A"}"#).unwrap();
761        let de: Test = from_value(&v).unwrap();
762        assert_eq!(de, Test::A);
763        let v = serde_json::from_str(r#"{"o": [{"k":"B", "v": {"n":0}}]}"#).unwrap();
764        let de: Test = from_value(&v).unwrap();
765        assert_eq!(de, Test::B(0));
766        let v = serde_json::from_str(r#"{"o": [{"k":"Tuple", "v": {"a": [{"n":0}, {"n":3}]}}]}"#)
767            .unwrap();
768        let de: Test = from_value(&v).unwrap();
769        assert_eq!(de, Test::Tuple(0, 3));
770        let v = serde_json::from_str(
771            r#"{"o": [{"k":"Struct", "v": {"o": [{"k":"a", "v": {"n":0}}]}}]}"#
772        )
773        .unwrap();
774        let de: Test = from_value(&v).unwrap();
775        assert_eq!(de, Test::Struct { a: 0 });
776    }
777}
playwright/imp/core/message/de.rs

playwright/imp/core/message/
de.rs
