1 /************************************************************** 2 * 3 * Licensed to the Apache Software Foundation (ASF) under one 4 * or more contributor license agreements. See the NOTICE file 5 * distributed with this work for additional information 6 * regarding copyright ownership. The ASF licenses this file 7 * to you under the Apache License, Version 2.0 (the 8 * "License"); you may not use this file except in compliance 9 * with the License. You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, 14 * software distributed under the License is distributed on an 15 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16 * KIND, either express or implied. See the License for the 17 * specific language governing permissions and limitations 18 * under the License. 19 * 20 *************************************************************/ 21 22 23 24 25 // MARKER(update_precomp.py): autogen include statement, do not remove 26 #include "precompiled_sal.hxx" 27 #include <testshl/simpleheader.hxx> 28 29 /** print a UNI_CODE file name. 30 */ 31 inline void printOUString( ::rtl::OUString const & _suStr ) 32 { 33 rtl::OString aString; 34 35 t_print( "OUString: " ); 36 aString = ::rtl::OUStringToOString( _suStr, RTL_TEXTENCODING_ASCII_US ); 37 t_print( "%s\n", aString.getStr( ) ); 38 } 39 40 41 namespace rtl_ustr 42 { 43 44 class compare : public CppUnit::TestFixture 45 { 46 public: 47 48 49 void compare_000() 50 { 51 rtl_ustr_compare( NULL, NULL); 52 // should not GPF 53 } 54 55 void compare_000_1() 56 { 57 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 58 rtl_ustr_compare( aStr1.getStr(), NULL); 59 // should not GPF 60 } 61 void compare_001() 62 { 63 rtl::OUString aStr1; 64 rtl::OUString aStr2; 65 66 sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()); 67 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 68 } 69 70 void compare_002() 71 { 72 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 73 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line must be equal."); 74 75 sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()); 76 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 77 } 78 79 void compare_003() 80 { 81 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); 82 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); 83 84 sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()); 85 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 86 } 87 88 // Change the following lines only, if you add, remove or rename 89 // member functions of the current class, 90 // because these macros are need by auto register mechanism. 91 92 CPPUNIT_TEST_SUITE(compare); 93 CPPUNIT_TEST(compare_000); 94 CPPUNIT_TEST(compare_000_1); 95 CPPUNIT_TEST(compare_001); 96 CPPUNIT_TEST(compare_002); 97 CPPUNIT_TEST(compare_003); 98 CPPUNIT_TEST_SUITE_END(); 99 }; // class compare 100 101 102 class compareIgnoreAsciiCase : public CppUnit::TestFixture 103 { 104 public: 105 106 void compare_000() 107 { 108 rtl_ustr_compareIgnoreAsciiCase( NULL, NULL); 109 } 110 111 void compare_000_1() 112 { 113 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 114 rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), NULL); 115 } 116 void compare_001() 117 { 118 rtl::OUString aStr1; 119 rtl::OUString aStr2; 120 121 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 122 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 123 } 124 125 void compare_002() 126 { 127 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 128 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line must be equal."); 129 130 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 131 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 132 } 133 134 void compare_002_1() 135 { 136 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 137 rtl::OUString aStr2 = rtl::OUString::createFromAscii("LINE MUST BE EQUAL."); 138 139 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 140 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); 141 } 142 143 void compare_003() 144 { 145 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); 146 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); 147 148 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 149 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 150 } 151 152 // Change the following lines only, if you add, remove or rename 153 // member functions of the current class, 154 // because these macros are need by auto register mechanism. 155 156 CPPUNIT_TEST_SUITE(compareIgnoreAsciiCase); 157 CPPUNIT_TEST(compare_000); 158 CPPUNIT_TEST(compare_000_1); 159 CPPUNIT_TEST(compare_001); 160 CPPUNIT_TEST(compare_002); 161 CPPUNIT_TEST(compare_002_1); 162 CPPUNIT_TEST(compare_003); 163 CPPUNIT_TEST_SUITE_END(); 164 }; // class compareIgnoreAsciiCase 165 166 // ----------------------------------------------------------------------------- 167 168 class shortenedCompareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture 169 { 170 public: 171 172 void compare_000() 173 { 174 rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0, 0); 175 } 176 177 void compare_000_1() 178 { 179 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 180 rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0, 1); 181 } 182 void compare_001() 183 { 184 rtl::OUString aStr1; 185 rtl::OUString aStr2; 186 187 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), aStr2.getStr(), aStr2.getLength(), aStr1.getLength()); 188 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 189 } 190 191 void compare_002() 192 { 193 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 194 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line must be equal."); 195 196 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 197 aStr2.getStr(), aStr2.getLength(), 198 aStr1.getLength()); 199 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 200 } 201 202 void compare_002_1() 203 { 204 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 205 rtl::OUString aStr2 = rtl::OUString::createFromAscii("LINE MUST BE EQUAL."); 206 207 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 208 aStr2.getStr(), aStr2.getLength(), 209 aStr1.getLength()); 210 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); 211 } 212 213 void compare_003() 214 { 215 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); 216 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); 217 218 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 219 aStr2.getStr(), aStr2.getLength(), 220 5); 221 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal first 5 characters.", nValue == 0); 222 } 223 224 void compare_004() 225 { 226 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); 227 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); 228 229 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 230 aStr2.getStr(), aStr2.getLength(), 231 aStr1.getLength()); 232 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 233 } 234 235 // Change the following lines only, if you add, remove or rename 236 // member functions of the current class, 237 // because these macros are need by auto register mechanism. 238 239 CPPUNIT_TEST_SUITE(shortenedCompareIgnoreAsciiCase_WithLength); 240 CPPUNIT_TEST(compare_000); 241 CPPUNIT_TEST(compare_000_1); 242 CPPUNIT_TEST(compare_001); 243 CPPUNIT_TEST(compare_002); 244 CPPUNIT_TEST(compare_002_1); 245 CPPUNIT_TEST(compare_003); 246 CPPUNIT_TEST(compare_004); 247 CPPUNIT_TEST_SUITE_END(); 248 }; // class compare 249 250 251 // // ----------------------------------------------------------------------------- 252 // 253 // class hashCode : public CppUnit::TestFixture 254 // { 255 // public: 256 // 257 // void hashCode_000() 258 // { 259 // sal_Int32 nHashCode = rtl_ustr_hashCode( NULL ); 260 // volatile int dummy = 0; 261 // } 262 // 263 // void hashCode_001() 264 // { 265 // rtl::OString aStr1 = "Line for a hashCode."; 266 // sal_Int32 nHashCode = rtl_ustr_hashCode( aStr1.getStr() ); 267 // t_print("hashcode: %d\n", nHashCode); 268 // // CPPUNIT_ASSERT_MESSAGE("failed.", nValue == 0); 269 // } 270 // 271 // void hashCode_002() 272 // { 273 // rtl::OString aStr1 = "Line for a hashCode."; 274 // sal_Int32 nHashCode1 = rtl_ustr_hashCode( aStr1.getStr() ); 275 // 276 // rtl::OString aStr2 = "Line for a hashCode."; 277 // sal_Int32 nHashCode2 = rtl_ustr_hashCode( aStr2.getStr() ); 278 // 279 // CPPUNIT_ASSERT_MESSAGE("hashcodes must be equal.", nHashCode1 == nHashCode2 ); 280 // } 281 // 282 // void hashCode_003() 283 // { 284 // rtl::OString aStr1 = "Line for a hashCode."; 285 // sal_Int32 nHashCode1 = rtl_ustr_hashCode( aStr1.getStr() ); 286 // 287 // rtl::OString aStr2 = "Line for an other hashcode."; 288 // sal_Int32 nHashCode2 = rtl_ustr_hashCode( aStr2.getStr() ); 289 // 290 // CPPUNIT_ASSERT_MESSAGE("hashcodes must differ.", nHashCode1 != nHashCode2 ); 291 // } 292 // 293 // // Change the following lines only, if you add, remove or rename 294 // // member functions of the current class, 295 // // because these macros are need by auto register mechanism. 296 // 297 // CPPUNIT_TEST_SUITE(hashCode); 298 // CPPUNIT_TEST(hashCode_000); 299 // CPPUNIT_TEST(hashCode_001); 300 // CPPUNIT_TEST(hashCode_002); 301 // CPPUNIT_TEST(hashCode_003); 302 // CPPUNIT_TEST_SUITE_END(); 303 // }; // class compare 304 // 305 // 306 // // ----------------------------------------------------------------------------- 307 // 308 class indexOfChar : public CppUnit::TestFixture 309 { 310 public: 311 312 void indexOfChar_000() 313 { 314 rtl_ustr_indexOfChar( NULL, 0 ); 315 } 316 317 void indexOfChar_001() 318 { 319 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfChar."); 320 321 sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'L' ); 322 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); 323 324 /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'i' ); 325 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 1); 326 327 /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'n' ); 328 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 2); 329 330 /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'e' ); 331 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 3); 332 } 333 334 void indexOfChar_002() 335 { 336 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfChar."); 337 sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'y' ); 338 339 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); 340 } 341 342 // Change the following lines only, if you add, remove or rename 343 // member functions of the current class, 344 // because these macros are need by auto register mechanism. 345 346 CPPUNIT_TEST_SUITE(indexOfChar); 347 CPPUNIT_TEST(indexOfChar_000); 348 CPPUNIT_TEST(indexOfChar_001); 349 CPPUNIT_TEST(indexOfChar_002); 350 CPPUNIT_TEST_SUITE_END(); 351 }; // class indexOfChar 352 353 // // ----------------------------------------------------------------------------- 354 class lastIndexOfChar : public CppUnit::TestFixture 355 { 356 public: 357 358 void lastIndexOfChar_000() 359 { 360 rtl_ustr_lastIndexOfChar( NULL, 0 ); 361 } 362 363 void lastIndexOfChar_001() 364 { 365 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfChar."); 366 367 sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'C' ); 368 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 22); 369 370 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'h' ); 371 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 23); 372 373 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'a' ); 374 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 24); 375 376 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'r' ); 377 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 25); 378 } 379 380 void lastIndexOfChar_002() 381 { 382 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfChar."); 383 sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'y' ); 384 385 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); 386 } 387 388 // Change the following lines only, if you add, remove or rename 389 // member functions of the current class, 390 // because these macros are need by auto register mechanism. 391 392 CPPUNIT_TEST_SUITE(lastIndexOfChar); 393 CPPUNIT_TEST(lastIndexOfChar_000); 394 CPPUNIT_TEST(lastIndexOfChar_001); 395 CPPUNIT_TEST(lastIndexOfChar_002); 396 CPPUNIT_TEST_SUITE_END(); 397 }; // class lastIndexOfChar 398 399 400 // ----------------------------------------------------------------------------- 401 402 class indexOfStr : public CppUnit::TestFixture 403 { 404 public: 405 406 void indexOfStr_000() 407 { 408 rtl_ustr_indexOfStr( NULL, 0 ); 409 } 410 411 void indexOfStr_000_1() 412 { 413 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); 414 rtl_ustr_indexOfStr( aStr1.getStr(), 0 ); 415 } 416 417 void indexOfStr_001() 418 { 419 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); 420 421 rtl::OUString suSearch = rtl::OUString::createFromAscii("Line"); 422 sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); 423 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); 424 425 /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("for"); 426 /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); 427 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 5); 428 429 /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("a"); 430 /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); 431 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 9); 432 433 /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("a index"); 434 /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); 435 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex ==9); 436 } 437 438 void indexOfStr_002() 439 { 440 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); 441 rtl::OUString suSearch = rtl::OUString::createFromAscii("not exist"); 442 sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch ); 443 444 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); 445 } 446 447 // Change the following lines only, if you add, remove or rename 448 // member functions of the current class, 449 // because these macros are need by auto register mechanism. 450 451 CPPUNIT_TEST_SUITE(indexOfStr); 452 CPPUNIT_TEST(indexOfStr_000); 453 CPPUNIT_TEST(indexOfStr_001); 454 CPPUNIT_TEST(indexOfStr_002); 455 CPPUNIT_TEST_SUITE_END(); 456 }; // class compare 457 // ----------------------------------------------------------------------------- 458 459 460 class lastIndexOfStr : public CppUnit::TestFixture 461 { 462 public: 463 464 void lastIndexOfStr_000() 465 { 466 rtl_ustr_lastIndexOfStr( NULL, NULL ); 467 } 468 469 void lastIndexOfStr_000_1() 470 { 471 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); 472 rtl_ustr_lastIndexOfStr( aStr1.getStr(), NULL ); 473 } 474 475 void lastIndexOfStr_001() 476 { 477 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); 478 rtl::OUString aSearchStr = rtl::OUString::createFromAscii("Index"); 479 480 sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 481 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 15); 482 483 /* rtl::OString */ aSearchStr = rtl::OUString::createFromAscii("Line"); 484 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 485 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 0); 486 487 /* rtl::OString */ aSearchStr = rtl::OUString::createFromAscii(""); 488 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 489 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1); 490 } 491 492 void lastIndexOfStr_002() 493 { 494 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); 495 rtl::OUString aSearchStr = rtl::OUString::createFromAscii("foo"); 496 sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 497 498 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == -1 ); 499 } 500 501 void lastIndexOfStr_003() 502 { 503 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); 504 rtl::OUString aSearchStr = rtl::OUString::createFromAscii("O"); 505 sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 506 507 CPPUNIT_ASSERT_MESSAGE("index is wrong.", nIndex == 20 ); 508 } 509 510 // Change the following lines only, if you add, remove or rename 511 // member functions of the current class, 512 // because these macros are need by auto register mechanism. 513 514 CPPUNIT_TEST_SUITE(lastIndexOfStr); 515 CPPUNIT_TEST(lastIndexOfStr_000); 516 CPPUNIT_TEST(lastIndexOfStr_001); 517 CPPUNIT_TEST(lastIndexOfStr_002); 518 CPPUNIT_TEST(lastIndexOfStr_003); 519 CPPUNIT_TEST_SUITE_END(); 520 }; // class lastIndexOfStr 521 522 // ----------------------------------------------------------------------------- 523 524 class replaceChar : public CppUnit::TestFixture 525 { 526 public: 527 528 void replaceChar_000() 529 { 530 rtl_ustr_replaceChar( NULL, 0, 0 ); 531 } 532 533 void replaceChar_001() 534 { 535 rtl::OUString aStr1 = rtl::OUString::createFromAscii("replace char."); 536 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("ruplacu char."); 537 538 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 539 sal_Unicode* pStr = (sal_Unicode*) malloc( nLength + sizeof(sal_Unicode)); // length + 1 (null terminator) 540 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 541 memset(pStr, 0, nLength + sizeof(sal_Unicode)); 542 memcpy(pStr, aStr1.getStr(), nLength); 543 544 rtl_ustr_replaceChar( pStr, 'e', 'u' ); 545 rtl::OUString suStr(pStr, aStr1.getLength()); 546 547 CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(suStr) == sal_True); 548 free(pStr); 549 } 550 551 // Change the following lines only, if you add, remove or rename 552 // member functions of the current class, 553 // because these macros are need by auto register mechanism. 554 555 CPPUNIT_TEST_SUITE(replaceChar); 556 CPPUNIT_TEST(replaceChar_000); 557 CPPUNIT_TEST(replaceChar_001); 558 CPPUNIT_TEST_SUITE_END(); 559 }; // class replaceChar 560 561 // ----------------------------------------------------------------------------- 562 563 class replaceChar_WithLength : public CppUnit::TestFixture 564 { 565 public: 566 567 void replaceChar_WithLength_000() 568 { 569 rtl_ustr_replaceChar_WithLength( NULL, 0, 0, 0 ); 570 } 571 572 void replaceChar_WithLength_000_1() 573 { 574 rtl_ustr_replaceChar_WithLength( NULL, 1, 0, 0 ); 575 } 576 void replaceChar_WithLength_001() 577 { 578 rtl::OUString aStr1 = rtl::OUString::createFromAscii("replace char."); 579 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("ruplace char."); 580 581 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 582 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); 583 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 584 memcpy(pStr, aStr1.getStr(), nLength); 585 586 rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' ); 587 rtl::OUString suStr(pStr, aStr1.getLength()); 588 589 CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(suStr) == sal_True); 590 free(pStr); 591 } 592 593 void replaceChar_WithLength_002() 594 { 595 rtl::OUString aStr1 = rtl::OUString::createFromAscii("eeeeeeeeeeeee"); 596 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("uuuuuueeeeeee"); 597 598 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 599 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); // no null terminator is need 600 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 601 memcpy(pStr, aStr1.getStr(), nLength); 602 603 rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' ); 604 rtl::OUString suStr(pStr, aStr1.getLength()); 605 606 CPPUNIT_ASSERT_MESSAGE("replace failed", aShouldStr1.equals(suStr) == sal_True); 607 free(pStr); 608 } 609 610 // Change the following lines only, if you add, remove or rename 611 // member functions of the current class, 612 // because these macros are need by auto register mechanism. 613 614 CPPUNIT_TEST_SUITE(replaceChar_WithLength); 615 CPPUNIT_TEST(replaceChar_WithLength_000); 616 CPPUNIT_TEST(replaceChar_WithLength_000_1); 617 CPPUNIT_TEST(replaceChar_WithLength_001); 618 CPPUNIT_TEST(replaceChar_WithLength_002); 619 CPPUNIT_TEST_SUITE_END(); 620 }; // class replaceChar 621 622 623 // ----------------------------------------------------------------------------- 624 625 class toAsciiLowerCase : public CppUnit::TestFixture 626 { 627 public: 628 629 void toAsciiLowerCase_000() 630 { 631 rtl_ustr_toAsciiLowerCase( NULL ); 632 } 633 634 void toAsciiLowerCase_001() 635 { 636 rtl::OUString aStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII LOWER CASE."); 637 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("change this to ascii lower case."); 638 639 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 640 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode) ); // we need to add '\0' so one more 641 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 642 memset(pStr, 0, nLength + sizeof(sal_Unicode)); // empty the sal_Unicode array 643 memcpy(pStr, aStr1.getStr(), nLength); 644 645 rtl_ustr_toAsciiLowerCase( pStr ); 646 rtl::OUString suStr(pStr, aStr1.getLength()); 647 648 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True); 649 free(pStr); 650 } 651 652 // Change the following lines only, if you add, remove or rename 653 // member functions of the current class, 654 // because these macros are need by auto register mechanism. 655 656 CPPUNIT_TEST_SUITE(toAsciiLowerCase); 657 CPPUNIT_TEST(toAsciiLowerCase_000); 658 CPPUNIT_TEST(toAsciiLowerCase_001); 659 CPPUNIT_TEST_SUITE_END(); 660 }; // class replaceChar 661 662 663 class toAsciiLowerCase_WithLength : public CppUnit::TestFixture 664 { 665 public: 666 667 void toAsciiLowerCase_WithLength_000() 668 { 669 rtl_ustr_toAsciiLowerCase_WithLength( NULL, 0 ); 670 } 671 672 void toAsciiLowerCase_WithLength_001() 673 { 674 rtl::OUString aStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII LOWER CASE."); 675 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("change thiS TO ASCII LOWER CASE."); 676 677 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 678 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); 679 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 680 memcpy(pStr, aStr1.getStr(), nLength); 681 682 rtl_ustr_toAsciiLowerCase_WithLength( pStr, 10 ); 683 684 rtl::OUString suStr(pStr, aStr1.getLength()); 685 sal_Bool bResult = aShouldStr1.equals(suStr); 686 687 printOUString(suStr); 688 t_print("Result length: %d\n", suStr.getLength() ); 689 t_print("Result: %d\n", bResult); 690 691 CPPUNIT_ASSERT_MESSAGE("failed", bResult == sal_True); 692 free(pStr); 693 } 694 695 // Change the following lines only, if you add, remove or rename 696 // member functions of the current class, 697 // because these macros are need by auto register mechanism. 698 699 CPPUNIT_TEST_SUITE(toAsciiLowerCase_WithLength); 700 CPPUNIT_TEST(toAsciiLowerCase_WithLength_000); 701 CPPUNIT_TEST(toAsciiLowerCase_WithLength_001); 702 CPPUNIT_TEST_SUITE_END(); 703 }; // class replaceChar 704 705 // ----------------------------------------------------------------------------- 706 707 class toAsciiUpperCase : public CppUnit::TestFixture 708 { 709 public: 710 711 void toAsciiUpperCase_000() 712 { 713 rtl_ustr_toAsciiUpperCase( NULL ); 714 } 715 716 void toAsciiUpperCase_001() 717 { 718 rtl::OUString aStr1 = rtl::OUString::createFromAscii("change this to ascii upper case."); 719 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII UPPER CASE."); 720 721 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 722 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator 723 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 724 memset(pStr, 0, nLength + sizeof(sal_Unicode)); 725 memcpy(pStr, aStr1.getStr(), nLength); 726 727 rtl_ustr_toAsciiUpperCase( pStr ); 728 rtl::OUString suStr(pStr, aStr1.getLength()); 729 730 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True); 731 free(pStr); 732 } 733 734 // Change the following lines only, if you add, remove or rename 735 // member functions of the current class, 736 // because these macros are need by auto register mechanism. 737 738 CPPUNIT_TEST_SUITE(toAsciiUpperCase); 739 CPPUNIT_TEST(toAsciiUpperCase_000); 740 CPPUNIT_TEST(toAsciiUpperCase_001); 741 CPPUNIT_TEST_SUITE_END(); 742 }; // class replaceChar 743 744 745 class toAsciiUpperCase_WithLength : public CppUnit::TestFixture 746 { 747 public: 748 749 void toAsciiUpperCase_WithLength_000() 750 { 751 rtl_ustr_toAsciiUpperCase_WithLength( NULL, 0 ); 752 } 753 754 void toAsciiUpperCase_WithLength_001() 755 { 756 rtl::OUString aStr1 = rtl::OUString::createFromAscii("change this to ascii lower case."); 757 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIs to ascii lower case."); 758 759 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 760 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); 761 CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 762 763 memcpy(pStr, aStr1.getStr(), nLength); 764 rtl_ustr_toAsciiUpperCase_WithLength( pStr, 10 ); 765 rtl::OUString suStr(pStr, aStr1.getLength()); 766 767 // t_print("Uppercase with length: '%s'\n", aStr1.getStr()); 768 CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True); 769 free(pStr); 770 } 771 772 // Change the following lines only, if you add, remove or rename 773 // member functions of the current class, 774 // because these macros are need by auto register mechanism. 775 776 CPPUNIT_TEST_SUITE(toAsciiUpperCase_WithLength); 777 CPPUNIT_TEST(toAsciiUpperCase_WithLength_000); 778 CPPUNIT_TEST(toAsciiUpperCase_WithLength_001); 779 CPPUNIT_TEST_SUITE_END(); 780 }; // class replaceChar 781 782 783 // ----------------------------------------------------------------------------- 784 785 class trim_WithLength : public CppUnit::TestFixture 786 { 787 public: 788 void trim_WithLength_000() 789 { 790 rtl_ustr_trim_WithLength(NULL, 0); 791 // should not GPF 792 } 793 794 void trim_WithLength_000_1() 795 { 796 rtl::OUString suStr = rtl::OUString::createFromAscii(" trim this"); 797 798 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 799 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 800 memcpy(pStr, suStr.getStr(), nLength); 801 802 rtl_ustr_trim_WithLength( pStr, 0 ); 803 free(pStr); 804 } 805 806 void trim_WithLength_001() 807 { 808 rtl::OUString suStr = rtl::OUString::createFromAscii(" trim this"); 809 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 810 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 811 memcpy(pStr, suStr.getStr(), nLength); 812 813 rtl_ustr_trim_WithLength( pStr, 2 ); 814 815 CPPUNIT_ASSERT_MESSAGE("string should be empty", rtl::OUString(pStr).getLength() == 0); 816 free(pStr); 817 } 818 819 820 void trim_WithLength_002() 821 { 822 rtl::OUString suStr = rtl::OUString::createFromAscii("trim this"); 823 824 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 825 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 826 memcpy(pStr, suStr.getStr(), nLength); 827 828 rtl_ustr_trim_WithLength( pStr, 5 ); 829 830 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", rtl::OUString(pStr).getLength() == 4); 831 free(pStr); 832 } 833 834 835 void trim_WithLength_003() 836 { 837 rtl::OUString suStr = rtl::OUString::createFromAscii(" trim this"); 838 839 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 840 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 841 memcpy(pStr, suStr.getStr(), nLength); 842 843 rtl_ustr_trim_WithLength( pStr, 11 ); 844 845 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", rtl::OUString(pStr).getLength() == 4); 846 free(pStr); 847 } 848 849 void trim_WithLength_004() 850 { 851 rtl::OUString suStr = rtl::OUString::createFromAscii("\r\n\t \n\r trim \n this"); 852 853 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 854 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 855 memcpy(pStr, suStr.getStr(), nLength); 856 857 rtl_ustr_trim_WithLength( pStr, 17 ); 858 859 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim'", rtl::OUString(pStr).getLength() == 4); 860 free(pStr); 861 } 862 863 void trim_WithLength_005() 864 { 865 rtl::OUString suStr = rtl::OUString::createFromAscii("\r\n\t \n\r trim \t this \n\r\t\t "); 866 867 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 868 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 869 memcpy(pStr, suStr.getStr(), nLength); 870 871 rtl_ustr_trim_WithLength( pStr, suStr.getLength() ); 872 873 CPPUNIT_ASSERT_MESSAGE("string should contain 'trim \\t this'", rtl::OUString(pStr).getLength() == 11); 874 free(pStr); 875 } 876 877 // Change the following lines only, if you add, remove or rename 878 // member functions of the current class, 879 // because these macros are need by auto register mechanism. 880 881 CPPUNIT_TEST_SUITE(trim_WithLength); 882 CPPUNIT_TEST(trim_WithLength_000); 883 CPPUNIT_TEST(trim_WithLength_000_1); 884 CPPUNIT_TEST(trim_WithLength_001); 885 CPPUNIT_TEST(trim_WithLength_002); 886 CPPUNIT_TEST(trim_WithLength_003); 887 CPPUNIT_TEST(trim_WithLength_004); 888 CPPUNIT_TEST(trim_WithLength_005); 889 CPPUNIT_TEST_SUITE_END(); 890 }; 891 892 // ----------------------------------------------------------------------------- 893 894 class valueOfChar : public CppUnit::TestFixture 895 { 896 public: 897 void valueOfChar_000() 898 { 899 rtl_ustr_valueOfChar(NULL, 0); 900 // should not GPF 901 } 902 void valueOfChar_001() 903 { 904 sal_Unicode *pStr = (sal_Unicode*)malloc(RTL_USTR_MAX_VALUEOFCHAR); 905 if (pStr) 906 { 907 rtl_ustr_valueOfChar(pStr, 'A'); 908 909 CPPUNIT_ASSERT_MESSAGE("string should contain 'A'", pStr[0] == L'A'); 910 free(pStr); 911 } 912 } 913 914 // Change the following lines only, if you add, remove or rename 915 // member functions of the current class, 916 // because these macros are need by auto register mechanism. 917 918 CPPUNIT_TEST_SUITE(valueOfChar); 919 CPPUNIT_TEST(valueOfChar_000); 920 CPPUNIT_TEST(valueOfChar_001); 921 CPPUNIT_TEST_SUITE_END(); 922 }; 923 924 925 926 927 class ascii_compare_WithLength : public CppUnit::TestFixture 928 { 929 public: 930 void zero_length() 931 { 932 sal_Unicode pUnicode[] = {0xffff, 0xffff}; 933 char const * pAscii = "reference"; 934 935 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(pUnicode, 0, pAscii); 936 CPPUNIT_ASSERT_MESSAGE("ref string is empty, compare failed, needs to be <0.", value < 0); 937 } 938 939 void equal_ascii_shorter() 940 { 941 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("referenceString")); 942 char const * pAscii = "reference"; 943 944 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 945 CPPUNIT_ASSERT_MESSAGE("ref string is bigger, compare failed, needs to be >0.", value > 0); 946 } 947 948 void equal_ascii_shorter_asciiLength() 949 { 950 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("referenceString")); 951 char const * pAscii = "reference"; 952 953 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, rtl_str_getLength(pAscii), pAscii); 954 CPPUNIT_ASSERT_MESSAGE("ref string is bigger despite ascii length, compare failed, needs to be == 0.", value == 0); 955 } 956 957 void equal_ref_shorter() 958 { 959 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("reference")); 960 char const * pAscii = "referenceString"; 961 962 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 963 CPPUNIT_ASSERT_MESSAGE("ascii string is bigger, but only compared to ref length, needs to be 0.", value < 0); 964 } 965 966 void equal() 967 { 968 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("reference")); 969 char const * pAscii = "reference"; 970 971 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 972 CPPUNIT_ASSERT_MESSAGE("strings are equal, compare failed, needs to be 0.", value == 0); 973 } 974 975 void unequal_reference_bigger() 976 { 977 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("defghi")); 978 char const * pAscii = "abc"; 979 980 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 981 CPPUNIT_ASSERT_MESSAGE("strings are unequal and ref is bigger, needs to be >0.", value > 0); 982 } 983 984 void unequal_ascii_bigger() 985 { 986 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("abc")); 987 char const * pAscii = "defghi"; 988 989 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 990 991 CPPUNIT_ASSERT_MESSAGE("strings are unequal and ascii is bigger, needs to be <0.", value < 0); 992 } 993 994 CPPUNIT_TEST_SUITE(ascii_compare_WithLength); 995 CPPUNIT_TEST(zero_length); 996 CPPUNIT_TEST(equal_ascii_shorter); 997 CPPUNIT_TEST(equal_ascii_shorter_asciiLength); 998 CPPUNIT_TEST(equal_ref_shorter); 999 CPPUNIT_TEST(equal); 1000 CPPUNIT_TEST(unequal_reference_bigger); 1001 CPPUNIT_TEST(unequal_ascii_bigger); 1002 CPPUNIT_TEST_SUITE_END(); 1003 }; 1004 1005 1006 1007 1008 class ascii_shortenedCompareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture 1009 { 1010 public: 1011 1012 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_000() 1013 { 1014 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0); 1015 // should not GPF 1016 } 1017 1018 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_1() 1019 { 1020 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1021 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0); 1022 // should not GPF 1023 } 1024 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_2() 1025 { 1026 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1027 rtl::OString sStr2 = "Line is shorter."; 1028 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), sStr2.getLength(), sStr2.getStr(), 0); 1029 // should not GPF 1030 } 1031 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_001() 1032 { 1033 rtl::OUString suStr1; 1034 rtl::OString sStr2; 1035 1036 sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1, 0, sStr2.getStr(), 0); 1037 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 1038 } 1039 1040 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_002() 1041 { 1042 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1043 rtl::OString sStr2 = "Line must be equal."; 1044 1045 sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr(), sStr2.getLength()); 1046 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 1047 } 1048 1049 void ascii_shortenedCompareIgnoreAsciiCase_WithLength_003() 1050 { 1051 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 1052 rtl::OString sStr2 = "Line must be differ and longer."; 1053 1054 sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr(), sStr2.getLength()); 1055 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 1056 } 1057 1058 // Change the following lines only, if you add, remove or rename 1059 // member functions of the current class, 1060 // because these macros are need by auto register mechanism. 1061 1062 CPPUNIT_TEST_SUITE(ascii_shortenedCompareIgnoreAsciiCase_WithLength); 1063 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_000); 1064 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_1); 1065 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_2); 1066 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_001); 1067 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_002); 1068 CPPUNIT_TEST(ascii_shortenedCompareIgnoreAsciiCase_WithLength_003); 1069 CPPUNIT_TEST_SUITE_END(); 1070 }; // class ascii_shortenedCompareIgnoreAsciiCase_WithLength 1071 1072 // ----------------------------------------------------------------------------- 1073 1074 class ascii_compareIgnoreAsciiCase_WithLength : public CppUnit::TestFixture 1075 { 1076 public: 1077 1078 void ascii_compareIgnoreAsciiCase_WithLength_000() 1079 { 1080 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( NULL, 0, NULL); 1081 // should not GPF 1082 } 1083 1084 void ascii_compareIgnoreAsciiCase_WithLength_000_1() 1085 { 1086 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1087 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aStr1.getStr(), 0, NULL); 1088 // should not GPF 1089 } 1090 void ascii_compareIgnoreAsciiCase_WithLength_000_2() 1091 { 1092 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1093 rtl::OString sStr2 = "Line is shorter."; 1094 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aStr1.getStr(), sStr2.getLength(), sStr2.getStr()); 1095 // should not GPF 1096 } 1097 void ascii_compareIgnoreAsciiCase_WithLength_001() 1098 { 1099 rtl::OUString suStr1; 1100 rtl::OString sStr2; 1101 1102 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1, 0, sStr2.getStr()); 1103 CPPUNIT_ASSERT_MESSAGE("compareIgnoreAsciiCase_WithLength failed, strings are equal.", nValue == 0); 1104 } 1105 1106 void ascii_compareIgnoreAsciiCase_WithLength_002() 1107 { 1108 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1109 rtl::OString sStr2 = "Line must be equal."; 1110 1111 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr()); 1112 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 1113 } 1114 1115 void ascii_compareIgnoreAsciiCase_WithLength_003() 1116 { 1117 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 1118 rtl::OString sStr2 = "Line must be differ and longer."; 1119 1120 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr()); 1121 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 1122 } 1123 1124 // Change the following lines only, if you add, remove or rename 1125 // member functions of the current class, 1126 // because these macros are need by auto register mechanism. 1127 1128 CPPUNIT_TEST_SUITE(ascii_compareIgnoreAsciiCase_WithLength); 1129 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_000); 1130 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_000_1); 1131 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_000_2); 1132 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_001); 1133 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_002); 1134 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_WithLength_003); 1135 CPPUNIT_TEST_SUITE_END(); 1136 }; // class ascii_compareIgnoreAsciiCase_WithLength 1137 1138 // ----------------------------------------------------------------------------- 1139 1140 class ascii_compare : public CppUnit::TestFixture 1141 { 1142 public: 1143 1144 void ascii_compare_000() 1145 { 1146 rtl_ustr_ascii_compare( NULL, NULL); 1147 // should not GPF 1148 } 1149 1150 void ascii_compare_000_1() 1151 { 1152 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1153 rtl_ustr_ascii_compare( aStr1.getStr(), NULL); 1154 // should not GPF 1155 } 1156 void ascii_compare_001() 1157 { 1158 rtl::OUString suStr1; 1159 rtl::OString sStr2; 1160 1161 sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1, sStr2.getStr()); 1162 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 1163 } 1164 1165 void ascii_compare_002() 1166 { 1167 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1168 rtl::OString sStr2 = "Line must be equal."; 1169 1170 sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.getStr()); 1171 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 1172 } 1173 1174 void ascii_compare_003() 1175 { 1176 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 1177 rtl::OString sStr2 = "Line foo bar, ok, differ."; 1178 1179 sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.getStr()); 1180 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 1181 } 1182 1183 // Change the following lines only, if you add, remove or rename 1184 // member functions of the current class, 1185 // because these macros are need by auto register mechanism. 1186 1187 CPPUNIT_TEST_SUITE(ascii_compare); 1188 CPPUNIT_TEST(ascii_compare_000); 1189 CPPUNIT_TEST(ascii_compare_000_1); 1190 CPPUNIT_TEST(ascii_compare_001); 1191 CPPUNIT_TEST(ascii_compare_002); 1192 CPPUNIT_TEST(ascii_compare_003); 1193 CPPUNIT_TEST_SUITE_END(); 1194 }; // class ascii_compare 1195 1196 // ----------------------------------------------------------------------------- 1197 1198 class ascii_compareIgnoreAsciiCase : public CppUnit::TestFixture 1199 { 1200 public: 1201 1202 void ascii_compareIgnoreAsciiCase_000() 1203 { 1204 rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL); 1205 // should not GPF 1206 } 1207 1208 void ascii_compareIgnoreAsciiCase_000_1() 1209 { 1210 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1211 rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL); 1212 // should not GPF 1213 } 1214 void ascii_compareIgnoreAsciiCase_001() 1215 { 1216 rtl::OUString suStr1; 1217 rtl::OString sStr2; 1218 1219 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1, sStr2.getStr()); 1220 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 1221 } 1222 1223 void ascii_compareIgnoreAsciiCase_002() 1224 { 1225 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1226 rtl::OString sStr2 = "Line must be equal."; 1227 1228 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1229 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 1230 } 1231 1232 void ascii_compareIgnoreAsciiCase_002_1() 1233 { 1234 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal, when ignore case."); 1235 rtl::OString sStr2 = "LINE MUST BE EQUAL, WHEN IGNORE CASE."; 1236 1237 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1238 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); 1239 } 1240 1241 void ascii_compareIgnoreAsciiCase_003() 1242 { 1243 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 1244 rtl::OString sStr2 = "Line foo bar, ok, differ."; 1245 1246 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1247 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 1248 } 1249 1250 //! LLA: some more tests with some high level strings 1251 1252 // void ascii_compareIgnoreAsciiCase_001() 1253 // { 1254 // rtl::OUString suStr1 = rtl::OUString::createFromAscii("change this to ascii upper case."); 1255 // rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII UPPER CASE."); 1256 // 1257 // sal_uInt32 nLength = suStr1.getLength() * sizeof(sal_Unicode); 1258 // sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator 1259 // CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 1260 // memset(pStr, 0, nLength + sizeof(sal_Unicode)); 1261 // memcpy(pStr, suStr1.getStr(), nLength); 1262 // 1263 // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr ); 1264 // rtl::OUString suStr(pStr, suStr1.getLength()); 1265 // 1266 // CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True); 1267 // free(pStr); 1268 // } 1269 1270 // Change the following lines only, if you add, remove or rename 1271 // member functions of the current class, 1272 // because these macros are need by auto register mechanism. 1273 1274 CPPUNIT_TEST_SUITE(ascii_compareIgnoreAsciiCase); 1275 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000); 1276 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000_1); 1277 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_001); 1278 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002); 1279 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002_1); 1280 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_003); 1281 CPPUNIT_TEST_SUITE_END(); 1282 }; // class ascii_compareIgnoreAsciiCase 1283 1284 1285 // sample out of inc/rtl/ustring.hxx 1286 // rtl_uString * pToken = NULL; 1287 // sal_Int32 nIndex = 0; 1288 // do 1289 // { 1290 // ... 1291 // nIndex = rtl_uString_getToken(&pToken, pStr, 0, ';', nIndex); 1292 // ... 1293 // } 1294 // while (nIndex >= 0); 1295 1296 class getToken : public CppUnit::TestFixture 1297 { 1298 public: 1299 1300 void getToken_000() 1301 { 1302 rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL); 1303 // should not GPF 1304 } 1305 1306 void ascii_compareIgnoreAsciiCase_000_1() 1307 { 1308 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1309 rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL); 1310 // should not GPF 1311 } 1312 void ascii_compareIgnoreAsciiCase_001() 1313 { 1314 rtl::OUString suStr1; 1315 rtl::OString sStr2; 1316 1317 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1, sStr2.getStr()); 1318 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 1319 } 1320 1321 void ascii_compareIgnoreAsciiCase_002() 1322 { 1323 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1324 rtl::OString sStr2 = "Line must be equal."; 1325 1326 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1327 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal.", nValue == 0); 1328 } 1329 1330 void ascii_compareIgnoreAsciiCase_002_1() 1331 { 1332 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal, when ignore case."); 1333 rtl::OString sStr2 = "LINE MUST BE EQUAL, WHEN IGNORE CASE."; 1334 1335 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1336 CPPUNIT_ASSERT_MESSAGE("compare failed, strings are equal (if case insensitve).", nValue == 0); 1337 } 1338 1339 void ascii_compareIgnoreAsciiCase_003() 1340 { 1341 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 1342 rtl::OString sStr2 = "Line foo bar, ok, differ."; 1343 1344 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1345 CPPUNIT_ASSERT_MESSAGE("compare failed, strings differ.", nValue != 0); 1346 } 1347 1348 //! LLA: some more tests with some high level strings 1349 1350 // void ascii_compareIgnoreAsciiCase_001() 1351 // { 1352 // rtl::OUString suStr1 = rtl::OUString::createFromAscii("change this to ascii upper case."); 1353 // rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII UPPER CASE."); 1354 // 1355 // sal_uInt32 nLength = suStr1.getLength() * sizeof(sal_Unicode); 1356 // sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator 1357 // CPPUNIT_ASSERT_MESSAGE("can't get memory for test", pStr != NULL); 1358 // memset(pStr, 0, nLength + sizeof(sal_Unicode)); 1359 // memcpy(pStr, suStr1.getStr(), nLength); 1360 // 1361 // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr ); 1362 // rtl::OUString suStr(pStr, suStr1.getLength()); 1363 // 1364 // CPPUNIT_ASSERT_MESSAGE("failed", aShouldStr1.equals(suStr) == sal_True); 1365 // free(pStr); 1366 // } 1367 1368 // Change the following lines only, if you add, remove or rename 1369 // member functions of the current class, 1370 // because these macros are need by auto register mechanism. 1371 1372 CPPUNIT_TEST_SUITE(ascii_compareIgnoreAsciiCase); 1373 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000); 1374 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_000_1); 1375 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_001); 1376 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002); 1377 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_002_1); 1378 CPPUNIT_TEST(ascii_compareIgnoreAsciiCase_003); 1379 CPPUNIT_TEST_SUITE_END(); 1380 }; // class ascii_compareIgnoreAsciiCase 1381 1382 // ----------------------------------------------------------------------------- 1383 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::compare, "rtl_ustr"); 1384 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::compareIgnoreAsciiCase, "rtl_ustr"); 1385 1386 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_compare_WithLength, "rtl_ustr"); 1387 1388 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::shortenedCompareIgnoreAsciiCase_WithLength, "rtl_ustr"); 1389 // CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::hashCode, "rtl_ustr"); 1390 1391 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::indexOfChar, "rtl_ustr"); 1392 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::lastIndexOfChar, "rtl_ustr"); 1393 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::indexOfStr, "rtl_ustr"); 1394 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::lastIndexOfStr, "rtl_ustr"); 1395 1396 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::replaceChar, "rtl_ustr"); 1397 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::replaceChar_WithLength, "rtl_ustr"); 1398 1399 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::toAsciiLowerCase, "rtl_ustr"); 1400 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::toAsciiLowerCase_WithLength, "rtl_ustr"); 1401 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::toAsciiUpperCase, "rtl_ustr"); 1402 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::toAsciiUpperCase_WithLength, "rtl_ustr"); 1403 1404 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::trim_WithLength, "rtl_ustr"); 1405 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::valueOfChar, "rtl_ustr"); 1406 1407 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_compare, "rtl_ustr"); 1408 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_compareIgnoreAsciiCase, "rtl_ustr"); 1409 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_compareIgnoreAsciiCase_WithLength, "rtl_ustr"); 1410 CPPUNIT_TEST_SUITE_NAMED_REGISTRATION(rtl_ustr::ascii_shortenedCompareIgnoreAsciiCase_WithLength, "rtl_ustr"); 1411 1412 } // namespace rtl_ustr 1413 1414 // ----------------------------------------------------------------------------- 1415 1416 // this macro creates an empty function, which will called by the RegisterAllFunctions() 1417 // to let the user the possibility to also register some functions by hand. 1418 NOADDITIONAL; 1419 1420 1421