1use std::iter::Iterator;
  2
  3use quick_xml::reader::Reader;
  4
  5use element::Element;
  6
  7const TEST_STRING: &'static str = r#"<?xml version="1.0" encoding="utf-8"?><root xmlns="root_ns" a="b" xml:lang="en">meow<child c="d" /><child xmlns="child_ns" d="e" xml:lang="fr" />nya</root>"#;
  8
  9fn build_test_tree() -> Element {
 10    let mut root = Element::builder("root")
 11                           .ns("root_ns")
 12                           .attr("xml:lang", "en")
 13                           .attr("a", "b")
 14                           .build();
 15    root.append_text_node("meow");
 16    let child = Element::builder("child")
 17                        .attr("c", "d")
 18                        .build();
 19    root.append_child(child);
 20    let other_child = Element::builder("child")
 21                              .ns("child_ns")
 22                              .attr("d", "e")
 23                              .attr("xml:lang", "fr")
 24                              .build();
 25    root.append_child(other_child);
 26    root.append_text_node("nya");
 27    root
 28}
 29
 30#[test]
 31fn reader_works() {
 32    let mut reader = Reader::from_str(TEST_STRING);
 33    assert_eq!(Element::from_reader(&mut reader).unwrap(), build_test_tree());
 34}
 35
 36#[test]
 37fn writer_works() {
 38    let root = build_test_tree();
 39    let mut writer = Vec::new();
 40    {
 41        root.write_to(&mut writer).unwrap();
 42    }
 43    assert_eq!(String::from_utf8(writer).unwrap(), TEST_STRING);
 44}
 45
 46#[test]
 47fn writer_escapes_attributes() {
 48    let root = Element::builder("root")
 49        .attr("a", "\"Air\" quotes")
 50        .build();
 51    let mut writer = Vec::new();
 52    {
 53        root.write_to(&mut writer).unwrap();
 54    }
 55    assert_eq!(String::from_utf8(writer).unwrap(),
 56               r#"<?xml version="1.0" encoding="utf-8"?><root a="&quot;Air&quot; quotes" />"#
 57    );
 58}
 59
 60#[test]
 61fn writer_escapes_text() {
 62    let root = Element::builder("root")
 63        .append("<3")
 64        .build();
 65    let mut writer = Vec::new();
 66    {
 67        root.write_to(&mut writer).unwrap();
 68    }
 69    assert_eq!(String::from_utf8(writer).unwrap(),
 70               r#"<?xml version="1.0" encoding="utf-8"?><root>&lt;3</root>"#
 71    );
 72}
 73
 74#[test]
 75fn builder_works() {
 76    let elem = Element::builder("a")
 77                       .ns("b")
 78                       .attr("c", "d")
 79                       .append(Element::builder("child"))
 80                       .append("e")
 81                       .build();
 82    assert_eq!(elem.name(), "a");
 83    assert_eq!(elem.ns(), Some("b".to_owned()));
 84    assert_eq!(elem.attr("c"), Some("d"));
 85    assert_eq!(elem.attr("x"), None);
 86    assert_eq!(elem.text(), "e");
 87    assert!(elem.has_child("child", "b"));
 88    assert!(elem.is("a", "b"));
 89}
 90
 91#[test]
 92fn children_iter_works() {
 93    let root = build_test_tree();
 94    let mut iter = root.children();
 95    assert!(iter.next().unwrap().is("child", "root_ns"));
 96    assert!(iter.next().unwrap().is("child", "child_ns"));
 97    assert_eq!(iter.next(), None);
 98}
 99
100#[test]
101fn get_child_works() {
102    let root = build_test_tree();
103    assert_eq!(root.get_child("child", "inexistent_ns"), None);
104    assert_eq!(root.get_child("not_a_child", "root_ns"), None);
105    assert!(root.get_child("child", "root_ns").unwrap().is("child", "root_ns"));
106    assert!(root.get_child("child", "child_ns").unwrap().is("child", "child_ns"));
107    assert_eq!(root.get_child("child", "root_ns").unwrap().attr("c"), Some("d"));
108    assert_eq!(root.get_child("child", "child_ns").unwrap().attr("d"), Some("e"));
109}
110
111#[test]
112fn namespace_propagation_works() {
113    let mut root = Element::builder("root").ns("root_ns").build();
114    let mut child = Element::bare("child");
115    let grandchild = Element::bare("grandchild");
116    child.append_child(grandchild);
117    root.append_child(child);
118
119    assert_eq!(root.get_child("child", "root_ns").unwrap().ns(), root.ns());
120    assert_eq!(root.get_child("child", "root_ns").unwrap()
121                   .get_child("grandchild", "root_ns").unwrap()
122                   .ns(), root.ns());
123}
124
125#[test]
126fn two_elements_with_same_arguments_different_order_are_equal() {
127    let elem1: Element = "<a b='a' c=''/>".parse().unwrap();
128    let elem2: Element = "<a c='' b='a'/>".parse().unwrap();
129    assert_eq!(elem1, elem2);
130
131    let elem1: Element = "<a b='a' c=''/>".parse().unwrap();
132    let elem2: Element = "<a c='d' b='a'/>".parse().unwrap();
133    assert_ne!(elem1, elem2);
134}
135
136#[test]
137fn namespace_attributes_works() {
138    let mut reader = Reader::from_str(TEST_STRING);
139    let root = Element::from_reader(&mut reader).unwrap();
140    assert_eq!("en", root.attr("xml:lang").unwrap());
141    assert_eq!("fr", root.get_child("child", "child_ns").unwrap().attr("xml:lang").unwrap());
142}
143
144#[test]
145fn wrongly_closed_elements_error() {
146    let elem1 = "<a></b>".parse::<Element>();
147    assert!(elem1.is_err());
148    let elem1 = "<a></c></a>".parse::<Element>();
149    assert!(elem1.is_err());
150    let elem1 = "<a><c><d/></c></a>".parse::<Element>();
151    assert!(elem1.is_ok());
152}
153
154#[test]
155fn namespace_simple() {
156    let elem: Element = "<message xmlns='jabber:client'/>".parse().unwrap();
157    assert_eq!(elem.name(), "message");
158    assert_eq!(elem.ns(), Some("jabber:client".to_owned()));
159}
160
161#[test]
162fn namespace_prefixed() {
163    let elem: Element = "<stream:features xmlns:stream='http://etherx.jabber.org/streams'/>"
164        .parse().unwrap();
165    assert_eq!(elem.name(), "features");
166    assert_eq!(elem.ns(), Some("http://etherx.jabber.org/streams".to_owned()));
167}
168
169#[test]
170fn namespace_inherited_simple() {
171    let elem: Element = "<stream xmlns='jabber:client'><message/></stream>".parse().unwrap();
172    assert_eq!(elem.name(), "stream");
173    assert_eq!(elem.ns(), Some("jabber:client".to_owned()));
174    let child = elem.children().next().unwrap();
175    assert_eq!(child.name(), "message");
176    assert_eq!(child.ns(), Some("jabber:client".to_owned()));
177}
178
179#[test]
180fn namespace_inherited_prefixed1() {
181    let elem: Element = "<stream:features xmlns:stream='http://etherx.jabber.org/streams' xmlns='jabber:client'><message/></stream:features>"
182        .parse().unwrap();
183    assert_eq!(elem.name(), "features");
184    assert_eq!(elem.ns(), Some("http://etherx.jabber.org/streams".to_owned()));
185    let child = elem.children().next().unwrap();
186    assert_eq!(child.name(), "message");
187    assert_eq!(child.ns(), Some("jabber:client".to_owned()));
188}
189
190#[test]
191fn namespace_inherited_prefixed2() {
192    let elem: Element = "<stream xmlns='http://etherx.jabber.org/streams' xmlns:jabber='jabber:client'><jabber:message/></stream>"
193        .parse().unwrap();
194    assert_eq!(elem.name(), "stream");
195    assert_eq!(elem.ns(), Some("http://etherx.jabber.org/streams".to_owned()));
196    let child = elem.children().next().unwrap();
197    assert_eq!(child.name(), "message");
198    assert_eq!(child.ns(), Some("jabber:client".to_owned()));
199}