lib0 0.16.10

Efficient binary encoding library for Yrs
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150

mod de;
mod ser;

pub use de::from_any;
pub use ser::to_any;

#[cfg(test)]
mod test {
    use super::*;
    use crate::any::Any;
    use serde::{Deserialize, Serialize};
    use std::collections::HashMap;

    #[test]
    fn test_struct_any_roundtrip() {
        #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
        struct Test {
            bool: bool,
            int: i64,
            negative_int: i64,
            max_int: i64,
            min_int: i64,
            real_number: f64,
            max_number: f64,
            min_number: f64,
            null: Option<bool>,
            some: Option<bool>,
            undefined: Option<bool>,
            nested: Nested,
            enum_a: StringEnum,
            enum_b: StringEnum,
            enum_c: StringEnum,
            array: Vec<Option<Nested>>,
        }

        #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
        struct Nested {
            int: i16,
            other: f32,
        }

        #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
        enum StringEnum {
            VariantA,
            VariantB(String),
            VariantC { test: bool },
        }

        let test = Test {
            bool: true,
            int: 1,
            negative_int: -1,
            max_int: i64::MAX,
            min_int: i64::MIN,
            real_number: -123.2387f64,
            max_number: f64::MIN,
            min_number: f64::MAX,
            null: None,
            some: Some(false),
            undefined: None,
            nested: Nested {
                int: 100,
                other: 100.0,
            },
            enum_a: StringEnum::VariantA,
            enum_b: StringEnum::VariantB("test".to_string()),
            enum_c: StringEnum::VariantC { test: true },
            array: vec![None, Some(Nested { int: 0, other: 0.0 }), None],
        };

        assert_eq!(test, from_any(&to_any(&test).unwrap()).unwrap())
    }

    #[test]
    fn test_enum_untagged_any_roundtrip() {
        #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
        struct Test {
            enum_a: StringEnum,
            enum_b: StringEnum,
            enum_c: StringEnum,
        }

        #[derive(Debug, Serialize, Deserialize, Clone, PartialEq)]
        #[serde(untagged)]
        enum StringEnum {
            VariantA,
            VariantB(String),
            VariantC { test: bool },
        }

        let test = Test {
            enum_a: StringEnum::VariantA,
            enum_b: StringEnum::VariantB("test".to_string()),
            enum_c: StringEnum::VariantC { test: true },
        };

        assert_eq!(test, from_any(&to_any(&test).unwrap()).unwrap())
    }

    #[test]
    fn test_any_to_json_roundtrip() {
        let any = Any::Map(Box::new(HashMap::from([
            ("bool".into(), Any::Bool(true)),
            ("int".into(), Any::BigInt(1)),
            ("negativeInt".into(), Any::BigInt(-1)),
            ("maxInt".into(), Any::BigInt(i64::MAX)),
            ("minInt".into(), Any::BigInt(i64::MIN)),
            ("realNumber".into(), Any::Number(-123.2387f64)),
            ("maxNumber".into(), Any::Number(f64::MIN)),
            ("minNumber".into(), Any::Number(f64::MAX)),
            ("null".into(), Any::Null),
            (
                "map".into(),
                Any::Map(Box::new(HashMap::from([
                    ("bool".into(), Any::Bool(true)),
                    ("int".into(), Any::BigInt(1)),
                    ("negativeInt".into(), Any::BigInt(-1)),
                    ("maxInt".into(), Any::BigInt(i64::MAX)),
                    ("minInt".into(), Any::BigInt(i64::MIN)),
                    ("realNumber".into(), Any::Number(-123.2387f64)),
                    ("maxNumber".into(), Any::Number(f64::MIN)),
                    ("minNumber".into(), Any::Number(f64::MAX)),
                    ("null".into(), Any::Null),
                ]))),
            ),
            (
                "key6".into(),
                Any::Array(
                    vec![
                        Any::Bool(true),
                        Any::BigInt(1),
                        Any::BigInt(-1),
                        Any::BigInt(i64::MAX),
                        Any::BigInt(i64::MIN),
                        Any::Number(-123.2387f64),
                        Any::Number(f64::MIN),
                        Any::Number(f64::MAX),
                        Any::Null,
                    ]
                    .into_boxed_slice(),
                ),
            ),
        ])));

        assert_eq!(
            any,
            serde_json::from_str::<Any>(serde_json::to_string(&any).unwrap().as_str()).unwrap()
        );
    }
}