2 The software in this package is distributed under the GNU General
3 Public License version 2 (with a special exception described below).
5 A copy of GNU General Public License (GPL) is included in this distribution,
6 in the file COPYING.GPL.
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.
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.
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.
20 /***************************************************************************
21 * Copyright (C) 2006-2011 by Intra2net AG *
23 ***************************************************************************/
25 // #include <iostream>
29 // #include <stdexcept>
31 #define BOOST_TEST_DYN_LINK
32 #include <boost/test/unit_test.hpp>
33 #include <boost/foreach.hpp>
34 #include <boost/numeric/conversion/cast.hpp>
36 #include <stringfunc.hxx>
37 #include <containerfunc.hpp>
44 typedef std::list< std::string > StringList;
46 BOOST_AUTO_TEST_SUITE(stringfunc)
48 BOOST_AUTO_TEST_CASE(smart_html_entites1)
50 string output = smart_html_entities("Test");
52 BOOST_CHECK_EQUAL(string("Test"), output);
55 BOOST_AUTO_TEST_CASE(smart_html_entites2)
57 string output = smart_html_entities("Täst");
59 BOOST_CHECK_EQUAL(string("Täst"), output);
62 BOOST_AUTO_TEST_CASE(smart_html_entites3)
64 string output = smart_html_entities("<>");
66 BOOST_CHECK_EQUAL(string("<>"), output);
69 BOOST_AUTO_TEST_CASE(smart_html_entites4)
71 string output = smart_html_entities("<ümlaut>");
73 BOOST_CHECK_EQUAL(string("<ümlaut>"), output);
76 BOOST_AUTO_TEST_CASE(smart_html_entites5)
78 string output = smart_html_entities("Test<ümlaut>Blä");
80 BOOST_CHECK_EQUAL(string("Test<ümlaut>Blä"), output);
83 BOOST_AUTO_TEST_CASE(smart_html_entites6)
85 string output = smart_html_entities("System > Einstellungen");
87 BOOST_CHECK_EQUAL(string("System > Einstellungen"), output);
90 BOOST_AUTO_TEST_CASE(smart_html_entites7)
92 string output = smart_html_entities("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">\"System > Einstellungen\"</a>. Oder etwa nicht?");
94 BOOST_CHECK_EQUAL(string("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">"System > Einstellungen"</a>. Oder etwa nicht?"), output);
97 BOOST_AUTO_TEST_CASE(strip_html_tags1)
99 string output = strip_html_tags("Was für ein schöner Tag, finden Sie nicht?");
101 BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
104 BOOST_AUTO_TEST_CASE(strip_html_tags2)
106 string output = strip_html_tags("Was für ein <a href=\"wikipedia\" target=\"new\">schöner Tag</a>, finden Sie nicht?");
108 BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
113 BOOST_AUTO_TEST_CASE(html_entities1)
115 string output = html_entities("\xC3\xA4\xC3\xB6\xC3\xBC");
116 BOOST_CHECK_EQUAL(string("äöü"), output);
119 BOOST_AUTO_TEST_CASE(html_entities2)
121 string output = html_entities("\xC3\xA5 \xC3\xB5 \xC3\xBF");
122 BOOST_CHECK_EQUAL(string("å õ ÿ"), output);
125 BOOST_AUTO_TEST_CASE(html_entities3)
127 string output = html_entities("\xC4\x8E \xE0\xBC\xB1 \xE8\x82\x88");
128 BOOST_CHECK_EQUAL(string("Ď ༱ 肈"), output);
133 BOOST_AUTO_TEST_CASE(nice_unit_format1)
135 const int64_t two_bytes = 2;
137 string output = nice_unit_format(two_bytes, LongUnitFormat, UnitBase1000);
138 BOOST_CHECK_EQUAL(string("2.00 Bytes"), output);
140 output = nice_unit_format(two_bytes);
141 BOOST_CHECK_EQUAL(string("2.0 B"), output);
144 BOOST_AUTO_TEST_CASE(nice_unit_format2)
146 const int64_t two_kilobytes = 2000;
148 string output = nice_unit_format(two_kilobytes, LongUnitFormat, UnitBase1000);
149 BOOST_CHECK_EQUAL(string("2.00 KBytes"), output);
151 output = nice_unit_format(two_kilobytes);
152 BOOST_CHECK_EQUAL(string("2.0 KB"), output);
154 output = nice_unit_format(boost::numeric_cast<double>(two_kilobytes), LongUnitFormat, UnitBase1000);
155 BOOST_CHECK_EQUAL(string("2.00 KBytes"), output);
157 output = nice_unit_format(boost::numeric_cast<double>(two_kilobytes));
158 BOOST_CHECK_EQUAL(string("2.0 KB"), output);
160 const int64_t two_and_half_kilobytes = 2500;
162 output = nice_unit_format(two_and_half_kilobytes, LongUnitFormat, UnitBase1000);
163 BOOST_CHECK_EQUAL(string("2.50 KBytes"), output);
165 output = nice_unit_format(two_and_half_kilobytes);
166 BOOST_CHECK_EQUAL(string("2.4 KB"), output);
168 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_kilobytes), LongUnitFormat, UnitBase1000);
169 BOOST_CHECK_EQUAL(string("2.50 KBytes"), output);
171 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_kilobytes));
172 BOOST_CHECK_EQUAL(string("2.4 KB"), output);
175 BOOST_AUTO_TEST_CASE(nice_unit_format3)
177 const int64_t two_megabytes = 2000000;
179 string output = nice_unit_format(two_megabytes, LongUnitFormat, UnitBase1000);
180 BOOST_CHECK_EQUAL(string("2.00 MBytes"), output);
182 output = nice_unit_format(two_megabytes);
183 BOOST_CHECK_EQUAL(string("1.9 MB"), output);
185 output = nice_unit_format(boost::numeric_cast<double>(two_megabytes), LongUnitFormat, UnitBase1000);
186 BOOST_CHECK_EQUAL(string("2.00 MBytes"), output);
188 output = nice_unit_format(boost::numeric_cast<double>(two_megabytes));
189 BOOST_CHECK_EQUAL(string("1.9 MB"), output);
191 const int64_t two_and_half_megabytes = 2500000;
193 output = nice_unit_format(two_and_half_megabytes, LongUnitFormat, UnitBase1000);
194 BOOST_CHECK_EQUAL(string("2.50 MBytes"), output);
196 output = nice_unit_format(two_and_half_megabytes);
197 BOOST_CHECK_EQUAL(string("2.4 MB"), output);
199 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_megabytes), LongUnitFormat, UnitBase1000);
200 BOOST_CHECK_EQUAL(string("2.50 MBytes"), output);
202 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_megabytes));
203 BOOST_CHECK_EQUAL(string("2.4 MB"), output);
207 BOOST_AUTO_TEST_CASE(nice_unit_format4)
209 const int64_t two_gigabytes = 2000000000LL;
211 string output = nice_unit_format(two_gigabytes, LongUnitFormat, UnitBase1000);
212 BOOST_CHECK_EQUAL(string("2.00 GBytes"), output);
214 output = nice_unit_format(two_gigabytes);
215 BOOST_CHECK_EQUAL(string("1.9 GB"), output);
217 output = nice_unit_format(boost::numeric_cast<double>(two_gigabytes), LongUnitFormat, UnitBase1000);
218 BOOST_CHECK_EQUAL(string("2.00 GBytes"), output);
220 output = nice_unit_format(boost::numeric_cast<double>(two_gigabytes));
221 BOOST_CHECK_EQUAL(string("1.9 GB"), output);
223 const int64_t two_and_half_gigabytes = 2500000000LL;
225 output = nice_unit_format(two_and_half_gigabytes, LongUnitFormat, UnitBase1000);
226 BOOST_CHECK_EQUAL(string("2.50 GBytes"), output);
228 output = nice_unit_format(two_and_half_gigabytes);
229 BOOST_CHECK_EQUAL(string("2.3 GB"), output);
231 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_gigabytes), LongUnitFormat, UnitBase1000);
232 BOOST_CHECK_EQUAL(string("2.50 GBytes"), output);
234 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_gigabytes));
235 BOOST_CHECK_EQUAL(string("2.3 GB"), output);
238 BOOST_AUTO_TEST_CASE(nice_unit_format5)
240 const int64_t two_terabytes = 2000000000000LL;
242 string output = nice_unit_format(two_terabytes, LongUnitFormat, UnitBase1000);
243 BOOST_CHECK_EQUAL(string("2.00 TBytes"), output);
245 output = nice_unit_format(two_terabytes);
246 BOOST_CHECK_EQUAL(string("1.8 TB"), output);
248 output = nice_unit_format(boost::numeric_cast<double>(two_terabytes), LongUnitFormat, UnitBase1000);
249 BOOST_CHECK_EQUAL(string("2.00 TBytes"), output);
251 output = nice_unit_format(boost::numeric_cast<double>(two_terabytes));
252 BOOST_CHECK_EQUAL(string("1.8 TB"), output);
254 const int64_t two_and_half_terabytes = 2500000000000LL;
256 output = nice_unit_format(two_and_half_terabytes, LongUnitFormat, UnitBase1000);
257 BOOST_CHECK_EQUAL(string("2.50 TBytes"), output);
259 output = nice_unit_format(two_and_half_terabytes);
260 BOOST_CHECK_EQUAL(string("2.3 TB"), output);
262 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_terabytes), LongUnitFormat, UnitBase1000);
263 BOOST_CHECK_EQUAL(string("2.50 TBytes"), output);
265 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_terabytes));
266 BOOST_CHECK_EQUAL(string("2.3 TB"), output);
269 BOOST_AUTO_TEST_CASE(nice_unit_format6)
271 const int64_t two_petabytes = 2000000000000000LL;
273 string output = nice_unit_format(two_petabytes, LongUnitFormat, UnitBase1000);
274 BOOST_CHECK_EQUAL(string("2.00 PBytes"), output);
276 output = nice_unit_format(two_petabytes);
277 BOOST_CHECK_EQUAL(string("1.8 PB"), output);
279 output = nice_unit_format(boost::numeric_cast<double>(two_petabytes), LongUnitFormat, UnitBase1000);
280 BOOST_CHECK_EQUAL(string("2.00 PBytes"), output);
282 output = nice_unit_format(boost::numeric_cast<double>(two_petabytes));
283 BOOST_CHECK_EQUAL(string("1.8 PB"), output);
285 const int64_t two_and_half_petabytes = 2500000000000000LL;
287 output = nice_unit_format(two_and_half_petabytes, LongUnitFormat, UnitBase1000);
288 BOOST_CHECK_EQUAL(string("2.50 PBytes"), output);
290 output = nice_unit_format(two_and_half_petabytes);
291 BOOST_CHECK_EQUAL(string("2.2 PB"), output);
293 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_petabytes), LongUnitFormat, UnitBase1000);
294 BOOST_CHECK_EQUAL(string("2.50 PBytes"), output);
296 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_petabytes));
297 BOOST_CHECK_EQUAL(string("2.2 PB"), output);
300 BOOST_AUTO_TEST_CASE(nice_unit_format7)
302 const int64_t two_exabytes = 2000000000000000000LL;
304 string output = nice_unit_format(two_exabytes, LongUnitFormat, UnitBase1000);
305 BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output);
307 output = nice_unit_format(two_exabytes);
308 BOOST_CHECK_EQUAL(string("1776.4 PB"), output);
310 output = nice_unit_format(boost::numeric_cast<double>(two_exabytes), LongUnitFormat, UnitBase1000);
311 BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output);
313 output = nice_unit_format(boost::numeric_cast<double>(two_exabytes));
314 BOOST_CHECK_EQUAL(string("1776.4 PB"), output);
316 const int64_t two_and_half_exabytes = 2500000000000000000LL;
318 output = nice_unit_format(two_and_half_exabytes, LongUnitFormat, UnitBase1000);
319 BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output);
321 output = nice_unit_format(two_and_half_exabytes);
322 BOOST_CHECK_EQUAL(string("2220.4 PB"), output);
324 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_exabytes), LongUnitFormat, UnitBase1000);
325 BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output);
327 output = nice_unit_format(boost::numeric_cast<double>(two_and_half_exabytes));
328 BOOST_CHECK_EQUAL(string("2220.4 PB"), output);
331 BOOST_AUTO_TEST_CASE(nice_unit_format8)
333 const int64_t max_representable_64bits_number = 9223372036854775807LL;
335 string output = nice_unit_format(max_representable_64bits_number, LongUnitFormat, UnitBase1000);
336 BOOST_CHECK_EQUAL(string("9223.40 PBytes"), output);
338 output = nice_unit_format(max_representable_64bits_number);
339 BOOST_CHECK_EQUAL(string("8192.0 PB"), output);
342 double val = boost::numeric_cast<double>(max_representable_64bits_number);
343 BOOST_MESSAGE("val as int64 is " << max_representable_64bits_number << " and as double is " << val);
344 BOOST_MESSAGE("val rounded is " << round(val));
345 BOOST_CHECK_EQUAL(val, round(val));
346 BOOST_MESSAGE("half as int64 is " << boost::numeric_cast<int64_t>(round(val/2))); // ok
347 BOOST_MESSAGE("cast back is " << boost::numeric_cast<int64_t>(round(val))); // throws a positive overflow
348 output = nice_unit_format(boost::numeric_cast<double>(max_representable_64bits_number), LongUnitFormat, UnitBase1000);
349 BOOST_CHECK_EQUAL(string("9223.40 PBytes"), output);
351 output = nice_unit_format(boost::numeric_cast<double>(max_representable_64bits_number));
352 BOOST_CHECK_EQUAL(string("8192.0 PB"), output);
356 BOOST_AUTO_TEST_CASE(TestTrim)
360 BOOST_CHECK_EQUAL( std::string("s1"), s );
364 BOOST_CHECK_EQUAL( std::string("s2"), s );
368 BOOST_CHECK_EQUAL( std::string("s3"), s );
372 BOOST_CHECK_EQUAL( std::string("s4:s4"), s);
374 /* non modifying version */
377 BOOST_CHECK_EQUAL( std::string("s1"), trim(s) );
380 BOOST_CHECK_EQUAL( std::string("s2"), trim(s) );
381 BOOST_CHECK_EQUAL( std::string(" s2"), s );
384 BOOST_CHECK_EQUAL( std::string("s3"), trim(s) );
385 BOOST_CHECK_EQUAL( std::string("s3 "), s );
388 BOOST_CHECK_EQUAL( std::string("s4:s4"), trim(s,":+-a") );
393 BOOST_AUTO_TEST_CASE(TestChomp)
398 BOOST_CHECK_EQUAL( std::string("s1"), s );
402 BOOST_CHECK_EQUAL( std::string("s2"), s );
406 BOOST_CHECK_EQUAL( std::string("s3"), s );
410 BOOST_CHECK_EQUAL( std::string(":s4:"), s);
412 /* non modifiying versions */
415 BOOST_CHECK_EQUAL( std::string("s1"), chomp(s) );
418 BOOST_CHECK_EQUAL( std::string("s2"), chomp(s) );
419 BOOST_CHECK_EQUAL( std::string("s2\n"), s);
422 BOOST_CHECK_EQUAL( std::string("s3"), chomp(s,":") );
423 BOOST_CHECK_EQUAL( std::string("s3:"), s);
426 BOOST_CHECK_EQUAL( std::string(":s4:"), chomp(s,"s:") );
427 BOOST_CHECK_EQUAL( std::string(":s4::"), s);
432 BOOST_AUTO_TEST_CASE(TestSuffixFuncs)
434 std::string s1("12.cpp");
436 BOOST_CHECK_EQUAL( true, has_suffix(s1,".cpp") );
437 BOOST_CHECK_EQUAL( true, has_suffix(s1,"pp") );
438 BOOST_CHECK_EQUAL( false, has_suffix(s1,"hpp") );
439 BOOST_CHECK_EQUAL( false, has_suffix(s1,"cp") );
440 BOOST_CHECK_EQUAL( false, has_suffix(s1,"") );
442 std::string s1c1= remove_suffix(s1,".cpp");
443 BOOST_CHECK_EQUAL( std::string("12"), s1c1 );
445 std::string s1c2= remove_suffix(s1,"p");
446 BOOST_CHECK_EQUAL( std::string("12.cp"), s1c2 );
448 std::string s1c3= remove_suffix(s1,"cp");
449 BOOST_CHECK_EQUAL( std::string("12.cpp"), s1c3 );
451 std::string s2(".cpp");
452 BOOST_CHECK_EQUAL( true, has_suffix(s2,".cpp") );
454 std::string s2c1= remove_suffix(s2,".cpp");
455 BOOST_CHECK_EQUAL( std::string(""), s2c1 );
457 } // eo TestSuffixFuncs()
461 BOOST_AUTO_TEST_CASE(TestPrefixFuncs)
463 std::string s1("12.cpp");
465 BOOST_CHECK_EQUAL( true, has_prefix(s1,"12") );
466 BOOST_CHECK_EQUAL( true, has_prefix(s1, "1") );
467 BOOST_CHECK_EQUAL( false, has_prefix(s1, "2") );
468 BOOST_CHECK_EQUAL( false, has_prefix(s1, "") );
470 std::string s1c1= remove_prefix(s1, "12");
471 BOOST_CHECK_EQUAL( std::string(".cpp"), s1c1);
472 } // eo TestPrefixFuncs()
476 BOOST_AUTO_TEST_CASE(TestLowerUpperFuncs)
478 std::string u1("CASE CONVERSION TEST..");
479 std::string l1("case conversion test..");
481 std::string test1(l1);
484 BOOST_CHECK_EQUAL( u1, test1 );
487 BOOST_CHECK_EQUAL( l1, test1 );
490 BOOST_CHECK_EQUAL( u1, to_upper(l1) );
491 BOOST_CHECK_EQUAL( l1, to_lower(u1) );
492 } // eo TestLowerUpper
496 BOOST_AUTO_TEST_CASE(PairSplit1)
499 get_push_back_filler(str_list)
500 ("a=11")("a= 11")("a =11 ")("a = 11 ")(" a = 11 ")
502 BOOST_CHECK_EQUAL( 5u, str_list.size() );
503 for(StringList::iterator it= str_list.begin();
504 it != str_list.end();
507 std::string key, value;
508 bool res= pair_split( *it, key, value);
510 BOOST_CHECK_EQUAL( true , res );
511 BOOST_CHECK_EQUAL( std::string("a"), key );
512 BOOST_CHECK_EQUAL( std::string("11"), value );
515 std::string key, value;
518 res= pair_split(" 1 : 2 ", key, value, ':');
519 BOOST_CHECK_EQUAL( true, res );
520 BOOST_CHECK_EQUAL( std::string("1"), key);
521 BOOST_CHECK_EQUAL( std::string("2"), value);
526 BOOST_AUTO_TEST_CASE(SplitString1)
538 split_string(block, list1, "\n");
539 // since the blocks ends with \n we should have 6 lines (the last one empty):
540 BOOST_CHECK_EQUAL( 6u, list1.size() );
541 BOOST_CHECK_EQUAL( std::string(), list1.back() );
542 BOOST_CHECK_EQUAL( std::string("Zeile 1"), list1.front() );
546 split_string(block, list2, "\n", true);
548 // now we omitted empty lines, now we should have only 4 lines left:
549 BOOST_CHECK_EQUAL( 4u, list2.size() );
550 BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() );
551 BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() );
553 list2= split_string(block, "\n", true, "+-");
555 // again, we omitted empty lines, but also trimmed away leading and trailing "+" and "-"
556 BOOST_CHECK_EQUAL( 4u, list2.size() );
557 BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() );
558 BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() );
559 BOOST_CHECK_EQUAL( std::string("Zeile-2"), *(++list2.begin()) );
564 BOOST_AUTO_TEST_CASE(SplitString2)
566 std::string line("172.16.0.0/16 dev eth0 scope link src 172.16.1.111");
570 split_string(line, list1, " ", true, Whitespaces);
572 BOOST_CHECK_EQUAL( 7u, list1.size() );
578 BOOST_AUTO_TEST_CASE(SplitStringEmpty)
580 std::string line("");
584 split_string(line, list1, " ", true, Whitespaces);
586 BOOST_CHECK_EQUAL( 0u, list1.size() );
587 } // eo SplitStringEmpty
590 BOOST_AUTO_TEST_CASE(SplitStringDelimiterOnly)
592 std::string line(" ");
596 split_string(line, list1, " ", true, Whitespaces);
598 BOOST_CHECK_EQUAL( 0u, list1.size() );
599 } // eo SplitStringDelimiterOnly
602 BOOST_AUTO_TEST_CASE(SplitToVector)
604 std::string line("0;1;2;3;4;5;6;7;8;9");
605 std::vector<std::string> result;
606 split_string(line, result, ";");
607 BOOST_REQUIRE_EQUAL(result.size(), 10);
608 BOOST_CHECK_EQUAL(result[0], "0");
609 BOOST_CHECK_EQUAL(result[4], "4");
610 BOOST_CHECK_EQUAL(result[9], "9");
614 BOOST_AUTO_TEST_CASE(JoinString1)
616 std::list< std::string > parts;
617 get_push_back_filler(parts)("1")("2")("drei");
619 std::string joined_string= join_string(parts,"/");
620 // we should have slashes between the strings:
621 BOOST_CHECK_EQUAL( std::string("1/2/drei") , joined_string );
623 parts.push_back( std::string() );
624 joined_string= join_string(parts,"/");
625 // now we should have an additional trailing slash:
626 BOOST_CHECK_EQUAL( std::string("1/2/drei/") , joined_string );
628 parts.push_front( std::string() );
629 joined_string= join_string(parts,"/");
630 // now we should have an additional leading slash:
631 BOOST_CHECK_EQUAL( std::string("/1/2/drei/") , joined_string );
636 BOOST_AUTO_TEST_CASE(JoinStringVector)
638 std::vector< std::string > parts;
639 get_push_back_filler(parts)("1")("2")("drei");
641 std::string joined_string= join_string(parts,"/");
642 // we should have slashes between the strings:
643 BOOST_CHECK_EQUAL( std::string("1/2/drei") , joined_string );
645 parts.push_back( std::string() );
646 joined_string= join_string(parts,"/");
647 // now we should have an additional trailing slash:
648 BOOST_CHECK_EQUAL( std::string("1/2/drei/") , joined_string );
650 parts.insert(parts.begin(), "");
651 joined_string= join_string(parts,"/");
652 // now we should have an additional leading slash:
653 BOOST_CHECK_EQUAL( std::string("/1/2/drei/") , joined_string );
655 } // eo JoinStringVector
658 BOOST_AUTO_TEST_CASE(ConversionStringInt)
660 std::string s1("24");
661 std::string s1x("25x");
665 i1= string_to<int>(s1);
666 BOOST_CHECK_EQUAL( 24, i1 );
667 i1= string_to<int>(s1x);
668 BOOST_CHECK_EQUAL( 25, i1 );
670 res= string_to<int>(s1,i1);
671 BOOST_CHECK_EQUAL( true, res );
672 BOOST_CHECK_EQUAL( 24, i1 );
674 res= string_to<int>(s1x,i1);
675 BOOST_CHECK_EQUAL( false, res );
677 std::string ss1= to_string( 24 );
678 BOOST_CHECK_EQUAL( std::string("24"), ss1);
680 } // eo ConversionStringInt()
684 BOOST_AUTO_TEST_CASE(HexBinaryConversion)
686 std::string hex1("49324E");
687 std::string bin1("I2N");
689 BOOST_CHECK_EQUAL( hex1, convert_binary_to_hex(bin1,true) );
690 BOOST_CHECK_EQUAL( bin1, convert_hex_to_binary(hex1) );
691 BOOST_CHECK_EQUAL( to_lower(hex1), convert_binary_to_hex(bin1) );
693 std::string hex2("0001");
694 std::string hex2a("00 01");
695 std::string hex2b("00:01");
696 std::string bin2("\0\1",2);
698 BOOST_CHECK_EQUAL( hex2, convert_binary_to_hex(bin2) );
699 BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2) );
700 BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2a) );
701 BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2b) );
703 BOOST_REQUIRE_THROW( convert_hex_to_binary("01 kein hex"), std::runtime_error);
704 } // eo HexConversion()
706 BOOST_AUTO_TEST_CASE(HexIntConversion)
708 BOOST_CHECK_EQUAL( 255 , hex_string_to<uint32_t>("ff") );
709 BOOST_CHECK_EQUAL( 18866985 , hex_string_to<uint32_t>("11FE329") );
710 BOOST_CHECK_EQUAL( 44 , hex_string_to<uint32_t>("0x2C") );
713 BOOST_AUTO_TEST_CASE(sanitize_for_logging1)
715 string output = sanitize_for_logging("normaler string ohne aerger");
717 BOOST_CHECK_EQUAL(string("normaler string ohne aerger"), output);
720 BOOST_AUTO_TEST_CASE(sanitize_for_logging2)
722 string to_test="fiese";
723 to_test.push_back(0);
726 string output = sanitize_for_logging(to_test);
728 BOOST_CHECK_EQUAL(string("fiese?null"), output);
731 BOOST_AUTO_TEST_CASE(sanitize_for_logging3)
733 string output = sanitize_for_logging("läuter ümlaute utf8");
735 BOOST_CHECK_EQUAL(string("l??uter ??mlaute utf8"), output);
738 BOOST_AUTO_TEST_CASE(find_html_comments_test)
740 string text = "bla-->" // ==> (npos, 6)
742 "bla<!--bla<!--bla-->bla-->" // ==> (16, 26), (9, 32)
744 "bla<!--bla-->" // ==> (35, 45)
746 "--><!----><!--" // ==> (npos, 48), (48, 55), (55, npos)
748 "bla<!--bla-->"; // ==> (62, 72)
750 BOOST_REQUIRE_EQUAL(text.length(), 72);
751 vector<CommentZone> expect;
752 expect.push_back(CommentZone(string::npos, 6));
753 expect.push_back(CommentZone(16, 26));
754 expect.push_back(CommentZone( 9, 32));
755 expect.push_back(CommentZone(35, 45));
756 expect.push_back(CommentZone(string::npos, 48));
757 expect.push_back(CommentZone(48, 55));
758 expect.push_back(CommentZone(55, string::npos));
759 expect.push_back(CommentZone(62, 72));
760 vector<CommentZone> result = find_html_comments(text);
761 //BOOST_CHECK_EQUAL_COLLECTIONS(result.begin(), result.end(), not working, requires ...
762 // expect.begin(), expect.end()); ... operator<<(CommentZone)
763 BOOST_CHECK_EQUAL(result.size(), expect.size());
764 BOOST_FOREACH(const CommentZone &comment, expect)
765 BOOST_CHECK_MESSAGE(find(result.begin(), result.end(), comment) != result.end(),
766 "Find (" << comment.first << "-" << comment.second << ")");
769 BOOST_AUTO_TEST_CASE(remove_html_comments_test)
771 const string original = "First line outside\n"
775 "foo bar, what a surprise.\n"
776 "<!-- short tag-less comment -->\n"
777 " Html cannot handle this, thinks that FOO ended above\n"
779 "This, neither. No nested comments\n"
780 "some text <!--BAZ more text\n"
782 "more text BAZ--> even more\n"
784 "second line outside\n"
785 "<!-- second comment -->";
786 string text = original;
787 string expect = "First line outside\n"
789 "second line outside\n";
790 remove_html_comments(text);
791 BOOST_CHECK_EQUAL(text, expect);
792 remove_html_comments(text); // should not have any effect
793 BOOST_CHECK_EQUAL(text, expect);
795 text = string("test<!--") + original;
796 remove_html_comments(text);
797 BOOST_CHECK_EQUAL(text, "test");
799 text = original + "-->test";
800 remove_html_comments(text);
801 BOOST_CHECK_EQUAL(text, "test");
804 BOOST_AUTO_TEST_SUITE_END()