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 "gtest/gtest.h" 28 #include <rtl/ustring.hxx> 29 30 /** print a UNI_CODE file name. 31 */ 32 inline void printOUString( ::rtl::OUString const & _suStr ) 33 { 34 rtl::OString aString; 35 36 printf( "OUString: " ); 37 aString = ::rtl::OUStringToOString( _suStr, RTL_TEXTENCODING_ASCII_US ); 38 printf( "%s\n", aString.getStr( ) ); 39 } 40 41 42 namespace rtl_ustr 43 { 44 45 class compare : public ::testing::Test 46 { 47 public: 48 }; // class compare 49 50 TEST_F(compare, compare_000) 51 { 52 rtl_ustr_compare( NULL, NULL); 53 // should not GPF 54 } 55 56 TEST_F(compare, compare_000_1) 57 { 58 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 59 rtl_ustr_compare( aStr1.getStr(), NULL); 60 // should not GPF 61 } 62 TEST_F(compare, compare_001) 63 { 64 rtl::OUString aStr1; 65 rtl::OUString aStr2; 66 67 sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()); 68 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 69 } 70 71 TEST_F(compare, compare_002) 72 { 73 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 74 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line must be equal."); 75 76 sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()); 77 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 78 } 79 80 TEST_F(compare, compare_003) 81 { 82 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); 83 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); 84 85 sal_Int32 nValue = rtl_ustr_compare( aStr1.getStr(), aStr2.getStr()); 86 ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; 87 } 88 89 class compareIgnoreAsciiCase : public ::testing::Test 90 { 91 public: 92 }; // class compareIgnoreAsciiCase 93 94 TEST_F(compareIgnoreAsciiCase, compare_000) 95 { 96 rtl_ustr_compareIgnoreAsciiCase( NULL, NULL); 97 } 98 99 TEST_F(compareIgnoreAsciiCase, compare_000_1) 100 { 101 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 102 rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), NULL); 103 } 104 TEST_F(compareIgnoreAsciiCase, compare_001) 105 { 106 rtl::OUString aStr1; 107 rtl::OUString aStr2; 108 109 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 110 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 111 } 112 113 TEST_F(compareIgnoreAsciiCase, compare_002) 114 { 115 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 116 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line must be equal."); 117 118 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 119 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 120 } 121 122 TEST_F(compareIgnoreAsciiCase, compare_002_1) 123 { 124 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 125 rtl::OUString aStr2 = rtl::OUString::createFromAscii("LINE MUST BE EQUAL."); 126 127 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 128 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal (if case insensitve)."; 129 } 130 131 TEST_F(compareIgnoreAsciiCase, compare_003) 132 { 133 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); 134 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); 135 136 sal_Int32 nValue = rtl_ustr_compareIgnoreAsciiCase( aStr1.getStr(), aStr2.getStr()); 137 ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; 138 } 139 // ----------------------------------------------------------------------------- 140 141 class shortenedCompareIgnoreAsciiCase_WithLength : public ::testing::Test 142 { 143 public: 144 }; // class compare 145 146 TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_000) 147 { 148 rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0, 0); 149 } 150 151 TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_000_1) 152 { 153 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 154 rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0, 1); 155 } 156 TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_001) 157 { 158 rtl::OUString aStr1; 159 rtl::OUString aStr2; 160 161 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), aStr2.getStr(), aStr2.getLength(), aStr1.getLength()); 162 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 163 } 164 165 TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_002) 166 { 167 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 168 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line must be equal."); 169 170 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 171 aStr2.getStr(), aStr2.getLength(), 172 aStr1.getLength()); 173 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 174 } 175 176 TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_002_1) 177 { 178 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 179 rtl::OUString aStr2 = rtl::OUString::createFromAscii("LINE MUST BE EQUAL."); 180 181 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 182 aStr2.getStr(), aStr2.getLength(), 183 aStr1.getLength()); 184 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal (if case insensitve)."; 185 } 186 187 TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_003) 188 { 189 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); 190 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); 191 192 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 193 aStr2.getStr(), aStr2.getLength(), 194 5); 195 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal first 5 characters."; 196 } 197 198 TEST_F(shortenedCompareIgnoreAsciiCase_WithLength, compare_004) 199 { 200 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must differ."); 201 rtl::OUString aStr2 = rtl::OUString::createFromAscii("Line foo bar, ok, differ."); 202 203 sal_Int32 nValue = rtl_ustr_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), 204 aStr2.getStr(), aStr2.getLength(), 205 aStr1.getLength()); 206 ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; 207 } 208 209 // // ----------------------------------------------------------------------------- 210 // 211 // class hashCode : public ::testing::Test 212 // { 213 // public: 214 // }; 215 // 216 // TEST_F(hashCode, hashCode_000) 217 // { 218 // sal_Int32 nHashCode = rtl_ustr_hashCode( NULL ); 219 // volatile int dummy = 0; 220 // } 221 // 222 // TEST_F(hashCode, hashCode_001) 223 // { 224 // rtl::OString aStr1 = "Line for a hashCode."; 225 // sal_Int32 nHashCode = rtl_ustr_hashCode( aStr1.getStr() ); 226 // printf("hashcode: %d\n", nHashCode); 227 // // ASSERT_TRUE(nValue == 0) << "failed."; 228 // } 229 // 230 // TEST_F(hashCode, hashCode_002) 231 // { 232 // rtl::OString aStr1 = "Line for a hashCode."; 233 // sal_Int32 nHashCode1 = rtl_ustr_hashCode( aStr1.getStr() ); 234 // 235 // rtl::OString aStr2 = "Line for a hashCode."; 236 // sal_Int32 nHashCode2 = rtl_ustr_hashCode( aStr2.getStr() ); 237 // 238 // ASSERT_TRUE(nHashCode1 == nHashCode2) << "hashcodes must be equal."; 239 // } 240 // 241 // TEST_F(hashCode, hashCode_003) 242 // { 243 // rtl::OString aStr1 = "Line for a hashCode."; 244 // sal_Int32 nHashCode1 = rtl_ustr_hashCode( aStr1.getStr() ); 245 // 246 // rtl::OString aStr2 = "Line for an other hashcode."; 247 // sal_Int32 nHashCode2 = rtl_ustr_hashCode( aStr2.getStr() ); 248 // 249 // ASSERT_TRUE(nHashCode1 != nHashCode2) << "hashcodes must differ."; 250 // } 251 // 252 // 253 // // ----------------------------------------------------------------------------- 254 // 255 class indexOfChar : public ::testing::Test 256 { 257 public: 258 }; // class indexOfChar 259 260 TEST_F(indexOfChar, indexOfChar_000) 261 { 262 rtl_ustr_indexOfChar( NULL, 0 ); 263 } 264 265 TEST_F(indexOfChar, indexOfChar_001) 266 { 267 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfChar."); 268 269 sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'L' ); 270 ASSERT_TRUE(nIndex == 0) << "index is wrong."; 271 272 /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'i' ); 273 ASSERT_TRUE(nIndex == 1) << "index is wrong."; 274 275 /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'n' ); 276 ASSERT_TRUE(nIndex == 2) << "index is wrong."; 277 278 /* sal_Int32 */ nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'e' ); 279 ASSERT_TRUE(nIndex == 3) << "index is wrong."; 280 } 281 282 TEST_F(indexOfChar, indexOfChar_002) 283 { 284 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfChar."); 285 sal_Int32 nIndex = rtl_ustr_indexOfChar( aStr1.getStr(), 'y' ); 286 287 ASSERT_TRUE(nIndex == -1) << "index is wrong."; 288 } 289 290 // // ----------------------------------------------------------------------------- 291 class lastIndexOfChar : public ::testing::Test 292 { 293 public: 294 }; // class lastIndexOfChar 295 296 TEST_F(lastIndexOfChar, lastIndexOfChar_000) 297 { 298 rtl_ustr_lastIndexOfChar( NULL, 0 ); 299 } 300 301 TEST_F(lastIndexOfChar, lastIndexOfChar_001) 302 { 303 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfChar."); 304 305 sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'C' ); 306 ASSERT_TRUE(nIndex == 22) << "index is wrong."; 307 308 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'h' ); 309 ASSERT_TRUE(nIndex == 23) << "index is wrong."; 310 311 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'a' ); 312 ASSERT_TRUE(nIndex == 24) << "index is wrong."; 313 314 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'r' ); 315 ASSERT_TRUE(nIndex == 25) << "index is wrong."; 316 } 317 318 TEST_F(lastIndexOfChar, lastIndexOfChar_002) 319 { 320 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfChar."); 321 sal_Int32 nIndex = rtl_ustr_lastIndexOfChar( aStr1.getStr(), 'y' ); 322 323 ASSERT_TRUE(nIndex == -1) << "index is wrong."; 324 } 325 326 // ----------------------------------------------------------------------------- 327 328 class indexOfStr : public ::testing::Test 329 { 330 public: 331 }; // class compare 332 333 TEST_F(indexOfStr, indexOfStr_000) 334 { 335 rtl_ustr_indexOfStr( NULL, 0 ); 336 } 337 338 TEST_F(indexOfStr, indexOfStr_000_1) 339 { 340 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); 341 rtl_ustr_indexOfStr( aStr1.getStr(), 0 ); 342 } 343 344 TEST_F(indexOfStr, indexOfStr_001) 345 { 346 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); 347 348 rtl::OUString suSearch = rtl::OUString::createFromAscii("Line"); 349 sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() ); 350 ASSERT_TRUE(nIndex == 0) << "index is wrong."; 351 352 /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("for"); 353 /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() ); 354 ASSERT_TRUE(nIndex == 5) << "index is wrong."; 355 356 /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("a"); 357 /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() ); 358 ASSERT_TRUE(nIndex == 9) << "index is wrong."; 359 360 /* rtl::OUString */ suSearch = rtl::OUString::createFromAscii("a index"); 361 /* sal_Int32 */ nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() ); 362 ASSERT_TRUE(nIndex ==9) << "index is wrong."; 363 } 364 365 TEST_F(indexOfStr, indexOfStr_002) 366 { 367 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a indexOfStr."); 368 rtl::OUString suSearch = rtl::OUString::createFromAscii("not exist"); 369 sal_Int32 nIndex = rtl_ustr_indexOfStr( aStr1.getStr(), suSearch.getStr() ); 370 371 ASSERT_TRUE(nIndex == -1) << "index is wrong."; 372 } 373 374 // ----------------------------------------------------------------------------- 375 376 377 class lastIndexOfStr : public ::testing::Test 378 { 379 public: 380 }; // class lastIndexOfStr 381 382 TEST_F(lastIndexOfStr, lastIndexOfStr_000) 383 { 384 rtl_ustr_lastIndexOfStr( NULL, NULL ); 385 } 386 387 TEST_F(lastIndexOfStr, lastIndexOfStr_000_1) 388 { 389 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); 390 rtl_ustr_lastIndexOfStr( aStr1.getStr(), NULL ); 391 } 392 393 TEST_F(lastIndexOfStr, lastIndexOfStr_001) 394 { 395 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); 396 rtl::OUString aSearchStr = rtl::OUString::createFromAscii("Index"); 397 398 sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 399 ASSERT_TRUE(nIndex == 15) << "index is wrong."; 400 401 /* rtl::OString */ aSearchStr = rtl::OUString::createFromAscii("Line"); 402 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 403 ASSERT_TRUE(nIndex == 0) << "index is wrong."; 404 405 /* rtl::OString */ aSearchStr = rtl::OUString::createFromAscii(""); 406 /* sal_Int32 */ nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 407 ASSERT_TRUE(nIndex == -1) << "index is wrong."; 408 } 409 410 TEST_F(lastIndexOfStr, lastIndexOfStr_002) 411 { 412 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); 413 rtl::OUString aSearchStr = rtl::OUString::createFromAscii("foo"); 414 sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 415 416 ASSERT_TRUE(nIndex == -1) << "index is wrong."; 417 } 418 419 TEST_F(lastIndexOfStr, lastIndexOfStr_003) 420 { 421 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line for a lastIndexOfStr."); 422 rtl::OUString aSearchStr = rtl::OUString::createFromAscii("O"); 423 sal_Int32 nIndex = rtl_ustr_lastIndexOfStr( aStr1.getStr(), aSearchStr.getStr() ); 424 425 ASSERT_TRUE(nIndex == 20) << "index is wrong."; 426 } 427 428 // ----------------------------------------------------------------------------- 429 430 class replaceChar : public ::testing::Test 431 { 432 public: 433 }; // class replaceChar 434 435 TEST_F(replaceChar, replaceChar_000) 436 { 437 rtl_ustr_replaceChar( NULL, 0, 0 ); 438 } 439 440 TEST_F(replaceChar, replaceChar_001) 441 { 442 rtl::OUString aStr1 = rtl::OUString::createFromAscii("replace char."); 443 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("ruplacu char."); 444 445 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 446 sal_Unicode* pStr = (sal_Unicode*) malloc( nLength + sizeof(sal_Unicode)); // length + 1 (null terminator) 447 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 448 memset(pStr, 0, nLength + sizeof(sal_Unicode)); 449 memcpy(pStr, aStr1.getStr(), nLength); 450 451 rtl_ustr_replaceChar( pStr, 'e', 'u' ); 452 rtl::OUString suStr(pStr, aStr1.getLength()); 453 454 ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "replace failed"; 455 free(pStr); 456 } 457 458 // ----------------------------------------------------------------------------- 459 460 class replaceChar_WithLength : public ::testing::Test 461 { 462 public: 463 }; // class replaceChar 464 465 TEST_F(replaceChar_WithLength, replaceChar_WithLength_000) 466 { 467 rtl_ustr_replaceChar_WithLength( NULL, 0, 0, 0 ); 468 } 469 470 TEST_F(replaceChar_WithLength, replaceChar_WithLength_000_1) 471 { 472 rtl_ustr_replaceChar_WithLength( NULL, 1, 0, 0 ); 473 } 474 TEST_F(replaceChar_WithLength, replaceChar_WithLength_001) 475 { 476 rtl::OUString aStr1 = rtl::OUString::createFromAscii("replace char."); 477 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("ruplace char."); 478 479 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 480 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); 481 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 482 memcpy(pStr, aStr1.getStr(), nLength); 483 484 rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' ); 485 rtl::OUString suStr(pStr, aStr1.getLength()); 486 487 ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "replace failed"; 488 free(pStr); 489 } 490 491 TEST_F(replaceChar_WithLength, replaceChar_WithLength_002) 492 { 493 rtl::OUString aStr1 = rtl::OUString::createFromAscii("eeeeeeeeeeeee"); 494 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("uuuuuueeeeeee"); 495 496 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 497 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); // no null terminator is need 498 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 499 memcpy(pStr, aStr1.getStr(), nLength); 500 501 rtl_ustr_replaceChar_WithLength( pStr, 6, 'e', 'u' ); 502 rtl::OUString suStr(pStr, aStr1.getLength()); 503 504 ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "replace failed"; 505 free(pStr); 506 } 507 508 // ----------------------------------------------------------------------------- 509 510 class toAsciiLowerCase : public ::testing::Test 511 { 512 public: 513 }; // class replaceChar 514 515 TEST_F(toAsciiLowerCase, toAsciiLowerCase_000) 516 { 517 rtl_ustr_toAsciiLowerCase( NULL ); 518 } 519 520 TEST_F(toAsciiLowerCase, toAsciiLowerCase_001) 521 { 522 rtl::OUString aStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII LOWER CASE."); 523 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("change this to ascii lower case."); 524 525 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 526 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode) ); // we need to add '\0' so one more 527 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 528 memset(pStr, 0, nLength + sizeof(sal_Unicode)); // empty the sal_Unicode array 529 memcpy(pStr, aStr1.getStr(), nLength); 530 531 rtl_ustr_toAsciiLowerCase( pStr ); 532 rtl::OUString suStr(pStr, aStr1.getLength()); 533 534 ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; 535 free(pStr); 536 } 537 538 class toAsciiLowerCase_WithLength : public ::testing::Test 539 { 540 }; // class replaceChar 541 542 TEST_F(toAsciiLowerCase, toAsciiLowerCase_WithLength_000) 543 { 544 rtl_ustr_toAsciiLowerCase_WithLength( NULL, 0 ); 545 } 546 547 TEST_F(toAsciiLowerCase, toAsciiLowerCase_WithLength_001) 548 { 549 rtl::OUString aStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII LOWER CASE."); 550 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("change thiS TO ASCII LOWER CASE."); 551 552 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 553 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); 554 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 555 memcpy(pStr, aStr1.getStr(), nLength); 556 557 rtl_ustr_toAsciiLowerCase_WithLength( pStr, 10 ); 558 559 rtl::OUString suStr(pStr, aStr1.getLength()); 560 sal_Bool bResult = aShouldStr1.equals(suStr); 561 562 printOUString(suStr); 563 printf("Result length: %d\n", suStr.getLength() ); 564 printf("Result: %d\n", bResult); 565 566 ASSERT_TRUE(bResult == sal_True) << "failed"; 567 free(pStr); 568 } 569 570 // ----------------------------------------------------------------------------- 571 572 class toAsciiUpperCase : public ::testing::Test 573 { 574 public: 575 }; // class replaceChar 576 577 TEST_F(toAsciiUpperCase, toAsciiUpperCase_000) 578 { 579 rtl_ustr_toAsciiUpperCase( NULL ); 580 } 581 582 TEST_F(toAsciiUpperCase, toAsciiUpperCase_001) 583 { 584 rtl::OUString aStr1 = rtl::OUString::createFromAscii("change this to ascii upper case."); 585 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII UPPER CASE."); 586 587 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 588 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator 589 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 590 memset(pStr, 0, nLength + sizeof(sal_Unicode)); 591 memcpy(pStr, aStr1.getStr(), nLength); 592 593 rtl_ustr_toAsciiUpperCase( pStr ); 594 rtl::OUString suStr(pStr, aStr1.getLength()); 595 596 ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; 597 free(pStr); 598 } 599 600 class toAsciiUpperCase_WithLength : public ::testing::Test 601 { 602 public: 603 }; // class replaceChar 604 605 TEST_F(toAsciiUpperCase_WithLength, toAsciiUpperCase_WithLength_000) 606 { 607 rtl_ustr_toAsciiUpperCase_WithLength( NULL, 0 ); 608 } 609 610 TEST_F(toAsciiUpperCase_WithLength, toAsciiUpperCase_WithLength_001) 611 { 612 rtl::OUString aStr1 = rtl::OUString::createFromAscii("change this to ascii lower case."); 613 rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIs to ascii lower case."); 614 615 sal_uInt32 nLength = aStr1.getLength() * sizeof(sal_Unicode); 616 sal_Unicode* pStr = (sal_Unicode*) malloc(nLength); 617 ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 618 619 memcpy(pStr, aStr1.getStr(), nLength); 620 rtl_ustr_toAsciiUpperCase_WithLength( pStr, 10 ); 621 rtl::OUString suStr(pStr, aStr1.getLength()); 622 623 // printf("Uppercase with length: '%s'\n", aStr1.getStr()); 624 ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; 625 free(pStr); 626 } 627 628 // ----------------------------------------------------------------------------- 629 630 class trim_WithLength : public ::testing::Test 631 { 632 public: 633 }; 634 635 TEST_F(trim_WithLength, trim_WithLength_000) 636 { 637 rtl_ustr_trim_WithLength(NULL, 0); 638 // should not GPF 639 } 640 641 TEST_F(trim_WithLength, trim_WithLength_000_1) 642 { 643 rtl::OUString suStr = rtl::OUString::createFromAscii(" trim this"); 644 645 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 646 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 647 memcpy(pStr, suStr.getStr(), nLength); 648 649 rtl_ustr_trim_WithLength( pStr, 0 ); 650 free(pStr); 651 } 652 653 TEST_F(trim_WithLength, trim_WithLength_001) 654 { 655 rtl::OUString suStr = rtl::OUString::createFromAscii(" trim this"); 656 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 657 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 658 memcpy(pStr, suStr.getStr(), nLength); 659 660 rtl_ustr_trim_WithLength( pStr, 2 ); 661 662 ASSERT_TRUE(rtl::OUString(pStr).getLength() == 0) << "string should be empty"; 663 free(pStr); 664 } 665 666 667 TEST_F(trim_WithLength, trim_WithLength_002) 668 { 669 rtl::OUString suStr = rtl::OUString::createFromAscii("trim this"); 670 671 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 672 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 673 memcpy(pStr, suStr.getStr(), nLength); 674 675 rtl_ustr_trim_WithLength( pStr, 5 ); 676 677 ASSERT_TRUE(rtl::OUString(pStr).getLength() == 4) << "string should contain 'trim'"; 678 free(pStr); 679 } 680 681 682 TEST_F(trim_WithLength, trim_WithLength_003) 683 { 684 rtl::OUString suStr = rtl::OUString::createFromAscii(" trim this"); 685 686 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 687 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 688 memcpy(pStr, suStr.getStr(), nLength); 689 690 rtl_ustr_trim_WithLength( pStr, 11 ); 691 692 ASSERT_TRUE(rtl::OUString(pStr).getLength() == 4) << "string should contain 'trim'"; 693 free(pStr); 694 } 695 696 TEST_F(trim_WithLength, trim_WithLength_004) 697 { 698 rtl::OUString suStr = rtl::OUString::createFromAscii("\r\n\t \n\r trim \n this"); 699 700 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 701 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 702 memcpy(pStr, suStr.getStr(), nLength); 703 704 rtl_ustr_trim_WithLength( pStr, 17 ); 705 706 ASSERT_TRUE(rtl::OUString(pStr).getLength() == 4) << "string should contain 'trim'"; 707 free(pStr); 708 } 709 710 TEST_F(trim_WithLength, trim_WithLength_005) 711 { 712 rtl::OUString suStr = rtl::OUString::createFromAscii("\r\n\t \n\r trim \t this \n\r\t\t "); 713 714 sal_uInt32 nLength = suStr.getLength() * sizeof(sal_Unicode); 715 sal_Unicode *pStr = (sal_Unicode*)malloc(nLength); 716 memcpy(pStr, suStr.getStr(), nLength); 717 718 rtl_ustr_trim_WithLength( pStr, suStr.getLength() ); 719 720 ASSERT_TRUE(rtl::OUString(pStr).getLength() == 11) << "string should contain 'trim \\t this'"; 721 free(pStr); 722 } 723 724 // ----------------------------------------------------------------------------- 725 726 class valueOfChar : public ::testing::Test 727 { 728 public: 729 }; 730 731 TEST_F(valueOfChar, valueOfChar_000) 732 { 733 rtl_ustr_valueOfChar(NULL, 0); 734 // should not GPF 735 } 736 TEST_F(valueOfChar, valueOfChar_001) 737 { 738 sal_Unicode *pStr = (sal_Unicode*)malloc(RTL_USTR_MAX_VALUEOFCHAR); 739 if (pStr) 740 { 741 rtl_ustr_valueOfChar(pStr, 'A'); 742 743 ASSERT_TRUE(pStr[0] == L'A') << "string should contain 'A'"; 744 free(pStr); 745 } 746 } 747 748 749 class ascii_compare_WithLength : public ::testing::Test 750 { 751 public: 752 }; 753 754 TEST_F(ascii_compare_WithLength, zero_length) 755 { 756 sal_Unicode pUnicode[] = {0xffff, 0xffff}; 757 char const * pAscii = "reference"; 758 759 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(pUnicode, 0, pAscii); 760 ASSERT_TRUE(value < 0) << "ref string is empty, compare failed, needs to be <0."; 761 } 762 763 TEST_F(ascii_compare_WithLength, equal_ascii_shorter) 764 { 765 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("referenceString")); 766 char const * pAscii = "reference"; 767 768 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 769 ASSERT_TRUE(value > 0) << "ref string is bigger, compare failed, needs to be >0."; 770 } 771 772 TEST_F(ascii_compare_WithLength, equal_ascii_shorter_asciiLength) 773 { 774 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("referenceString")); 775 char const * pAscii = "reference"; 776 777 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, rtl_str_getLength(pAscii), pAscii); 778 ASSERT_TRUE(value == 0) << "ref string is bigger despite ascii length, compare failed, needs to be == 0."; 779 } 780 781 TEST_F(ascii_compare_WithLength, equal_ref_shorter) 782 { 783 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("reference")); 784 char const * pAscii = "referenceString"; 785 786 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 787 ASSERT_TRUE(value < 0) << "ascii string is bigger, but only compared to ref length, needs to be 0."; 788 } 789 790 TEST_F(ascii_compare_WithLength, equal) 791 { 792 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("reference")); 793 char const * pAscii = "reference"; 794 795 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 796 ASSERT_TRUE(value == 0) << "strings are equal, compare failed, needs to be 0."; 797 } 798 799 TEST_F(ascii_compare_WithLength, unequal_reference_bigger) 800 { 801 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("defghi")); 802 char const * pAscii = "abc"; 803 804 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 805 ASSERT_TRUE(value > 0) << "strings are unequal and ref is bigger, needs to be >0."; 806 } 807 808 TEST_F(ascii_compare_WithLength, unequal_ascii_bigger) 809 { 810 rtl::OUString refStr(RTL_CONSTASCII_USTRINGPARAM("abc")); 811 char const * pAscii = "defghi"; 812 813 sal_Int32 value = rtl_ustr_ascii_compare_WithLength(refStr.pData->buffer, refStr.pData->length, pAscii); 814 815 ASSERT_TRUE(value < 0) << "strings are unequal and ascii is bigger, needs to be <0."; 816 } 817 818 819 class ascii_shortenedCompareIgnoreAsciiCase_WithLength : public ::testing::Test 820 { 821 public: 822 }; // class ascii_shortenedCompareIgnoreAsciiCase_WithLength 823 824 TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_000) 825 { 826 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( NULL, 0, NULL, 0); 827 // should not GPF 828 } 829 830 TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_1) 831 { 832 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 833 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), aStr1.getLength(), NULL, 0); 834 // should not GPF 835 } 836 TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_000_2) 837 { 838 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 839 rtl::OString sStr2 = "Line is shorter."; 840 rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( aStr1.getStr(), sStr2.getLength(), sStr2.getStr(), 0); 841 // should not GPF 842 } 843 TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_001) 844 { 845 rtl::OUString suStr1; 846 rtl::OString sStr2; 847 848 sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), 0, sStr2.getStr(), 0); 849 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 850 } 851 852 TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_002) 853 { 854 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 855 rtl::OString sStr2 = "Line must be equal."; 856 857 sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr(), sStr2.getLength()); 858 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 859 } 860 861 TEST_F(ascii_shortenedCompareIgnoreAsciiCase_WithLength, ascii_shortenedCompareIgnoreAsciiCase_WithLength_003) 862 { 863 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 864 rtl::OString sStr2 = "Line must be differ and longer."; 865 866 sal_Int32 nValue = rtl_ustr_ascii_shortenedCompareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr(), sStr2.getLength()); 867 ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; 868 } 869 870 // ----------------------------------------------------------------------------- 871 872 class ascii_compareIgnoreAsciiCase_WithLength : public ::testing::Test 873 { 874 public: 875 }; // class ascii_compareIgnoreAsciiCase_WithLength 876 877 TEST_F(ascii_compareIgnoreAsciiCase_WithLength, ascii_compareIgnoreAsciiCase_WithLength_000) 878 { 879 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( NULL, 0, NULL); 880 // should not GPF 881 } 882 883 TEST_F(ascii_compareIgnoreAsciiCase_WithLength, ascii_compareIgnoreAsciiCase_WithLength_000_1) 884 { 885 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 886 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aStr1.getStr(), 0, NULL); 887 // should not GPF 888 } 889 TEST_F(ascii_compareIgnoreAsciiCase_WithLength, ascii_compareIgnoreAsciiCase_WithLength_000_2) 890 { 891 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 892 rtl::OString sStr2 = "Line is shorter."; 893 rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( aStr1.getStr(), sStr2.getLength(), sStr2.getStr()); 894 // should not GPF 895 } 896 TEST_F(ascii_compareIgnoreAsciiCase_WithLength, ascii_compareIgnoreAsciiCase_WithLength_001) 897 { 898 rtl::OUString suStr1; 899 rtl::OString sStr2; 900 901 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), 0, sStr2.getStr()); 902 ASSERT_TRUE(nValue == 0) << "compareIgnoreAsciiCase_WithLength failed, strings are equal."; 903 } 904 905 TEST_F(ascii_compareIgnoreAsciiCase_WithLength, ascii_compareIgnoreAsciiCase_WithLength_002) 906 { 907 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 908 rtl::OString sStr2 = "Line must be equal."; 909 910 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr()); 911 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 912 } 913 914 TEST_F(ascii_compareIgnoreAsciiCase_WithLength, ascii_compareIgnoreAsciiCase_WithLength_003) 915 { 916 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 917 rtl::OString sStr2 = "Line must be differ and longer."; 918 919 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase_WithLength( suStr1.getStr(), suStr1.getLength(), sStr2.getStr()); 920 ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; 921 } 922 // ----------------------------------------------------------------------------- 923 924 class ascii_compare : public ::testing::Test 925 { 926 public: 927 }; // class ascii_compare 928 929 TEST_F(ascii_compare, ascii_compare_000) 930 { 931 rtl_ustr_ascii_compare( NULL, NULL); 932 // should not GPF 933 } 934 935 TEST_F(ascii_compare, ascii_compare_000_1) 936 { 937 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 938 rtl_ustr_ascii_compare( aStr1.getStr(), NULL); 939 // should not GPF 940 } 941 TEST_F(ascii_compare, ascii_compare_001) 942 { 943 rtl::OUString suStr1; 944 rtl::OString sStr2; 945 946 sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.getStr()); 947 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 948 } 949 950 TEST_F(ascii_compare, ascii_compare_002) 951 { 952 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 953 rtl::OString sStr2 = "Line must be equal."; 954 955 sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.getStr()); 956 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 957 } 958 959 TEST_F(ascii_compare, ascii_compare_003) 960 { 961 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 962 rtl::OString sStr2 = "Line foo bar, ok, differ."; 963 964 sal_Int32 nValue = rtl_ustr_ascii_compare( suStr1.getStr(), sStr2.getStr()); 965 ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; 966 } 967 968 // ----------------------------------------------------------------------------- 969 970 class ascii_compareIgnoreAsciiCase : public ::testing::Test 971 { 972 public: 973 }; // class ascii_compareIgnoreAsciiCase 974 975 TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_000) 976 { 977 rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL); 978 // should not GPF 979 } 980 981 TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_000_1) 982 { 983 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 984 rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL); 985 // should not GPF 986 } 987 TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_001) 988 { 989 rtl::OUString suStr1; 990 rtl::OString sStr2; 991 992 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 993 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 994 } 995 996 TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_002) 997 { 998 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 999 rtl::OString sStr2 = "Line must be equal."; 1000 1001 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1002 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 1003 } 1004 1005 TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_002_1) 1006 { 1007 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal, when ignore case."); 1008 rtl::OString sStr2 = "LINE MUST BE EQUAL, WHEN IGNORE CASE."; 1009 1010 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1011 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal (if case insensitve)."; 1012 } 1013 1014 TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_003) 1015 { 1016 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 1017 rtl::OString sStr2 = "Line foo bar, ok, differ."; 1018 1019 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1020 ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; 1021 } 1022 1023 //! LLA: some more tests with some high level strings 1024 1025 // TEST_F(ascii_compareIgnoreAsciiCase, ascii_compareIgnoreAsciiCase_001() 1026 // { 1027 // rtl::OUString suStr1 = rtl::OUString::createFromAscii("change this to ascii upper case."); 1028 // rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII UPPER CASE."); 1029 // 1030 // sal_uInt32 nLength = suStr1.getLength() * sizeof(sal_Unicode); 1031 // sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator 1032 // ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 1033 // memset(pStr, 0, nLength + sizeof(sal_Unicode)); 1034 // memcpy(pStr, suStr1.getStr(), nLength); 1035 // 1036 // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr ); 1037 // rtl::OUString suStr(pStr, suStr1.getLength()); 1038 // 1039 // ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; 1040 // free(pStr); 1041 // } 1042 1043 // sample out of inc/rtl/ustring.hxx 1044 // rtl_uString * pToken = NULL; 1045 // sal_Int32 nIndex = 0; 1046 // do 1047 // { 1048 // ... 1049 // nIndex = rtl_uString_getToken(&pToken, pStr, 0, ';', nIndex); 1050 // ... 1051 // } 1052 // while (nIndex >= 0); 1053 1054 class getToken : public ::testing::Test 1055 { 1056 public: 1057 }; // class ascii_compareIgnoreAsciiCase 1058 1059 TEST_F(getToken, getToken_000) 1060 { 1061 rtl_ustr_ascii_compareIgnoreAsciiCase( NULL, NULL); 1062 // should not GPF 1063 } 1064 1065 TEST_F(getToken, ascii_compareIgnoreAsciiCase_000_1) 1066 { 1067 rtl::OUString aStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1068 rtl_ustr_ascii_compareIgnoreAsciiCase( aStr1.getStr(), NULL); 1069 // should not GPF 1070 } 1071 TEST_F(getToken, ascii_compareIgnoreAsciiCase_001) 1072 { 1073 rtl::OUString suStr1; 1074 rtl::OString sStr2; 1075 1076 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1077 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 1078 } 1079 1080 TEST_F(getToken, ascii_compareIgnoreAsciiCase_002) 1081 { 1082 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal."); 1083 rtl::OString sStr2 = "Line must be equal."; 1084 1085 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1086 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal."; 1087 } 1088 1089 TEST_F(getToken, ascii_compareIgnoreAsciiCase_002_1) 1090 { 1091 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must be equal, when ignore case."); 1092 rtl::OString sStr2 = "LINE MUST BE EQUAL, WHEN IGNORE CASE."; 1093 1094 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1095 ASSERT_TRUE(nValue == 0) << "compare failed, strings are equal (if case insensitve)."; 1096 } 1097 1098 TEST_F(getToken, ascii_compareIgnoreAsciiCase_003) 1099 { 1100 rtl::OUString suStr1 = rtl::OUString::createFromAscii("Line must differ."); 1101 rtl::OString sStr2 = "Line foo bar, ok, differ."; 1102 1103 sal_Int32 nValue = rtl_ustr_ascii_compareIgnoreAsciiCase( suStr1.getStr(), sStr2.getStr()); 1104 ASSERT_TRUE(nValue != 0) << "compare failed, strings differ."; 1105 } 1106 1107 //! LLA: some more tests with some high level strings 1108 1109 // TEST_F(getToken, ascii_compareIgnoreAsciiCase_001) 1110 // { 1111 // rtl::OUString suStr1 = rtl::OUString::createFromAscii("change this to ascii upper case."); 1112 // rtl::OUString aShouldStr1 = rtl::OUString::createFromAscii("CHANGE THIS TO ASCII UPPER CASE."); 1113 // 1114 // sal_uInt32 nLength = suStr1.getLength() * sizeof(sal_Unicode); 1115 // sal_Unicode* pStr = (sal_Unicode*) malloc(nLength + sizeof(sal_Unicode)); // length + null terminator 1116 // ASSERT_TRUE(pStr != NULL) << "can't get memory for test"; 1117 // memset(pStr, 0, nLength + sizeof(sal_Unicode)); 1118 // memcpy(pStr, suStr1.getStr(), nLength); 1119 // 1120 // rtl_ustr_ascii_compareIgnoreAsciiCase( pStr ); 1121 // rtl::OUString suStr(pStr, suStr1.getLength()); 1122 // 1123 // ASSERT_TRUE(aShouldStr1.equals(suStr) == sal_True) << "failed"; 1124 // free(pStr); 1125 // } 1126 1127 } // namespace rtl_ustr 1128 1129 1130 int main(int argc, char **argv) 1131 { 1132 ::testing::InitGoogleTest(&argc, argv); 1133 return RUN_ALL_TESTS(); 1134 } 1135