1 #![forbid(unsafe_code)]
2
3 extern crate xml;
4
5 use std::io::{BufReader, SeekFrom};
6 use std::io::prelude::*;
7 use std::fs::File;
8 use std::str;
9
10 use xml::reader::EventReader;
11 use xml::writer::EmitterConfig;
12
13 macro_rules! unwrap_all {
14 ($($e:expr);+) => {{
15 $($e.unwrap();)+
16 }}
17 }
18
19 #[test]
reading_writing_equal_with_namespaces()20 fn reading_writing_equal_with_namespaces() {
21 let mut f = File::open("tests/documents/sample_2.xml").unwrap();
22 let mut b = Vec::new();
23
24 {
25 let r = EventReader::new(BufReader::new(&mut f));
26 let mut w = EmitterConfig::default().perform_indent(true).create_writer(&mut b);
27
28 for e in r {
29 match e {
30 Ok(e) => if let Some(e) = e.as_writer_event() {
31 match w.write(e) {
32 Ok(_) => {},
33 Err(e) => panic!("Writer error: {:?}", e)
34 }
35 },
36 Err(e) => panic!("Error: {}", e)
37 }
38 }
39 }
40
41 f.seek(SeekFrom::Start(0)).unwrap();
42 let mut fs = String::new();
43 f.read_to_string(&mut fs).unwrap();
44
45 let bs = String::from_utf8(b).unwrap();
46
47 assert_eq!(fs.trim(), bs.trim());
48 }
49
50 #[test]
writing_simple()51 fn writing_simple() {
52 use xml::writer::XmlEvent;
53
54 let mut b = Vec::new();
55
56 {
57 let mut w = EmitterConfig::new().write_document_declaration(false).create_writer(&mut b);
58
59 w.write(XmlEvent::start_element("h:hello").ns("h", "urn:hello-world")).unwrap();
60 w.write("hello world").unwrap();
61 w.write(XmlEvent::end_element()).unwrap();
62 }
63
64 assert_eq!(
65 str::from_utf8(&b).unwrap(),
66 r#"<h:hello xmlns:h="urn:hello-world">hello world</h:hello>"#
67 );
68 }
69
70 #[test]
writing_empty_elements_with_normalizing()71 fn writing_empty_elements_with_normalizing() {
72 use xml::writer::XmlEvent;
73
74 let mut b = Vec::new();
75
76 {
77 let mut w = EmitterConfig::new().write_document_declaration(false).create_writer(&mut b);
78
79 unwrap_all! {
80 w.write(XmlEvent::start_element("hello"));
81 w.write(XmlEvent::start_element("world"));
82 w.write(XmlEvent::end_element());
83 w.write(XmlEvent::end_element())
84 }
85 }
86
87 assert_eq!(str::from_utf8(&b).unwrap(), r#"<hello><world /></hello>"#);
88 }
89
90 #[test]
writing_empty_elements_without_normalizing()91 fn writing_empty_elements_without_normalizing() {
92 use xml::writer::XmlEvent;
93
94 let mut b = Vec::new();
95
96 {
97 let mut w = EmitterConfig::new()
98 .write_document_declaration(false)
99 .normalize_empty_elements(false)
100 .create_writer(&mut b);
101
102 unwrap_all! {
103 w.write(XmlEvent::start_element("hello"));
104 w.write(XmlEvent::start_element("world"));
105 w.write(XmlEvent::end_element());
106 w.write(XmlEvent::end_element())
107 }
108 }
109
110 assert_eq!(str::from_utf8(&b).unwrap(), r#"<hello><world></world></hello>"#);
111 }
112
113 #[test]
writing_empty_elements_without_pad_self_closing()114 fn writing_empty_elements_without_pad_self_closing() {
115 use xml::writer::XmlEvent;
116
117 let mut b = Vec::new();
118
119 {
120 let mut w = EmitterConfig::new()
121 .write_document_declaration(false)
122 .pad_self_closing(false)
123 .create_writer(&mut b);
124
125 unwrap_all! {
126 w.write(XmlEvent::start_element("hello"));
127 w.write(XmlEvent::start_element("world"));
128 w.write(XmlEvent::end_element());
129 w.write(XmlEvent::end_element())
130 }
131 }
132
133 assert_eq!(str::from_utf8(&b).unwrap(), r#"<hello><world/></hello>"#);
134 }
135 #[test]
writing_empty_elements_pad_self_closing_explicit()136 fn writing_empty_elements_pad_self_closing_explicit() {
137 use xml::writer::XmlEvent;
138
139 let mut b = Vec::new();
140
141 {
142 let mut w = EmitterConfig::new()
143 .write_document_declaration(false)
144 .pad_self_closing(true)
145 .create_writer(&mut b);
146
147 unwrap_all! {
148 w.write(XmlEvent::start_element("hello"));
149 w.write(XmlEvent::start_element("world"));
150 w.write(XmlEvent::end_element());
151 w.write(XmlEvent::end_element())
152 }
153 }
154
155 assert_eq!(str::from_utf8(&b).unwrap(), r#"<hello><world /></hello>"#);
156 }
157
158 #[test]
writing_comments_with_indentation()159 fn writing_comments_with_indentation() {
160 use xml::writer::XmlEvent;
161
162 let mut b = Vec::new();
163
164 {
165 let mut w = EmitterConfig::new()
166 .write_document_declaration(false)
167 .perform_indent(true)
168 .create_writer(&mut b);
169
170 unwrap_all! {
171 w.write(XmlEvent::start_element("hello"));
172 w.write(XmlEvent::start_element("world"));
173 w.write(XmlEvent::comment(" this is a manually padded comment\t"));
174 w.write(XmlEvent::comment("this is an unpadded comment"));
175 w.write(XmlEvent::end_element());
176 w.write(XmlEvent::end_element())
177 }
178 }
179
180 assert_eq!(
181 str::from_utf8(&b).unwrap(),
182 "<hello>
183 <world>
184 <!-- this is a manually padded comment\t-->
185 <!-- this is an unpadded comment -->
186 </world>
187 </hello>");
188 }
189
190 #[test]
issue_112_overriding_namepace_prefix()191 fn issue_112_overriding_namepace_prefix() {
192 use xml::writer::XmlEvent;
193
194 let mut b = Vec::new();
195
196 {
197 let mut w = EmitterConfig::new()
198 .write_document_declaration(false)
199 .create_writer(&mut b);
200
201 unwrap_all! {
202 w.write(XmlEvent::start_element("iq").ns("", "jabber:client").ns("a", "urn:A"));
203 w.write(XmlEvent::start_element("bind").ns("", "urn:ietf:params:xml:ns:xmpp-bind"));
204 w.write(XmlEvent::end_element());
205 w.write(XmlEvent::start_element("whatever").ns("a", "urn:X"));
206 w.write(XmlEvent::end_element());
207 w.write(XmlEvent::end_element())
208 }
209 }
210
211 assert_eq!(
212 str::from_utf8(&b).unwrap(),
213 r#"<iq xmlns="jabber:client" xmlns:a="urn:A"><bind xmlns="urn:ietf:params:xml:ns:xmpp-bind" /><whatever xmlns:a="urn:X" /></iq>"#
214 )
215 }
216
217 #[test]
attribute_escaping()218 fn attribute_escaping() {
219 use xml::writer::XmlEvent;
220
221 let mut b = Vec::new();
222
223 {
224 let mut w = EmitterConfig::new()
225 .write_document_declaration(false)
226 .perform_indent(true)
227 .create_writer(&mut b);
228
229 unwrap_all! {
230 w.write(
231 XmlEvent::start_element("hello")
232 .attr("testLt", "<")
233 .attr("testGt", ">")
234 );
235 w.write(XmlEvent::end_element());
236 w.write(
237 XmlEvent::start_element("hello")
238 .attr("testQuot", "\"")
239 .attr("testApos", "\'")
240 );
241 w.write(XmlEvent::end_element());
242 w.write(
243 XmlEvent::start_element("hello")
244 .attr("testAmp", "&")
245 );
246 w.write(XmlEvent::end_element());
247 w.write(
248 XmlEvent::start_element("hello")
249 .attr("testNl", "\n")
250 .attr("testCr", "\r")
251 );
252 w.write(XmlEvent::end_element());
253 w.write(
254 XmlEvent::start_element("hello")
255 .attr("testNl", "\\n")
256 .attr("testCr", "\\r")
257 );
258 w.write(XmlEvent::end_element())
259 }
260 }
261 assert_eq!(
262 str::from_utf8(&b).unwrap(),
263 "<hello testLt=\"<\" testGt=\">\" />
264 <hello testQuot=\""\" testApos=\"'\" />
265 <hello testAmp=\"&\" />
266 <hello testNl=\"
\" testCr=\"
\" />
267 <hello testNl=\"\\n\" testCr=\"\\r\" />"
268 );
269 }