musli 0.0.149

Müsli is a flexible and efficient serialization framework.
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
151
152
153
154

use musli::{Decode, Encode};

#[test]
fn named() {
    #[derive(Debug, PartialEq, Encode, Decode)]
    #[musli(tag = "type", name_all = "snake_case")]
    pub enum Enum {
        #[musli(name_all = "snake_case")]
        OneField { string: String, number: u32 },
        #[musli(name_all = "snake_case")]
        TwoFields { string: String },
    }

    musli::macros::assert_roundtrip_eq! {
        descriptive,
        Enum::OneField {
            string: String::from("Hello"),
            number: 42,
        },
        json = r#"{"type":"one_field","string":"Hello","number":42}"#
    };

    musli::macros::assert_roundtrip_eq! {
        descriptive,
        Enum::TwoFields {
            string: String::from("Hello")
        },
        json = r#"{"type":"two_fields","string":"Hello"}"#
    };

    musli::macros::assert_roundtrip_eq! {
        descriptive,
        Enum::TwoFields {
            string: String::from("\"\u{0000}")
        },
        json = r#"{"type":"two_fields","string":"\"\u0000"}"#
    };
}

#[test]
fn transparent() {
    #[derive(Debug, PartialEq, Encode, Decode)]
    #[musli(name_all = "snake_case")]
    pub struct Struct {
        string: String,
    }

    #[derive(Debug, PartialEq, Encode, Decode)]
    #[musli(tag = "type", name_all = "snake_case")]
    pub enum Enum {
        #[musli(transparent, name_all = "snake_case")]
        Tuple(Struct),
        #[musli(transparent, name_all = "snake_case")]
        Struct { st: Struct },
    }

    musli::macros::assert_roundtrip_eq! {
        descriptive,
        Enum::Tuple(Struct {
            string: String::from("Hello")
        }),
        json = r#"{"type":"tuple","string":"Hello"}"#
    };

    musli::macros::assert_roundtrip_eq! {
        descriptive,
        Enum::Tuple(Struct {
            string: String::from("\"\u{0000}")
        }),
        json = r#"{"type":"tuple","string":"\"\u0000"}"#
    };

    musli::macros::assert_roundtrip_eq! {
        descriptive,
        Enum::Struct {
            st: Struct {
                string: String::from("Hello")
            }
        },
        json = r#"{"type":"struct","string":"Hello"}"#
    };

    musli::macros::assert_roundtrip_eq! {
        descriptive,
        Enum::Struct {
            st: Struct {
                string: String::from("\"\u{0000}")
            }
        },
        json = r#"{"type":"struct","string":"\"\u0000"}"#
    };
}

#[test]
fn indexed() {
    macro_rules! test_case {
        ($ty:ty) => {{
            #[derive(Debug, PartialEq, Encode, Decode)]
            #[musli(name(type = $ty), tag(value = 11, type = $ty))]
            pub enum Indexed {
                #[musli(name = 22)]
                Variant1 { variant1: u32 },
                #[musli(name = 33)]
                Variant2 { variant2: u32 },
            }

            musli::macros::assert_roundtrip_eq! {
                descriptive,
                Indexed::Variant1 { variant1: 10 },
                json = r#"{"11":22,"variant1":10}"#
            };

            musli::macros::assert_roundtrip_eq! {
                descriptive,
                Indexed::Variant2 { variant2: 20 },
                json = r#"{"11":33,"variant2":20}"#
            };

            #[derive(Debug, PartialEq, Encode, Decode)]
            #[musli(name(type = $ty), tag(value = 11, type = $ty))]
            pub enum IndexedBounds {
                #[musli(name = <$ty>::MAX)]
                Variant1 { variant1: u32 },
                #[musli(name = <$ty>::MIN)]
                Variant2 { variant2: u32 },
            }

            musli::macros::assert_roundtrip_eq! {
                descriptive,
                IndexedBounds::Variant1 { variant1: 10 },
                json = format!(r#"{{"11":{},"variant1":10}}"#, <$ty>::MAX)
            };

            musli::macros::assert_roundtrip_eq! {
                descriptive,
                IndexedBounds::Variant2 { variant2: 20 },
                json = format!(r#"{{"11":{},"variant2":20}}"#, <$ty>::MIN)
            };
        }};
    }

    test_case!(u8);
    test_case!(u16);
    test_case!(u32);
    test_case!(u64);
    test_case!(u128);
    test_case!(i8);
    test_case!(i16);
    test_case!(i32);
    test_case!(i64);
    test_case!(i128);
    test_case!(usize);
    test_case!(isize);
}