sal/qa/rtl/ostring/rtl_str.cxx

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