1use crate::element::Element;
2
3use quick_xml::Reader;
4
5const TEST_STRING: &'static str = r#"<root xmlns="root_ns" a="b" xml:lang="en">meow<child c="d"/><child xmlns="child_ns" d="e" xml:lang="fr"/>nya</root>"#;
6
7fn build_test_tree() -> Element {
8 let mut root = Element::builder("root")
9 .ns("root_ns")
10 .attr("xml:lang", "en")
11 .attr("a", "b")
12 .build();
13 root.append_text_node("meow");
14 let child = Element::builder("child").attr("c", "d").build();
15 root.append_child(child);
16 let other_child = Element::builder("child")
17 .ns("child_ns")
18 .attr("d", "e")
19 .attr("xml:lang", "fr")
20 .build();
21 root.append_child(other_child);
22 root.append_text_node("nya");
23 root
24}
25
26#[cfg(feature = "comments")]
27const COMMENT_TEST_STRING: &'static str = r#"<root><!--This is a child.--><child attr="val"><!--This is a grandchild.--><grandchild/></child></root>"#;
28
29#[cfg(feature = "comments")]
30fn build_comment_test_tree() -> Element {
31 let mut root = Element::builder("root").build();
32 root.append_comment_node("This is a child.");
33 let mut child = Element::builder("child").attr("attr", "val").build();
34 child.append_comment_node("This is a grandchild.");
35 let grand_child = Element::builder("grandchild").build();
36 child.append_child(grand_child);
37 root.append_child(child);
38 root
39}
40
41#[test]
42fn reader_works() {
43 let mut reader = Reader::from_str(TEST_STRING);
44 assert_eq!(
45 Element::from_reader(&mut reader).unwrap(),
46 build_test_tree()
47 );
48}
49
50#[test]
51fn writer_works() {
52 let root = build_test_tree();
53 let mut writer = Vec::new();
54 {
55 root.write_to(&mut writer).unwrap();
56 }
57 assert_eq!(String::from_utf8(writer).unwrap(), TEST_STRING);
58}
59
60#[test]
61fn writer_with_decl_works() {
62 let root = build_test_tree();
63 let mut writer = Vec::new();
64 {
65 root.write_to_decl(&mut writer).unwrap();
66 }
67 let result = format!(r#"<?xml version="1.0" encoding="utf-8"?>{}"#, TEST_STRING);
68 assert_eq!(String::from_utf8(writer).unwrap(), result);
69}
70
71#[test]
72fn writer_escapes_attributes() {
73 let root = Element::builder("root").attr("a", "\"Air\" quotes").build();
74 let mut writer = Vec::new();
75 {
76 root.write_to(&mut writer).unwrap();
77 }
78 assert_eq!(
79 String::from_utf8(writer).unwrap(),
80 r#"<root a=""Air" quotes"/>"#
81 );
82}
83
84#[test]
85fn writer_escapes_text() {
86 let root = Element::builder("root").append("<3").build();
87 let mut writer = Vec::new();
88 {
89 root.write_to(&mut writer).unwrap();
90 }
91 assert_eq!(String::from_utf8(writer).unwrap(), r#"<root><3</root>"#);
92}
93
94#[test]
95fn builder_works() {
96 let elem = Element::builder("a")
97 .ns("b")
98 .attr("c", "d")
99 .append(Element::builder("child"))
100 .append("e")
101 .build();
102 assert_eq!(elem.name(), "a");
103 assert_eq!(elem.ns(), Some("b".to_owned()));
104 assert_eq!(elem.attr("c"), Some("d"));
105 assert_eq!(elem.attr("x"), None);
106 assert_eq!(elem.text(), "e");
107 assert!(elem.has_child("child", "b"));
108 assert!(elem.is("a", "b"));
109}
110
111#[test]
112fn children_iter_works() {
113 let root = build_test_tree();
114 let mut iter = root.children();
115 assert!(iter.next().unwrap().is("child", "root_ns"));
116 assert!(iter.next().unwrap().is("child", "child_ns"));
117 assert_eq!(iter.next(), None);
118}
119
120#[test]
121fn get_child_works() {
122 let root = build_test_tree();
123 assert_eq!(root.get_child("child", "inexistent_ns"), None);
124 assert_eq!(root.get_child("not_a_child", "root_ns"), None);
125 assert!(root
126 .get_child("child", "root_ns")
127 .unwrap()
128 .is("child", "root_ns"));
129 assert!(root
130 .get_child("child", "child_ns")
131 .unwrap()
132 .is("child", "child_ns"));
133 assert_eq!(
134 root.get_child("child", "root_ns").unwrap().attr("c"),
135 Some("d")
136 );
137 assert_eq!(
138 root.get_child("child", "child_ns").unwrap().attr("d"),
139 Some("e")
140 );
141}
142
143#[test]
144fn namespace_propagation_works() {
145 let mut root = Element::builder("root").ns("root_ns").build();
146 let mut child = Element::bare("child");
147 let grandchild = Element::bare("grandchild");
148 child.append_child(grandchild);
149 root.append_child(child);
150
151 assert_eq!(root.get_child("child", "root_ns").unwrap().ns(), root.ns());
152 assert_eq!(
153 root.get_child("child", "root_ns")
154 .unwrap()
155 .get_child("grandchild", "root_ns")
156 .unwrap()
157 .ns(),
158 root.ns()
159 );
160}
161
162#[test]
163fn two_elements_with_same_arguments_different_order_are_equal() {
164 let elem1: Element = "<a b='a' c=''/>".parse().unwrap();
165 let elem2: Element = "<a c='' b='a'/>".parse().unwrap();
166 assert_eq!(elem1, elem2);
167
168 let elem1: Element = "<a b='a' c=''/>".parse().unwrap();
169 let elem2: Element = "<a c='d' b='a'/>".parse().unwrap();
170 assert_ne!(elem1, elem2);
171}
172
173#[test]
174fn namespace_attributes_works() {
175 let mut reader = Reader::from_str(TEST_STRING);
176 let root = Element::from_reader(&mut reader).unwrap();
177 assert_eq!("en", root.attr("xml:lang").unwrap());
178 assert_eq!(
179 "fr",
180 root.get_child("child", "child_ns")
181 .unwrap()
182 .attr("xml:lang")
183 .unwrap()
184 );
185}
186
187#[test]
188fn wrongly_closed_elements_error() {
189 let elem1 = "<a></b>".parse::<Element>();
190 assert!(elem1.is_err());
191 let elem1 = "<a></c></a>".parse::<Element>();
192 assert!(elem1.is_err());
193 let elem1 = "<a><c><d/></c></a>".parse::<Element>();
194 assert!(elem1.is_ok());
195}
196
197#[test]
198fn namespace_simple() {
199 let elem: Element = "<message xmlns='jabber:client'/>".parse().unwrap();
200 assert_eq!(elem.name(), "message");
201 assert_eq!(elem.ns(), Some("jabber:client".to_owned()));
202}
203
204#[test]
205fn namespace_prefixed() {
206 let elem: Element = "<stream:features xmlns:stream='http://etherx.jabber.org/streams'/>"
207 .parse()
208 .unwrap();
209 assert_eq!(elem.name(), "features");
210 assert_eq!(
211 elem.ns(),
212 Some("http://etherx.jabber.org/streams".to_owned())
213 );
214}
215
216#[test]
217fn namespace_inherited_simple() {
218 let elem: Element = "<stream xmlns='jabber:client'><message/></stream>"
219 .parse()
220 .unwrap();
221 assert_eq!(elem.name(), "stream");
222 assert_eq!(elem.ns(), Some("jabber:client".to_owned()));
223 let child = elem.children().next().unwrap();
224 assert_eq!(child.name(), "message");
225 assert_eq!(child.ns(), Some("jabber:client".to_owned()));
226}
227
228#[test]
229fn namespace_inherited_prefixed1() {
230 let elem: Element = "<stream:features xmlns:stream='http://etherx.jabber.org/streams' xmlns='jabber:client'><message/></stream:features>"
231 .parse().unwrap();
232 assert_eq!(elem.name(), "features");
233 assert_eq!(
234 elem.ns(),
235 Some("http://etherx.jabber.org/streams".to_owned())
236 );
237 let child = elem.children().next().unwrap();
238 assert_eq!(child.name(), "message");
239 assert_eq!(child.ns(), Some("jabber:client".to_owned()));
240}
241
242#[test]
243fn namespace_inherited_prefixed2() {
244 let elem: Element = "<stream xmlns='http://etherx.jabber.org/streams' xmlns:jabber='jabber:client'><jabber:message/></stream>"
245 .parse().unwrap();
246 assert_eq!(elem.name(), "stream");
247 assert_eq!(
248 elem.ns(),
249 Some("http://etherx.jabber.org/streams".to_owned())
250 );
251 let child = elem.children().next().unwrap();
252 assert_eq!(child.name(), "message");
253 assert_eq!(child.ns(), Some("jabber:client".to_owned()));
254}
255
256#[cfg(feature = "comments")]
257#[test]
258fn read_comments() {
259 let mut reader = Reader::from_str(COMMENT_TEST_STRING);
260 assert_eq!(
261 Element::from_reader(&mut reader).unwrap(),
262 build_comment_test_tree()
263 );
264}
265
266#[cfg(feature = "comments")]
267#[test]
268fn write_comments() {
269 let root = build_comment_test_tree();
270 let mut writer = Vec::new();
271 {
272 root.write_to(&mut writer).unwrap();
273 }
274 assert_eq!(String::from_utf8(writer).unwrap(), COMMENT_TEST_STRING);
275}
276
277#[test]
278fn xml_error() {
279 match "<a></b>".parse::<Element>() {
280 Err(crate::error::Error::XmlError(_)) => (),
281 err => panic!("No or wrong error: {:?}", err),
282 }
283
284 match "<a></".parse::<Element>() {
285 Err(crate::error::Error::XmlError(_)) => (),
286 err => panic!("No or wrong error: {:?}", err),
287 }
288}
289
290#[test]
291fn invalid_element_error() {
292 match "<a:b:c>".parse::<Element>() {
293 Err(crate::error::Error::InvalidElement) => (),
294 err => panic!("No or wrong error: {:?}", err),
295 }
296}