1 #![feature(test)]
2 
3 extern crate quick_xml;
4 extern crate test;
5 
6 use quick_xml::events::Event;
7 use quick_xml::Reader;
8 use test::Bencher;
9 
10 #[bench]
bench_quick_xml_normal(b: &mut Bencher)11 fn bench_quick_xml_normal(b: &mut Bencher) {
12     let src: &[u8] = include_bytes!("../tests/sample_rss.xml");
13     b.iter(|| {
14         let mut r = Reader::from_reader(src);
15         r.check_end_names(false).check_comments(false);
16         let mut count = test::black_box(0);
17         let mut buf = Vec::new();
18         loop {
19             match r.read_event(&mut buf) {
20                 Ok(Event::Start(_)) | Ok(Event::Empty(_)) => count += 1,
21                 Ok(Event::Eof) => break,
22                 _ => (),
23             }
24             buf.clear();
25         }
26         assert_eq!(count, 1550);
27     });
28 }
29 
30 #[bench]
bench_quick_xml_namespaced(b: &mut Bencher)31 fn bench_quick_xml_namespaced(b: &mut Bencher) {
32     let src: &[u8] = include_bytes!("../tests/sample_rss.xml");
33     b.iter(|| {
34         let mut r = Reader::from_reader(src);
35         r.check_end_names(false).check_comments(false);
36         let mut count = test::black_box(0);
37         let mut buf = Vec::new();
38         let mut ns_buf = Vec::new();
39         loop {
40             match r.read_namespaced_event(&mut buf, &mut ns_buf) {
41                 Ok((_, Event::Start(_))) | Ok((_, Event::Empty(_))) => count += 1,
42                 Ok((_, Event::Eof)) => break,
43                 _ => (),
44             }
45             buf.clear();
46         }
47         assert_eq!(count, 1550);
48     });
49 }
50 
51 #[bench]
bench_quick_xml_escaped(b: &mut Bencher)52 fn bench_quick_xml_escaped(b: &mut Bencher) {
53     let src: &[u8] = include_bytes!("../tests/sample_rss.xml");
54     b.iter(|| {
55         let mut buf = Vec::new();
56         let mut r = Reader::from_reader(src);
57         r.check_end_names(false).check_comments(false);
58         let mut count = test::black_box(0);
59         let mut nbtxt = test::black_box(0);
60         loop {
61             match r.read_event(&mut buf) {
62                 Ok(Event::Start(_)) | Ok(Event::Empty(_)) => count += 1,
63                 Ok(Event::Text(ref e)) => nbtxt += e.unescaped().unwrap().len(),
64                 Ok(Event::Eof) => break,
65                 _ => (),
66             }
67             buf.clear();
68         }
69         assert_eq!(count, 1550);
70 
71         // Windows has \r\n instead of \n
72         #[cfg(windows)]
73         assert_eq!(nbtxt, 67661);
74 
75         #[cfg(not(windows))]
76         assert_eq!(nbtxt, 66277);
77     });
78 }
79 
80 #[bench]
bench_quick_xml_normal_trimmed(b: &mut Bencher)81 fn bench_quick_xml_normal_trimmed(b: &mut Bencher) {
82     let src: &[u8] = include_bytes!("../tests/sample_rss.xml");
83     b.iter(|| {
84         let mut r = Reader::from_reader(src);
85         r.check_end_names(false)
86             .check_comments(false)
87             .trim_text(true);
88         let mut count = test::black_box(0);
89         let mut buf = Vec::new();
90         loop {
91             match r.read_event(&mut buf) {
92                 Ok(Event::Start(_)) | Ok(Event::Empty(_)) => count += 1,
93                 Ok(Event::Eof) => break,
94                 _ => (),
95             }
96             buf.clear();
97         }
98         assert_eq!(count, 1550);
99     });
100 }
101 
102 #[bench]
bench_quick_xml_namespaced_trimmed(b: &mut Bencher)103 fn bench_quick_xml_namespaced_trimmed(b: &mut Bencher) {
104     let src: &[u8] = include_bytes!("../tests/sample_rss.xml");
105     b.iter(|| {
106         let mut r = Reader::from_reader(src);
107         r.check_end_names(false)
108             .check_comments(false)
109             .trim_text(true);
110         let mut count = test::black_box(0);
111         let mut buf = Vec::new();
112         let mut ns_buf = Vec::new();
113         loop {
114             match r.read_namespaced_event(&mut buf, &mut ns_buf) {
115                 Ok((_, Event::Start(_))) | Ok((_, Event::Empty(_))) => count += 1,
116                 Ok((_, Event::Eof)) => break,
117                 _ => (),
118             }
119             buf.clear();
120         }
121         assert_eq!(count, 1550);
122     });
123 }
124 
125 #[bench]
bench_quick_xml_escaped_trimmed(b: &mut Bencher)126 fn bench_quick_xml_escaped_trimmed(b: &mut Bencher) {
127     let src: &[u8] = include_bytes!("../tests/sample_rss.xml");
128     b.iter(|| {
129         let mut buf = Vec::new();
130         let mut r = Reader::from_reader(src);
131         r.check_end_names(false)
132             .check_comments(false)
133             .trim_text(true);
134         let mut count = test::black_box(0);
135         let mut nbtxt = test::black_box(0);
136         loop {
137             match r.read_event(&mut buf) {
138                 Ok(Event::Start(_)) | Ok(Event::Empty(_)) => count += 1,
139                 Ok(Event::Text(ref e)) => nbtxt += e.unescaped().unwrap().len(),
140                 Ok(Event::Eof) => break,
141                 _ => (),
142             }
143             buf.clear();
144         }
145         assert_eq!(count, 1550);
146 
147         // Windows has \r\n instead of \n
148         #[cfg(windows)]
149         assert_eq!(nbtxt, 50334);
150 
151         #[cfg(not(windows))]
152         assert_eq!(nbtxt, 50261);
153     });
154 }
155 
156 #[bench]
bench_quick_xml_one_text_event(b: &mut Bencher)157 fn bench_quick_xml_one_text_event(b: &mut Bencher) {
158     let src = "Hello world!".repeat(512 / 12).into_bytes();
159     let mut buf = Vec::with_capacity(1024);
160     b.iter(|| {
161         let mut r = Reader::from_reader(src.as_ref());
162         let mut nbtxt = test::black_box(0);
163         r.check_end_names(false).check_comments(false);
164         match r.read_event(&mut buf) {
165             Ok(Event::Text(ref e)) => nbtxt += e.unescaped().unwrap().len(),
166             something_else => panic!("Did not expect {:?}", something_else),
167         };
168 
169         buf.clear();
170 
171         assert_eq!(nbtxt, 504);
172     })
173 }
174 
175 #[bench]
bench_quick_xml_one_start_event_trimmed(b: &mut Bencher)176 fn bench_quick_xml_one_start_event_trimmed(b: &mut Bencher) {
177     let src = format!(r#"<hello target="{}">"#, "world".repeat(512 / 5)).into_bytes();
178     let mut buf = Vec::with_capacity(1024);
179     b.iter(|| {
180         let mut r = Reader::from_reader(src.as_ref());
181         let mut nbtxt = test::black_box(0);
182         r.check_end_names(false)
183             .check_comments(false)
184             .trim_text(true);
185         match r.read_event(&mut buf) {
186             Ok(Event::Start(ref e)) => nbtxt += e.unescaped().unwrap().len(),
187             something_else => panic!("Did not expect {:?}", something_else),
188         };
189 
190         buf.clear();
191 
192         assert_eq!(nbtxt, 525);
193     })
194 }
195 
196 #[bench]
bench_quick_xml_one_comment_event_trimmed(b: &mut Bencher)197 fn bench_quick_xml_one_comment_event_trimmed(b: &mut Bencher) {
198     let src = format!(r#"<!-- hello "{}" -->"#, "world".repeat(512 / 5)).into_bytes();
199     let mut buf = Vec::with_capacity(1024);
200     b.iter(|| {
201         let mut r = Reader::from_reader(src.as_ref());
202         let mut nbtxt = test::black_box(0);
203         r.check_end_names(false)
204             .check_comments(false)
205             .trim_text(true);
206         match r.read_event(&mut buf) {
207             Ok(Event::Comment(ref e)) => nbtxt += e.unescaped().unwrap().len(),
208             something_else => panic!("Did not expect {:?}", something_else),
209         };
210 
211         buf.clear();
212 
213         assert_eq!(nbtxt, 520);
214     })
215 }
216 
217 #[bench]
bench_quick_xml_one_cdata_event_trimmed(b: &mut Bencher)218 fn bench_quick_xml_one_cdata_event_trimmed(b: &mut Bencher) {
219     let src = format!(r#"<![CDATA[hello "{}"]]>"#, "world".repeat(512 / 5)).into_bytes();
220     let mut buf = Vec::with_capacity(1024);
221     b.iter(|| {
222         let mut r = Reader::from_reader(src.as_ref());
223         let mut nbtxt = test::black_box(0);
224         r.check_end_names(false)
225             .check_comments(false)
226             .trim_text(true);
227         match r.read_event(&mut buf) {
228             Ok(Event::CData(ref e)) => nbtxt += e.unescaped().unwrap().len(),
229             something_else => panic!("Did not expect {:?}", something_else),
230         };
231 
232         buf.clear();
233 
234         assert_eq!(nbtxt, 518);
235     })
236 }
237