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>
28 // #include <stdexcept>
30 #define BOOST_TEST_DYN_LINK
31 #include <boost/test/unit_test.hpp>
33 #include <stringfunc.hxx>
34 #include <containerfunc.hpp>
39 typedef std::list< std::string > StringList;
41 BOOST_AUTO_TEST_SUITE(stringfunc)
43 BOOST_AUTO_TEST_CASE(smart_html_entites1)
45 string output = smart_html_entities("Test");
47 BOOST_CHECK_EQUAL(string("Test"), output);
50 BOOST_AUTO_TEST_CASE(smart_html_entites2)
52 string output = smart_html_entities("Täst");
54 BOOST_CHECK_EQUAL(string("Täst"), output);
57 BOOST_AUTO_TEST_CASE(smart_html_entites3)
59 string output = smart_html_entities("<>");
61 BOOST_CHECK_EQUAL(string("<>"), output);
64 BOOST_AUTO_TEST_CASE(smart_html_entites4)
66 string output = smart_html_entities("<ümlaut>");
68 BOOST_CHECK_EQUAL(string("<ümlaut>"), output);
71 BOOST_AUTO_TEST_CASE(smart_html_entites5)
73 string output = smart_html_entities("Test<ümlaut>Blä");
75 BOOST_CHECK_EQUAL(string("Test<ümlaut>Blä"), output);
78 BOOST_AUTO_TEST_CASE(smart_html_entites6)
80 string output = smart_html_entities("System > Einstellungen");
82 BOOST_CHECK_EQUAL(string("System > Einstellungen"), output);
85 BOOST_AUTO_TEST_CASE(smart_html_entites7)
87 string output = smart_html_entities("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">\"System > Einstellungen\"</a>. Oder etwa nicht?");
89 BOOST_CHECK_EQUAL(string("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">"System > Einstellungen"</a>. Oder etwa nicht?"), output);
92 BOOST_AUTO_TEST_CASE(strip_html_tags1)
94 string output = strip_html_tags("Was für ein schöner Tag, finden Sie nicht?");
96 BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
99 BOOST_AUTO_TEST_CASE(strip_html_tags2)
101 string output = strip_html_tags("Was für ein <a href=\"wikipedia\" target=\"new\">schöner Tag</a>, finden Sie nicht?");
103 BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
108 BOOST_AUTO_TEST_CASE(html_entities1)
110 string output = html_entities("\xC3\xA4\xC3\xB6\xC3\xBC");
111 BOOST_CHECK_EQUAL(string("äöü"), output);
114 BOOST_AUTO_TEST_CASE(html_entities2)
116 string output = html_entities("\xC3\xA5 \xC3\xB5 \xC3\xBF");
117 BOOST_CHECK_EQUAL(string("å õ ÿ"), output);
120 BOOST_AUTO_TEST_CASE(html_entities3)
122 string output = html_entities("\xC4\x8E \xE0\xBC\xB1 \xE8\x82\x88");
123 BOOST_CHECK_EQUAL(string("Ď ༱ 肈"), output);
128 BOOST_AUTO_TEST_CASE(nice_unit_format1)
130 const int64_t two_bytes = 2;
132 string output = nice_unit_format(two_bytes, LongUnitFormat, UnitBase1000);
133 BOOST_CHECK_EQUAL(string("2.00 Bytes"), output);
135 output = nice_unit_format(two_bytes);
136 BOOST_CHECK_EQUAL(string("2.0 B"), output);
139 BOOST_AUTO_TEST_CASE(nice_unit_format2)
141 const int64_t two_kilobytes = 2000;
143 string output = nice_unit_format(two_kilobytes, LongUnitFormat, UnitBase1000);
144 BOOST_CHECK_EQUAL(string("2.00 KBytes"), output);
146 output = nice_unit_format(two_kilobytes);
147 BOOST_CHECK_EQUAL(string("2.0 KB"), output);
149 const int64_t two_and_half_kilobytes = 2500;
151 output = nice_unit_format(two_and_half_kilobytes, LongUnitFormat, UnitBase1000);
152 BOOST_CHECK_EQUAL(string("2.50 KBytes"), output);
154 output = nice_unit_format(two_and_half_kilobytes);
155 BOOST_CHECK_EQUAL(string("2.4 KB"), output);
158 BOOST_AUTO_TEST_CASE(nice_unit_format3)
160 const int64_t two_megabytes = 2000000;
162 string output = nice_unit_format(two_megabytes, LongUnitFormat, UnitBase1000);
163 BOOST_CHECK_EQUAL(string("2.00 MBytes"), output);
165 output = nice_unit_format(two_megabytes);
166 BOOST_CHECK_EQUAL(string("1.9 MB"), output);
168 const int64_t two_and_half_megabytes = 2500000;
170 output = nice_unit_format(two_and_half_megabytes, LongUnitFormat, UnitBase1000);
171 BOOST_CHECK_EQUAL(string("2.50 MBytes"), output);
173 output = nice_unit_format(two_and_half_megabytes);
174 BOOST_CHECK_EQUAL(string("2.4 MB"), output);
178 BOOST_AUTO_TEST_CASE(nice_unit_format4)
180 const int64_t two_gigabytes = 2000000000LL;
182 string output = nice_unit_format(two_gigabytes, LongUnitFormat, UnitBase1000);
183 BOOST_CHECK_EQUAL(string("2.00 GBytes"), output);
185 output = nice_unit_format(two_gigabytes);
186 BOOST_CHECK_EQUAL(string("1.9 GB"), output);
188 const int64_t two_and_half_gigabytes = 2500000000LL;
190 output = nice_unit_format(two_and_half_gigabytes, LongUnitFormat, UnitBase1000);
191 BOOST_CHECK_EQUAL(string("2.50 GBytes"), output);
193 output = nice_unit_format(two_and_half_gigabytes);
194 BOOST_CHECK_EQUAL(string("2.3 GB"), output);
197 BOOST_AUTO_TEST_CASE(nice_unit_format5)
199 const int64_t two_terabytes = 2000000000000LL;
201 string output = nice_unit_format(two_terabytes, LongUnitFormat, UnitBase1000);
202 BOOST_CHECK_EQUAL(string("2.00 TBytes"), output);
204 output = nice_unit_format(two_terabytes);
205 BOOST_CHECK_EQUAL(string("1.8 TB"), output);
207 const int64_t two_and_half_terabytes = 2500000000000LL;
209 output = nice_unit_format(two_and_half_terabytes, LongUnitFormat, UnitBase1000);
210 BOOST_CHECK_EQUAL(string("2.50 TBytes"), output);
212 output = nice_unit_format(two_and_half_terabytes);
213 BOOST_CHECK_EQUAL(string("2.3 TB"), output);
216 BOOST_AUTO_TEST_CASE(nice_unit_format6)
218 const int64_t two_petabytes = 2000000000000000LL;
220 string output = nice_unit_format(two_petabytes, LongUnitFormat, UnitBase1000);
221 BOOST_CHECK_EQUAL(string("2.00 PBytes"), output);
223 output = nice_unit_format(two_petabytes);
224 BOOST_CHECK_EQUAL(string("1.8 PB"), output);
226 const int64_t two_and_half_petabytes = 2500000000000000LL;
228 output = nice_unit_format(two_and_half_petabytes, LongUnitFormat, UnitBase1000);
229 BOOST_CHECK_EQUAL(string("2.50 PBytes"), output);
231 output = nice_unit_format(two_and_half_petabytes);
232 BOOST_CHECK_EQUAL(string("2.2 PB"), output);
235 BOOST_AUTO_TEST_CASE(nice_unit_format7)
237 const int64_t two_exabytes = 2000000000000000000LL;
239 string output = nice_unit_format(two_exabytes, LongUnitFormat, UnitBase1000);
240 BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output);
242 output = nice_unit_format(two_exabytes);
243 BOOST_CHECK_EQUAL(string("1776.4 PB"), output);
245 const int64_t two_and_half_exabytes = 2500000000000000000LL;
247 output = nice_unit_format(two_and_half_exabytes, LongUnitFormat, UnitBase1000);
248 BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output);
250 output = nice_unit_format(two_and_half_exabytes);
251 BOOST_CHECK_EQUAL(string("2220.4 PB"), output);
254 BOOST_AUTO_TEST_CASE(nice_unit_format8)
256 const int64_t max_representable_64bits_number = 9223372036854775807LL;
258 string output = nice_unit_format(max_representable_64bits_number, LongUnitFormat, UnitBase1000);
259 BOOST_CHECK_EQUAL(string("9223.40 PBytes"), output);
261 output = nice_unit_format(max_representable_64bits_number);
262 BOOST_CHECK_EQUAL(string("8192.0 PB"), output);
265 BOOST_AUTO_TEST_CASE(TestTrim)
269 BOOST_CHECK_EQUAL( std::string("s1"), s );
273 BOOST_CHECK_EQUAL( std::string("s2"), s );
277 BOOST_CHECK_EQUAL( std::string("s3"), s );
281 BOOST_CHECK_EQUAL( std::string("s4:s4"), s);
283 /* non modifying version */
286 BOOST_CHECK_EQUAL( std::string("s1"), trim(s) );
289 BOOST_CHECK_EQUAL( std::string("s2"), trim(s) );
290 BOOST_CHECK_EQUAL( std::string(" s2"), s );
293 BOOST_CHECK_EQUAL( std::string("s3"), trim(s) );
294 BOOST_CHECK_EQUAL( std::string("s3 "), s );
297 BOOST_CHECK_EQUAL( std::string("s4:s4"), trim(s,":+-a") );
302 BOOST_AUTO_TEST_CASE(TestChomp)
307 BOOST_CHECK_EQUAL( std::string("s1"), s );
311 BOOST_CHECK_EQUAL( std::string("s2"), s );
315 BOOST_CHECK_EQUAL( std::string("s3"), s );
319 BOOST_CHECK_EQUAL( std::string(":s4:"), s);
321 /* non modifiying versions */
324 BOOST_CHECK_EQUAL( std::string("s1"), chomp(s) );
327 BOOST_CHECK_EQUAL( std::string("s2"), chomp(s) );
328 BOOST_CHECK_EQUAL( std::string("s2\n"), s);
331 BOOST_CHECK_EQUAL( std::string("s3"), chomp(s,":") );
332 BOOST_CHECK_EQUAL( std::string("s3:"), s);
335 BOOST_CHECK_EQUAL( std::string(":s4:"), chomp(s,"s:") );
336 BOOST_CHECK_EQUAL( std::string(":s4::"), s);
341 BOOST_AUTO_TEST_CASE(TestSuffixFuncs)
343 std::string s1("12.cpp");
345 BOOST_CHECK_EQUAL( true, has_suffix(s1,".cpp") );
346 BOOST_CHECK_EQUAL( true, has_suffix(s1,"pp") );
347 BOOST_CHECK_EQUAL( false, has_suffix(s1,"hpp") );
348 BOOST_CHECK_EQUAL( false, has_suffix(s1,"cp") );
349 BOOST_CHECK_EQUAL( false, has_suffix(s1,"") );
351 std::string s1c1= remove_suffix(s1,".cpp");
352 BOOST_CHECK_EQUAL( std::string("12"), s1c1 );
354 std::string s1c2= remove_suffix(s1,"p");
355 BOOST_CHECK_EQUAL( std::string("12.cp"), s1c2 );
357 std::string s1c3= remove_suffix(s1,"cp");
358 BOOST_CHECK_EQUAL( std::string("12.cpp"), s1c3 );
360 std::string s2(".cpp");
361 BOOST_CHECK_EQUAL( true, has_suffix(s2,".cpp") );
363 std::string s2c1= remove_suffix(s2,".cpp");
364 BOOST_CHECK_EQUAL( std::string(""), s2c1 );
366 } // eo TestSuffixFuncs()
370 BOOST_AUTO_TEST_CASE(TestPrefixFuncs)
372 std::string s1("12.cpp");
374 BOOST_CHECK_EQUAL( true, has_prefix(s1,"12") );
375 BOOST_CHECK_EQUAL( true, has_prefix(s1, "1") );
376 BOOST_CHECK_EQUAL( false, has_prefix(s1, "2") );
377 BOOST_CHECK_EQUAL( false, has_prefix(s1, "") );
379 std::string s1c1= remove_prefix(s1, "12");
380 BOOST_CHECK_EQUAL( std::string(".cpp"), s1c1);
381 } // eo TestPrefixFuncs()
385 BOOST_AUTO_TEST_CASE(TestLowerUpperFuncs)
387 std::string u1("CASE CONVERSION TEST..");
388 std::string l1("case conversion test..");
390 std::string test1(l1);
393 BOOST_CHECK_EQUAL( u1, test1 );
396 BOOST_CHECK_EQUAL( l1, test1 );
399 BOOST_CHECK_EQUAL( u1, to_upper(l1) );
400 BOOST_CHECK_EQUAL( l1, to_lower(u1) );
401 } // eo TestLowerUpper
405 BOOST_AUTO_TEST_CASE(PairSplit1)
408 get_push_back_filler(str_list)
409 ("a=11")("a= 11")("a =11 ")("a = 11 ")(" a = 11 ")
411 BOOST_CHECK_EQUAL( 5u, str_list.size() );
412 for(StringList::iterator it= str_list.begin();
413 it != str_list.end();
416 std::string key, value;
417 bool res= pair_split( *it, key, value);
419 BOOST_CHECK_EQUAL( true , res );
420 BOOST_CHECK_EQUAL( std::string("a"), key );
421 BOOST_CHECK_EQUAL( std::string("11"), value );
424 std::string key, value;
427 res= pair_split(" 1 : 2 ", key, value, ':');
428 BOOST_CHECK_EQUAL( true, res );
429 BOOST_CHECK_EQUAL( std::string("1"), key);
430 BOOST_CHECK_EQUAL( std::string("2"), value);
435 BOOST_AUTO_TEST_CASE(SplitString1)
447 split_string(block, list1, "\n");
448 // since the blocks ends with \n we should have 6 lines (the last one empty):
449 BOOST_CHECK_EQUAL( 6u, list1.size() );
450 BOOST_CHECK_EQUAL( std::string(), list1.back() );
451 BOOST_CHECK_EQUAL( std::string("Zeile 1"), list1.front() );
455 split_string(block, list2, "\n", true);
457 // now we omitted empty lines, now we should have only 4 lines left:
458 BOOST_CHECK_EQUAL( 4u, list2.size() );
459 BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() );
460 BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() );
462 list2= split_string(block, "\n", true, "+-");
464 // again, we omitted empty lines, but also trimmed away leading and trailing "+" and "-"
465 BOOST_CHECK_EQUAL( 4u, list2.size() );
466 BOOST_CHECK_EQUAL( std::string("Zeile 5"), list2.back() );
467 BOOST_CHECK_EQUAL( std::string("Zeile 1"), list2.front() );
468 BOOST_CHECK_EQUAL( std::string("Zeile-2"), *(++list2.begin()) );
473 BOOST_AUTO_TEST_CASE(SplitString2)
475 std::string line("172.16.0.0/16 dev eth0 scope link src 172.16.1.111");
479 split_string(line, list1, " ", true, Whitespaces);
481 BOOST_CHECK_EQUAL( 7u, list1.size() );
487 BOOST_AUTO_TEST_CASE(SplitStringEmpty)
489 std::string line("");
493 split_string(line, list1, " ", true, Whitespaces);
495 BOOST_CHECK_EQUAL( 0u, list1.size() );
496 } // eo SplitStringEmpty
499 BOOST_AUTO_TEST_CASE(SplitStringDelimiterOnly)
501 std::string line(" ");
505 split_string(line, list1, " ", true, Whitespaces);
507 BOOST_CHECK_EQUAL( 0u, list1.size() );
508 } // eo SplitStringDelimiterOnly
512 BOOST_AUTO_TEST_CASE(JoinString1)
514 std::list< std::string > parts;
515 get_push_back_filler(parts)("1")("2")("drei");
517 std::string joined_string= join_string(parts,"/");
518 // we should have slashes between the strings:
519 BOOST_CHECK_EQUAL( std::string("1/2/drei") , joined_string );
521 parts.push_back( std::string() );
522 joined_string= join_string(parts,"/");
523 // now we should have an additional trailing slash:
524 BOOST_CHECK_EQUAL( std::string("1/2/drei/") , joined_string );
526 parts.push_front( std::string() );
527 joined_string= join_string(parts,"/");
528 // now we should have an additional leading slash:
529 BOOST_CHECK_EQUAL( std::string("/1/2/drei/") , joined_string );
535 BOOST_AUTO_TEST_CASE(ConversionStringInt)
537 std::string s1("24");
538 std::string s1x("25x");
542 i1= string_to<int>(s1);
543 BOOST_CHECK_EQUAL( 24, i1 );
544 i1= string_to<int>(s1x);
545 BOOST_CHECK_EQUAL( 25, i1 );
547 res= string_to<int>(s1,i1);
548 BOOST_CHECK_EQUAL( true, res );
549 BOOST_CHECK_EQUAL( 24, i1 );
551 res= string_to<int>(s1x,i1);
552 BOOST_CHECK_EQUAL( false, res );
554 std::string ss1= to_string( 24 );
555 BOOST_CHECK_EQUAL( std::string("24"), ss1);
557 } // eo ConversionStringInt()
561 BOOST_AUTO_TEST_CASE(HexConversion)
563 std::string hex1("49324E");
564 std::string bin1("I2N");
566 BOOST_CHECK_EQUAL( hex1, convert_binary_to_hex(bin1,true) );
567 BOOST_CHECK_EQUAL( bin1, convert_hex_to_binary(hex1) );
568 BOOST_CHECK_EQUAL( to_lower(hex1), convert_binary_to_hex(bin1) );
570 std::string hex2("0001");
571 std::string hex2a("00 01");
572 std::string hex2b("00:01");
573 std::string bin2("\0\1",2);
575 BOOST_CHECK_EQUAL( hex2, convert_binary_to_hex(bin2) );
576 BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2) );
577 BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2a) );
578 BOOST_CHECK_EQUAL( bin2, convert_hex_to_binary(hex2b) );
580 BOOST_REQUIRE_THROW( convert_hex_to_binary("01 kein hex"), std::runtime_error);
581 } // eo HexConversion()
583 BOOST_AUTO_TEST_SUITE_END()