Commit | Line | Data |
---|---|---|
0e23f538 TJ |
1 | /* |
2 | The software in this package is distributed under the GNU General | |
3 | Public License version 2 (with a special exception described below). | |
4 | ||
5 | A copy of GNU General Public License (GPL) is included in this distribution, | |
6 | in the file COPYING.GPL. | |
7 | ||
8 | As a special exception, if other files instantiate templates or use macros | |
9 | or inline functions from this file, or you compile this file and link it | |
10 | with other works to produce a work based on this file, this file | |
11 | does not by itself cause the resulting work to be covered | |
12 | by the GNU General Public License. | |
13 | ||
14 | However the source code for this file must still be made available | |
15 | in accordance with section (3) of the GNU General Public License. | |
16 | ||
17 | This exception does not invalidate any other reasons why a work based | |
18 | on this file might be covered by the GNU General Public License. | |
19 | */ | |
118e216e | 20 | /*************************************************************************** |
652f47a7 | 21 | * Copyright (C) 2006-2011 by Intra2net AG * |
118e216e TJ |
22 | * * |
23 | ***************************************************************************/ | |
24 | ||
25 | // #include <iostream> | |
26 | #include <string> | |
d435d600 | 27 | #include <cmath> |
118e216e TJ |
28 | // #include <sstream> |
29 | // #include <stdexcept> | |
30 | ||
9fe0853b TJ |
31 | #define BOOST_TEST_DYN_LINK |
32 | #include <boost/test/unit_test.hpp> | |
67a3dacb | 33 | #include <boost/foreach.hpp> |
d435d600 | 34 | #include <boost/numeric/conversion/cast.hpp> |
118e216e TJ |
35 | |
36 | #include <stringfunc.hxx> | |
57e78ccd | 37 | #include <containerfunc.hpp> |
3bcc713f | 38 | #include <iostream> |
99e07fab | 39 | #include <stdint.h> |
118e216e TJ |
40 | |
41 | using namespace std; | |
57e78ccd | 42 | using namespace I2n; |
118e216e | 43 | |
9fe0853b TJ |
44 | typedef std::list< std::string > StringList; |
45 | ||
46 | BOOST_AUTO_TEST_SUITE(stringfunc) | |
47 | ||
1f3aa42a | 48 | BOOST_AUTO_TEST_CASE(smart_html_entities1) |
9fe0853b TJ |
49 | { |
50 | string output = smart_html_entities("Test"); | |
51 | ||
52 | BOOST_CHECK_EQUAL(string("Test"), output); | |
53 | } | |
54 | ||
1f3aa42a | 55 | BOOST_AUTO_TEST_CASE(smart_html_entities2) |
9fe0853b TJ |
56 | { |
57 | string output = smart_html_entities("Täst"); | |
58 | ||
59 | BOOST_CHECK_EQUAL(string("Täst"), output); | |
60 | } | |
61 | ||
1f3aa42a | 62 | BOOST_AUTO_TEST_CASE(smart_html_entities3) |
9fe0853b TJ |
63 | { |
64 | string output = smart_html_entities("<>"); | |
65 | ||
66 | BOOST_CHECK_EQUAL(string("<>"), output); | |
67 | } | |
68 | ||
1f3aa42a | 69 | BOOST_AUTO_TEST_CASE(smart_html_entities4) |
9fe0853b TJ |
70 | { |
71 | string output = smart_html_entities("<ümlaut>"); | |
72 | ||
73 | BOOST_CHECK_EQUAL(string("<ümlaut>"), output); | |
74 | } | |
75 | ||
1f3aa42a | 76 | BOOST_AUTO_TEST_CASE(smart_html_entities5) |
9fe0853b TJ |
77 | { |
78 | string output = smart_html_entities("Test<ümlaut>Blä"); | |
79 | ||
80 | BOOST_CHECK_EQUAL(string("Test<ümlaut>Blä"), output); | |
81 | } | |
82 | ||
1f3aa42a | 83 | BOOST_AUTO_TEST_CASE(smart_html_entities6) |
9fe0853b TJ |
84 | { |
85 | string output = smart_html_entities("System > Einstellungen"); | |
86 | ||
87 | BOOST_CHECK_EQUAL(string("System > Einstellungen"), output); | |
88 | } | |
89 | ||
1f3aa42a | 90 | BOOST_AUTO_TEST_CASE(smart_html_entities7) |
9fe0853b TJ |
91 | { |
92 | string output = smart_html_entities("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">\"System > Einstellungen\"</a>. Oder etwa nicht?"); | |
93 | ||
94 | BOOST_CHECK_EQUAL(string("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">"System > Einstellungen"</a>. Oder etwa nicht?"), output); | |
95 | } | |
96 | ||
97 | BOOST_AUTO_TEST_CASE(strip_html_tags1) | |
98 | { | |
99 | string output = strip_html_tags("Was für ein schöner Tag, finden Sie nicht?"); | |
100 | ||
101 | BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output); | |
102 | } | |
103 | ||
104 | BOOST_AUTO_TEST_CASE(strip_html_tags2) | |
105 | { | |
106 | string output = strip_html_tags("Was für ein <a href=\"wikipedia\" target=\"new\">schöner Tag</a>, finden Sie nicht?"); | |
107 | ||
108 | BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output); | |
109 | } | |
110 | ||
8b06a5c9 GMF |
111 | |
112 | ||
9fe0853b TJ |
113 | BOOST_AUTO_TEST_CASE(html_entities1) |
114 | { | |
115 | string output = html_entities("\xC3\xA4\xC3\xB6\xC3\xBC"); | |
116 | BOOST_CHECK_EQUAL(string("äöü"), output); | |
117 | } | |
118 | ||
119 | BOOST_AUTO_TEST_CASE(html_entities2) | |
120 | { | |
121 | string output = html_entities("\xC3\xA5 \xC3\xB5 \xC3\xBF"); | |
122 | BOOST_CHECK_EQUAL(string("å õ ÿ"), output); | |
123 | } | |
124 | ||
125 | BOOST_AUTO_TEST_CASE(html_entities3) | |
126 | { | |
127 | string output = html_entities("\xC4\x8E \xE0\xBC\xB1 \xE8\x82\x88"); | |
128 | BOOST_CHECK_EQUAL(string("Ď ༱ 肈"), output); | |
129 | } | |
130 | ||
dfc07029 PG |
131 | BOOST_AUTO_TEST_CASE(entities_latin1) |
132 | { | |
133 | BOOST_CHECK_EQUAL((std::string)"noop", html_entities_iso ("noop")); | |
134 | BOOST_CHECK_EQUAL((std::string)"täst", html_entities_iso ("t\xe4st")); | |
135 | BOOST_CHECK_EQUAL((std::string)"TÄST", html_entities_iso ("T\xc4ST")); | |
136 | } | |
8b06a5c9 GMF |
137 | |
138 | ||
388626dc GMF |
139 | BOOST_AUTO_TEST_CASE(nice_unit_format1) |
140 | { | |
141 | const int64_t two_bytes = 2; | |
8b06a5c9 | 142 | |
70fc0674 | 143 | string output = nice_unit_format(two_bytes, LongUnitFormat, UnitBase1000); |
388626dc | 144 | BOOST_CHECK_EQUAL(string("2.00 Bytes"), output); |
8b06a5c9 | 145 | |
4388cc08 | 146 | output = nice_unit_format(two_bytes); |
8b06a5c9 | 147 | BOOST_CHECK_EQUAL(string("2.0 B"), output); |
388626dc GMF |
148 | } |
149 | ||
150 | BOOST_AUTO_TEST_CASE(nice_unit_format2) | |
151 | { | |
152 | const int64_t two_kilobytes = 2000; | |
8b06a5c9 | 153 | |
70fc0674 | 154 | string output = nice_unit_format(two_kilobytes, LongUnitFormat, UnitBase1000); |
388626dc GMF |
155 | BOOST_CHECK_EQUAL(string("2.00 KBytes"), output); |
156 | ||
4388cc08 | 157 | output = nice_unit_format(two_kilobytes); |
8b06a5c9 GMF |
158 | BOOST_CHECK_EQUAL(string("2.0 KB"), output); |
159 | ||
d435d600 CH |
160 | output = nice_unit_format(boost::numeric_cast<double>(two_kilobytes), LongUnitFormat, UnitBase1000); |
161 | BOOST_CHECK_EQUAL(string("2.00 KBytes"), output); | |
162 | ||
163 | output = nice_unit_format(boost::numeric_cast<double>(two_kilobytes)); | |
164 | BOOST_CHECK_EQUAL(string("2.0 KB"), output); | |
165 | ||
388626dc | 166 | const int64_t two_and_half_kilobytes = 2500; |
8b06a5c9 | 167 | |
70fc0674 | 168 | output = nice_unit_format(two_and_half_kilobytes, LongUnitFormat, UnitBase1000); |
388626dc | 169 | BOOST_CHECK_EQUAL(string("2.50 KBytes"), output); |
8b06a5c9 | 170 | |
4388cc08 | 171 | output = nice_unit_format(two_and_half_kilobytes); |
8b06a5c9 | 172 | BOOST_CHECK_EQUAL(string("2.4 KB"), output); |
d435d600 CH |
173 | |
174 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_kilobytes), LongUnitFormat, UnitBase1000); | |
175 | BOOST_CHECK_EQUAL(string("2.50 KBytes"), output); | |
176 | ||
177 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_kilobytes)); | |
178 | BOOST_CHECK_EQUAL(string("2.4 KB"), output); | |
388626dc GMF |
179 | } |
180 | ||
181 | BOOST_AUTO_TEST_CASE(nice_unit_format3) | |
182 | { | |
183 | const int64_t two_megabytes = 2000000; | |
8b06a5c9 | 184 | |
70fc0674 | 185 | string output = nice_unit_format(two_megabytes, LongUnitFormat, UnitBase1000); |
388626dc GMF |
186 | BOOST_CHECK_EQUAL(string("2.00 MBytes"), output); |
187 | ||
4388cc08 | 188 | output = nice_unit_format(two_megabytes); |
8b06a5c9 GMF |
189 | BOOST_CHECK_EQUAL(string("1.9 MB"), output); |
190 | ||
d435d600 CH |
191 | output = nice_unit_format(boost::numeric_cast<double>(two_megabytes), LongUnitFormat, UnitBase1000); |
192 | BOOST_CHECK_EQUAL(string("2.00 MBytes"), output); | |
193 | ||
194 | output = nice_unit_format(boost::numeric_cast<double>(two_megabytes)); | |
195 | BOOST_CHECK_EQUAL(string("1.9 MB"), output); | |
196 | ||
388626dc | 197 | const int64_t two_and_half_megabytes = 2500000; |
8b06a5c9 | 198 | |
70fc0674 | 199 | output = nice_unit_format(two_and_half_megabytes, LongUnitFormat, UnitBase1000); |
388626dc | 200 | BOOST_CHECK_EQUAL(string("2.50 MBytes"), output); |
8b06a5c9 | 201 | |
4388cc08 | 202 | output = nice_unit_format(two_and_half_megabytes); |
8b06a5c9 GMF |
203 | BOOST_CHECK_EQUAL(string("2.4 MB"), output); |
204 | ||
d435d600 CH |
205 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_megabytes), LongUnitFormat, UnitBase1000); |
206 | BOOST_CHECK_EQUAL(string("2.50 MBytes"), output); | |
207 | ||
208 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_megabytes)); | |
209 | BOOST_CHECK_EQUAL(string("2.4 MB"), output); | |
210 | ||
388626dc GMF |
211 | } |
212 | ||
213 | BOOST_AUTO_TEST_CASE(nice_unit_format4) | |
214 | { | |
215 | const int64_t two_gigabytes = 2000000000LL; | |
8b06a5c9 | 216 | |
70fc0674 | 217 | string output = nice_unit_format(two_gigabytes, LongUnitFormat, UnitBase1000); |
388626dc GMF |
218 | BOOST_CHECK_EQUAL(string("2.00 GBytes"), output); |
219 | ||
4388cc08 | 220 | output = nice_unit_format(two_gigabytes); |
8b06a5c9 GMF |
221 | BOOST_CHECK_EQUAL(string("1.9 GB"), output); |
222 | ||
d435d600 CH |
223 | output = nice_unit_format(boost::numeric_cast<double>(two_gigabytes), LongUnitFormat, UnitBase1000); |
224 | BOOST_CHECK_EQUAL(string("2.00 GBytes"), output); | |
225 | ||
226 | output = nice_unit_format(boost::numeric_cast<double>(two_gigabytes)); | |
227 | BOOST_CHECK_EQUAL(string("1.9 GB"), output); | |
228 | ||
388626dc | 229 | const int64_t two_and_half_gigabytes = 2500000000LL; |
8b06a5c9 | 230 | |
70fc0674 | 231 | output = nice_unit_format(two_and_half_gigabytes, LongUnitFormat, UnitBase1000); |
388626dc | 232 | BOOST_CHECK_EQUAL(string("2.50 GBytes"), output); |
8b06a5c9 | 233 | |
4388cc08 | 234 | output = nice_unit_format(two_and_half_gigabytes); |
8b06a5c9 | 235 | BOOST_CHECK_EQUAL(string("2.3 GB"), output); |
d435d600 CH |
236 | |
237 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_gigabytes), LongUnitFormat, UnitBase1000); | |
238 | BOOST_CHECK_EQUAL(string("2.50 GBytes"), output); | |
239 | ||
240 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_gigabytes)); | |
241 | BOOST_CHECK_EQUAL(string("2.3 GB"), output); | |
388626dc GMF |
242 | } |
243 | ||
244 | BOOST_AUTO_TEST_CASE(nice_unit_format5) | |
245 | { | |
246 | const int64_t two_terabytes = 2000000000000LL; | |
8b06a5c9 | 247 | |
70fc0674 | 248 | string output = nice_unit_format(two_terabytes, LongUnitFormat, UnitBase1000); |
388626dc GMF |
249 | BOOST_CHECK_EQUAL(string("2.00 TBytes"), output); |
250 | ||
4388cc08 | 251 | output = nice_unit_format(two_terabytes); |
8b06a5c9 GMF |
252 | BOOST_CHECK_EQUAL(string("1.8 TB"), output); |
253 | ||
d435d600 CH |
254 | output = nice_unit_format(boost::numeric_cast<double>(two_terabytes), LongUnitFormat, UnitBase1000); |
255 | BOOST_CHECK_EQUAL(string("2.00 TBytes"), output); | |
256 | ||
257 | output = nice_unit_format(boost::numeric_cast<double>(two_terabytes)); | |
258 | BOOST_CHECK_EQUAL(string("1.8 TB"), output); | |
259 | ||
388626dc | 260 | const int64_t two_and_half_terabytes = 2500000000000LL; |
8b06a5c9 | 261 | |
70fc0674 | 262 | output = nice_unit_format(two_and_half_terabytes, LongUnitFormat, UnitBase1000); |
388626dc | 263 | BOOST_CHECK_EQUAL(string("2.50 TBytes"), output); |
8b06a5c9 | 264 | |
4388cc08 | 265 | output = nice_unit_format(two_and_half_terabytes); |
8b06a5c9 | 266 | BOOST_CHECK_EQUAL(string("2.3 TB"), output); |
d435d600 CH |
267 | |
268 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_terabytes), LongUnitFormat, UnitBase1000); | |
269 | BOOST_CHECK_EQUAL(string("2.50 TBytes"), output); | |
270 | ||
271 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_terabytes)); | |
272 | BOOST_CHECK_EQUAL(string("2.3 TB"), output); | |
388626dc GMF |
273 | } |
274 | ||
275 | BOOST_AUTO_TEST_CASE(nice_unit_format6) | |
276 | { | |
277 | const int64_t two_petabytes = 2000000000000000LL; | |
8b06a5c9 | 278 | |
70fc0674 | 279 | string output = nice_unit_format(two_petabytes, LongUnitFormat, UnitBase1000); |
388626dc GMF |
280 | BOOST_CHECK_EQUAL(string("2.00 PBytes"), output); |
281 | ||
4388cc08 | 282 | output = nice_unit_format(two_petabytes); |
8b06a5c9 GMF |
283 | BOOST_CHECK_EQUAL(string("1.8 PB"), output); |
284 | ||
d435d600 CH |
285 | output = nice_unit_format(boost::numeric_cast<double>(two_petabytes), LongUnitFormat, UnitBase1000); |
286 | BOOST_CHECK_EQUAL(string("2.00 PBytes"), output); | |
287 | ||
288 | output = nice_unit_format(boost::numeric_cast<double>(two_petabytes)); | |
289 | BOOST_CHECK_EQUAL(string("1.8 PB"), output); | |
290 | ||
388626dc | 291 | const int64_t two_and_half_petabytes = 2500000000000000LL; |
8b06a5c9 | 292 | |
70fc0674 | 293 | output = nice_unit_format(two_and_half_petabytes, LongUnitFormat, UnitBase1000); |
388626dc | 294 | BOOST_CHECK_EQUAL(string("2.50 PBytes"), output); |
8b06a5c9 | 295 | |
4388cc08 | 296 | output = nice_unit_format(two_and_half_petabytes); |
8b06a5c9 | 297 | BOOST_CHECK_EQUAL(string("2.2 PB"), output); |
d435d600 CH |
298 | |
299 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_petabytes), LongUnitFormat, UnitBase1000); | |
300 | BOOST_CHECK_EQUAL(string("2.50 PBytes"), output); | |
301 | ||
302 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_petabytes)); | |
303 | BOOST_CHECK_EQUAL(string("2.2 PB"), output); | |
388626dc GMF |
304 | } |
305 | ||
306 | BOOST_AUTO_TEST_CASE(nice_unit_format7) | |
307 | { | |
308 | const int64_t two_exabytes = 2000000000000000000LL; | |
8b06a5c9 | 309 | |
70fc0674 | 310 | string output = nice_unit_format(two_exabytes, LongUnitFormat, UnitBase1000); |
83809f5e | 311 | BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output); |
388626dc | 312 | |
4388cc08 | 313 | output = nice_unit_format(two_exabytes); |
83809f5e | 314 | BOOST_CHECK_EQUAL(string("1776.4 PB"), output); |
8b06a5c9 | 315 | |
d435d600 CH |
316 | output = nice_unit_format(boost::numeric_cast<double>(two_exabytes), LongUnitFormat, UnitBase1000); |
317 | BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output); | |
318 | ||
319 | output = nice_unit_format(boost::numeric_cast<double>(two_exabytes)); | |
320 | BOOST_CHECK_EQUAL(string("1776.4 PB"), output); | |
321 | ||
388626dc | 322 | const int64_t two_and_half_exabytes = 2500000000000000000LL; |
8b06a5c9 | 323 | |
70fc0674 | 324 | output = nice_unit_format(two_and_half_exabytes, LongUnitFormat, UnitBase1000); |
83809f5e | 325 | BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output); |
8b06a5c9 | 326 | |
4388cc08 | 327 | output = nice_unit_format(two_and_half_exabytes); |
83809f5e | 328 | BOOST_CHECK_EQUAL(string("2220.4 PB"), output); |
d435d600 CH |
329 | |
330 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_exabytes), LongUnitFormat, UnitBase1000); | |
331 | BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output); | |
332 | ||
333 | output = nice_unit_format(boost::numeric_cast<double>(two_and_half_exabytes)); | |
334 | BOOST_CHECK_EQUAL(string("2220.4 PB"), output); | |
83809f5e GMF |
335 | } |
336 | ||
337 | BOOST_AUTO_TEST_CASE(nice_unit_format8) | |
338 | { | |
339 | const int64_t max_representable_64bits_number = 9223372036854775807LL; | |
340 | ||
70fc0674 | 341 | string output = nice_unit_format(max_representable_64bits_number, LongUnitFormat, UnitBase1000); |
83809f5e GMF |
342 | BOOST_CHECK_EQUAL(string("9223.40 PBytes"), output); |
343 | ||
4388cc08 | 344 | output = nice_unit_format(max_representable_64bits_number); |
83809f5e | 345 | BOOST_CHECK_EQUAL(string("8192.0 PB"), output); |
d435d600 CH |
346 | |
347 | /* | |
348 | double val = boost::numeric_cast<double>(max_representable_64bits_number); | |
349 | BOOST_MESSAGE("val as int64 is " << max_representable_64bits_number << " and as double is " << val); | |
350 | BOOST_MESSAGE("val rounded is " << round(val)); | |
351 | BOOST_CHECK_EQUAL(val, round(val)); | |
352 | BOOST_MESSAGE("half as int64 is " << boost::numeric_cast<int64_t>(round(val/2))); // ok | |
353 | BOOST_MESSAGE("cast back is " << boost::numeric_cast<int64_t>(round(val))); // throws a positive overflow | |
354 | output = nice_unit_format(boost::numeric_cast<double>(max_representable_64bits_number), LongUnitFormat, UnitBase1000); | |
355 | BOOST_CHECK_EQUAL(string("9223.40 PBytes"), output); | |
356 | ||
357 | output = nice_unit_format(boost::numeric_cast<double>(max_representable_64bits_number)); | |
358 | BOOST_CHECK_EQUAL(string("8192.0 PB"), output); | |
359 | */ | |
388626dc GMF |
360 | } |
361 | ||
9fe0853b TJ |
362 | BOOST_AUTO_TEST_CASE(TestTrim) |
363 | { | |
364 | std::string s("s1"); | |
365 | trim_mod(s); | |
366 | BOOST_CHECK_EQUAL( std::string("s1"), s ); | |
367 | ||
368 | s=" s2"; | |
369 | trim_mod(s); | |
370 | BOOST_CHECK_EQUAL( std::string("s2"), s ); | |
371 | ||
372 | s="s3 "; | |
373 | trim_mod(s); | |
374 | BOOST_CHECK_EQUAL( std::string("s3"), s ); | |
375 | ||
376 | s="::s4:s4::++--aa"; | |
377 | trim_mod(s,":+-a"); | |
378 | BOOST_CHECK_EQUAL( std::string("s4:s4"), s); | |
379 | ||
380 | /* non modifying version */ | |
381 | ||
382 | s= "s1"; | |
383 | BOOST_CHECK_EQUAL( std::string("s1"), trim(s) ); | |
384 | ||
385 | s=" s2"; | |
386 | BOOST_CHECK_EQUAL( std::string("s2"), trim(s) ); | |
387 | BOOST_CHECK_EQUAL( std::string(" s2"), s ); | |
388 | ||
389 | s="s3 "; | |
390 | BOOST_CHECK_EQUAL( std::string("s3"), trim(s) ); | |
391 | BOOST_CHECK_EQUAL( std::string("s3 "), s ); | |
392 | ||
393 | s="::s4:s4::++--aa"; | |
394 | BOOST_CHECK_EQUAL( std::string("s4:s4"), trim(s,":+-a") ); | |
395 | } // eo TestTrim() | |
396 | ||
397 | ||
398 | ||
399 | BOOST_AUTO_TEST_CASE(TestChomp) | |
400 | { | |
401 | std::string s("s1"); | |
402 | ||
403 | chomp_mod(s); | |
404 | BOOST_CHECK_EQUAL( std::string("s1"), s ); | |
405 | ||
406 | s="s2\n"; | |
407 | chomp_mod(s); | |
408 | BOOST_CHECK_EQUAL( std::string("s2"), s ); | |
409 | ||
410 | s="s3:"; | |
411 | chomp_mod(s,":"); | |
412 | BOOST_CHECK_EQUAL( std::string("s3"), s ); | |
413 | ||
414 | s=":s4::"; | |
415 | chomp_mod(s,"s:"); | |
416 | BOOST_CHECK_EQUAL( std::string(":s4:"), s); | |
417 | ||
418 | /* non modifiying versions */ | |
419 | s= "s1"; | |
420 | ||
421 | BOOST_CHECK_EQUAL( std::string("s1"), chomp(s) ); | |
422 | ||
423 | s="s2\n"; | |
424 | BOOST_CHECK_EQUAL( std::string("s2"), chomp(s) ); | |
425 | BOOST_CHECK_EQUAL( std::string("s2\n"), s); | |
426 | ||
427 | s="s3:"; | |
428 | BOOST_CHECK_EQUAL( std::string("s3"), chomp(s,":") ); | |
429 | BOOST_CHECK_EQUAL( std::string("s3:"), s); | |
430 | ||
431 | s=":s4::"; | |
432 | BOOST_CHECK_EQUAL( std::string(":s4:"), chomp(s,"s:") ); | |
433 | BOOST_CHECK_EQUAL( std::string(":s4::"), s); | |
434 | } // eo TestChomp() | |
435 | ||
436 | ||
437 | ||
438 | BOOST_AUTO_TEST_CASE(TestSuffixFuncs) | |
439 | { | |
440 | std::string s1("12.cpp"); | |
441 | ||
442 | BOOST_CHECK_EQUAL( true, has_suffix(s1,".cpp") ); | |
443 | BOOST_CHECK_EQUAL( true, has_suffix(s1,"pp") ); | |
444 | BOOST_CHECK_EQUAL( false, has_suffix(s1,"hpp") ); | |
445 | BOOST_CHECK_EQUAL( false, has_suffix(s1,"cp") ); | |
446 | BOOST_CHECK_EQUAL( false, has_suffix(s1,"") ); | |
447 | ||
448 | std::string s1c1= remove_suffix(s1,".cpp"); | |
449 | BOOST_CHECK_EQUAL( std::string("12"), s1c1 ); | |
450 | ||
451 | std::string s1c2= remove_suffix(s1,"p"); | |
452 | BOOST_CHECK_EQUAL( std::string("12.cp"), s1c2 ); | |
453 | ||
454 | std::string s1c3= remove_suffix(s1,"cp"); | |
455 | BOOST_CHECK_EQUAL( std::string("12.cpp"), s1c3 ); | |
456 | ||
457 | std::string s2(".cpp"); | |
458 | BOOST_CHECK_EQUAL( true, has_suffix(s2,".cpp") ); | |
459 | ||
460 | std::string s2c1= remove_suffix(s2,".cpp"); | |
461 | BOOST_CHECK_EQUAL( std::string(""), s2c1 ); | |
462 | ||
463 | } // eo TestSuffixFuncs() | |
464 | ||
465 | ||
466 | ||
467 | BOOST_AUTO_TEST_CASE(TestPrefixFuncs) | |
468 | { | |
469 | std::string s1("12.cpp"); | |
470 | ||
471 | BOOST_CHECK_EQUAL( true, has_prefix(s1,"12") ); | |
472 | BOOST_CHECK_EQUAL( true, has_prefix(s1, "1") ); | |
473 | BOOST_CHECK_EQUAL( false, has_prefix(s1, "2") ); | |
474 | BOOST_CHECK_EQUAL( false, has_prefix(s1, "") ); | |
475 | ||
476 | std::string s1c1= remove_prefix(s1, "12"); | |
477 | BOOST_CHECK_EQUAL( std::string(".cpp"), s1c1); | |
478 | } // eo TestPrefixFuncs() | |
479 | ||
480 | ||
481 | ||
482 | BOOST_AUTO_TEST_CASE(TestLowerUpperFuncs) | |
483 | { | |
484 | std::string u1("CASE CONVERSION TEST.."); | |
485 | std::string l1("case conversion test.."); | |
486 | ||
487 | std::string test1(l1); | |
488 | ||
489 | to_upper_mod(test1); | |
490 | BOOST_CHECK_EQUAL( u1, test1 ); | |
491 | ||
492 | to_lower_mod(test1); | |
493 | BOOST_CHECK_EQUAL( l1, test1 ); | |
494 | ||
495 | ||
496 | BOOST_CHECK_EQUAL( u1, to_upper(l1) ); | |
497 | BOOST_CHECK_EQUAL( l1, to_lower(u1) ); | |
498 | } // eo TestLowerUpper | |
499 | ||
500 | ||
501 | ||
502 | BOOST_AUTO_TEST_CASE(PairSplit1) | |
503 | { | |
504 | StringList str_list; | |
505 | get_push_back_filler(str_list) | |
506 | ("a=11")("a= 11")("a =11 ")("a = 11 ")(" a = 11 ") | |
507 | ; | |
508 | BOOST_CHECK_EQUAL( 5u, str_list.size() ); | |
509 | for(StringList::iterator it= str_list.begin(); | |
510 | it != str_list.end(); | |
511 | ++it) | |
512 | { | |
513 | std::string key, value; | |
514 | bool res= pair_split( *it, key, value); | |
515 | ||
516 | BOOST_CHECK_EQUAL( true , res ); | |
517 | BOOST_CHECK_EQUAL( std::string("a"), key ); | |
518 | BOOST_CHECK_EQUAL( std::string("11"), value ); | |
519 | } | |
520 | ||
521 | std::string key, value; | |
522 | bool res; | |
523 | ||
524 | res= pair_split(" 1 : 2 ", key, value, ':'); | |
525 | BOOST_CHECK_EQUAL( true, res ); | |
526 | BOOST_CHECK_EQUAL( std::string("1"), key); | |
527 | BOOST_CHECK_EQUAL( std::string("2"), value); | |
528 | } // eo PairSplit1 | |
529 | ||
530 | ||
531 | ||
532 | BOOST_AUTO_TEST_CASE(SplitString1) | |
118e216e | 533 | { |
9fe0853b TJ |
534 | std::string block( |
535 | "Zeile 1\n" | |
536 | "++Zeile-2--\n" | |
537 | "Zeile 3\n" | |
538 | "\n" | |
539 | "Zeile 5\n" | |
540 | ); | |
541 | ||
542 | StringList list1; | |
543 | ||
544 | split_string(block, list1, "\n"); | |
545 | // since the blocks ends with \n we should have 6 lines (the last one empty): | |
546 | BOOST_CHECK_EQUAL( 6u, list1.size() ); | |
547 | BOOST_CHECK_EQUAL( std::string(), list1.back() ); | |
548 | BOOST_CHECK_EQUAL( std::string("Zeile 1"), list1.front() ); | |
549 | ||
550 | StringList list2; | |
551 | ||
552 | split_string(block, list2, "\n", true); | |
553 | ||
554 | // now we omitted empty lines, now we should have only 4 lines left: | |
555 | BOOST_CHECK_EQUAL( 4u, list2.size() ); | |
556 | BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() ); | |
557 | BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() ); | |
558 | ||
559 | list2= split_string(block, "\n", true, "+-"); | |
560 | ||
561 | // again, we omitted empty lines, but also trimmed away leading and trailing "+" and "-" | |
562 | BOOST_CHECK_EQUAL( 4u, list2.size() ); | |
563 | BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() ); | |
564 | BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() ); | |
565 | BOOST_CHECK_EQUAL( std::string("Zeile-2"), *(++list2.begin()) ); | |
566 | } // eo SplitString1 | |
567 | ||
568 | ||
569 | ||
570 | BOOST_AUTO_TEST_CASE(SplitString2) | |
571 | { | |
572 | std::string line("172.16.0.0/16 dev eth0 scope link src 172.16.1.111"); | |
573 | ||
574 | StringList list1; | |
575 | ||
576 | split_string(line, list1, " ", true, Whitespaces); | |
577 | ||
578 | BOOST_CHECK_EQUAL( 7u, list1.size() ); | |
579 | ||
580 | } // eo SplitString2 | |
581 | ||
582 | ||
583 | ||
584 | BOOST_AUTO_TEST_CASE(SplitStringEmpty) | |
585 | { | |
586 | std::string line(""); | |
587 | ||
588 | StringList list1; | |
589 | ||
590 | split_string(line, list1, " ", true, Whitespaces); | |
591 | ||
592 | BOOST_CHECK_EQUAL( 0u, list1.size() ); | |
593 | } // eo SplitStringEmpty | |
594 | ||
595 | ||
596 | BOOST_AUTO_TEST_CASE(SplitStringDelimiterOnly) | |
597 | { | |
598 | std::string line(" "); | |
599 | ||
600 | StringList list1; | |
601 | ||
602 | split_string(line, list1, " ", true, Whitespaces); | |
603 | ||
604 | BOOST_CHECK_EQUAL( 0u, list1.size() ); | |
605 | } // eo SplitStringDelimiterOnly | |
606 | ||
607 | ||
338da253 CH |
608 | BOOST_AUTO_TEST_CASE(SplitToVector) |
609 | { | |
610 | std::string line("0;1;2;3;4;5;6;7;8;9"); | |
611 | std::vector<std::string> result; | |
612 | split_string(line, result, ";"); | |
613 | BOOST_REQUIRE_EQUAL(result.size(), 10); | |
614 | BOOST_CHECK_EQUAL(result[0], "0"); | |
615 | BOOST_CHECK_EQUAL(result[4], "4"); | |
616 | BOOST_CHECK_EQUAL(result[9], "9"); | |
617 | } | |
618 | ||
9fe0853b TJ |
619 | |
620 | BOOST_AUTO_TEST_CASE(JoinString1) | |
621 | { | |
622 | std::list< std::string > parts; | |
9fe0853b | 623 | std::string joined_string= join_string(parts,"/"); |
5ad80381 PG |
624 | BOOST_CHECK_EQUAL( std::string("") , joined_string ); |
625 | ||
626 | parts.push_back ("1"); | |
627 | joined_string= join_string(parts,"/"); | |
628 | // we should have slashes between the strings: | |
629 | BOOST_CHECK_EQUAL( std::string("1") , joined_string ); | |
630 | ||
631 | get_push_back_filler(parts)("2")("drei"); | |
632 | ||
633 | joined_string= join_string(parts,"/"); | |
9fe0853b TJ |
634 | // we should have slashes between the strings: |
635 | BOOST_CHECK_EQUAL( std::string("1/2/drei") , joined_string ); | |
636 | ||
637 | parts.push_back( std::string() ); | |
638 | joined_string= join_string(parts,"/"); | |
639 | // now we should have an additional trailing slash: | |
640 | BOOST_CHECK_EQUAL( std::string("1/2/drei/") , joined_string ); | |
641 | ||
642 | parts.push_front( std::string() ); | |
643 | joined_string= join_string(parts,"/"); | |
644 | // now we should have an additional leading slash: | |
645 | BOOST_CHECK_EQUAL( std::string("/1/2/drei/") , joined_string ); | |
646 | ||
647 | } // eo JoinString1 | |
648 | ||
649 | ||
376ec4fa CH |
650 | BOOST_AUTO_TEST_CASE(JoinStringVector) |
651 | { | |
652 | std::vector< std::string > parts; | |
653 | get_push_back_filler(parts)("1")("2")("drei"); | |
654 | ||
655 | std::string joined_string= join_string(parts,"/"); | |
656 | // we should have slashes between the strings: | |
657 | BOOST_CHECK_EQUAL( std::string("1/2/drei") , joined_string ); | |
658 | ||
659 | parts.push_back( std::string() ); | |
660 | joined_string= join_string(parts,"/"); | |
661 | // now we should have an additional trailing slash: | |
662 | BOOST_CHECK_EQUAL( std::string("1/2/drei/") , joined_string ); | |
663 | ||
664 | parts.insert(parts.begin(), ""); | |
665 | joined_string= join_string(parts,"/"); | |
666 | // now we should have an additional leading slash: | |
667 | BOOST_CHECK_EQUAL( std::string("/1/2/drei/") , joined_string ); | |
668 | ||
669 | } // eo JoinStringVector | |
670 | ||
9fe0853b | 671 | |
5ad80381 PG |
672 | BOOST_AUTO_TEST_CASE(JoinStringSet) |
673 | { | |
674 | std::set< std::string > parts; | |
675 | ||
676 | std::string joined_string= join_string(parts,"/"); | |
677 | BOOST_CHECK_EQUAL( std::string() , joined_string ); | |
678 | ||
679 | parts.insert ("foo"); | |
680 | joined_string= join_string(parts,"/"); | |
681 | BOOST_CHECK_EQUAL( std::string("foo") , joined_string ); | |
682 | ||
683 | parts.insert ("bar"); | |
684 | parts.insert ("baz"); | |
685 | ||
686 | joined_string= join_string(parts,"/"); | |
687 | // we should have slashes between the strings: | |
688 | BOOST_CHECK_EQUAL( std::string("bar/baz/foo") , joined_string ); | |
689 | ||
690 | parts.insert( std::string() ); | |
691 | joined_string= join_string(parts,"/"); | |
692 | // now we should have an additional trailing slash: | |
693 | BOOST_CHECK_EQUAL( std::string("/bar/baz/foo") , joined_string ); | |
694 | } // eo JoinStringSet | |
695 | ||
696 | ||
697 | BOOST_AUTO_TEST_CASE(JoinStringIterSet_Empty) | |
698 | { | |
699 | std::set< std::string > parts; | |
700 | ||
701 | // empty sequence → empty string | |
702 | BOOST_CHECK_EQUAL(join_string (parts.begin (), parts.end () ), ""); | |
703 | BOOST_CHECK_EQUAL(join_string (parts.begin (), parts.end (), "/"), ""); | |
704 | } // eo JoinStringSet | |
705 | ||
706 | BOOST_AUTO_TEST_CASE(JoinStringIterSet_One) | |
707 | { | |
708 | std::set< std::string > parts; | |
709 | ||
710 | parts.insert ("foo"); | |
711 | ||
712 | // cardinality == 1 → no delimiter | |
713 | BOOST_CHECK_EQUAL(join_string (parts.begin (), parts.end () ), "foo"); | |
714 | BOOST_CHECK_EQUAL(join_string (parts.begin (), parts.end (), "/"), "foo"); | |
715 | } // eo JoinStringSet | |
716 | ||
717 | BOOST_AUTO_TEST_CASE(JoinStringIterSet) | |
718 | { | |
719 | std::set< std::string > parts; | |
720 | ||
721 | parts.insert ("foo"); | |
722 | parts.insert ("bar"); | |
723 | parts.insert ("baz"); | |
724 | ||
725 | std::string joined_string= join_string(parts.begin (), parts.end (), "/"); | |
726 | // we should have slashes between the strings: | |
727 | BOOST_CHECK_EQUAL( std::string("bar/baz/foo") , joined_string ); | |
728 | ||
729 | parts.insert( std::string() ); | |
730 | joined_string= join_string(parts.begin (), parts.end (),"/"); | |
731 | // now we should have an additional trailing slash: | |
732 | BOOST_CHECK_EQUAL( std::string("/bar/baz/foo") , joined_string ); | |
733 | } // eo JoinStringSet | |
734 | ||
735 | ||
bb53c38f PG |
736 | BOOST_AUTO_TEST_CASE(JoinStringIterSet_Default) |
737 | { /* default delimiter is newline */ | |
738 | std::set< std::string > parts; | |
739 | ||
740 | parts.insert ("foo"); | |
741 | parts.insert ("bar"); | |
742 | parts.insert ("baz"); | |
743 | ||
744 | BOOST_CHECK_EQUAL(join_string (parts.begin (), parts.end ()), "bar\nbaz\nfoo"); | |
745 | BOOST_CHECK_EQUAL(join_string (parts ), "bar\nbaz\nfoo"); | |
746 | ||
747 | } // eo JoinStringSet | |
748 | ||
749 | ||
750 | BOOST_AUTO_TEST_CASE(JoinStringArray_Empty) | |
751 | { | |
752 | const char *const parts [] = { NULL }; | |
753 | ||
754 | BOOST_CHECK_EQUAL(join_string(&parts [0], &parts [0], "/"), ""); | |
755 | BOOST_CHECK_EQUAL(join_string(parts , "/"), ""); | |
756 | ||
757 | BOOST_CHECK_EQUAL(join_string(&parts [0], &parts [0]), ""); | |
758 | BOOST_CHECK_EQUAL(join_string(parts ), ""); | |
759 | ||
760 | } // eo JoinStringSet | |
761 | ||
762 | BOOST_AUTO_TEST_CASE(JoinStringArray_One) | |
763 | { | |
764 | const char *const parts [] = { "one", NULL }; | |
765 | ||
766 | BOOST_CHECK_EQUAL(join_string(&parts [0], &parts [1], "/"), "one"); | |
767 | BOOST_CHECK_EQUAL(join_string(parts , "/"), "one"); | |
768 | ||
769 | BOOST_CHECK_EQUAL(join_string(&parts [0], &parts [1]), "one"); | |
770 | BOOST_CHECK_EQUAL(join_string(parts ), "one"); | |
771 | ||
772 | } // eo JoinStringSet | |
773 | ||
774 | BOOST_AUTO_TEST_CASE(JoinStringArray_Many) | |
775 | { | |
776 | const char *const parts [5] = { "one", "two", "three", "many", NULL }; | |
777 | ||
778 | BOOST_CHECK_EQUAL(join_string(&parts [0], &parts [4], "/"), "one/two/three/many"); | |
779 | BOOST_CHECK_EQUAL(join_string(parts , "/"), "one/two/three/many"); | |
780 | ||
781 | BOOST_CHECK_EQUAL(join_string(&parts [0], &parts [4]), "one\ntwo\nthree\nmany"); | |
782 | BOOST_CHECK_EQUAL(join_string(parts ), "one\ntwo\nthree\nmany"); | |
783 | ||
784 | } // eo JoinStringSet | |
785 | ||
786 | ||
9fe0853b TJ |
787 | BOOST_AUTO_TEST_CASE(ConversionStringInt) |
788 | { | |
789 | std::string s1("24"); | |
790 | std::string s1x("25x"); | |
791 | int i1=0; | |
792 | bool res= false; | |
793 | ||
794 | i1= string_to<int>(s1); | |
795 | BOOST_CHECK_EQUAL( 24, i1 ); | |
796 | i1= string_to<int>(s1x); | |
797 | BOOST_CHECK_EQUAL( 25, i1 ); | |
798 | ||
799 | res= string_to<int>(s1,i1); | |
800 | BOOST_CHECK_EQUAL( true, res ); | |
801 | BOOST_CHECK_EQUAL( 24, i1 ); | |
802 | ||
803 | res= string_to<int>(s1x,i1); | |
804 | BOOST_CHECK_EQUAL( false, res ); | |
805 | ||
806 | std::string ss1= to_string( 24 ); | |
807 | BOOST_CHECK_EQUAL( std::string("24"), ss1); | |
808 | ||
809 | } // eo ConversionStringInt() | |
810 | ||
811 | ||
812 | ||
3bcc713f | 813 | BOOST_AUTO_TEST_CASE(HexBinaryConversion) |
9fe0853b TJ |
814 | { |
815 | std::string hex1("49324E"); | |
816 | std::string bin1("I2N"); | |
817 | ||
818 | BOOST_CHECK_EQUAL( hex1, convert_binary_to_hex(bin1,true) ); | |
819 | BOOST_CHECK_EQUAL( bin1, convert_hex_to_binary(hex1) ); | |
820 | BOOST_CHECK_EQUAL( to_lower(hex1), convert_binary_to_hex(bin1) ); | |
821 | ||
822 | std::string hex2("0001"); | |
823 | std::string hex2a("00 01"); | |
824 | std::string hex2b("00:01"); | |
825 | std::string bin2("\0\1",2); | |
826 | ||
827 | BOOST_CHECK_EQUAL( hex2, convert_binary_to_hex(bin2) ); | |
828 | BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2) ); | |
829 | BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2a) ); | |
830 | BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2b) ); | |
831 | ||
832 | BOOST_REQUIRE_THROW( convert_hex_to_binary("01 kein hex"), std::runtime_error); | |
833 | } // eo HexConversion() | |
834 | ||
3bcc713f GE |
835 | BOOST_AUTO_TEST_CASE(HexIntConversion) |
836 | { | |
837 | BOOST_CHECK_EQUAL( 255 , hex_string_to<uint32_t>("ff") ); | |
838 | BOOST_CHECK_EQUAL( 18866985 , hex_string_to<uint32_t>("11FE329") ); | |
839 | BOOST_CHECK_EQUAL( 44 , hex_string_to<uint32_t>("0x2C") ); | |
840 | } | |
841 | ||
b953bf36 GE |
842 | BOOST_AUTO_TEST_CASE(sanitize_for_logging1) |
843 | { | |
844 | string output = sanitize_for_logging("normaler string ohne aerger"); | |
845 | ||
846 | BOOST_CHECK_EQUAL(string("normaler string ohne aerger"), output); | |
847 | } | |
848 | ||
849 | BOOST_AUTO_TEST_CASE(sanitize_for_logging2) | |
850 | { | |
851 | string to_test="fiese"; | |
852 | to_test.push_back(0); | |
853 | to_test+="null"; | |
854 | ||
855 | string output = sanitize_for_logging(to_test); | |
856 | ||
857 | BOOST_CHECK_EQUAL(string("fiese?null"), output); | |
858 | } | |
859 | ||
860 | BOOST_AUTO_TEST_CASE(sanitize_for_logging3) | |
861 | { | |
862 | string output = sanitize_for_logging("läuter ümlaute utf8"); | |
863 | ||
864 | BOOST_CHECK_EQUAL(string("l??uter ??mlaute utf8"), output); | |
865 | } | |
866 | ||
67a3dacb CH |
867 | BOOST_AUTO_TEST_CASE(find_html_comments_test) |
868 | { | |
869 | string text = "bla-->" // ==> (npos, 6) | |
870 | // 0 6 | |
871 | "bla<!--bla<!--bla-->bla-->" // ==> (16, 26), (9, 32) | |
872 | // 6 9 16 26 32 | |
873 | "bla<!--bla-->" // ==> (35, 45) | |
874 | // 32 35 45 | |
875 | "--><!----><!--" // ==> (npos, 48), (48, 55), (55, npos) | |
876 | // 45 48 55 59 | |
877 | "bla<!--bla-->"; // ==> (62, 72) | |
878 | // 59 62 72 | |
879 | BOOST_REQUIRE_EQUAL(text.length(), 72); | |
880 | vector<CommentZone> expect; | |
881 | expect.push_back(CommentZone(string::npos, 6)); | |
882 | expect.push_back(CommentZone(16, 26)); | |
883 | expect.push_back(CommentZone( 9, 32)); | |
884 | expect.push_back(CommentZone(35, 45)); | |
885 | expect.push_back(CommentZone(string::npos, 48)); | |
886 | expect.push_back(CommentZone(48, 55)); | |
887 | expect.push_back(CommentZone(55, string::npos)); | |
888 | expect.push_back(CommentZone(62, 72)); | |
46dd1321 | 889 | vector<CommentZone> result = find_html_comments(text); |
67a3dacb CH |
890 | //BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), not working, requires ... |
891 | // expect.begin(), expect.end()); ... operator<<(CommentZone) | |
892 | BOOST_CHECK_EQUAL(result.size(), expect.size()); | |
893 | BOOST_FOREACH(const CommentZone &comment, expect) | |
894 | BOOST_CHECK_MESSAGE(find(result.begin(), result.end(), comment) != result.end(), | |
895 | "Find (" << comment.first << "-" << comment.second << ")"); | |
896 | } | |
897 | ||
898 | BOOST_AUTO_TEST_CASE(remove_html_comments_test) | |
899 | { | |
900 | const string original = "First line outside\n" | |
901 | "text <!--FOO\n" | |
902 | "Inside foo\n" | |
903 | "<!--BAR\n" | |
904 | "foo bar, what a surprise.\n" | |
905 | "<!-- short tag-less comment -->\n" | |
906 | " Html cannot handle this, thinks that FOO ended above\n" | |
907 | "BAR-->\n" | |
908 | "This, neither. No nested comments\n" | |
909 | "some text <!--BAZ more text\n" | |
910 | "Aaarggh!" | |
911 | "more text BAZ--> even more\n" | |
912 | "FOO--> text\n" | |
913 | "second line outside\n" | |
914 | "<!-- second comment -->"; | |
915 | string text = original; | |
916 | string expect = "First line outside\n" | |
917 | "text text\n" | |
918 | "second line outside\n"; | |
919 | remove_html_comments(text); | |
920 | BOOST_CHECK_EQUAL(text, expect); | |
921 | remove_html_comments(text); // should not have any effect | |
922 | BOOST_CHECK_EQUAL(text, expect); | |
923 | ||
924 | text = string("test<!--") + original; | |
925 | remove_html_comments(text); | |
926 | BOOST_CHECK_EQUAL(text, "test"); | |
927 | ||
928 | text = original + "-->test"; | |
929 | remove_html_comments(text); | |
930 | BOOST_CHECK_EQUAL(text, "test"); | |
931 | } | |
932 | ||
1ecd3006 CH |
933 | BOOST_AUTO_TEST_CASE(shorten_stl_types_string) |
934 | { | |
935 | BOOST_CHECK_EQUAL(shorten_stl_types("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"), | |
936 | "std::string"); | |
937 | } | |
938 | ||
939 | BOOST_AUTO_TEST_CASE(shorten_stl_types_simple) | |
940 | { | |
941 | BOOST_CHECK_EQUAL(shorten_stl_types("std::list<some_type, std::allocator<some_type> >"), | |
942 | "std::list<some_type, _alloc_>"); | |
943 | } | |
944 | ||
945 | BOOST_AUTO_TEST_CASE(shorten_stl_types_multiple) | |
946 | { | |
947 | BOOST_CHECK_EQUAL(shorten_stl_types("std::basic_string<char, std::char_traits<char>, std::allocator<char> > my_func(std::list<some_type, std::allocator<some_type> >, std::vector<int, std::allocator<int> >)"), | |
948 | "std::string my_func(std::list<some_type, _alloc_>, std::vector<int, _alloc_>)"); | |
949 | } | |
950 | ||
951 | BOOST_AUTO_TEST_CASE(shorten_stl_types_complex) | |
952 | { | |
953 | BOOST_CHECK_EQUAL(shorten_stl_types("std::list<boost::shared_ptr<some_type>, std::allocator<boost::shared_ptr<some_type> > >"), | |
954 | "std::list<boost::shared_ptr<some_type>, _alloc_>"); | |
955 | } | |
956 | ||
957 | BOOST_AUTO_TEST_CASE(shorten_stl_types_nested) | |
958 | { | |
959 | //"std::list<int, std::allocator<int> >" | |
960 | //"std::list<std::list<int, std::allocator<int> >, std::allocator<std::list<int, std::allocator<int> > > >" | |
961 | BOOST_CHECK_EQUAL(shorten_stl_types("std::list<std::list<int, std::allocator<int> >, std::allocator<std::list<int, std::allocator<int> > > >"), | |
962 | "std::list<std::list<int, _alloc_>, _alloc_>"); | |
963 | } | |
964 | ||
965 | BOOST_AUTO_TEST_CASE(shorten_stl_types_nothing) | |
966 | { | |
967 | string text = ""; | |
968 | BOOST_CHECK_EQUAL(shorten_stl_types(text), text); | |
969 | text = "int f(void)"; | |
970 | BOOST_CHECK_EQUAL(shorten_stl_types(text), text); | |
971 | text = "std::cout << \"Test\" << std::endl;"; | |
972 | BOOST_CHECK_EQUAL(shorten_stl_types(text), text); | |
973 | text = "bla<blubb>"; | |
974 | BOOST_CHECK_EQUAL(shorten_stl_types(text), text); | |
975 | text = "std::list<> is a class template"; | |
976 | BOOST_CHECK_EQUAL(shorten_stl_types(text), text); | |
977 | text = "std::list<int, std::allocator<int>\n>"; | |
978 | BOOST_CHECK_EQUAL(shorten_stl_types(text), text); | |
979 | } | |
980 | ||
2bb72337 TJ |
981 | BOOST_AUTO_TEST_CASE(base64_encode_decode) |
982 | { | |
983 | string text = "Hello World\n"; | |
984 | ||
985 | string encoded = base64_encode(text); | |
986 | ||
987 | BOOST_CHECK_EQUAL("SGVsbG8gV29ybGQK", encoded); | |
988 | BOOST_CHECK_EQUAL(text, base64_decode(encoded)); | |
989 | } | |
990 | ||
991 | BOOST_AUTO_TEST_CASE(base64_empty_string) | |
992 | { | |
993 | string text = ""; | |
994 | string encoded = base64_encode(text); | |
995 | ||
996 | BOOST_CHECK_EQUAL("", encoded); | |
997 | BOOST_CHECK_EQUAL(text, base64_decode(encoded)); | |
998 | } | |
999 | ||
1000 | BOOST_AUTO_TEST_CASE(base64_large_string_with_zero) | |
1001 | { | |
1002 | // 10 MB data | |
1003 | int data_size = 1024 * 1024 * 10; | |
1004 | ||
1005 | string large_binary_data(data_size, 0); | |
1006 | BOOST_CHECK_EQUAL(data_size, large_binary_data.size()); | |
1007 | ||
1008 | string encoded = base64_encode(large_binary_data); | |
1009 | ||
1010 | string decoded = base64_decode(encoded); | |
1011 | BOOST_CHECK_EQUAL(large_binary_data, decoded); | |
1012 | } | |
1013 | ||
1ebab1e3 TJ |
1014 | BOOST_AUTO_TEST_CASE(base64_large_string_with_zero_encode_linefeeds) |
1015 | { | |
1016 | // 10 MB data | |
1017 | int data_size = 1024 * 1024 * 10; | |
1018 | ||
1019 | string large_binary_data(data_size, 0); | |
1020 | BOOST_CHECK_EQUAL(data_size, large_binary_data.size()); | |
1021 | ||
1022 | const bool one_line_mode = false; | |
1023 | string encoded = base64_encode(large_binary_data, one_line_mode); | |
1024 | ||
1025 | string decoded = base64_decode(encoded, one_line_mode); | |
1026 | BOOST_CHECK_EQUAL(large_binary_data, decoded); | |
1027 | } | |
1028 | ||
2bb72337 TJ |
1029 | BOOST_AUTO_TEST_CASE(base64_decode_garbage) |
1030 | { | |
1031 | std::string data = "Hello World, this is unencoded data"; | |
1032 | string decoded = base64_decode(data); | |
1033 | ||
1034 | // garbage turns out to be an empty string | |
1035 | BOOST_CHECK_EQUAL(0, decoded.size()); | |
1036 | } | |
1037 | ||
1ebab1e3 TJ |
1038 | BOOST_AUTO_TEST_CASE(base64_encode_with_linefeeds) |
1039 | { | |
1040 | const string data = string("Hello World\n") | |
1041 | + "Hello World\n" | |
1042 | + "Hello World\n" | |
1043 | + "Hello World\n" | |
1044 | + "Hello World\n" | |
1045 | + "Hello World\n" | |
1046 | + "Hello World\n"; | |
1047 | ||
1048 | const string encoded = base64_encode(data, false); | |
1049 | ||
1050 | const std::string expected = string("SGVsbG8gV29ybGQKSGVsbG8gV29ybGQKSGVsbG8gV29ybGQKSGVsbG8gV29ybGQK\n") | |
1051 | + "SGVsbG8gV29ybGQKSGVsbG8gV29ybGQKSGVsbG8gV29ybGQK\n"; | |
1052 | BOOST_CHECK_EQUAL(expected, encoded); | |
1053 | ||
1054 | // decode and compare | |
1055 | BOOST_CHECK_EQUAL(data, base64_decode(encoded, false)); | |
1056 | ||
1057 | // expected empty string when switching on single line base64 mode | |
1058 | // (openssl is very strict about this) | |
1059 | BOOST_CHECK_EQUAL("", base64_decode(encoded, true)); | |
1060 | } | |
1061 | ||
9fe0853b | 1062 | BOOST_AUTO_TEST_SUITE_END() |