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

   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 */
  20 /***************************************************************************
  21  *   Copyright (C) 2006-2011 by Intra2net AG                               *
  22  *                                                                         *
  23  ***************************************************************************/
  24
  25 // #include <iostream>
  26 #include <string>
  27 #include <cmath>
  28 // #include <sstream>
  29 // #include <stdexcept>
  30
  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>
  35
  36 #include <stringfunc.hxx>
  37 #include <containerfunc.hpp>
  38 #include <iostream>
  39 #include <stdint.h>
  40
  41 using namespace std;
  42 using namespace I2n;
  43
  44 typedef std::list< std::string > StringList;
  45
  46 BOOST_AUTO_TEST_SUITE(stringfunc)
  47
  48 BOOST_AUTO_TEST_CASE(smart_html_entites1)
  49 {
  50     string output = smart_html_entities("Test");
  51
  52     BOOST_CHECK_EQUAL(string("Test"), output);
  53 }
  54
  55 BOOST_AUTO_TEST_CASE(smart_html_entites2)
  56 {
  57     string output = smart_html_entities("Täst");
  58
  59     BOOST_CHECK_EQUAL(string("T&auml;st"), output);
  60 }
  61
  62 BOOST_AUTO_TEST_CASE(smart_html_entites3)
  63 {
  64     string output = smart_html_entities("<>");
  65
  66     BOOST_CHECK_EQUAL(string("<>"), output);
  67 }
  68
  69 BOOST_AUTO_TEST_CASE(smart_html_entites4)
  70 {
  71     string output = smart_html_entities("<ümlaut>");
  72
  73     BOOST_CHECK_EQUAL(string("<ümlaut>"), output);
  74 }
  75
  76 BOOST_AUTO_TEST_CASE(smart_html_entites5)
  77 {
  78     string output = smart_html_entities("Test<ümlaut>Blä");
  79
  80     BOOST_CHECK_EQUAL(string("Test<ümlaut>Bl&auml;"), output);
  81 }
  82
  83 BOOST_AUTO_TEST_CASE(smart_html_entites6)
  84 {
  85     string output = smart_html_entities("System > Einstellungen");
  86
  87     BOOST_CHECK_EQUAL(string("System &gt; Einstellungen"), output);
  88 }
  89
  90 BOOST_AUTO_TEST_CASE(smart_html_entites7)
  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\">&quot;System &gt; Einstellungen&quot;</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
 111
 112
 113 BOOST_AUTO_TEST_CASE(html_entities1)
 114 {
 115     string output = html_entities("\xC3\xA4\xC3\xB6\xC3\xBC");
 116     BOOST_CHECK_EQUAL(string("&auml;&ouml;&uuml;"), 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("&#229; &#245; &#255;"), 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("&#270; &#3889; &#32904;"), output);
 129 }
 130
 131
 132
 133 BOOST_AUTO_TEST_CASE(nice_unit_format1)
 134 {
 135     const int64_t two_bytes = 2;
 136
 137     string output = nice_unit_format(two_bytes, LongUnitFormat, UnitBase1000);
 138     BOOST_CHECK_EQUAL(string("2.00 Bytes"), output);
 139
 140     output = nice_unit_format(two_bytes);
 141     BOOST_CHECK_EQUAL(string("2.0 B"), output);
 142 }
 143
 144 BOOST_AUTO_TEST_CASE(nice_unit_format2)
 145 {
 146     const int64_t two_kilobytes = 2000;
 147
 148     string output = nice_unit_format(two_kilobytes, LongUnitFormat, UnitBase1000);
 149     BOOST_CHECK_EQUAL(string("2.00 KBytes"), output);
 150
 151     output = nice_unit_format(two_kilobytes);
 152     BOOST_CHECK_EQUAL(string("2.0 KB"), output);
 153
 154     output = nice_unit_format(boost::numeric_cast<double>(two_kilobytes), LongUnitFormat, UnitBase1000);
 155     BOOST_CHECK_EQUAL(string("2.00 KBytes"), output);
 156
 157     output = nice_unit_format(boost::numeric_cast<double>(two_kilobytes));
 158     BOOST_CHECK_EQUAL(string("2.0 KB"), output);
 159
 160     const int64_t two_and_half_kilobytes = 2500;
 161
 162     output = nice_unit_format(two_and_half_kilobytes, LongUnitFormat, UnitBase1000);
 163     BOOST_CHECK_EQUAL(string("2.50 KBytes"), output);
 164
 165     output = nice_unit_format(two_and_half_kilobytes);
 166     BOOST_CHECK_EQUAL(string("2.4 KB"), output);
 167
 168     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_kilobytes), LongUnitFormat, UnitBase1000);
 169     BOOST_CHECK_EQUAL(string("2.50 KBytes"), output);
 170
 171     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_kilobytes));
 172     BOOST_CHECK_EQUAL(string("2.4 KB"), output);
 173 }
 174
 175 BOOST_AUTO_TEST_CASE(nice_unit_format3)
 176 {
 177     const int64_t two_megabytes = 2000000;
 178
 179     string output = nice_unit_format(two_megabytes, LongUnitFormat, UnitBase1000);
 180     BOOST_CHECK_EQUAL(string("2.00 MBytes"), output);
 181
 182     output = nice_unit_format(two_megabytes);
 183     BOOST_CHECK_EQUAL(string("1.9 MB"), output);
 184
 185     output = nice_unit_format(boost::numeric_cast<double>(two_megabytes), LongUnitFormat, UnitBase1000);
 186     BOOST_CHECK_EQUAL(string("2.00 MBytes"), output);
 187
 188     output = nice_unit_format(boost::numeric_cast<double>(two_megabytes));
 189     BOOST_CHECK_EQUAL(string("1.9 MB"), output);
 190
 191     const int64_t two_and_half_megabytes = 2500000;
 192
 193     output = nice_unit_format(two_and_half_megabytes, LongUnitFormat, UnitBase1000);
 194     BOOST_CHECK_EQUAL(string("2.50 MBytes"), output);
 195
 196     output = nice_unit_format(two_and_half_megabytes);
 197     BOOST_CHECK_EQUAL(string("2.4 MB"), output);
 198
 199     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_megabytes), LongUnitFormat, UnitBase1000);
 200     BOOST_CHECK_EQUAL(string("2.50 MBytes"), output);
 201
 202     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_megabytes));
 203     BOOST_CHECK_EQUAL(string("2.4 MB"), output);
 204
 205 }
 206
 207 BOOST_AUTO_TEST_CASE(nice_unit_format4)
 208 {
 209     const int64_t two_gigabytes = 2000000000LL;
 210
 211     string output = nice_unit_format(two_gigabytes, LongUnitFormat, UnitBase1000);
 212     BOOST_CHECK_EQUAL(string("2.00 GBytes"), output);
 213
 214     output = nice_unit_format(two_gigabytes);
 215     BOOST_CHECK_EQUAL(string("1.9 GB"), output);
 216
 217     output = nice_unit_format(boost::numeric_cast<double>(two_gigabytes), LongUnitFormat, UnitBase1000);
 218     BOOST_CHECK_EQUAL(string("2.00 GBytes"), output);
 219
 220     output = nice_unit_format(boost::numeric_cast<double>(two_gigabytes));
 221     BOOST_CHECK_EQUAL(string("1.9 GB"), output);
 222
 223     const int64_t two_and_half_gigabytes = 2500000000LL;
 224
 225     output = nice_unit_format(two_and_half_gigabytes, LongUnitFormat, UnitBase1000);
 226     BOOST_CHECK_EQUAL(string("2.50 GBytes"), output);
 227
 228     output = nice_unit_format(two_and_half_gigabytes);
 229     BOOST_CHECK_EQUAL(string("2.3 GB"), output);
 230
 231     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_gigabytes), LongUnitFormat, UnitBase1000);
 232     BOOST_CHECK_EQUAL(string("2.50 GBytes"), output);
 233
 234     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_gigabytes));
 235     BOOST_CHECK_EQUAL(string("2.3 GB"), output);
 236 }
 237
 238 BOOST_AUTO_TEST_CASE(nice_unit_format5)
 239 {
 240     const int64_t two_terabytes = 2000000000000LL;
 241
 242     string output = nice_unit_format(two_terabytes, LongUnitFormat, UnitBase1000);
 243     BOOST_CHECK_EQUAL(string("2.00 TBytes"), output);
 244
 245     output = nice_unit_format(two_terabytes);
 246     BOOST_CHECK_EQUAL(string("1.8 TB"), output);
 247
 248     output = nice_unit_format(boost::numeric_cast<double>(two_terabytes), LongUnitFormat, UnitBase1000);
 249     BOOST_CHECK_EQUAL(string("2.00 TBytes"), output);
 250
 251     output = nice_unit_format(boost::numeric_cast<double>(two_terabytes));
 252     BOOST_CHECK_EQUAL(string("1.8 TB"), output);
 253
 254     const int64_t two_and_half_terabytes = 2500000000000LL;
 255
 256     output = nice_unit_format(two_and_half_terabytes, LongUnitFormat, UnitBase1000);
 257     BOOST_CHECK_EQUAL(string("2.50 TBytes"), output);
 258
 259     output = nice_unit_format(two_and_half_terabytes);
 260     BOOST_CHECK_EQUAL(string("2.3 TB"), output);
 261
 262     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_terabytes), LongUnitFormat, UnitBase1000);
 263     BOOST_CHECK_EQUAL(string("2.50 TBytes"), output);
 264
 265     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_terabytes));
 266     BOOST_CHECK_EQUAL(string("2.3 TB"), output);
 267 }
 268
 269 BOOST_AUTO_TEST_CASE(nice_unit_format6)
 270 {
 271     const int64_t two_petabytes = 2000000000000000LL;
 272
 273     string output = nice_unit_format(two_petabytes, LongUnitFormat, UnitBase1000);
 274     BOOST_CHECK_EQUAL(string("2.00 PBytes"), output);
 275
 276     output = nice_unit_format(two_petabytes);
 277     BOOST_CHECK_EQUAL(string("1.8 PB"), output);
 278
 279     output = nice_unit_format(boost::numeric_cast<double>(two_petabytes), LongUnitFormat, UnitBase1000);
 280     BOOST_CHECK_EQUAL(string("2.00 PBytes"), output);
 281
 282     output = nice_unit_format(boost::numeric_cast<double>(two_petabytes));
 283     BOOST_CHECK_EQUAL(string("1.8 PB"), output);
 284
 285     const int64_t two_and_half_petabytes = 2500000000000000LL;
 286
 287     output = nice_unit_format(two_and_half_petabytes, LongUnitFormat, UnitBase1000);
 288     BOOST_CHECK_EQUAL(string("2.50 PBytes"), output);
 289
 290     output = nice_unit_format(two_and_half_petabytes);
 291     BOOST_CHECK_EQUAL(string("2.2 PB"), output);
 292
 293     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_petabytes), LongUnitFormat, UnitBase1000);
 294     BOOST_CHECK_EQUAL(string("2.50 PBytes"), output);
 295
 296     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_petabytes));
 297     BOOST_CHECK_EQUAL(string("2.2 PB"), output);
 298 }
 299
 300 BOOST_AUTO_TEST_CASE(nice_unit_format7)
 301 {
 302     const int64_t two_exabytes = 2000000000000000000LL;
 303
 304     string output = nice_unit_format(two_exabytes, LongUnitFormat, UnitBase1000);
 305     BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output);
 306
 307     output = nice_unit_format(two_exabytes);
 308     BOOST_CHECK_EQUAL(string("1776.4 PB"), output);
 309
 310     output = nice_unit_format(boost::numeric_cast<double>(two_exabytes), LongUnitFormat, UnitBase1000);
 311     BOOST_CHECK_EQUAL(string("2000.00 PBytes"), output);
 312
 313     output = nice_unit_format(boost::numeric_cast<double>(two_exabytes));
 314     BOOST_CHECK_EQUAL(string("1776.4 PB"), output);
 315
 316     const int64_t two_and_half_exabytes = 2500000000000000000LL;
 317
 318     output = nice_unit_format(two_and_half_exabytes, LongUnitFormat, UnitBase1000);
 319     BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output);
 320
 321     output = nice_unit_format(two_and_half_exabytes);
 322     BOOST_CHECK_EQUAL(string("2220.4 PB"), output);
 323
 324     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_exabytes), LongUnitFormat, UnitBase1000);
 325     BOOST_CHECK_EQUAL(string("2500.00 PBytes"), output);
 326
 327     output = nice_unit_format(boost::numeric_cast<double>(two_and_half_exabytes));
 328     BOOST_CHECK_EQUAL(string("2220.4 PB"), output);
 329 }
 330
 331 BOOST_AUTO_TEST_CASE(nice_unit_format8)
 332 {
 333     const int64_t max_representable_64bits_number = 9223372036854775807LL;
 334
 335     string output = nice_unit_format(max_representable_64bits_number, LongUnitFormat, UnitBase1000);
 336     BOOST_CHECK_EQUAL(string("9223.40 PBytes"), output);
 337
 338     output = nice_unit_format(max_representable_64bits_number);
 339     BOOST_CHECK_EQUAL(string("8192.0 PB"), output);
 340
 341     /*
 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);
 350
 351     output = nice_unit_format(boost::numeric_cast<double>(max_representable_64bits_number));
 352     BOOST_CHECK_EQUAL(string("8192.0 PB"), output);
 353     */
 354 }
 355
 356 BOOST_AUTO_TEST_CASE(TestTrim)
 357 {
 358     std::string s("s1");
 359     trim_mod(s);
 360     BOOST_CHECK_EQUAL( std::string("s1"), s );
 361
 362     s="  s2";
 363     trim_mod(s);
 364     BOOST_CHECK_EQUAL( std::string("s2"), s );
 365
 366     s="s3   ";
 367     trim_mod(s);
 368     BOOST_CHECK_EQUAL( std::string("s3"), s );
 369
 370     s="::s4:s4::++--aa";
 371     trim_mod(s,":+-a");
 372     BOOST_CHECK_EQUAL( std::string("s4:s4"), s);
 373
 374     /* non modifying version */
 375
 376     s= "s1";
 377     BOOST_CHECK_EQUAL( std::string("s1"), trim(s) );
 378
 379     s="  s2";
 380     BOOST_CHECK_EQUAL( std::string("s2"), trim(s) );
 381     BOOST_CHECK_EQUAL( std::string("  s2"), s );
 382
 383     s="s3   ";
 384     BOOST_CHECK_EQUAL( std::string("s3"), trim(s) );
 385     BOOST_CHECK_EQUAL( std::string("s3   "), s );
 386
 387     s="::s4:s4::++--aa";
 388     BOOST_CHECK_EQUAL( std::string("s4:s4"), trim(s,":+-a") );
 389 } // eo TestTrim()
 390
 391
 392
 393 BOOST_AUTO_TEST_CASE(TestChomp)
 394 {
 395     std::string s("s1");
 396
 397     chomp_mod(s);
 398     BOOST_CHECK_EQUAL( std::string("s1"), s );
 399
 400     s="s2\n";
 401     chomp_mod(s);
 402     BOOST_CHECK_EQUAL( std::string("s2"), s );
 403
 404     s="s3:";
 405     chomp_mod(s,":");
 406     BOOST_CHECK_EQUAL( std::string("s3"), s );
 407
 408     s=":s4::";
 409     chomp_mod(s,"s:");
 410     BOOST_CHECK_EQUAL( std::string(":s4:"), s);
 411
 412     /* non modifiying versions */
 413     s= "s1";
 414
 415     BOOST_CHECK_EQUAL( std::string("s1"), chomp(s) );
 416
 417     s="s2\n";
 418     BOOST_CHECK_EQUAL( std::string("s2"), chomp(s) );
 419     BOOST_CHECK_EQUAL( std::string("s2\n"), s);
 420
 421     s="s3:";
 422     BOOST_CHECK_EQUAL( std::string("s3"), chomp(s,":") );
 423     BOOST_CHECK_EQUAL( std::string("s3:"), s);
 424
 425     s=":s4::";
 426     BOOST_CHECK_EQUAL( std::string(":s4:"), chomp(s,"s:") );
 427     BOOST_CHECK_EQUAL( std::string(":s4::"), s);
 428 } // eo TestChomp()
 429
 430
 431
 432 BOOST_AUTO_TEST_CASE(TestSuffixFuncs)
 433 {
 434     std::string s1("12.cpp");
 435
 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,"") );
 441
 442     std::string s1c1= remove_suffix(s1,".cpp");
 443     BOOST_CHECK_EQUAL( std::string("12"), s1c1 );
 444
 445     std::string s1c2= remove_suffix(s1,"p");
 446     BOOST_CHECK_EQUAL( std::string("12.cp"), s1c2 );
 447
 448     std::string s1c3= remove_suffix(s1,"cp");
 449     BOOST_CHECK_EQUAL( std::string("12.cpp"), s1c3 );
 450
 451     std::string s2(".cpp");
 452     BOOST_CHECK_EQUAL( true, has_suffix(s2,".cpp") );
 453
 454     std::string s2c1= remove_suffix(s2,".cpp");
 455     BOOST_CHECK_EQUAL( std::string(""), s2c1 );
 456
 457 } // eo TestSuffixFuncs()
 458
 459
 460
 461 BOOST_AUTO_TEST_CASE(TestPrefixFuncs)
 462 {
 463     std::string s1("12.cpp");
 464
 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, "") );
 469
 470     std::string s1c1= remove_prefix(s1, "12");
 471     BOOST_CHECK_EQUAL( std::string(".cpp"), s1c1);
 472 } // eo TestPrefixFuncs()
 473
 474
 475
 476 BOOST_AUTO_TEST_CASE(TestLowerUpperFuncs)
 477 {
 478     std::string u1("CASE CONVERSION TEST..");
 479     std::string l1("case conversion test..");
 480
 481     std::string test1(l1);
 482
 483     to_upper_mod(test1);
 484     BOOST_CHECK_EQUAL( u1, test1 );
 485
 486     to_lower_mod(test1);
 487     BOOST_CHECK_EQUAL( l1, test1 );
 488
 489
 490     BOOST_CHECK_EQUAL( u1, to_upper(l1) );
 491     BOOST_CHECK_EQUAL( l1, to_lower(u1) );
 492 } // eo TestLowerUpper
 493
 494
 495
 496 BOOST_AUTO_TEST_CASE(PairSplit1)
 497 {
 498     StringList str_list;
 499     get_push_back_filler(str_list)
 500         ("a=11")("a= 11")("a =11 ")("a =  11 ")("  a    =    11   ")
 501     ;
 502     BOOST_CHECK_EQUAL( 5u, str_list.size() );
 503     for(StringList::iterator it= str_list.begin();
 504         it != str_list.end();
 505         ++it)
 506     {
 507         std::string key, value;
 508         bool res= pair_split( *it, key, value);
 509
 510         BOOST_CHECK_EQUAL( true , res );
 511         BOOST_CHECK_EQUAL( std::string("a"), key );
 512         BOOST_CHECK_EQUAL( std::string("11"), value );
 513     }
 514
 515     std::string key, value;
 516     bool res;
 517
 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);
 522 } // eo PairSplit1
 523
 524
 525
 526 BOOST_AUTO_TEST_CASE(SplitString1)
 527 {
 528     std::string block(
 529         "Zeile 1\n"
 530         "++Zeile-2--\n"
 531         "Zeile 3\n"
 532         "\n"
 533         "Zeile 5\n"
 534     );
 535
 536     StringList list1;
 537
 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() );
 543
 544     StringList list2;
 545
 546     split_string(block, list2, "\n", true);
 547
 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() );
 552
 553     list2= split_string(block, "\n", true, "+-");
 554
 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()) );
 560 } // eo SplitString1
 561
 562
 563
 564 BOOST_AUTO_TEST_CASE(SplitString2)
 565 {
 566     std::string line("172.16.0.0/16 dev eth0  scope link  src 172.16.1.111");
 567
 568     StringList list1;
 569
 570     split_string(line, list1, " ", true, Whitespaces);
 571
 572     BOOST_CHECK_EQUAL( 7u, list1.size() );
 573
 574 } // eo SplitString2
 575
 576
 577
 578 BOOST_AUTO_TEST_CASE(SplitStringEmpty)
 579 {
 580     std::string line("");
 581
 582     StringList list1;
 583
 584     split_string(line, list1, " ", true, Whitespaces);
 585
 586     BOOST_CHECK_EQUAL( 0u, list1.size() );
 587 } // eo SplitStringEmpty
 588
 589
 590 BOOST_AUTO_TEST_CASE(SplitStringDelimiterOnly)
 591 {
 592     std::string line(" ");
 593
 594     StringList list1;
 595
 596     split_string(line, list1, " ", true, Whitespaces);
 597
 598     BOOST_CHECK_EQUAL( 0u, list1.size() );
 599 } // eo SplitStringDelimiterOnly
 600
 601
 602 BOOST_AUTO_TEST_CASE(SplitToVector)
 603 {
 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");
 611 }
 612
 613
 614 BOOST_AUTO_TEST_CASE(JoinString1)
 615 {
 616     std::list< std::string > parts;
 617     get_push_back_filler(parts)("1")("2")("drei");
 618
 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 );
 622
 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 );
 627
 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 );
 632
 633 } // eo JoinString1
 634
 635
 636 BOOST_AUTO_TEST_CASE(JoinStringVector)
 637 {
 638     std::vector< std::string > parts;
 639     get_push_back_filler(parts)("1")("2")("drei");
 640
 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 );
 644
 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 );
 649
 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 );
 654
 655 } // eo JoinStringVector
 656
 657
 658 BOOST_AUTO_TEST_CASE(ConversionStringInt)
 659 {
 660     std::string s1("24");
 661     std::string s1x("25x");
 662     int i1=0;
 663     bool res= false;
 664
 665     i1= string_to<int>(s1);
 666     BOOST_CHECK_EQUAL( 24, i1 );
 667     i1= string_to<int>(s1x);
 668     BOOST_CHECK_EQUAL( 25, i1 );
 669
 670     res= string_to<int>(s1,i1);
 671     BOOST_CHECK_EQUAL( true, res );
 672     BOOST_CHECK_EQUAL( 24, i1 );
 673
 674     res= string_to<int>(s1x,i1);
 675     BOOST_CHECK_EQUAL( false, res );
 676
 677     std::string ss1= to_string( 24 );
 678     BOOST_CHECK_EQUAL( std::string("24"), ss1);
 679
 680 } // eo ConversionStringInt()
 681
 682
 683
 684 BOOST_AUTO_TEST_CASE(HexBinaryConversion)
 685 {
 686     std::string hex1("49324E");
 687     std::string bin1("I2N");
 688
 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) );
 692
 693     std::string hex2("0001");
 694     std::string hex2a("00 01");
 695     std::string hex2b("00:01");
 696     std::string bin2("\0\1",2);
 697
 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) );
 702
 703     BOOST_REQUIRE_THROW( convert_hex_to_binary("01 kein hex"), std::runtime_error);
 704 } // eo HexConversion()
 705
 706 BOOST_AUTO_TEST_CASE(HexIntConversion)
 707 {
 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") );
 711 }
 712
 713 BOOST_AUTO_TEST_CASE(sanitize_for_logging1)
 714 {
 715     string output = sanitize_for_logging("normaler string ohne aerger");
 716
 717     BOOST_CHECK_EQUAL(string("normaler string ohne aerger"), output);
 718 }
 719
 720 BOOST_AUTO_TEST_CASE(sanitize_for_logging2)
 721 {
 722     string to_test="fiese";
 723     to_test.push_back(0);
 724     to_test+="null";
 725
 726     string output = sanitize_for_logging(to_test);
 727
 728     BOOST_CHECK_EQUAL(string("fiese?null"), output);
 729 }
 730
 731 BOOST_AUTO_TEST_CASE(sanitize_for_logging3)
 732 {
 733     string output = sanitize_for_logging("läuter ümlaute utf8");
 734
 735     BOOST_CHECK_EQUAL(string("l??uter ??mlaute utf8"), output);
 736 }
 737
 738 BOOST_AUTO_TEST_CASE(find_html_comments_test)
 739 {
 740     string text = "bla-->"  // ==> (npos, 6)
 741                //  0     6
 742                   "bla<!--bla<!--bla-->bla-->"  // ==> (16, 26), (9, 32)
 743                //  6  9     16        26     32
 744                   "bla<!--bla-->"  // ==> (35, 45)
 745                // 32 35        45
 746                   "--><!----><!--"    // ==> (npos, 48), (48, 55), (55, npos)
 747                // 45 48      55 59
 748                   "bla<!--bla-->";  // ==> (62, 72)
 749                // 59 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 << ")");
 767 }
 768
 769 BOOST_AUTO_TEST_CASE(remove_html_comments_test)
 770 {
 771     const string original = "First line outside\n"
 772                             "text <!--FOO\n"
 773                             "Inside foo\n"
 774                             "<!--BAR\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"
 778                             "BAR-->\n"
 779                             "This, neither. No nested comments\n"
 780                             "some text <!--BAZ more text\n"
 781                             "Aaarggh!"
 782                             "more text BAZ--> even more\n"
 783                             "FOO--> text\n"
 784                             "second line outside\n"
 785                             "<!-- second comment -->";
 786     string text = original;
 787     string expect = "First line outside\n"
 788                     "text  text\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);
 794
 795     text = string("test<!--") + original;
 796     remove_html_comments(text);
 797     BOOST_CHECK_EQUAL(text, "test");
 798
 799     text = original + "-->test";
 800     remove_html_comments(text);
 801     BOOST_CHECK_EQUAL(text, "test");
 802 }
 803
 804 BOOST_AUTO_TEST_CASE(shorten_stl_types_string)
 805 {
 806     BOOST_CHECK_EQUAL(shorten_stl_types("std::basic_string<char, std::char_traits<char>, std::allocator<char> >"),
 807                       "std::string");
 808 }
 809
 810 BOOST_AUTO_TEST_CASE(shorten_stl_types_simple)
 811 {
 812     BOOST_CHECK_EQUAL(shorten_stl_types("std::list<some_type, std::allocator<some_type> >"),
 813                       "std::list<some_type, _alloc_>");
 814 }
 815
 816 BOOST_AUTO_TEST_CASE(shorten_stl_types_multiple)
 817 {
 818     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> >)"),
 819                       "std::string my_func(std::list<some_type, _alloc_>, std::vector<int, _alloc_>)");
 820 }
 821
 822 BOOST_AUTO_TEST_CASE(shorten_stl_types_complex)
 823 {
 824     BOOST_CHECK_EQUAL(shorten_stl_types("std::list<boost::shared_ptr<some_type>, std::allocator<boost::shared_ptr<some_type> > >"),
 825                       "std::list<boost::shared_ptr<some_type>, _alloc_>");
 826 }
 827
 828 BOOST_AUTO_TEST_CASE(shorten_stl_types_nested)
 829 {
 830               //"std::list<int, std::allocator<int> >"
 831     //"std::list<std::list<int, std::allocator<int> >, std::allocator<std::list<int, std::allocator<int> > > >"
 832     BOOST_CHECK_EQUAL(shorten_stl_types("std::list<std::list<int, std::allocator<int> >, std::allocator<std::list<int, std::allocator<int> > > >"),
 833                       "std::list<std::list<int, _alloc_>, _alloc_>");
 834 }
 835
 836 BOOST_AUTO_TEST_CASE(shorten_stl_types_nothing)
 837 {
 838     string text = "";
 839     BOOST_CHECK_EQUAL(shorten_stl_types(text), text);
 840     text = "int f(void)";
 841     BOOST_CHECK_EQUAL(shorten_stl_types(text), text);
 842     text = "std::cout << \"Test\" << std::endl;";
 843     BOOST_CHECK_EQUAL(shorten_stl_types(text), text);
 844     text = "bla<blubb>";
 845     BOOST_CHECK_EQUAL(shorten_stl_types(text), text);
 846     text = "std::list<> is a class template";
 847     BOOST_CHECK_EQUAL(shorten_stl_types(text), text);
 848     text = "std::list<int, std::allocator<int>\n>";
 849     BOOST_CHECK_EQUAL(shorten_stl_types(text), text);
 850 }
 851
 852 BOOST_AUTO_TEST_SUITE_END()