sal/qa/rtl/ostring/rtl_str.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  *
   9  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/types.h>
  21 #include <cppunit/TestFixture.h>
  22 #include <cppunit/extensions/HelperMacros.h>
  23 #include <cppunit/plugin/TestPlugIn.h>
  24
  25 #include <rtl/string.hxx>
  26 #include <cstring>
  27
  28 namespace rtl_str
  29 {
  30
  31     class compare : public CppUnit::TestFixture
  32     {
  33     public:
  34
  35         void compare_000()
  36             {
  37                 rtl_str_compare( NULL, NULL);
  38             }
  39
  40         void compare_000_1()
  41             {
  42                 OString aStr1 = "Line must be equal.";
  43                 rtl_str_compare( aStr1.getStr(), NULL);
  44             }
  45         void compare_001()
  46             {
  47                 OString aStr1 = "";
  48                 OString aStr2 = "";
  49
  50                 sal_Int32 nValue = rtl_str_compare( aStr1.getStr(), aStr2.getStr());
  51                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
  52             }
  53
  54         void compare_002()
  55             {
  56                 OString aStr1 = "Line must be equal.";
  57                 OString aStr2 = "Line must be equal.";
  58
  59                 sal_Int32 nValue = rtl_str_compare( aStr1.getStr(), aStr2.getStr());
  60                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
  61             }
  62
  63         void compare_003()
  64             {
  65                 OString aStr1 = "Line must differ.";
  66                 OString aStr2 = "Line foo bar, ok, differ.";
  67
  68                 sal_Int32 nValue = rtl_str_compare( aStr1.getStr(), aStr2.getStr());
  69                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
  70             }
  71
  72     // Change the following lines only, if you add, remove or rename
  73     // member functions of the current class,
  74     // because these macros are need by auto register mechanism.
  75
  76     CPPUNIT_TEST_SUITE(compare);
  77     CPPUNIT_TEST(compare_000);
  78     CPPUNIT_TEST(compare_000_1);
  79     CPPUNIT_TEST(compare_001);
  80     CPPUNIT_TEST(compare_002);
  81     CPPUNIT_TEST(compare_003);
  82     CPPUNIT_TEST_SUITE_END();
  83 }; // class compare
  84
  85     class compareIgnoreAsciiCase : public CppUnit::TestFixture
  86     {
  87     public:
  88
  89         void compare_000()
  90             {
  91                 rtl_str_compareIgnoreAsciiCase( NULL, NULL);
  92             }
  93
  94         void compare_000_1()
  95             {
  96                 OString aStr1 = "Line must be equal.";
  97                 rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), NULL);
  98             }
  99         void compare_001()
 100             {
 101                 OString aStr1 = "";
 102                 OString aStr2 = "";
 103
 104                 sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr());
 105                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
 106             }
 107
 108         void compare_002()
 109             {
 110                 OString aStr1 = "Line must be equal.";
 111                 OString aStr2 = "Line must be equal.";
 112
 113                 sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr());
 114                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
 115             }
 116
 117         void compare_002_1()
 118             {
 119                 OString aStr1 = "Line must be equal.";
 120                 OString aStr2 = "LINE MUST BE EQUAL.";
 121
 122                 sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr());
 123                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitive).", nValue == 0);
 124             }
 125
 126         void compare_003()
 127             {
 128                 OString aStr1 = "Line must differ.";
 129                 OString aStr2 = "Line foo bar, ok, differ.";
 130
 131                 sal_Int32 nValue = rtl_str_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr());
 132                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
 133             }
 134
 135     // Change the following lines only, if you add, remove or rename
 136     // member functions of the current class,
 137     // because these macros are need by auto register mechanism.
 138
 139     CPPUNIT_TEST_SUITE(compareIgnoreAsciiCase);
 140     CPPUNIT_TEST(compare_000);
 141     CPPUNIT_TEST(compare_000_1);
 142     CPPUNIT_TEST(compare_001);
 143     CPPUNIT_TEST(compare_002);
 144     CPPUNIT_TEST(compare_002_1);
 145     CPPUNIT_TEST(compare_003);
 146     CPPUNIT_TEST_SUITE_END();
 147     }; // class compareIgnoreAsciiCase
 148
 149     class shortenedCompareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture
 150     {
 151     public:
 152
 153         void compare_000()
 154             {
 155                 rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0, 0);
 156             }
 157
 158         void compare_000_1()
 159             {
 160                 OString aStr1 = "Line must be equal.";
 161                 rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0, 1);
 162             }
 163         void compare_001()
 164             {
 165                 OString aStr1 = "";
 166                 OString aStr2 = "";
 167
 168                 sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), aStr2.getStr(), aStr2.getLength(), aStr1.getLength());
 169                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
 170             }
 171
 172         void compare_002()
 173             {
 174                 OString aStr1 = "Line must be equal.";
 175                 OString aStr2 = "Line must be equal.";
 176
 177                 sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(),
 178                                                                                        aStr2.getStr(), aStr2.getLength(),
 179                                                                                        aStr1.getLength());
 180                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0);
 181             }
 182
 183         void compare_002_1()
 184             {
 185                 OString aStr1 = "Line must be equal.";
 186                 OString aStr2 = "LINE MUST BE EQUAL.";
 187
 188                 sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(),
 189                                                                                        aStr2.getStr(), aStr2.getLength(),
 190                                                                                        aStr1.getLength());
 191                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitive).", nValue == 0);
 192             }
 193
 194         void compare_003()
 195             {
 196                 OString aStr1 = "Line must differ.";
 197                 OString aStr2 = "Line foo bar, ok, differ.";
 198
 199                 sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(),
 200                                                                                        aStr2.getStr(), aStr2.getLength(),
 201                                                                                        5);
 202                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal first 5 characters.", nValue == 0);
 203             }
 204
 205         void compare_004()
 206             {
 207                 OString aStr1 = "Line must differ.";
 208                 OString aStr2 = "Line foo bar, ok, differ.";
 209
 210                 sal_Int32 nValue = rtl_str_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(),
 211                                                                                        aStr2.getStr(), aStr2.getLength(),
 212                                                                                        aStr1.getLength());
 213                 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0);
 214             }
 215
 216     // Change the following lines only, if you add, remove or rename
 217     // member functions of the current class,
 218     // because these macros are need by auto register mechanism.
 219
 220     CPPUNIT_TEST_SUITE(shortenedCompareIgnoreAsciiCase_WithLength);
 221     CPPUNIT_TEST(compare_000);
 222     CPPUNIT_TEST(compare_000_1);
 223     CPPUNIT_TEST(compare_001);
 224     CPPUNIT_TEST(compare_002);
 225     CPPUNIT_TEST(compare_002_1);
 226     CPPUNIT_TEST(compare_003);
 227     CPPUNIT_TEST(compare_004);
 228     CPPUNIT_TEST_SUITE_END();
 229 }; // class compare
 230
 231     class hashCode : public CppUnit::TestFixture
 232     {
 233     public:
 234
 235         void hashCode_000()
 236             {
 237                 rtl_str_hashCode( NULL );
 238             }
 239
 240         void hashCode_001()
 241             {
 242                 OString aStr1 = "Line for a hashCode.";
 243                 sal_Int32 nHashCode = rtl_str_hashCode( aStr1.getStr() );
 244                 printf("hashcode: %d\n", nHashCode);
 245                 // CPPUNIT_ASSERT_MESSAGE("failed.", nValue == 0);
 246             }
 247
 248         void hashCode_002()
 249             {
 250                 OString aStr1 = "Line for a hashCode.";
 251                 sal_Int32 nHashCode1 = rtl_str_hashCode( aStr1.getStr() );
 252
 253                 OString aStr2 = "Line for a hashCode.";
 254                 sal_Int32 nHashCode2 = rtl_str_hashCode( aStr2.getStr() );
 255
 256                 CPPUNIT_ASSERT_MESSAGE("hashcodes must be equal.", nHashCode1 == nHashCode2 );
 257             }
 258
 259         void hashCode_003()
 260             {
 261                 OString aStr1 = "Line for a hashCode.";
 262                 sal_Int32 nHashCode1 = rtl_str_hashCode( aStr1.getStr() );
 263
 264                 OString aStr2 = "Line for another hashcode.";
 265                 sal_Int32 nHashCode2 = rtl_str_hashCode( aStr2.getStr() );
 266
 267                 CPPUNIT_ASSERT_MESSAGE("hashcodes must differ.", nHashCode1 != nHashCode2 );
 268             }
 269
 270         // Change the following lines only, if you add, remove or rename
 271         // member functions of the current class,
 272         // because these macros are need by auto register mechanism.
 273
 274         CPPUNIT_TEST_SUITE(hashCode);
 275         CPPUNIT_TEST(hashCode_000);
 276         CPPUNIT_TEST(hashCode_001);
 277         CPPUNIT_TEST(hashCode_002);
 278         CPPUNIT_TEST(hashCode_003);
 279         CPPUNIT_TEST_SUITE_END();
 280     }; // class compare
 281
 282     class indexOfChar : public CppUnit::TestFixture
 283     {
 284     public:
 285
 286         void indexOfChar_000()
 287             {
 288                 rtl_str_indexOfChar( NULL, 0 );
 289             }
 290
 291         void indexOfChar_001()
 292             {
 293                 OString aStr1 = "Line for an indexOfChar.";
 294
 295                 sal_Int32 nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'L' );
 296                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0);
 297
 298                 /* sal_Int32 */ nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'i' );
 299                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 1);
 300
 301                 /* sal_Int32 */ nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'n' );
 302                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 2);
 303
 304                 /* sal_Int32 */ nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'e' );
 305                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 3);
 306             }
 307
 308         void indexOfChar_002()
 309             {
 310                 OString aStr1 = "Line for an indexOfChar.";
 311                 sal_Int32 nIndex = rtl_str_indexOfChar( aStr1.getStr(), 'y' );
 312
 313                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 );
 314             }
 315
 316         // Change the following lines only, if you add, remove or rename
 317         // member functions of the current class,
 318         // because these macros are need by auto register mechanism.
 319
 320         CPPUNIT_TEST_SUITE(indexOfChar);
 321         CPPUNIT_TEST(indexOfChar_000);
 322         CPPUNIT_TEST(indexOfChar_001);
 323         CPPUNIT_TEST(indexOfChar_002);
 324         CPPUNIT_TEST_SUITE_END();
 325     }; // class compare
 326
 327     class lastIndexOfChar : public CppUnit::TestFixture
 328     {
 329     public:
 330
 331         void lastIndexOfChar_000()
 332             {
 333                 rtl_str_lastIndexOfChar( NULL, 0 );
 334             }
 335
 336         void lastIndexOfChar_001()
 337             {
 338                 OString aStr1 = "Line for a lastIndexOfChar.";
 339
 340                 sal_Int32 nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'C' );
 341                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 22);
 342
 343                 /* sal_Int32 */ nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'h' );
 344                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 23);
 345
 346                 /* sal_Int32 */ nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'a' );
 347                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 24);
 348
 349                 /* sal_Int32 */ nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'r' );
 350                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 25);
 351             }
 352
 353         void lastIndexOfChar_002()
 354             {
 355                 OString aStr1 = "Line for a lastIndexOfChar.";
 356                 sal_Int32 nIndex = rtl_str_lastIndexOfChar( aStr1.getStr(), 'y' );
 357
 358                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 );
 359             }
 360
 361         // Change the following lines only, if you add, remove or rename
 362         // member functions of the current class,
 363         // because these macros are need by auto register mechanism.
 364
 365         CPPUNIT_TEST_SUITE(lastIndexOfChar);
 366         CPPUNIT_TEST(lastIndexOfChar_000);
 367         CPPUNIT_TEST(lastIndexOfChar_001);
 368         CPPUNIT_TEST(lastIndexOfChar_002);
 369         CPPUNIT_TEST_SUITE_END();
 370     }; // class lastIndexOfChar
 371
 372     class indexOfStr : public CppUnit::TestFixture
 373     {
 374     public:
 375
 376         void indexOfStr_000()
 377             {
 378                 rtl_str_indexOfStr( NULL, 0 );
 379             }
 380
 381         void indexOfStr_000_1()
 382             {
 383                 OString aStr1 = "Line for an indexOfStr.";
 384                 rtl_str_indexOfStr( aStr1.getStr(), 0 );
 385             }
 386
 387         void indexOfStr_001()
 388             {
 389                 OString aStr1 = "Line for an indexOfStr.";
 390
 391                 sal_Int32 nIndex = rtl_str_indexOfStr( aStr1.getStr(), "Line" );
 392                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0);
 393
 394                 /* sal_Int32 */ nIndex = rtl_str_indexOfStr( aStr1.getStr(), "for" );
 395                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 5);
 396
 397                 /* sal_Int32 */ nIndex = rtl_str_indexOfStr( aStr1.getStr(), "a" );
 398                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 9);
 399
 400                 /* sal_Int32 */ nIndex = rtl_str_indexOfStr( aStr1.getStr(), "an index" );
 401                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex ==9);
 402             }
 403
 404         void indexOfStr_002()
 405             {
 406                 OString aStr1 = "Line for an indexOfStr.";
 407                 sal_Int32 nIndex = rtl_str_indexOfStr( aStr1.getStr(), "not exist" );
 408
 409                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 );
 410             }
 411
 412         // Change the following lines only, if you add, remove or rename
 413         // member functions of the current class,
 414         // because these macros are need by auto register mechanism.
 415
 416         CPPUNIT_TEST_SUITE(indexOfStr);
 417         CPPUNIT_TEST(indexOfStr_000);
 418         CPPUNIT_TEST(indexOfStr_001);
 419         CPPUNIT_TEST(indexOfStr_002);
 420         CPPUNIT_TEST_SUITE_END();
 421     }; // class compare
 422
 423     class lastIndexOfStr : public CppUnit::TestFixture
 424     {
 425     public:
 426
 427         void lastIndexOfStr_000()
 428             {
 429                 rtl_str_lastIndexOfStr( NULL, NULL );
 430             }
 431
 432         void lastIndexOfStr_000_1()
 433             {
 434                 OString aStr1 = "Line for a lastIndexOfStr.";
 435                 rtl_str_lastIndexOfStr( aStr1.getStr(), NULL );
 436             }
 437
 438         void lastIndexOfStr_001()
 439             {
 440                 OString aStr1 = "Line for a lastIndexOfStr.";
 441                 OString aSearchStr = "Index";
 442
 443                 sal_Int32 nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
 444                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 15);
 445
 446                 /* OString */ aSearchStr = "Line";
 447                 /* sal_Int32 */ nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
 448                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0);
 449
 450                 /* OString */ aSearchStr = "";
 451                 /* sal_Int32 */ nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
 452                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1);
 453             }
 454
 455         void lastIndexOfStr_002()
 456             {
 457                 OString aStr1 = "Line for a lastIndexOfStr.";
 458                 OString aSearchStr = "foo";
 459                 sal_Int32 nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
 460
 461                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 );
 462             }
 463
 464         void lastIndexOfStr_003()
 465             {
 466                 OString aStr1 = "Line for a lastIndexOfStr.";
 467                 OString aSearchStr = "O";
 468                 sal_Int32 nIndex = rtl_str_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() );
 469
 470                 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 20 );
 471             }
 472
 473         // Change the following lines only, if you add, remove or rename
 474         // member functions of the current class,
 475         // because these macros are need by auto register mechanism.
 476
 477         CPPUNIT_TEST_SUITE(lastIndexOfStr);
 478         CPPUNIT_TEST(lastIndexOfStr_000);
 479         CPPUNIT_TEST(lastIndexOfStr_001);
 480         CPPUNIT_TEST(lastIndexOfStr_002);
 481         CPPUNIT_TEST(lastIndexOfStr_003);
 482         CPPUNIT_TEST_SUITE_END();
 483     }; // class lastIndexOfStr
 484
 485     class replaceChar : public CppUnit::TestFixture
 486     {
 487     public:
 488
 489         void replaceChar_000()
 490             {
 491                 rtl_str_replaceChar( NULL, 0, 0 );
 492             }
 493
 494         void replaceChar_001()
 495             {
 496                 OString aStr1 = "replace char.";
 497                 OString aShouldStr1 = "ruplacu char.";
 498
 499                 sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1);
 500                 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
 501                 strcpy(pStr, aStr1.getStr());
 502
 503                 rtl_str_replaceChar( pStr, 'e', 'u' );
 504
 505                 CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(OString(pStr)) == sal_True);
 506                 free(pStr);
 507             }
 508
 509         // Change the following lines only, if you add, remove or rename
 510         // member functions of the current class,
 511         // because these macros are need by auto register mechanism.
 512
 513         CPPUNIT_TEST_SUITE(replaceChar);
 514         CPPUNIT_TEST(replaceChar_000);
 515         CPPUNIT_TEST(replaceChar_001);
 516         CPPUNIT_TEST_SUITE_END();
 517     }; // class replaceChar
 518
 519     class replaceChar_WithLength : public CppUnit::TestFixture
 520     {
 521     public:
 522
 523         void replaceChar_WithLength_000()
 524             {
 525                 rtl_str_replaceChar_WithLength( NULL, 0, 0, 0 );
 526             }
 527
 528         void replaceChar_WithLength_000_1()
 529             {
 530                 rtl_str_replaceChar_WithLength( NULL, 1, 0, 0 );
 531             }
 532         void replaceChar_WithLength_001()
 533             {
 534                 OString aStr1 = "replace char.";
 535                 OString aShouldStr1 = "ruplace char.";
 536
 537                 sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1);
 538                 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
 539                 strcpy(pStr, aStr1.getStr());
 540
 541                 rtl_str_replaceChar_WithLength( pStr, 6, 'e', 'u' );
 542
 543                 CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(OString(pStr)) == sal_True);
 544                 free(pStr);
 545             }
 546
 547         // Change the following lines only, if you add, remove or rename
 548         // member functions of the current class,
 549         // because these macros are need by auto register mechanism.
 550
 551         CPPUNIT_TEST_SUITE(replaceChar_WithLength);
 552         CPPUNIT_TEST(replaceChar_WithLength_000);
 553         CPPUNIT_TEST(replaceChar_WithLength_000_1);
 554         CPPUNIT_TEST(replaceChar_WithLength_001);
 555         CPPUNIT_TEST_SUITE_END();
 556     }; // class replaceChar
 557
 558     class toAsciiLowerCase : public CppUnit::TestFixture
 559     {
 560     public:
 561
 562         void toAsciiLowerCase_000()
 563             {
 564                 rtl_str_toAsciiLowerCase( NULL );
 565             }
 566
 567         void toAsciiLowerCase_001()
 568             {
 569                 OString aStr1 = "CHANGE THIS TO ASCII LOWER CASE.";
 570                 OString aShouldStr1 = "change this to ascii lower case.";
 571
 572                 sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1);
 573                 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
 574                 strcpy(pStr, aStr1.getStr());
 575
 576                 rtl_str_toAsciiLowerCase( pStr );
 577
 578                 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(OString(pStr)) == sal_True);
 579                 free(pStr);
 580             }
 581
 582         // Change the following lines only, if you add, remove or rename
 583         // member functions of the current class,
 584         // because these macros are need by auto register mechanism.
 585
 586         CPPUNIT_TEST_SUITE(toAsciiLowerCase);
 587         CPPUNIT_TEST(toAsciiLowerCase_000);
 588         CPPUNIT_TEST(toAsciiLowerCase_001);
 589         CPPUNIT_TEST_SUITE_END();
 590     }; // class replaceChar
 591
 592     class toAsciiLowerCase_WithLength : public CppUnit::TestFixture
 593     {
 594     public:
 595
 596         void toAsciiLowerCase_WithLength_000()
 597             {
 598                 rtl_str_toAsciiLowerCase_WithLength( NULL, 0 );
 599             }
 600
 601         void toAsciiLowerCase_WithLength_001()
 602             {
 603                 OString aStr1 = "CHANGE THIS TO ASCII LOWER CASE.";
 604                 OString aShouldStr1 = "change thiS TO ASCII LOWER CASE.";
 605
 606                 sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1);
 607                 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
 608                 strcpy(pStr, aStr1.getStr());
 609
 610                 rtl_str_toAsciiLowerCase_WithLength( pStr, 10 );
 611
 612                 printf("Lowercase with length: '%s'\n", pStr);
 613                 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(OString(pStr)) == sal_True);
 614                 free(pStr);
 615             }
 616
 617         // Change the following lines only, if you add, remove or rename
 618         // member functions of the current class,
 619         // because these macros are need by auto register mechanism.
 620
 621         CPPUNIT_TEST_SUITE(toAsciiLowerCase_WithLength);
 622         CPPUNIT_TEST(toAsciiLowerCase_WithLength_000);
 623         CPPUNIT_TEST(toAsciiLowerCase_WithLength_001);
 624         CPPUNIT_TEST_SUITE_END();
 625     }; // class replaceChar
 626
 627     class toAsciiUpperCase : public CppUnit::TestFixture
 628     {
 629     public:
 630
 631         void toAsciiUpperCase_000()
 632             {
 633                 rtl_str_toAsciiUpperCase( NULL );
 634             }
 635
 636         void toAsciiUpperCase_001()
 637             {
 638                 OString aStr1 = "change this to ascii upper case.";
 639                 OString aShouldStr1 = "CHANGE THIS TO ASCII UPPER CASE.";
 640
 641                 sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1);
 642                 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
 643                 strcpy(pStr, aStr1.getStr());
 644
 645                 rtl_str_toAsciiUpperCase( pStr );
 646
 647                 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(OString(pStr)) == sal_True);
 648                 free(pStr);
 649             }
 650
 651         // Change the following lines only, if you add, remove or rename
 652         // member functions of the current class,
 653         // because these macros are need by auto register mechanism.
 654
 655         CPPUNIT_TEST_SUITE(toAsciiUpperCase);
 656         CPPUNIT_TEST(toAsciiUpperCase_000);
 657         CPPUNIT_TEST(toAsciiUpperCase_001);
 658         CPPUNIT_TEST_SUITE_END();
 659     }; // class replaceChar
 660
 661     class toAsciiUpperCase_WithLength : public CppUnit::TestFixture
 662     {
 663     public:
 664
 665         void toAsciiUpperCase_WithLength_000()
 666             {
 667                 rtl_str_toAsciiUpperCase_WithLength( NULL, 0 );
 668             }
 669
 670         void toAsciiUpperCase_WithLength_001()
 671             {
 672                 OString aStr1 = "change this to ascii lower case.";
 673                 OString aShouldStr1 = "CHANGE THIs to ascii lower case.";
 674
 675                 sal_Char* pStr = (sal_Char*) malloc(aStr1.getLength() + 1);
 676                 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL);
 677
 678                 strcpy(pStr, aStr1.getStr());
 679                 rtl_str_toAsciiUpperCase_WithLength( pStr, 10 );
 680
 681                 printf("Uppercase with length: '%s'\n", aStr1.getStr());
 682                 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(OString(pStr)) == sal_True);
 683                 free(pStr);
 684             }
 685
 686         // Change the following lines only, if you add, remove or rename
 687         // member functions of the current class,
 688         // because these macros are need by auto register mechanism.
 689
 690         CPPUNIT_TEST_SUITE(toAsciiUpperCase_WithLength);
 691         CPPUNIT_TEST(toAsciiUpperCase_WithLength_000);
 692         CPPUNIT_TEST(toAsciiUpperCase_WithLength_001);
 693         CPPUNIT_TEST_SUITE_END();
 694     }; // class replaceChar
 695
 696     class trim_WithLength : public CppUnit::TestFixture
 697     {
 698       public:
 699         void trim_WithLength_000()
 700         {
 701             rtl_str_trim_WithLength(NULL, 0);
 702             // should not GPF
 703         }
 704
 705         void trim_WithLength_000_1()
 706         {
 707             char pStr[] = { "  trim this" };
 708             rtl_str_trim_WithLength( pStr, 0 );
 709         }
 710
 711         void trim_WithLength_001()
 712         {
 713             char const *pStr = "  trim this";
 714             sal_Char *pStr2 = strdup(pStr);
 715             if (pStr2)
 716             {
 717                 rtl_str_trim_WithLength( pStr2, 2 );
 718
 719                 CPPUNIT_ASSERT_MESSAGE("string should be empty", strlen(pStr2) == 0);
 720                 free(pStr2);
 721             }
 722         }
 723
 724         void trim_WithLength_002()
 725         {
 726             char const *pStr = "trim this";
 727             sal_Char *pStr2 = strdup(pStr);
 728             if (pStr2)
 729             {
 730                 rtl_str_trim_WithLength( pStr2, 5 );
 731
 732                 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 4);
 733                 free(pStr2);
 734             }
 735         }
 736
 737         void trim_WithLength_003()
 738         {
 739             char const *pStr = "     trim   this";
 740             sal_Char *pStr2 = strdup(pStr);
 741             if (pStr2)
 742             {
 743                 strcpy(pStr2, pStr);
 744                 rtl_str_trim_WithLength( pStr2, 11 );
 745
 746                 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 4);
 747                 free(pStr2);
 748             }
 749         }
 750
 751         void trim_WithLength_004()
 752         {
 753             char const *pStr = "\r\n\t \n\r    trim  \n this";
 754             sal_Char *pStr2 = strdup(pStr);
 755             if (pStr2)
 756             {
 757                 rtl_str_trim_WithLength( pStr2, 17 );
 758
 759                 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 4);
 760                 free(pStr2);
 761             }
 762         }
 763
 764         void trim_WithLength_005()
 765         {
 766             char const *pStr = "\r\n\t \n\r    trim \t this \n\r\t\t     ";
 767             sal_Char *pStr2 = strdup(pStr);
 768             if (pStr2)
 769             {
 770                 rtl_str_trim_WithLength( pStr2, strlen(pStr2) );
 771
 772                 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", strlen(pStr2) == 11);
 773                 free(pStr2);
 774             }
 775         }
 776
 777         // Change the following lines only, if you add, remove or rename
 778         // member functions of the current class,
 779         // because these macros are need by auto register mechanism.
 780
 781         CPPUNIT_TEST_SUITE(trim_WithLength);
 782         CPPUNIT_TEST(trim_WithLength_000);
 783         CPPUNIT_TEST(trim_WithLength_000_1);
 784         CPPUNIT_TEST(trim_WithLength_001);
 785         CPPUNIT_TEST(trim_WithLength_002);
 786         CPPUNIT_TEST(trim_WithLength_003);
 787         CPPUNIT_TEST(trim_WithLength_004);
 788         CPPUNIT_TEST(trim_WithLength_005);
 789         CPPUNIT_TEST_SUITE_END();
 790     };
 791
 792     class valueOfChar : public CppUnit::TestFixture
 793     {
 794       public:
 795         void valueOfChar_000()
 796             {
 797                 rtl_str_valueOfChar(NULL, 0);
 798                 // should not GPF
 799             }
 800         void valueOfChar_001()
 801             {
 802                 sal_Char *pStr = (sal_Char*)malloc(RTL_STR_MAX_VALUEOFCHAR);
 803                 if (pStr)
 804                 {
 805                     rtl_str_valueOfChar(pStr, 'A');
 806
 807                     CPPUNIT_ASSERT_MESSAGE("string should contain 'A'", pStr[0] == 'A');
 808                     free(pStr);
 809                 }
 810             }
 811
 812         // Change the following lines only, if you add, remove or rename
 813         // member functions of the current class,
 814         // because these macros are need by auto register mechanism.
 815
 816         CPPUNIT_TEST_SUITE(valueOfChar);
 817         CPPUNIT_TEST(valueOfChar_000);
 818         CPPUNIT_TEST(valueOfChar_001);
 819         CPPUNIT_TEST_SUITE_END();
 820     };
 821
 822 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::compare);
 823 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::compareIgnoreAsciiCase);
 824 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::shortenedCompareIgnoreAsciiCase_WithLength);
 825 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::hashCode);
 826
 827 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::indexOfChar);
 828 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::lastIndexOfChar);
 829 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::indexOfStr);
 830 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::lastIndexOfStr);
 831
 832 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::replaceChar);
 833 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::replaceChar_WithLength);
 834
 835 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::toAsciiLowerCase);
 836 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::toAsciiLowerCase_WithLength);
 837 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::toAsciiUpperCase);
 838 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::toAsciiUpperCase_WithLength);
 839
 840 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::trim_WithLength);
 841 CPPUNIT_TEST_SUITE_REGISTRATION(rtl_str::valueOfChar);
 842
 843 } // namespace rtl_str
 844
 845 // this macro creates an empty function, which will called by the RegisterAllFunctions()
 846 // to let the user the possibility to also register some functions by hand.
 847 CPPUNIT_PLUGIN_IMPLEMENT();
 848
 849 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */