developer.intra2net.com Git - libi2ncommon/blob - test/stringfunc.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2006 by Intra2net AG                                    *
   3  *   info@intra2net.com                                                    *
   4  *                                                                         *
   5  ***************************************************************************/
   6
   7 // #include <iostream>
   8 #include <string>
   9 // #include <sstream>
  10 // #include <stdexcept>
  11
  12 #define BOOST_TEST_DYN_LINK
  13 #include <boost/test/unit_test.hpp>
  14
  15 #include <stringfunc.hxx>
  16 #include <containerfunc.hpp>
  17
  18 using namespace std;
  19 using namespace I2n;
  20
  21 typedef std::list< std::string > StringList;
  22
  23 BOOST_AUTO_TEST_SUITE(stringfunc)
  24
  25 BOOST_AUTO_TEST_CASE(smart_html_entites1)
  26 {
  27     string output = smart_html_entities("Test");
  28
  29     BOOST_CHECK_EQUAL(string("Test"), output);
  30 }
  31
  32 BOOST_AUTO_TEST_CASE(smart_html_entites2)
  33 {
  34     string output = smart_html_entities("Täst");
  35
  36     BOOST_CHECK_EQUAL(string("T&auml;st"), output);
  37 }
  38
  39 BOOST_AUTO_TEST_CASE(smart_html_entites3)
  40 {
  41     string output = smart_html_entities("<>");
  42
  43     BOOST_CHECK_EQUAL(string("<>"), output);
  44 }
  45
  46 BOOST_AUTO_TEST_CASE(smart_html_entites4)
  47 {
  48     string output = smart_html_entities("<ümlaut>");
  49
  50     BOOST_CHECK_EQUAL(string("<ümlaut>"), output);
  51 }
  52
  53 BOOST_AUTO_TEST_CASE(smart_html_entites5)
  54 {
  55     string output = smart_html_entities("Test<ümlaut>Blä");
  56
  57     BOOST_CHECK_EQUAL(string("Test<ümlaut>Bl&auml;"), output);
  58 }
  59
  60 BOOST_AUTO_TEST_CASE(smart_html_entites6)
  61 {
  62     string output = smart_html_entities("System > Einstellungen");
  63
  64     BOOST_CHECK_EQUAL(string("System &gt; Einstellungen"), output);
  65 }
  66
  67 BOOST_AUTO_TEST_CASE(smart_html_entites7)
  68 {
  69     string output = smart_html_entities("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">\"System > Einstellungen\"</a>. Oder etwa nicht?");
  70
  71     BOOST_CHECK_EQUAL(string("Finden Sie <b>auf</b> der Seite <a href=\"fdslfsl\">&quot;System &gt; Einstellungen&quot;</a>. Oder etwa nicht?"), output);
  72 }
  73
  74 BOOST_AUTO_TEST_CASE(strip_html_tags1)
  75 {
  76     string output = strip_html_tags("Was für ein schöner Tag, finden Sie nicht?");
  77
  78     BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
  79 }
  80
  81 BOOST_AUTO_TEST_CASE(strip_html_tags2)
  82 {
  83     string output = strip_html_tags("Was für ein <a href=\"wikipedia\" target=\"new\">schöner Tag</a>, finden Sie nicht?");
  84
  85     BOOST_CHECK_EQUAL(string("Was für ein schöner Tag, finden Sie nicht?"), output);
  86 }
  87
  88
  89
  90 BOOST_AUTO_TEST_CASE(html_entities1)
  91 {
  92     string output = html_entities("\xC3\xA4\xC3\xB6\xC3\xBC");
  93     BOOST_CHECK_EQUAL(string("&auml;&ouml;&uuml;"), output);
  94 }
  95
  96 BOOST_AUTO_TEST_CASE(html_entities2)
  97 {
  98     string output = html_entities("\xC3\xA5 \xC3\xB5 \xC3\xBF");
  99     BOOST_CHECK_EQUAL(string("&#229; &#245; &#255;"), output);
 100 }
 101
 102 BOOST_AUTO_TEST_CASE(html_entities3)
 103 {
 104     string output = html_entities("\xC4\x8E \xE0\xBC\xB1 \xE8\x82\x88");
 105     BOOST_CHECK_EQUAL(string("&#270; &#3889; &#32904;"), output);
 106 }
 107
 108
 109
 110 BOOST_AUTO_TEST_CASE(nice_unit_format1)
 111 {
 112     const int64_t two_bytes = 2;
 113
 114     string output = nice_unit_format(two_bytes, LongUnitFormat, UnitBase1000);
 115     BOOST_CHECK_EQUAL(string("2.00 Bytes"), output);
 116
 117     output = nice_unit_format(two_bytes, ShortUnitFormat, UnitBase1024);
 118     BOOST_CHECK_EQUAL(string("2.0 B"), output);
 119 }
 120
 121 BOOST_AUTO_TEST_CASE(nice_unit_format2)
 122 {
 123     const int64_t two_kilobytes = 2000;
 124
 125     string output = nice_unit_format(two_kilobytes, LongUnitFormat, UnitBase1000);
 126     BOOST_CHECK_EQUAL(string("2.00 KBytes"), output);
 127
 128     output = nice_unit_format(two_kilobytes, ShortUnitFormat, UnitBase1024);
 129     BOOST_CHECK_EQUAL(string("2.0 KB"), output);
 130
 131     const int64_t two_and_half_kilobytes = 2500;
 132
 133     output = nice_unit_format(two_and_half_kilobytes, LongUnitFormat, UnitBase1000);
 134     BOOST_CHECK_EQUAL(string("2.50 KBytes"), output);
 135
 136     output = nice_unit_format(two_and_half_kilobytes, ShortUnitFormat, UnitBase1024);
 137     BOOST_CHECK_EQUAL(string("2.4 KB"), output);
 138 }
 139
 140 BOOST_AUTO_TEST_CASE(nice_unit_format3)
 141 {
 142     const int64_t two_megabytes = 2000000;
 143
 144     string output = nice_unit_format(two_megabytes, LongUnitFormat, UnitBase1000);
 145     BOOST_CHECK_EQUAL(string("2.00 MBytes"), output);
 146
 147     output = nice_unit_format(two_megabytes, ShortUnitFormat, UnitBase1024);
 148     BOOST_CHECK_EQUAL(string("1.9 MB"), output);
 149
 150     const int64_t two_and_half_megabytes = 2500000;
 151
 152     output = nice_unit_format(two_and_half_megabytes, LongUnitFormat, UnitBase1000);
 153     BOOST_CHECK_EQUAL(string("2.50 MBytes"), output);
 154
 155     output = nice_unit_format(two_and_half_megabytes, ShortUnitFormat, UnitBase1024);
 156     BOOST_CHECK_EQUAL(string("2.4 MB"), output);
 157
 158 }
 159
 160 BOOST_AUTO_TEST_CASE(nice_unit_format4)
 161 {
 162     const int64_t two_gigabytes = 2000000000LL;
 163
 164     string output = nice_unit_format(two_gigabytes, LongUnitFormat, UnitBase1000);
 165     BOOST_CHECK_EQUAL(string("2.00 GBytes"), output);
 166
 167     output = nice_unit_format(two_gigabytes, ShortUnitFormat, UnitBase1024);
 168     BOOST_CHECK_EQUAL(string("1.9 GB"), output);
 169
 170     const int64_t two_and_half_gigabytes = 2500000000LL;
 171
 172     output = nice_unit_format(two_and_half_gigabytes, LongUnitFormat, UnitBase1000);
 173     BOOST_CHECK_EQUAL(string("2.50 GBytes"), output);
 174
 175     output = nice_unit_format(two_and_half_gigabytes, ShortUnitFormat, UnitBase1024);
 176     BOOST_CHECK_EQUAL(string("2.3 GB"), output);
 177 }
 178
 179 BOOST_AUTO_TEST_CASE(nice_unit_format5)
 180 {
 181     const int64_t two_terabytes = 2000000000000LL;
 182
 183     string output = nice_unit_format(two_terabytes, LongUnitFormat, UnitBase1000);
 184     BOOST_CHECK_EQUAL(string("2.00 TBytes"), output);
 185
 186     output = nice_unit_format(two_terabytes, ShortUnitFormat, UnitBase1024);
 187     BOOST_CHECK_EQUAL(string("1.8 TB"), output);
 188
 189     const int64_t two_and_half_terabytes = 2500000000000LL;
 190
 191     output = nice_unit_format(two_and_half_terabytes, LongUnitFormat, UnitBase1000);
 192     BOOST_CHECK_EQUAL(string("2.50 TBytes"), output);
 193
 194     output = nice_unit_format(two_and_half_terabytes, ShortUnitFormat, UnitBase1024);
 195     BOOST_CHECK_EQUAL(string("2.3 TB"), output);
 196 }
 197
 198 BOOST_AUTO_TEST_CASE(nice_unit_format6)
 199 {
 200     const int64_t two_petabytes = 2000000000000000LL;
 201
 202     string output = nice_unit_format(two_petabytes, LongUnitFormat, UnitBase1000);
 203     BOOST_CHECK_EQUAL(string("2.00 PBytes"), output);
 204
 205     output = nice_unit_format(two_petabytes, ShortUnitFormat, UnitBase1024);
 206     BOOST_CHECK_EQUAL(string("1.8 PB"), output);
 207
 208     const int64_t two_and_half_petabytes = 2500000000000000LL;
 209
 210     output = nice_unit_format(two_and_half_petabytes, LongUnitFormat, UnitBase1000);
 211     BOOST_CHECK_EQUAL(string("2.50 PBytes"), output);
 212
 213     output = nice_unit_format(two_and_half_petabytes, ShortUnitFormat, UnitBase1024);
 214     BOOST_CHECK_EQUAL(string("2.2 PB"), output);
 215 }
 216
 217 BOOST_AUTO_TEST_CASE(nice_unit_format7)
 218 {
 219     const int64_t two_exabytes = 2000000000000000000LL;
 220
 221     string output = nice_unit_format(two_exabytes, LongUnitFormat, UnitBase1000);
 222     BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output);
 223
 224     output = nice_unit_format(two_exabytes, ShortUnitFormat, UnitBase1024);
 225     BOOST_CHECK_EQUAL(string("1776.4 PB"), output);
 226
 227     const int64_t two_and_half_exabytes = 2500000000000000000LL;
 228
 229     output = nice_unit_format(two_and_half_exabytes, LongUnitFormat, UnitBase1000);
 230     BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output);
 231
 232     output = nice_unit_format(two_and_half_exabytes, ShortUnitFormat, UnitBase1024);
 233     BOOST_CHECK_EQUAL(string("2220.4 PB"), output);
 234 }
 235
 236 BOOST_AUTO_TEST_CASE(nice_unit_format8)
 237 {
 238     const int64_t max_representable_64bits_number = 9223372036854775807LL;
 239
 240     string output = nice_unit_format(max_representable_64bits_number, LongUnitFormat, UnitBase1000);
 241     BOOST_CHECK_EQUAL(string("9223.40 PBytes"), output);
 242
 243     output = nice_unit_format(max_representable_64bits_number, ShortUnitFormat, UnitBase1024);
 244     BOOST_CHECK_EQUAL(string("8192.0 PB"), output);
 245 }
 246
 247
 248
 249 BOOST_AUTO_TEST_CASE(imaputf7_to_utf8)
 250 {
 251     string output = utf7imap_to_utf8("Sp&AOQ-m");
 252     BOOST_CHECK_EQUAL(string("Späm"), output);
 253 }
 254
 255 BOOST_AUTO_TEST_CASE(utf8_to_imaputf7)
 256 {
 257     string output = utf8_to_utf7imap("Späm");
 258     BOOST_CHECK_EQUAL(string("Sp&AOQ-m"), output);
 259 }
 260
 261 /*
 262 **
 263 */
 264
 265 BOOST_AUTO_TEST_CASE(TestTrim)
 266 {
 267     std::string s("s1");
 268     trim_mod(s);
 269     BOOST_CHECK_EQUAL( std::string("s1"), s );
 270
 271     s="  s2";
 272     trim_mod(s);
 273     BOOST_CHECK_EQUAL( std::string("s2"), s );
 274
 275     s="s3   ";
 276     trim_mod(s);
 277     BOOST_CHECK_EQUAL( std::string("s3"), s );
 278
 279     s="::s4:s4::++--aa";
 280     trim_mod(s,":+-a");
 281     BOOST_CHECK_EQUAL( std::string("s4:s4"), s);
 282
 283     /* non modifying version */
 284
 285     s= "s1";
 286     BOOST_CHECK_EQUAL( std::string("s1"), trim(s) );
 287
 288     s="  s2";
 289     BOOST_CHECK_EQUAL( std::string("s2"), trim(s) );
 290     BOOST_CHECK_EQUAL( std::string("  s2"), s );
 291
 292     s="s3   ";
 293     BOOST_CHECK_EQUAL( std::string("s3"), trim(s) );
 294     BOOST_CHECK_EQUAL( std::string("s3   "), s );
 295
 296     s="::s4:s4::++--aa";
 297     BOOST_CHECK_EQUAL( std::string("s4:s4"), trim(s,":+-a") );
 298 } // eo TestTrim()
 299
 300
 301
 302 BOOST_AUTO_TEST_CASE(TestChomp)
 303 {
 304     std::string s("s1");
 305
 306     chomp_mod(s);
 307     BOOST_CHECK_EQUAL( std::string("s1"), s );
 308
 309     s="s2\n";
 310     chomp_mod(s);
 311     BOOST_CHECK_EQUAL( std::string("s2"), s );
 312
 313     s="s3:";
 314     chomp_mod(s,":");
 315     BOOST_CHECK_EQUAL( std::string("s3"), s );
 316
 317     s=":s4::";
 318     chomp_mod(s,"s:");
 319     BOOST_CHECK_EQUAL( std::string(":s4:"), s);
 320
 321     /* non modifiying versions */
 322     s= "s1";
 323
 324     BOOST_CHECK_EQUAL( std::string("s1"), chomp(s) );
 325
 326     s="s2\n";
 327     BOOST_CHECK_EQUAL( std::string("s2"), chomp(s) );
 328     BOOST_CHECK_EQUAL( std::string("s2\n"), s);
 329
 330     s="s3:";
 331     BOOST_CHECK_EQUAL( std::string("s3"), chomp(s,":") );
 332     BOOST_CHECK_EQUAL( std::string("s3:"), s);
 333
 334     s=":s4::";
 335     BOOST_CHECK_EQUAL( std::string(":s4:"), chomp(s,"s:") );
 336     BOOST_CHECK_EQUAL( std::string(":s4::"), s);
 337 } // eo TestChomp()
 338
 339
 340
 341 BOOST_AUTO_TEST_CASE(TestSuffixFuncs)
 342 {
 343     std::string s1("12.cpp");
 344
 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,"") );
 350
 351     std::string s1c1= remove_suffix(s1,".cpp");
 352     BOOST_CHECK_EQUAL( std::string("12"), s1c1 );
 353
 354     std::string s1c2= remove_suffix(s1,"p");
 355     BOOST_CHECK_EQUAL( std::string("12.cp"), s1c2 );
 356
 357     std::string s1c3= remove_suffix(s1,"cp");
 358     BOOST_CHECK_EQUAL( std::string("12.cpp"), s1c3 );
 359
 360     std::string s2(".cpp");
 361     BOOST_CHECK_EQUAL( true, has_suffix(s2,".cpp") );
 362
 363     std::string s2c1= remove_suffix(s2,".cpp");
 364     BOOST_CHECK_EQUAL( std::string(""), s2c1 );
 365
 366 } // eo TestSuffixFuncs()
 367
 368
 369
 370 BOOST_AUTO_TEST_CASE(TestPrefixFuncs)
 371 {
 372     std::string s1("12.cpp");
 373
 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, "") );
 378
 379     std::string s1c1= remove_prefix(s1, "12");
 380     BOOST_CHECK_EQUAL( std::string(".cpp"), s1c1);
 381 } // eo TestPrefixFuncs()
 382
 383
 384
 385 BOOST_AUTO_TEST_CASE(TestLowerUpperFuncs)
 386 {
 387     std::string u1("CASE CONVERSION TEST..");
 388     std::string l1("case conversion test..");
 389
 390     std::string test1(l1);
 391
 392     to_upper_mod(test1);
 393     BOOST_CHECK_EQUAL( u1, test1 );
 394
 395     to_lower_mod(test1);
 396     BOOST_CHECK_EQUAL( l1, test1 );
 397
 398
 399     BOOST_CHECK_EQUAL( u1, to_upper(l1) );
 400     BOOST_CHECK_EQUAL( l1, to_lower(u1) );
 401 } // eo TestLowerUpper
 402
 403
 404
 405 BOOST_AUTO_TEST_CASE(PairSplit1)
 406 {
 407     StringList str_list;
 408     get_push_back_filler(str_list)
 409         ("a=11")("a= 11")("a =11 ")("a =  11 ")("  a    =    11   ")
 410     ;
 411     BOOST_CHECK_EQUAL( 5u, str_list.size() );
 412     for(StringList::iterator it= str_list.begin();
 413         it != str_list.end();
 414         ++it)
 415     {
 416         std::string key, value;
 417         bool res= pair_split( *it, key, value);
 418
 419         BOOST_CHECK_EQUAL( true , res );
 420         BOOST_CHECK_EQUAL( std::string("a"), key );
 421         BOOST_CHECK_EQUAL( std::string("11"), value );
 422     }
 423
 424     std::string key, value;
 425     bool res;
 426
 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);
 431 } // eo PairSplit1
 432
 433
 434
 435 BOOST_AUTO_TEST_CASE(SplitString1)
 436 {
 437     std::string block(
 438         "Zeile 1\n"
 439         "++Zeile-2--\n"
 440         "Zeile 3\n"
 441         "\n"
 442         "Zeile 5\n"
 443     );
 444
 445     StringList list1;
 446
 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() );
 452
 453     StringList list2;
 454
 455     split_string(block, list2, "\n", true);
 456
 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() );
 461
 462     list2= split_string(block, "\n", true, "+-");
 463
 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()) );
 469 } // eo SplitString1
 470
 471
 472
 473 BOOST_AUTO_TEST_CASE(SplitString2)
 474 {
 475     std::string line("172.16.0.0/16 dev eth0  scope link  src 172.16.1.111");
 476
 477     StringList list1;
 478
 479     split_string(line, list1, " ", true, Whitespaces);
 480
 481     BOOST_CHECK_EQUAL( 7u, list1.size() );
 482
 483 } // eo SplitString2
 484
 485
 486
 487 BOOST_AUTO_TEST_CASE(SplitStringEmpty)
 488 {
 489     std::string line("");
 490
 491     StringList list1;
 492
 493     split_string(line, list1, " ", true, Whitespaces);
 494
 495     BOOST_CHECK_EQUAL( 0u, list1.size() );
 496 } // eo SplitStringEmpty
 497
 498
 499 BOOST_AUTO_TEST_CASE(SplitStringDelimiterOnly)
 500 {
 501     std::string line(" ");
 502
 503     StringList list1;
 504
 505     split_string(line, list1, " ", true, Whitespaces);
 506
 507     BOOST_CHECK_EQUAL( 0u, list1.size() );
 508 } // eo SplitStringDelimiterOnly
 509
 510
 511
 512 BOOST_AUTO_TEST_CASE(JoinString1)
 513 {
 514     std::list< std::string > parts;
 515     get_push_back_filler(parts)("1")("2")("drei");
 516
 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 );
 520
 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 );
 525
 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 );
 530
 531 } // eo JoinString1
 532
 533
 534
 535 BOOST_AUTO_TEST_CASE(ConversionStringInt)
 536 {
 537     std::string s1("24");
 538     std::string s1x("25x");
 539     int i1=0;
 540     bool res= false;
 541
 542     i1= string_to<int>(s1);
 543     BOOST_CHECK_EQUAL( 24, i1 );
 544     i1= string_to<int>(s1x);
 545     BOOST_CHECK_EQUAL( 25, i1 );
 546
 547     res= string_to<int>(s1,i1);
 548     BOOST_CHECK_EQUAL( true, res );
 549     BOOST_CHECK_EQUAL( 24, i1 );
 550
 551     res= string_to<int>(s1x,i1);
 552     BOOST_CHECK_EQUAL( false, res );
 553
 554     std::string ss1= to_string( 24 );
 555     BOOST_CHECK_EQUAL( std::string("24"), ss1);
 556
 557 } // eo ConversionStringInt()
 558
 559
 560
 561 BOOST_AUTO_TEST_CASE(HexConversion)
 562 {
 563     std::string hex1("49324E");
 564     std::string bin1("I2N");
 565
 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) );
 569
 570     std::string hex2("0001");
 571     std::string hex2a("00 01");
 572     std::string hex2b("00:01");
 573     std::string bin2("\0\1",2);
 574
 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) );
 579
 580     BOOST_REQUIRE_THROW( convert_hex_to_binary("01 kein hex"), std::runtime_error);
 581 } // eo HexConversion()
 582
 583 BOOST_AUTO_TEST_SUITE_END()