xrust 2.0.3

Support for XPath and XSLT
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

use std::fs;
use xrust::Node;
use xrust::parser::ParseError;
use xrust::parser::xml;
use xrust::trees::smite::RNode;

#[test]
fn serializer_issue_98() {
    /*
        Github issue number 98
        We wish to have XML documents output attributes in some stable order for test purposes.
        IMPORTANT NOTE: We will be stable for a particular version, but XML itself does not care
        about attribute order. We may switch the ordering between versions if we find a technical
        reason to do so.
    */

    let data = fs::read_to_string("tests/xml/issue-98.xml").unwrap();
    let mut prev_xml_output = None;

    for iteration in 0..100 {
        let doc = xml::parse(
            RNode::new_document(),
            data.clone().as_str(),
            Some(|_: &_| Err(ParseError::MissingNameSpace)),
        )
        .unwrap();
        let xml_output = doc.to_xml();
        if let Some(prev_xml_output) = &prev_xml_output {
            assert_eq!(&xml_output, prev_xml_output, "Failed on run {}", iteration);
        }
        prev_xml_output = Some(xml_output);
    }
}

#[test]
fn serializer_1() {
    /*
        Testing the XML output, simple document.
    */

    let data = "<doc><child/></doc>";

    let doc = xml::parse(
        RNode::new_document(),
        data,
        Some(|_: &_| Err(ParseError::MissingNameSpace)),
    )
    .unwrap();
    let xml_output = doc.to_xml();

    assert_eq!(xml_output, "<doc><child/></doc>");
}

#[test]
fn serializer_2() {
    /*
        Testing the XML output, with some namespaces.
    */

    let data = "<doc xmlns='ns1'><child xmlns='ns2'/></doc>";

    let doc = xml::parse(
        RNode::new_document(),
        data,
        Some(|_: &_| Err(ParseError::MissingNameSpace)),
    )
    .unwrap();
    let xml_output = doc.to_xml();

    assert_eq!(xml_output, "<doc xmlns='ns1'><child xmlns='ns2'/></doc>");
}

#[test]
fn serializer_3() {
    /*
        Testing the XML output, with some namespace aliases.
    */

    let data = "<a:doc xmlns:a='ns1'><a:child xmlns:a='ns2'/></a:doc>";

    let doc = xml::parse(
        RNode::new_document(),
        data,
        Some(|_: &_| Err(ParseError::MissingNameSpace)),
    )
    .unwrap();
    let xml_output = doc.to_xml();

    assert_eq!(
        xml_output,
        "<a:doc xmlns:a='ns1'><a:child xmlns:a='ns2'/></a:doc>"
    );
}

#[test]
fn serializer_4() {
    /*
        Testing the XML output, mixed content
    */

    let data = r#"<content att1='val1' xmlns:a='someothernamespace' att2='val2' xmlns='somenamespace' someatt='val5' other='valx' a:att4='val4'>
    <content2>text</content2>
    <content3/>
    <content4 xmlns='thirdnamespace' a:something='test'>text3</content4>
    <content05 xmlns:a='fourthnamespace' a:somethingelse='test2'>text4</content05>
</content>"#;

    let doc = xml::parse(
        RNode::new_document(),
        data,
        Some(|_: &_| Err(ParseError::MissingNameSpace)),
    )
    .unwrap();
    let xml_output = doc.to_xml();
    assert_eq!(xml_output, "<content xmlns='somenamespace' xmlns:a='someothernamespace' att1='val1' att2='val2' a:att4='val4' other='valx' someatt='val5'>
    <content2>text</content2>
    <content3/>
    <content4 xmlns='thirdnamespace' a:something='test'>text3</content4>
    <content05 xmlns:a='fourthnamespace' a:somethingelse='test2'>text4</content05>
</content>");
}

#[test]
#[ignore]
fn serializer_5() {
    /*
        Testing the XML output, characters to be escaped
    */

    let data = "<doc attr='&apos;'>XML escape test: &lt; &gt; &amp; &apos; &quot;</doc>";

    let doc = xml::parse(
        RNode::new_document(),
        data,
        Some(|_: &_| Err(ParseError::MissingNameSpace)),
    )
    .unwrap();
    let xml_output = doc.to_xml();

    assert_eq!(
        xml_output,
        "<doc attr='&apos;'>XML escape test: &lt; &gt; &amp; &apos; &quot;</doc>"
    );
}

#[test]
fn serializer_self_closing_tags() {
    /*
        GitLab issue number 121
        We wish to ensure that self closing tags are properly serialized.
    */
    let s = "<doc/>";
    let d = xml::parse(
        RNode::new_document(),
        s,
        Some(|_: &_| Err(ParseError::MissingNameSpace)),
    )
    .unwrap();

    assert_eq!(d.to_xml().to_string(), "<doc/>");
}