serde-xml-rs 0.8.2

xml-rs based deserializer for Serde (compatible with 1.0)
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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173

use crate::{from_str, to_string};
use rstest::rstest;
use serde::{Deserialize, Serialize};

mod given_simple_type {
    use super::*;

    #[rstest]
    #[case::string("<bla>This is a String</bla>", "This is a String".to_string())]
    #[case::string("<bla></bla>", "".to_string())]
    #[case::string("<bla>    </bla>", "".to_string())]
    #[case::string("<bla>&lt;boom/&gt;</bla>", "<boom/>".to_string())]
    #[case::string("<bla>&#9835;</bla>", "♫".to_string())]
    #[case::string("<bla>&#x266B;</bla>", "♫".to_string())]
    #[case::string("<bla>♫<![CDATA[<cookies/>]]>♫</bla>", "♫<cookies/>♫".to_string())]
    #[case::i64("<bla>0</bla>", 0i64)]
    #[case::i64("<bla>-2</bla>", -2i64)]
    #[case::i64("<bla>-1234</bla>", -1234i64)]
    #[case::i64("<bla> -1234 </bla>", -1234i64)]
    #[case::u64("<bla>0</bla>", 0u64)]
    #[case::u64("<bla>1234</bla>", 1234u64)]
    #[case::u64("<bla> 1234 </bla>", 1234u64)]
    #[case::bool("<bla>true</bla>", true)]
    #[case::bool("<bla>false</bla>", false)]
    #[case::unit("<bla/>", ())]
    #[case::f64("<bla>3.0</bla>", 3.0f64)]
    #[case::f64("<bla>3.1</bla>", 3.1f64)]
    #[case::f64("<bla>-1.2</bla>", -1.2f64)]
    #[case::f64("<bla>0.4</bla>", 0.4f64)]
    #[case::f64("<bla>0.4e5</bla>", 0.4e5f64)]
    #[case::f64("<bla>0.4e15</bla>", 0.4e15f64)]
    #[case::f64_precision_troubles("<bla>0.4e-01</bla>", 0.4e-01f64)]
    #[case::f64("<bla> 0.4e-01 </bla>", 0.4e-01f64)]
    #[case::option("<bla/>", Some("".to_string()))]
    #[case::option("<bla></bla>", Some("".to_string()))]
    #[case::option("<bla> </bla>", Some("".to_string()))]
    #[case::option("<bla>42</bla>", Some("42".to_string()))]
    #[test_log::test]
    fn when_deserialize_then_ok<T, 'de>(#[case] document: &str, #[case] expected: T)
    where
        T: std::fmt::Debug + PartialEq + Deserialize<'de>,
    {
        let actual: T = from_str(document).unwrap();
        assert_eq!(actual, expected);
    }

    #[rstest]
    #[case::string("This is a String".to_string())]
    #[case::string("".to_string())]
    #[case::i64(0i64)]
    #[case::u64(0u64)]
    #[case::bool(true)]
    #[case::bool(false)]
    #[case::unit(())]
    #[case::f64(3.0f64)]
    #[case::option(Some("".to_string()))]
    #[case::option(Some(42))]
    #[test_log::test]
    fn when_serialize_then_ko<T>(#[case] value: T)
    where
        T: std::fmt::Debug + PartialEq + Serialize,
    {
        assert!(to_string(&value).is_err());
    }
}

mod given_newtype_simple_type {
    use super::*;

    #[derive(Debug, PartialEq, Serialize, Deserialize)]
    #[serde(rename = "document")]
    struct Document<T>(T);

    #[rstest]
    #[test_log::test]
    #[case::string("abc".to_string(), "abc")]
    #[case::string("".to_string(), "")]
    #[case::string("<>&".to_string(), "&lt;&gt;&amp;")]
    #[case::string("♫".to_string(), "♫")]
    #[case::byte_buf(serde_bytes::ByteBuf::from("abc"), "abc")]
    #[case::char('a', "a")]
    #[case::bool_true(true, "true")]
    #[case::bool_false(false, "false")]
    #[case::u8(1u8, "1")]
    #[case::i32(1i32, "1")]
    #[case::f32(1.4f32, "1.4")]
    #[case::option_string(Some("abc".to_string()), "abc")]
    #[case::option_i32(Some(1i32), "1")]
    fn when_serialize_then_ok<'de, T>(#[case] content_value: T, #[case] content_text: &str)
    where
        T: std::fmt::Debug + PartialEq + Serialize + Deserialize<'de>,
    {
        let text = format!(
            r#"<?xml version="1.0" encoding="UTF-8"?><document>{}</document>"#,
            content_text
        );
        let value = Document(content_value);

        assert_eq!(to_string(&value).unwrap(), text);
    }

    #[rstest]
    #[case::string("abc".to_string(), "abc")]
    #[case::string("".to_string(), "")]
    #[case::string("".to_string(), "      ")]
    #[case::string("<>&".to_string(), "&lt;&gt;&amp;")]
    #[case::string("♫".to_string(), "♫")]
    #[case::byte_buf(serde_bytes::ByteBuf::from("abc"), "abc")]
    #[case::char('a', "a")]
    #[case::bool_true(true, "true")]
    #[case::bool_true(true, "1")]
    #[case::bool_false(false, "false")]
    #[case::bool_false(false, "0")]
    #[case::u8(1u8, "1")]
    #[case::i32(1i32, "1")]
    #[case::f32(1.4f32, "1.4")]
    #[case::option_string(Some("abc".to_string()), "abc")]
    #[case::option_i32(Some(1i32), "1")]
    #[test_log::test]
    fn when_deserialize_then_ok<'de, T>(#[case] content_value: T, #[case] content_text: &str)
    where
        T: std::fmt::Debug + PartialEq + Serialize + Deserialize<'de>,
    {
        let text = format!(
            r#"<?xml version="1.0" encoding="UTF-8"?><document>{}</document>"#,
            content_text
        );
        let value = Document(content_value);

        assert_eq!(from_str::<Document<T>>(&text).unwrap(), value);
    }

    #[rstest]
    #[case::not_a_bool(true, "verum")]
    #[test_log::test]
    fn when_deserialize_then_ko<'de, T>(#[case] _content_value: T, #[case] content_text: &str)
    where
        T: std::fmt::Debug + PartialEq + Serialize + Deserialize<'de>,
    {
        let text = format!(
            r#"<?xml version="1.0" encoding="UTF-8"?><document>{}</document>"#,
            content_text
        );
        assert!(from_str::<Document<T>>(&text).is_err());
    }
    #[rstest]
    #[case::unit(())]
    #[case::option_none(Option::<String>::None)]
    #[test_log::test]
    fn given_empty_value_when_serialize_then_empty_tag<'de, T>(#[case] content_value: T)
    where
        T: std::fmt::Debug + PartialEq + Serialize + Deserialize<'de>,
    {
        let text = r#"<?xml version="1.0" encoding="UTF-8"?><document />"#;
        let value = Document(content_value);

        assert_eq!(to_string(&value).unwrap(), text);
    }

    #[rstest]
    #[case::unit(())]
    #[case::option_none(Option::<String>::None)]
    #[test_log::test]
    fn given_empty_tag_when_deserialize_then_empty_value<'de, T>(#[case] content_value: T)
    where
        T: std::fmt::Debug + PartialEq + Serialize + Deserialize<'de>,
    {
        let text = r#"<?xml version="1.0" encoding="UTF-8"?><document />"#;
        let value = Document(content_value);

        assert_eq!(from_str::<Document<T>>(text).unwrap(), value);
    }
}