1 /******************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 2005-2011, International Business Machines Corporation and 4 * others. All Rights Reserved. 5 ********************************************************************/ 6 /************************************************************************ 7 * Tests for the UText and UTextIterator text abstraction classses 8 * 9 ************************************************************************/ 10 11 #include <string.h> 12 #include <stdio.h> 13 #include <stdlib.h> 14 #include "unicode/utypes.h" 15 #include "unicode/utext.h" 16 #include "unicode/utf8.h" 17 #include "unicode/ustring.h" 18 #include "unicode/uchriter.h" 19 #include "utxttest.h" 20 21 static UBool gFailed = FALSE; 22 static int gTestNum = 0; 23 24 // Forward decl 25 UText *openFragmentedUnicodeString(UText *ut, UnicodeString *s, UErrorCode *status); 26 27 #define TEST_ASSERT(x) \ 28 { if ((x)==FALSE) {errln("Test #%d failure in file %s at line %d\n", gTestNum, __FILE__, __LINE__);\ 29 gFailed = TRUE;\ 30 }} 31 32 33 #define TEST_SUCCESS(status) \ 34 { if (U_FAILURE(status)) {errln("Test #%d failure in file %s at line %d. Error = \"%s\"\n", \ 35 gTestNum, __FILE__, __LINE__, u_errorName(status)); \ 36 gFailed = TRUE;\ 37 }} 38 39 UTextTest::UTextTest() { 40 } 41 42 UTextTest::~UTextTest() { 43 } 44 45 46 void 47 UTextTest::runIndexedTest(int32_t index, UBool exec, 48 const char* &name, char* /*par*/) { 49 switch (index) { 50 case 0: name = "TextTest"; 51 if (exec) TextTest(); break; 52 case 1: name = "ErrorTest"; 53 if (exec) ErrorTest(); break; 54 case 2: name = "FreezeTest"; 55 if (exec) FreezeTest(); break; 56 case 3: name = "Ticket5560"; 57 if (exec) Ticket5560(); break; 58 case 4: name = "Ticket6847"; 59 if (exec) Ticket6847(); break; 60 case 5: name = "ComparisonTest"; 61 if (exec) ComparisonTest(); break; 62 default: name = ""; break; 63 } 64 } 65 66 // 67 // Quick and dirty random number generator. 68 // (don't use library so that results are portable. 69 static uint32_t m_seed = 1; 70 static uint32_t m_rand() 71 { 72 m_seed = m_seed * 1103515245 + 12345; 73 return (uint32_t)(m_seed/65536) % 32768; 74 } 75 76 77 // 78 // TextTest() 79 // 80 // Top Level function for UText testing. 81 // Specifies the strings to be tested, with the acutal testing itself 82 // being carried out in another function, TestString(). 83 // 84 void UTextTest::TextTest() { 85 int32_t i, j; 86 87 TestString("abcd\\U00010001xyz"); 88 TestString(""); 89 90 // Supplementary chars at start or end 91 TestString("\\U00010001"); 92 TestString("abc\\U00010001"); 93 TestString("\\U00010001abc"); 94 95 // Test simple strings of lengths 1 to 60, looking for glitches at buffer boundaries 96 UnicodeString s; 97 for (i=1; i<60; i++) { 98 s.truncate(0); 99 for (j=0; j<i; j++) { 100 if (j+0x30 == 0x5c) { 101 // backslash. Needs to be escaped 102 s.append((UChar)0x5c); 103 } 104 s.append(UChar(j+0x30)); 105 } 106 TestString(s); 107 } 108 109 // Test strings with odd-aligned supplementary chars, 110 // looking for glitches at buffer boundaries 111 for (i=1; i<60; i++) { 112 s.truncate(0); 113 s.append((UChar)0x41); 114 for (j=0; j<i; j++) { 115 s.append(UChar32(j+0x11000)); 116 } 117 TestString(s); 118 } 119 120 // String of chars of randomly varying size in utf-8 representation. 121 // Exercise the mapping, and the varying sized buffer. 122 // 123 s.truncate(0); 124 UChar32 c1 = 0; 125 UChar32 c2 = 0x100; 126 UChar32 c3 = 0xa000; 127 UChar32 c4 = 0x11000; 128 for (i=0; i<1000; i++) { 129 int len8 = m_rand()%4 + 1; 130 switch (len8) { 131 case 1: 132 c1 = (c1+1)%0x80; 133 // don't put 0 into string (0 terminated strings for some tests) 134 // don't put '\', will cause unescape() to fail. 135 if (c1==0x5c || c1==0) { 136 c1++; 137 } 138 s.append(c1); 139 break; 140 case 2: 141 s.append(c2++); 142 break; 143 case 3: 144 s.append(c3++); 145 break; 146 case 4: 147 s.append(c4++); 148 break; 149 } 150 } 151 TestString(s); 152 } 153 154 155 // 156 // TestString() Run a suite of UText tests on a string. 157 // The test string is unescaped before use. 158 // 159 void UTextTest::TestString(const UnicodeString &s) { 160 int32_t i; 161 int32_t j; 162 UChar32 c; 163 int32_t cpCount = 0; 164 UErrorCode status = U_ZERO_ERROR; 165 UText *ut = NULL; 166 int32_t saLen; 167 168 UnicodeString sa = s.unescape(); 169 saLen = sa.length(); 170 171 // 172 // Build up a mapping between code points and UTF-16 code unit indexes. 173 // 174 m *cpMap = new m[sa.length() + 1]; 175 j = 0; 176 for (i=0; i<sa.length(); i=sa.moveIndex32(i, 1)) { 177 c = sa.char32At(i); 178 cpMap[j].nativeIdx = i; 179 cpMap[j].cp = c; 180 j++; 181 cpCount++; 182 } 183 cpMap[j].nativeIdx = i; // position following the last char in utf-16 string. 184 185 186 // UChar * test, null terminated 187 status = U_ZERO_ERROR; 188 UChar *buf = new UChar[saLen+1]; 189 sa.extract(buf, saLen+1, status); 190 TEST_SUCCESS(status); 191 ut = utext_openUChars(NULL, buf, -1, &status); 192 TEST_SUCCESS(status); 193 TestAccess(sa, ut, cpCount, cpMap); 194 utext_close(ut); 195 delete [] buf; 196 197 // UChar * test, with length 198 status = U_ZERO_ERROR; 199 buf = new UChar[saLen+1]; 200 sa.extract(buf, saLen+1, status); 201 TEST_SUCCESS(status); 202 ut = utext_openUChars(NULL, buf, saLen, &status); 203 TEST_SUCCESS(status); 204 TestAccess(sa, ut, cpCount, cpMap); 205 utext_close(ut); 206 delete [] buf; 207 208 209 // UnicodeString test 210 status = U_ZERO_ERROR; 211 ut = utext_openUnicodeString(NULL, &sa, &status); 212 TEST_SUCCESS(status); 213 TestAccess(sa, ut, cpCount, cpMap); 214 TestCMR(sa, ut, cpCount, cpMap, cpMap); 215 utext_close(ut); 216 217 218 // Const UnicodeString test 219 status = U_ZERO_ERROR; 220 ut = utext_openConstUnicodeString(NULL, &sa, &status); 221 TEST_SUCCESS(status); 222 TestAccess(sa, ut, cpCount, cpMap); 223 utext_close(ut); 224 225 226 // Replaceable test. (UnicodeString inherits Replaceable) 227 status = U_ZERO_ERROR; 228 ut = utext_openReplaceable(NULL, &sa, &status); 229 TEST_SUCCESS(status); 230 TestAccess(sa, ut, cpCount, cpMap); 231 TestCMR(sa, ut, cpCount, cpMap, cpMap); 232 utext_close(ut); 233 234 // Character Iterator Tests 235 status = U_ZERO_ERROR; 236 const UChar *cbuf = sa.getBuffer(); 237 CharacterIterator *ci = new UCharCharacterIterator(cbuf, saLen, status); 238 TEST_SUCCESS(status); 239 ut = utext_openCharacterIterator(NULL, ci, &status); 240 TEST_SUCCESS(status); 241 TestAccess(sa, ut, cpCount, cpMap); 242 utext_close(ut); 243 delete ci; 244 245 246 // Fragmented UnicodeString (Chunk size of one) 247 // 248 status = U_ZERO_ERROR; 249 ut = openFragmentedUnicodeString(NULL, &sa, &status); 250 TEST_SUCCESS(status); 251 TestAccess(sa, ut, cpCount, cpMap); 252 utext_close(ut); 253 254 // 255 // UTF-8 test 256 // 257 258 // Convert the test string from UnicodeString to (char *) in utf-8 format 259 int32_t u8Len = sa.extract(0, sa.length(), NULL, 0, "utf-8"); 260 char *u8String = new char[u8Len + 1]; 261 sa.extract(0, sa.length(), u8String, u8Len+1, "utf-8"); 262 263 // Build up the map of code point indices in the utf-8 string 264 m * u8Map = new m[sa.length() + 1]; 265 i = 0; // native utf-8 index 266 for (j=0; j<cpCount ; j++) { // code point number 267 u8Map[j].nativeIdx = i; 268 U8_NEXT(u8String, i, u8Len, c) 269 u8Map[j].cp = c; 270 } 271 u8Map[cpCount].nativeIdx = u8Len; // position following the last char in utf-8 string. 272 273 // Do the test itself 274 status = U_ZERO_ERROR; 275 ut = utext_openUTF8(NULL, u8String, -1, &status); 276 TEST_SUCCESS(status); 277 TestAccess(sa, ut, cpCount, u8Map); 278 utext_close(ut); 279 280 281 282 delete []cpMap; 283 delete []u8Map; 284 delete []u8String; 285 } 286 287 // TestCMR test Copy, Move and Replace operations. 288 // us UnicodeString containing the test text. 289 // ut UText containing the same test text. 290 // cpCount number of code points in the test text. 291 // nativeMap Mapping from code points to native indexes for the UText. 292 // u16Map Mapping from code points to UTF-16 indexes, for use with the UnicodeString. 293 // 294 // This function runs a whole series of opertions on each incoming UText. 295 // The UText is deep-cloned prior to each operation, so that the original UText remains unchanged. 296 // 297 void UTextTest::TestCMR(const UnicodeString &us, UText *ut, int cpCount, m *nativeMap, m *u16Map) { 298 TEST_ASSERT(utext_isWritable(ut) == TRUE); 299 300 int srcLengthType; // Loop variables for selecting the postion and length 301 int srcPosType; // of the block to operate on within the source text. 302 int destPosType; 303 304 int srcIndex = 0; // Code Point indexes of the block to operate on for 305 int srcLength = 0; // a specific test. 306 307 int destIndex = 0; // Code point index of the destination for a copy/move test. 308 309 int32_t nativeStart = 0; // Native unit indexes for a test. 310 int32_t nativeLimit = 0; 311 int32_t nativeDest = 0; 312 313 int32_t u16Start = 0; // UTF-16 indexes for a test. 314 int32_t u16Limit = 0; // used when performing the same operation in a Unicode String 315 int32_t u16Dest = 0; 316 317 // Iterate over a whole series of source index, length and a target indexes. 318 // This is done with code point indexes; these will be later translated to native 319 // indexes using the cpMap. 320 for (srcLengthType=1; srcLengthType<=3; srcLengthType++) { 321 switch (srcLengthType) { 322 case 1: srcLength = 1; break; 323 case 2: srcLength = 5; break; 324 case 3: srcLength = cpCount / 3; 325 } 326 for (srcPosType=1; srcPosType<=5; srcPosType++) { 327 switch (srcPosType) { 328 case 1: srcIndex = 0; break; 329 case 2: srcIndex = 1; break; 330 case 3: srcIndex = cpCount - srcLength; break; 331 case 4: srcIndex = cpCount - srcLength - 1; break; 332 case 5: srcIndex = cpCount / 2; break; 333 } 334 if (srcIndex < 0 || srcIndex + srcLength > cpCount) { 335 // filter out bogus test cases - 336 // those with a source range that falls of an edge of the string. 337 continue; 338 } 339 340 // 341 // Copy and move tests. 342 // iterate over a variety of destination positions. 343 // 344 for (destPosType=1; destPosType<=4; destPosType++) { 345 switch (destPosType) { 346 case 1: destIndex = 0; break; 347 case 2: destIndex = 1; break; 348 case 3: destIndex = srcIndex - 1; break; 349 case 4: destIndex = srcIndex + srcLength + 1; break; 350 case 5: destIndex = cpCount-1; break; 351 case 6: destIndex = cpCount; break; 352 } 353 if (destIndex<0 || destIndex>cpCount) { 354 // filter out bogus test cases. 355 continue; 356 } 357 358 nativeStart = nativeMap[srcIndex].nativeIdx; 359 nativeLimit = nativeMap[srcIndex+srcLength].nativeIdx; 360 nativeDest = nativeMap[destIndex].nativeIdx; 361 362 u16Start = u16Map[srcIndex].nativeIdx; 363 u16Limit = u16Map[srcIndex+srcLength].nativeIdx; 364 u16Dest = u16Map[destIndex].nativeIdx; 365 366 gFailed = FALSE; 367 TestCopyMove(us, ut, FALSE, 368 nativeStart, nativeLimit, nativeDest, 369 u16Start, u16Limit, u16Dest); 370 371 TestCopyMove(us, ut, TRUE, 372 nativeStart, nativeLimit, nativeDest, 373 u16Start, u16Limit, u16Dest); 374 375 if (gFailed) { 376 return; 377 } 378 } 379 380 // 381 // Replace tests. 382 // 383 UnicodeString fullRepString("This is an arbitrary string that will be used as replacement text"); 384 for (int32_t replStrLen=0; replStrLen<20; replStrLen++) { 385 UnicodeString repStr(fullRepString, 0, replStrLen); 386 TestReplace(us, ut, 387 nativeStart, nativeLimit, 388 u16Start, u16Limit, 389 repStr); 390 if (gFailed) { 391 return; 392 } 393 } 394 395 } 396 } 397 398 } 399 400 // 401 // TestCopyMove run a single test case for utext_copy. 402 // Test cases are created in TestCMR and dispatched here for execution. 403 // 404 void UTextTest::TestCopyMove(const UnicodeString &us, UText *ut, UBool move, 405 int32_t nativeStart, int32_t nativeLimit, int32_t nativeDest, 406 int32_t u16Start, int32_t u16Limit, int32_t u16Dest) 407 { 408 UErrorCode status = U_ZERO_ERROR; 409 UText *targetUT = NULL; 410 gTestNum++; 411 gFailed = FALSE; 412 413 // 414 // clone the UText. The test will be run in the cloned copy 415 // so that we don't alter the original. 416 // 417 targetUT = utext_clone(NULL, ut, TRUE, FALSE, &status); 418 TEST_SUCCESS(status); 419 UnicodeString targetUS(us); // And copy the reference string. 420 421 // do the test operation first in the reference 422 targetUS.copy(u16Start, u16Limit, u16Dest); 423 if (move) { 424 // delete out the source range. 425 if (u16Limit < u16Dest) { 426 targetUS.removeBetween(u16Start, u16Limit); 427 } else { 428 int32_t amtCopied = u16Limit - u16Start; 429 targetUS.removeBetween(u16Start+amtCopied, u16Limit+amtCopied); 430 } 431 } 432 433 // Do the same operation in the UText under test 434 utext_copy(targetUT, nativeStart, nativeLimit, nativeDest, move, &status); 435 if (nativeDest > nativeStart && nativeDest < nativeLimit) { 436 TEST_ASSERT(status == U_INDEX_OUTOFBOUNDS_ERROR); 437 } else { 438 TEST_SUCCESS(status); 439 440 // Compare the results of the two parallel tests 441 int32_t usi = 0; // UnicodeString postion, utf-16 index. 442 int64_t uti = 0; // UText position, native index. 443 int32_t cpi; // char32 position (code point index) 444 UChar32 usc; // code point from Unicode String 445 UChar32 utc; // code point from UText 446 utext_setNativeIndex(targetUT, 0); 447 for (cpi=0; ; cpi++) { 448 usc = targetUS.char32At(usi); 449 utc = utext_next32(targetUT); 450 if (utc < 0) { 451 break; 452 } 453 TEST_ASSERT(uti == usi); 454 TEST_ASSERT(utc == usc); 455 usi = targetUS.moveIndex32(usi, 1); 456 uti = utext_getNativeIndex(targetUT); 457 if (gFailed) { 458 goto cleanupAndReturn; 459 } 460 } 461 int64_t expectedNativeLength = utext_nativeLength(ut); 462 if (move == FALSE) { 463 expectedNativeLength += nativeLimit - nativeStart; 464 } 465 uti = utext_getNativeIndex(targetUT); 466 TEST_ASSERT(uti == expectedNativeLength); 467 } 468 469 cleanupAndReturn: 470 utext_close(targetUT); 471 } 472 473 474 // 475 // TestReplace Test a single Replace operation. 476 // 477 void UTextTest::TestReplace( 478 const UnicodeString &us, // reference UnicodeString in which to do the replace 479 UText *ut, // UnicodeText object under test. 480 int32_t nativeStart, // Range to be replaced, in UText native units. 481 int32_t nativeLimit, 482 int32_t u16Start, // Range to be replaced, in UTF-16 units 483 int32_t u16Limit, // for use in the reference UnicodeString. 484 const UnicodeString &repStr) // The replacement string 485 { 486 UErrorCode status = U_ZERO_ERROR; 487 UText *targetUT = NULL; 488 gTestNum++; 489 gFailed = FALSE; 490 491 // 492 // clone the target UText. The test will be run in the cloned copy 493 // so that we don't alter the original. 494 // 495 targetUT = utext_clone(NULL, ut, TRUE, FALSE, &status); 496 TEST_SUCCESS(status); 497 UnicodeString targetUS(us); // And copy the reference string. 498 499 // 500 // Do the replace operation in the Unicode String, to 501 // produce a reference result. 502 // 503 targetUS.replace(u16Start, u16Limit-u16Start, repStr); 504 505 // 506 // Do the replace on the UText under test 507 // 508 const UChar *rs = repStr.getBuffer(); 509 int32_t rsLen = repStr.length(); 510 int32_t actualDelta = utext_replace(targetUT, nativeStart, nativeLimit, rs, rsLen, &status); 511 int32_t expectedDelta = repStr.length() - (nativeLimit - nativeStart); 512 TEST_ASSERT(actualDelta == expectedDelta); 513 514 // 515 // Compare the results 516 // 517 int32_t usi = 0; // UnicodeString postion, utf-16 index. 518 int64_t uti = 0; // UText position, native index. 519 int32_t cpi; // char32 position (code point index) 520 UChar32 usc; // code point from Unicode String 521 UChar32 utc; // code point from UText 522 int64_t expectedNativeLength = 0; 523 utext_setNativeIndex(targetUT, 0); 524 for (cpi=0; ; cpi++) { 525 usc = targetUS.char32At(usi); 526 utc = utext_next32(targetUT); 527 if (utc < 0) { 528 break; 529 } 530 TEST_ASSERT(uti == usi); 531 TEST_ASSERT(utc == usc); 532 usi = targetUS.moveIndex32(usi, 1); 533 uti = utext_getNativeIndex(targetUT); 534 if (gFailed) { 535 goto cleanupAndReturn; 536 } 537 } 538 expectedNativeLength = utext_nativeLength(ut) + expectedDelta; 539 uti = utext_getNativeIndex(targetUT); 540 TEST_ASSERT(uti == expectedNativeLength); 541 542 cleanupAndReturn: 543 utext_close(targetUT); 544 } 545 546 // 547 // TestAccess Test the read only access functions on a UText, including cloning. 548 // The text is accessed in a variety of ways, and compared with 549 // the reference UnicodeString. 550 // 551 void UTextTest::TestAccess(const UnicodeString &us, UText *ut, int cpCount, m *cpMap) { 552 // Run the standard tests on the caller-supplied UText. 553 TestAccessNoClone(us, ut, cpCount, cpMap); 554 555 // Re-run tests on a shallow clone. 556 utext_setNativeIndex(ut, 0); 557 UErrorCode status = U_ZERO_ERROR; 558 UText *shallowClone = utext_clone(NULL, ut, FALSE /*deep*/, FALSE /*readOnly*/, &status); 559 TEST_SUCCESS(status); 560 TestAccessNoClone(us, shallowClone, cpCount, cpMap); 561 562 // 563 // Rerun again on a deep clone. 564 // Note that text providers are not required to provide deep cloning, 565 // so unsupported errors are ignored. 566 // 567 status = U_ZERO_ERROR; 568 utext_setNativeIndex(shallowClone, 0); 569 UText *deepClone = utext_clone(NULL, shallowClone, TRUE, FALSE, &status); 570 utext_close(shallowClone); 571 if (status != U_UNSUPPORTED_ERROR) { 572 TEST_SUCCESS(status); 573 TestAccessNoClone(us, deepClone, cpCount, cpMap); 574 } 575 utext_close(deepClone); 576 } 577 578 579 // 580 // TestAccessNoClone() Test the read only access functions on a UText. 581 // The text is accessed in a variety of ways, and compared with 582 // the reference UnicodeString. 583 // 584 void UTextTest::TestAccessNoClone(const UnicodeString &us, UText *ut, int cpCount, m *cpMap) { 585 UErrorCode status = U_ZERO_ERROR; 586 gTestNum++; 587 588 // 589 // Check the length from the UText 590 // 591 int64_t expectedLen = cpMap[cpCount].nativeIdx; 592 int64_t utlen = utext_nativeLength(ut); 593 TEST_ASSERT(expectedLen == utlen); 594 595 // 596 // Iterate forwards, verify that we get the correct code points 597 // at the correct native offsets. 598 // 599 int i = 0; 600 int64_t index; 601 int64_t expectedIndex = 0; 602 int64_t foundIndex = 0; 603 UChar32 expectedC; 604 UChar32 foundC; 605 int64_t len; 606 607 for (i=0; i<cpCount; i++) { 608 expectedIndex = cpMap[i].nativeIdx; 609 foundIndex = utext_getNativeIndex(ut); 610 TEST_ASSERT(expectedIndex == foundIndex); 611 expectedC = cpMap[i].cp; 612 foundC = utext_next32(ut); 613 TEST_ASSERT(expectedC == foundC); 614 foundIndex = utext_getPreviousNativeIndex(ut); 615 TEST_ASSERT(expectedIndex == foundIndex); 616 if (gFailed) { 617 return; 618 } 619 } 620 foundC = utext_next32(ut); 621 TEST_ASSERT(foundC == U_SENTINEL); 622 623 // Repeat above, using macros 624 utext_setNativeIndex(ut, 0); 625 for (i=0; i<cpCount; i++) { 626 expectedIndex = cpMap[i].nativeIdx; 627 foundIndex = UTEXT_GETNATIVEINDEX(ut); 628 TEST_ASSERT(expectedIndex == foundIndex); 629 expectedC = cpMap[i].cp; 630 foundC = UTEXT_NEXT32(ut); 631 TEST_ASSERT(expectedC == foundC); 632 if (gFailed) { 633 return; 634 } 635 } 636 foundC = UTEXT_NEXT32(ut); 637 TEST_ASSERT(foundC == U_SENTINEL); 638 639 // 640 // Forward iteration (above) should have left index at the 641 // end of the input, which should == length(). 642 // 643 len = utext_nativeLength(ut); 644 foundIndex = utext_getNativeIndex(ut); 645 TEST_ASSERT(len == foundIndex); 646 647 // 648 // Iterate backwards over entire test string 649 // 650 len = utext_getNativeIndex(ut); 651 utext_setNativeIndex(ut, len); 652 for (i=cpCount-1; i>=0; i--) { 653 expectedC = cpMap[i].cp; 654 expectedIndex = cpMap[i].nativeIdx; 655 int64_t prevIndex = utext_getPreviousNativeIndex(ut); 656 foundC = utext_previous32(ut); 657 foundIndex = utext_getNativeIndex(ut); 658 TEST_ASSERT(expectedIndex == foundIndex); 659 TEST_ASSERT(expectedC == foundC); 660 TEST_ASSERT(prevIndex == foundIndex); 661 if (gFailed) { 662 return; 663 } 664 } 665 666 // 667 // Backwards iteration, above, should have left our iterator 668 // position at zero, and continued backwards iterationshould fail. 669 // 670 foundIndex = utext_getNativeIndex(ut); 671 TEST_ASSERT(foundIndex == 0); 672 foundIndex = utext_getPreviousNativeIndex(ut); 673 TEST_ASSERT(foundIndex == 0); 674 675 676 foundC = utext_previous32(ut); 677 TEST_ASSERT(foundC == U_SENTINEL); 678 foundIndex = utext_getNativeIndex(ut); 679 TEST_ASSERT(foundIndex == 0); 680 foundIndex = utext_getPreviousNativeIndex(ut); 681 TEST_ASSERT(foundIndex == 0); 682 683 684 // And again, with the macros 685 utext_setNativeIndex(ut, len); 686 for (i=cpCount-1; i>=0; i--) { 687 expectedC = cpMap[i].cp; 688 expectedIndex = cpMap[i].nativeIdx; 689 foundC = UTEXT_PREVIOUS32(ut); 690 foundIndex = UTEXT_GETNATIVEINDEX(ut); 691 TEST_ASSERT(expectedIndex == foundIndex); 692 TEST_ASSERT(expectedC == foundC); 693 if (gFailed) { 694 return; 695 } 696 } 697 698 // 699 // Backwards iteration, above, should have left our iterator 700 // position at zero, and continued backwards iterationshould fail. 701 // 702 foundIndex = UTEXT_GETNATIVEINDEX(ut); 703 TEST_ASSERT(foundIndex == 0); 704 705 foundC = UTEXT_PREVIOUS32(ut); 706 TEST_ASSERT(foundC == U_SENTINEL); 707 foundIndex = UTEXT_GETNATIVEINDEX(ut); 708 TEST_ASSERT(foundIndex == 0); 709 if (gFailed) { 710 return; 711 } 712 713 // 714 // next32From(), prevous32From(), Iterate in a somewhat random order. 715 // 716 int cpIndex = 0; 717 for (i=0; i<cpCount; i++) { 718 cpIndex = (cpIndex + 9973) % cpCount; 719 index = cpMap[cpIndex].nativeIdx; 720 expectedC = cpMap[cpIndex].cp; 721 foundC = utext_next32From(ut, index); 722 TEST_ASSERT(expectedC == foundC); 723 if (gFailed) { 724 return; 725 } 726 } 727 728 cpIndex = 0; 729 for (i=0; i<cpCount; i++) { 730 cpIndex = (cpIndex + 9973) % cpCount; 731 index = cpMap[cpIndex+1].nativeIdx; 732 expectedC = cpMap[cpIndex].cp; 733 foundC = utext_previous32From(ut, index); 734 TEST_ASSERT(expectedC == foundC); 735 if (gFailed) { 736 return; 737 } 738 } 739 740 741 // 742 // moveIndex(int32_t delta); 743 // 744 745 // Walk through frontwards, incrementing by one 746 utext_setNativeIndex(ut, 0); 747 for (i=1; i<=cpCount; i++) { 748 utext_moveIndex32(ut, 1); 749 index = utext_getNativeIndex(ut); 750 expectedIndex = cpMap[i].nativeIdx; 751 TEST_ASSERT(expectedIndex == index); 752 index = UTEXT_GETNATIVEINDEX(ut); 753 TEST_ASSERT(expectedIndex == index); 754 } 755 756 // Walk through frontwards, incrementing by two 757 utext_setNativeIndex(ut, 0); 758 for (i=2; i<cpCount; i+=2) { 759 utext_moveIndex32(ut, 2); 760 index = utext_getNativeIndex(ut); 761 expectedIndex = cpMap[i].nativeIdx; 762 TEST_ASSERT(expectedIndex == index); 763 index = UTEXT_GETNATIVEINDEX(ut); 764 TEST_ASSERT(expectedIndex == index); 765 } 766 767 // walk through the string backwards, decrementing by one. 768 i = cpMap[cpCount].nativeIdx; 769 utext_setNativeIndex(ut, i); 770 for (i=cpCount; i>=0; i--) { 771 expectedIndex = cpMap[i].nativeIdx; 772 index = utext_getNativeIndex(ut); 773 TEST_ASSERT(expectedIndex == index); 774 index = UTEXT_GETNATIVEINDEX(ut); 775 TEST_ASSERT(expectedIndex == index); 776 utext_moveIndex32(ut, -1); 777 } 778 779 780 // walk through backwards, decrementing by three 781 i = cpMap[cpCount].nativeIdx; 782 utext_setNativeIndex(ut, i); 783 for (i=cpCount; i>=0; i-=3) { 784 expectedIndex = cpMap[i].nativeIdx; 785 index = utext_getNativeIndex(ut); 786 TEST_ASSERT(expectedIndex == index); 787 index = UTEXT_GETNATIVEINDEX(ut); 788 TEST_ASSERT(expectedIndex == index); 789 utext_moveIndex32(ut, -3); 790 } 791 792 793 // 794 // Extract 795 // 796 int bufSize = us.length() + 10; 797 UChar *buf = new UChar[bufSize]; 798 status = U_ZERO_ERROR; 799 expectedLen = us.length(); 800 len = utext_extract(ut, 0, utlen, buf, bufSize, &status); 801 TEST_SUCCESS(status); 802 TEST_ASSERT(len == expectedLen); 803 int compareResult = us.compare(buf, -1); 804 TEST_ASSERT(compareResult == 0); 805 806 status = U_ZERO_ERROR; 807 len = utext_extract(ut, 0, utlen, NULL, 0, &status); 808 if (utlen == 0) { 809 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING); 810 } else { 811 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR); 812 } 813 TEST_ASSERT(len == expectedLen); 814 815 status = U_ZERO_ERROR; 816 u_memset(buf, 0x5555, bufSize); 817 len = utext_extract(ut, 0, utlen, buf, 1, &status); 818 if (us.length() == 0) { 819 TEST_SUCCESS(status); 820 TEST_ASSERT(buf[0] == 0); 821 } else { 822 // Buf len == 1, extracting a single 16 bit value. 823 // If the data char is supplementary, it doesn't matter whether the buffer remains unchanged, 824 // or whether the lead surrogate of the pair is extracted. 825 // It's a buffer overflow error in either case. 826 TEST_ASSERT(buf[0] == us.charAt(0) || 827 (buf[0] == 0x5555 && U_IS_SUPPLEMENTARY(us.char32At(0)))); 828 TEST_ASSERT(buf[1] == 0x5555); 829 if (us.length() == 1) { 830 TEST_ASSERT(status == U_STRING_NOT_TERMINATED_WARNING); 831 } else { 832 TEST_ASSERT(status == U_BUFFER_OVERFLOW_ERROR); 833 } 834 } 835 836 delete []buf; 837 } 838 839 840 // 841 // ComparisonTest() Check the string comparison functions. Based on UnicodeStringTest::TestCompare() 842 // 843 void UTextTest::ComparisonTest() 844 { 845 UErrorCode status = U_ZERO_ERROR; 846 UnicodeString test1Str("this is a test"); 847 UnicodeString test2Str("this is a test"); 848 UnicodeString test3Str("this is a test of the emergency broadcast system"); 849 UnicodeString test4Str("never say, \"this is a test\"!!"); 850 851 UText test1 = UTEXT_INITIALIZER; 852 UText test2 = UTEXT_INITIALIZER; 853 UText test3 = UTEXT_INITIALIZER; 854 UText test4 = UTEXT_INITIALIZER; 855 856 UChar uniChars[] = { 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 857 0x20, 0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0 }; 858 char chars[] = { 0x74, 0x68, 0x69, 0x73, 0x20, 0x69, 0x73, 859 0x20, 0x61, 0x20, 0x74, 0x65, 0x73, 0x74, 0 }; 860 861 UText uniCharText = UTEXT_INITIALIZER; 862 UText charText = UTEXT_INITIALIZER; 863 864 utext_openUnicodeString(&test1, &test1Str, &status); 865 utext_openUnicodeString(&test2, &test2Str, &status); 866 utext_openUnicodeString(&test3, &test3Str, &status); 867 utext_openUnicodeString(&test4, &test4Str, &status); 868 869 utext_openUChars(&uniCharText, uniChars, -1, &status); 870 utext_openUTF8(&charText, chars, -1, &status); 871 872 TEST_SUCCESS(status); 873 874 // test utext_compare(), simple 875 UTEXT_SETNATIVEINDEX(&test1, 0); 876 UTEXT_SETNATIVEINDEX(&test2, 0); 877 if (utext_compare(&test1, -1, &test2, -1) != 0) errln("utext_compare() failed, simple setup"); 878 UTEXT_SETNATIVEINDEX(&test1, 0); 879 UTEXT_SETNATIVEINDEX(&test3, 0); 880 if (utext_compare(&test1, -1, &test3, -1) >= 0) errln("utext_compare() failed, simple setup"); 881 UTEXT_SETNATIVEINDEX(&test1, 0); 882 UTEXT_SETNATIVEINDEX(&test4, 0); 883 if (utext_compare(&test1, -1, &test4, -1) <= 0) errln("utext_compare() failed, simple setup"); 884 885 // test utext_compareNativeLimit(), simple 886 UTEXT_SETNATIVEINDEX(&test1, 0); 887 UTEXT_SETNATIVEINDEX(&test2, 0); 888 if (utext_compareNativeLimit(&test1, -1, &test2, -1) != 0) errln("utext_compareNativeLimit() failed, simple setup"); 889 UTEXT_SETNATIVEINDEX(&test1, 0); 890 UTEXT_SETNATIVEINDEX(&test3, 0); 891 if (utext_compareNativeLimit(&test1, -1, &test3, -1) >= 0) errln("utext_compareNativeLimit() failed, simple setup"); 892 UTEXT_SETNATIVEINDEX(&test1, 0); 893 UTEXT_SETNATIVEINDEX(&test4, 0); 894 if (utext_compareNativeLimit(&test1, -1, &test4, -1) <= 0) errln("utext_compareNativeLimit() failed, simple setup"); 895 896 // test utext_compare(), one explicit length 897 UTEXT_SETNATIVEINDEX(&test1, 0); 898 UTEXT_SETNATIVEINDEX(&test2, 0); 899 if (utext_compare(&test1, 14, &test2, -1) != 0) errln("utext_compare() failed, one explicit length"); 900 UTEXT_SETNATIVEINDEX(&test2, 0); 901 UTEXT_SETNATIVEINDEX(&test3, 0); 902 if (utext_compare(&test3, 14, &test2, -1) != 0) errln("utext_compare() failed, one explicit length"); 903 UTEXT_SETNATIVEINDEX(&test2, 0); 904 UTEXT_SETNATIVEINDEX(&test4, 12); 905 if (utext_compare(&test4, 14, &test2, -1) != 0) errln("utext_compare() failed, one explicit length and offset"); 906 UTEXT_SETNATIVEINDEX(&test1, 0); 907 UTEXT_SETNATIVEINDEX(&test3, 0); 908 if (utext_compare(&test3, 18, &test2, -1) <= 0) errln("utext_compare() failed, one explicit length"); 909 910 // test utext_compareNativeLimit(), one explicit length 911 UTEXT_SETNATIVEINDEX(&test1, 0); 912 UTEXT_SETNATIVEINDEX(&test2, 0); 913 if (utext_compareNativeLimit(&test1, 14, &test2, -1) != 0) errln("utext_compareNativeLimit() failed, one explicit length"); 914 UTEXT_SETNATIVEINDEX(&test2, 0); 915 UTEXT_SETNATIVEINDEX(&test3, 0); 916 if (utext_compareNativeLimit(&test3, 14, &test2, -1) != 0) errln("utext_compareNativeLimit() failed, one explicit length"); 917 UTEXT_SETNATIVEINDEX(&test2, 0); 918 UTEXT_SETNATIVEINDEX(&test4, 12); 919 if (utext_compareNativeLimit(&test4, 26, &test2, -1) != 0) errln("utext_compareNativeLimit() failed, one explicit length and limit"); 920 UTEXT_SETNATIVEINDEX(&test1, 0); 921 UTEXT_SETNATIVEINDEX(&test3, 0); 922 if (utext_compareNativeLimit(&test3, 18, &test2, -1) <= 0) errln("utext_compareNativeLimit() failed, one explicit length"); 923 924 // test utext_compare(), UChar-based UText 925 UTEXT_SETNATIVEINDEX(&uniCharText, 0); 926 UTEXT_SETNATIVEINDEX(&test2, 0); 927 if (utext_compare(&test2, -1, &uniCharText, -1) != 0) errln("utext_compare() failed, UChar-based UText"); 928 UTEXT_SETNATIVEINDEX(&uniCharText, 0); 929 UTEXT_SETNATIVEINDEX(&test3, 0); 930 if (utext_compare(&test3, -1, &uniCharText, -1) <= 0) errln("utext_compare() failed, UChar-based UText"); 931 UTEXT_SETNATIVEINDEX(&uniCharText, 0); 932 UTEXT_SETNATIVEINDEX(&test4, 0); 933 if (utext_compare(&test4, -1, &uniCharText, -1) >= 0) errln("utext_compare() failed, UChar-based UText"); 934 935 // test utext_compareNativeLimit(), UChar-based UText 936 UTEXT_SETNATIVEINDEX(&uniCharText, 0); 937 UTEXT_SETNATIVEINDEX(&test2, 0); 938 if (utext_compareNativeLimit(&test2, -1, &uniCharText, -1) != 0) errln("utext_compareNativeLimit() failed, UChar-based UText"); 939 UTEXT_SETNATIVEINDEX(&uniCharText, 0); 940 UTEXT_SETNATIVEINDEX(&test3, 0); 941 if (utext_compareNativeLimit(&test3, -1, &uniCharText, -1) <= 0) errln("utext_compareNativeLimit() failed, UChar-based UText"); 942 UTEXT_SETNATIVEINDEX(&uniCharText, 0); 943 UTEXT_SETNATIVEINDEX(&test4, 0); 944 if (utext_compareNativeLimit(&test4, -1, &uniCharText, -1) >= 0) errln("utext_compareNativeLimit() failed, UChar-based UText"); 945 946 // test utext_compare(), UTF8-based UText 947 UTEXT_SETNATIVEINDEX(&charText, 0); 948 UTEXT_SETNATIVEINDEX(&test2, 0); 949 if (utext_compare(&test2, -1, &charText, -1) != 0) errln("utext_compare() failed, UTF8-based UText"); 950 UTEXT_SETNATIVEINDEX(&charText, 0); 951 UTEXT_SETNATIVEINDEX(&test3, 0); 952 if (utext_compare(&test3, -1, &charText, -1) <= 0) errln("utext_compare() failed, UTF8-based UText"); 953 UTEXT_SETNATIVEINDEX(&charText, 0); 954 UTEXT_SETNATIVEINDEX(&test4, 0); 955 if (utext_compare(&test4, -1, &charText, -1) >= 0) errln("utext_compare() failed, UTF8-based UText"); 956 957 // test utext_compareNativeLimit(), UTF8-based UText 958 UTEXT_SETNATIVEINDEX(&charText, 0); 959 UTEXT_SETNATIVEINDEX(&test2, 0); 960 if (utext_compareNativeLimit(&test2, -1, &charText, -1) != 0) errln("utext_compareNativeLimit() failed, UTF8-based UText"); 961 UTEXT_SETNATIVEINDEX(&charText, 0); 962 UTEXT_SETNATIVEINDEX(&test3, 0); 963 if (utext_compareNativeLimit(&test3, -1, &charText, -1) <= 0) errln("utext_compareNativeLimit() failed, UTF8-based UText"); 964 UTEXT_SETNATIVEINDEX(&charText, 0); 965 UTEXT_SETNATIVEINDEX(&test4, 0); 966 if (utext_compareNativeLimit(&test4, -1, &charText, -1) >= 0) errln("utext_compareNativeLimit() failed, UTF8-based UText"); 967 968 // test utext_compare(), length 969 UTEXT_SETNATIVEINDEX(&test1, 0); 970 UTEXT_SETNATIVEINDEX(&test2, 0); 971 if (utext_compare(&test1, -1, &test2, 4) != 0) errln("utext_compare() failed, one length"); 972 UTEXT_SETNATIVEINDEX(&test1, 0); 973 UTEXT_SETNATIVEINDEX(&test2, 0); 974 if (utext_compare(&test1, 5, &test2, 4) <= 0) errln("utext_compare() failed, both lengths"); 975 976 // test utext_compareNativeLimit(), limit 977 UTEXT_SETNATIVEINDEX(&test1, 0); 978 UTEXT_SETNATIVEINDEX(&test2, 0); 979 if (utext_compareNativeLimit(&test1, -1, &test2, 4) != 0) errln("utext_compareNativeLimit() failed, one limit"); 980 UTEXT_SETNATIVEINDEX(&test1, 0); 981 UTEXT_SETNATIVEINDEX(&test2, 0); 982 if (utext_compareNativeLimit(&test1, 5, &test2, 4) <= 0) errln("utext_compareNativeLimit() failed, both limits"); 983 984 // test utext_compare(), both explicit offsets and lengths 985 UTEXT_SETNATIVEINDEX(&test1, 0); 986 UTEXT_SETNATIVEINDEX(&test2, 0); 987 if (utext_compare(&test1, 14, &test2, 14) != 0) errln("utext_compare() failed, both explicit offsets and lengths"); 988 UTEXT_SETNATIVEINDEX(&test1, 0); 989 UTEXT_SETNATIVEINDEX(&test3, 0); 990 if (utext_compare(&test1, 14, &test3, 14) != 0) errln("utext_compare() failed, both explicit offsets and lengths"); 991 UTEXT_SETNATIVEINDEX(&test1, 0); 992 UTEXT_SETNATIVEINDEX(&test4, 12); 993 if (utext_compare(&test1, 14, &test4, 14) != 0) errln("utext_compare() failed, both explicit offsets and lengths"); 994 UTEXT_SETNATIVEINDEX(&test1, 10); 995 UTEXT_SETNATIVEINDEX(&test2, 0); 996 if (utext_compare(&test1, 4, &test2, 4) >= 0) errln("utext_compare() failed, both explicit offsets and lengths"); 997 UTEXT_SETNATIVEINDEX(&test1, 10); 998 UTEXT_SETNATIVEINDEX(&test3, 22); 999 if (utext_compare(&test1, 4, &test3, 9) <= 0) errln("utext_compare() failed, both explicit offsets and lengths"); 1000 UTEXT_SETNATIVEINDEX(&test1, 10); 1001 UTEXT_SETNATIVEINDEX(&test4, 22); 1002 if (utext_compare(&test1, 4, &test4, 4) != 0) errln("utext_compare() failed, both explicit offsets and lengths"); 1003 1004 // test utext_compareNativeLimit(), both explicit offsets and limits 1005 UTEXT_SETNATIVEINDEX(&test1, 0); 1006 UTEXT_SETNATIVEINDEX(&test2, 0); 1007 if (utext_compareNativeLimit(&test1, 14, &test2, 14) != 0) errln("utext_compareNativeLimit() failed, both explicit offsets and limits"); 1008 UTEXT_SETNATIVEINDEX(&test1, 0); 1009 UTEXT_SETNATIVEINDEX(&test3, 0); 1010 if (utext_compareNativeLimit(&test1, 14, &test3, 14) != 0) errln("utext_compareNativeLimit() failed, both explicit offsets and limits"); 1011 UTEXT_SETNATIVEINDEX(&test1, 0); 1012 UTEXT_SETNATIVEINDEX(&test4, 12); 1013 if (utext_compareNativeLimit(&test1, 14, &test4, 26) != 0) errln("utext_compareNativeLimit() failed, both explicit offsets and limits"); 1014 UTEXT_SETNATIVEINDEX(&test1, 10); 1015 UTEXT_SETNATIVEINDEX(&test2, 0); 1016 if (utext_compareNativeLimit(&test1, 14, &test2, 4) >= 0) errln("utext_compareNativeLimit() failed, both explicit offsets and limits"); 1017 UTEXT_SETNATIVEINDEX(&test1, 10); 1018 UTEXT_SETNATIVEINDEX(&test3, 22); 1019 if (utext_compareNativeLimit(&test1, 14, &test3, 31) <= 0) errln("utext_compareNativeLimit() failed, both explicit offsets and limits"); 1020 UTEXT_SETNATIVEINDEX(&test1, 10); 1021 UTEXT_SETNATIVEINDEX(&test4, 22); 1022 if (utext_compareNativeLimit(&test1, 14, &test4, 26) != 0) errln("utext_compareNativeLimit() failed, both explicit offsets and limits"); 1023 1024 /* test caseCompare() */ 1025 { 1026 static const UChar 1027 _mixed[]= { 0x61, 0x42, 0x131, 0x3a3, 0xdf, 0x130, 0x49, 0xfb03, 0xd93f, 0xdfff, 0 }, 1028 _otherDefault[]= { 0x41, 0x62, 0x131, 0x3c3, 0x73, 0x53, 0x69, 0x307, 0x69, 0x46, 0x66, 0x49, 0xd93f, 0xdfff, 0 }, 1029 _otherExcludeSpecialI[]={ 0x41, 0x62, 0x131, 0x3c3, 0x53, 0x73, 0x69, 0x131, 0x66, 0x46, 0x69, 0xd93f, 0xdfff, 0 }, 1030 _different[]= { 0x41, 0x62, 0x131, 0x3c3, 0x73, 0x53, 0x130, 0x49, 0x46, 0x66, 0x49, 0xd93f, 0xdffd, 0 }; 1031 1032 UText 1033 mixed = UTEXT_INITIALIZER, 1034 otherDefault = UTEXT_INITIALIZER, 1035 otherExcludeSpecialI = UTEXT_INITIALIZER, 1036 different = UTEXT_INITIALIZER; 1037 1038 utext_openUChars(&mixed, _mixed, -1, &status); 1039 utext_openUChars(&otherDefault, _otherDefault, -1, &status); 1040 utext_openUChars(&otherExcludeSpecialI, _otherExcludeSpecialI, -1, &status); 1041 utext_openUChars(&different, _different, -1, &status); 1042 1043 TEST_SUCCESS(status); 1044 1045 int32_t result; 1046 1047 /* test default options */ 1048 UTEXT_SETNATIVEINDEX(&mixed, 0); 1049 UTEXT_SETNATIVEINDEX(&otherDefault, 0); 1050 result = utext_caseCompare(&mixed, -1, &otherDefault, -1, U_FOLD_CASE_DEFAULT, &status); 1051 if (0 != result || U_FAILURE(status)) { 1052 errln("error: utext_caseCompare (other, default) gives %ld (should be 0) (%s)\n", result, u_errorName(status)); 1053 } 1054 UTEXT_SETNATIVEINDEX(&mixed, 0); 1055 UTEXT_SETNATIVEINDEX(&otherDefault, 0); 1056 result = utext_caseCompareNativeLimit(&mixed, -1, &otherDefault, -1, U_FOLD_CASE_DEFAULT, &status); 1057 if (0 != result || U_FAILURE(status)) { 1058 errln("error: utext_caseCompareNativeLimit (other, default) gives %ld (should be 0) (%s)\n", result, u_errorName(status)); 1059 } 1060 1061 /* test excluding special I */ 1062 UTEXT_SETNATIVEINDEX(&mixed, 0); 1063 UTEXT_SETNATIVEINDEX(&otherExcludeSpecialI, 0); 1064 result = utext_caseCompare(&mixed, -1, &otherExcludeSpecialI, -1, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &status); 1065 if (0 != result || U_FAILURE(status)) { 1066 errln("error: utext_caseCompare (otherExcludeSpecialI, U_FOLD_CASE_EXCLUDE_SPECIAL_I) gives %ld (should be 0) (%s)\n", result, u_errorName(status)); 1067 } 1068 UTEXT_SETNATIVEINDEX(&mixed, 0); 1069 UTEXT_SETNATIVEINDEX(&otherExcludeSpecialI, 0); 1070 result = utext_caseCompareNativeLimit(&mixed, -1, &otherExcludeSpecialI, -1, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &status); 1071 if (0 != result || U_FAILURE(status)) { 1072 errln("error: utext_caseCompareNativeLimit (otherExcludeSpecialI, U_FOLD_CASE_EXCLUDE_SPECIAL_I) gives %ld (should be 0) (%s)\n", result, u_errorName(status)); 1073 } 1074 UTEXT_SETNATIVEINDEX(&mixed, 0); 1075 UTEXT_SETNATIVEINDEX(&otherDefault, 0); 1076 result = utext_caseCompare(&mixed, -1, &otherDefault, -1, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &status); 1077 if (0 == result || U_FAILURE(status)) { 1078 errln("error: utext_caseCompare (other, U_FOLD_CASE_EXCLUDE_SPECIAL_I) gives %ld (should be nonzero) (%s)\n", result, u_errorName(status)); 1079 } 1080 UTEXT_SETNATIVEINDEX(&mixed, 0); 1081 UTEXT_SETNATIVEINDEX(&otherDefault, 0); 1082 result = utext_caseCompareNativeLimit(&mixed, -1, &otherDefault, -1, U_FOLD_CASE_EXCLUDE_SPECIAL_I, &status); 1083 if (0 == result || U_FAILURE(status)) { 1084 errln("error: utext_caseCompareNativeLimit (other, U_FOLD_CASE_EXCLUDE_SPECIAL_I) gives %ld (should be nonzero) (%s)\n", result, u_errorName(status)); 1085 } 1086 1087 /* test against different string */ 1088 UTEXT_SETNATIVEINDEX(&mixed, 0); 1089 UTEXT_SETNATIVEINDEX(&different, 0); 1090 result = utext_caseCompare(&mixed, -1, &different, -1, U_FOLD_CASE_DEFAULT, &status); 1091 if (0 >= result || U_FAILURE(status)) { 1092 errln("error: utext_caseCompare (different, default) gives %ld (should be positive) (%s)\n", result, u_errorName(status)); 1093 } 1094 UTEXT_SETNATIVEINDEX(&mixed, 0); 1095 UTEXT_SETNATIVEINDEX(&different, 0); 1096 result = utext_caseCompareNativeLimit(&mixed, -1, &different, -1, U_FOLD_CASE_DEFAULT, &status); 1097 if (0 >= result || U_FAILURE(status)) { 1098 errln("error: utext_caseCompareNativeLimit (different, default) gives %ld (should be positive) (%s)\n", result, u_errorName(status)); 1099 } 1100 1101 /* test caseCompare() - include the folded sharp s (U+00df) with different lengths */ 1102 UTEXT_SETNATIVEINDEX(&mixed, 1); 1103 UTEXT_SETNATIVEINDEX(&different, 1); 1104 result = utext_caseCompare(&mixed, 4, &different, 5, U_FOLD_CASE_DEFAULT, &status); 1105 if (0 != result || U_FAILURE(status)) { 1106 errln("error: utext_caseCompare (mixed[1-5), different[1-6), default) gives %ld (should be 0) (%s)\n", result, u_errorName(status)); 1107 } 1108 UTEXT_SETNATIVEINDEX(&mixed, 1); 1109 UTEXT_SETNATIVEINDEX(&different, 1); 1110 result = utext_caseCompareNativeLimit(&mixed, 5, &different, 6, U_FOLD_CASE_DEFAULT, &status); 1111 if (0 != result || U_FAILURE(status)) { 1112 errln("error: utext_caseCompareNativeLimit (mixed[1-5), different[1-6), default) gives %ld (should be 0) (%s)\n", result, u_errorName(status)); 1113 } 1114 1115 /* test caseCompare() - stop in the middle of the sharp s (U+00df) */ 1116 UTEXT_SETNATIVEINDEX(&mixed, 1); 1117 UTEXT_SETNATIVEINDEX(&different, 1); 1118 result = utext_caseCompare(&mixed, 4, &different, 4, U_FOLD_CASE_DEFAULT, &status); 1119 if (0 >= result || U_FAILURE(status)) { 1120 errln("error: utext_caseCompare (mixed[1-5), different[1-5), default) gives %ld (should be positive) (%s)\n", result, u_errorName(status)); 1121 } 1122 UTEXT_SETNATIVEINDEX(&mixed, 1); 1123 UTEXT_SETNATIVEINDEX(&different, 1); 1124 result = utext_caseCompareNativeLimit(&mixed, 5, &different, 5, U_FOLD_CASE_DEFAULT, &status); 1125 if (0 >= result || U_FAILURE(status)) { 1126 errln("error: utext_caseCompareNativeLimit (mixed[1-5), different[1-5), default) gives %ld (should be positive) (%s)\n", result, u_errorName(status)); 1127 } 1128 } 1129 1130 /* test surrogates in comparison */ 1131 { 1132 static const UChar 1133 _before[] = { 0x65, 0xd800, 0xd800, 0xdc01, 0x65, 0x00 }, 1134 _after[] = { 0x65, 0xd800, 0xdc00, 0x65, 0x00 }; 1135 1136 UText 1137 before = UTEXT_INITIALIZER, 1138 after = UTEXT_INITIALIZER; 1139 1140 utext_openUChars(&before, _before, -1, &status); 1141 utext_openUChars(&after, _after, -1, &status); 1142 1143 TEST_SUCCESS(status); 1144 int32_t result; 1145 1146 UTEXT_SETNATIVEINDEX(&before, 1); 1147 UTEXT_SETNATIVEINDEX(&after, 1); 1148 result = utext_compare(&before, -1, &after, -1); 1149 if (0 <= result || U_FAILURE(status)) { 1150 errln("error: utext_compare ({ 65, d800, 10001, 65 }, { 65, 10000, 65 }) gives %ld (should be negative) (%s)\n", result, u_errorName(status)); 1151 } 1152 1153 UTEXT_SETNATIVEINDEX(&before, 1); 1154 UTEXT_SETNATIVEINDEX(&after, 1); 1155 result = utext_compare(&before, 3, &after, 3); 1156 if (0 <= result || U_FAILURE(status)) { 1157 errln("error: utext_compare with lengths ({ 65, d800, 10001, 65 }, { 65, 10000, 65 }) gives %ld (should be negative) (%s)\n", result, u_errorName(status)); 1158 } 1159 1160 UTEXT_SETNATIVEINDEX(&before, 1); 1161 UTEXT_SETNATIVEINDEX(&after, 1); 1162 result = utext_caseCompare(&before, -1, &after, -1, U_FOLD_CASE_DEFAULT, &status); 1163 if (0 <= result || U_FAILURE(status)) { 1164 errln("error: utext_caseCompare ({ 65, d800, 10001, 65 }, { 65, 10000, 65 }) gives %ld (should be negative) (%s)\n", result, u_errorName(status)); 1165 } 1166 1167 UTEXT_SETNATIVEINDEX(&before, 1); 1168 UTEXT_SETNATIVEINDEX(&after, 1); 1169 result = utext_caseCompare(&before, 3, &after, 3, U_FOLD_CASE_DEFAULT, &status); 1170 if (0 <= result || U_FAILURE(status)) { 1171 errln("error: utext_caseCompare with lengths ({ 65, d800, 10001, 65 }, { 65, 10000, 65 }) gives %ld (should be negative) (%s)\n", result, u_errorName(status)); 1172 } 1173 1174 utext_close(&before); 1175 utext_close(&after); 1176 } 1177 1178 /* test surrogates at end of string */ 1179 { 1180 static const UChar 1181 _before[] = { 0x65, 0xd800, 0xd800, 0xdc01, 0x00 }, 1182 _after[] = { 0x65, 0xd800, 0xdc00, 0x00 }; 1183 1184 UText 1185 before = UTEXT_INITIALIZER, 1186 after = UTEXT_INITIALIZER; 1187 1188 utext_openUChars(&before, _before, -1, &status); 1189 utext_openUChars(&after, _after, -1, &status); 1190 1191 TEST_SUCCESS(status); 1192 int32_t result; 1193 1194 UTEXT_SETNATIVEINDEX(&before, 1); 1195 UTEXT_SETNATIVEINDEX(&after, 1); 1196 result = utext_compare(&before, -1, &after, -1); 1197 if (0 <= result || U_FAILURE(status)) { 1198 errln("error: utext_compare ({ 65, d800, 10001 }, { 65, 10000 }) gives %ld (should be negative) (%s)\n", result, u_errorName(status)); 1199 } 1200 1201 UTEXT_SETNATIVEINDEX(&before, 1); 1202 UTEXT_SETNATIVEINDEX(&after, 1); 1203 result = utext_caseCompare(&before, -1, &after, -1, U_FOLD_CASE_DEFAULT, &status); 1204 if (0 <= result || U_FAILURE(status)) { 1205 errln("error: utext_caseCompare ({ 65, d800, 10001 }, { 65, 10000 }) gives %ld (should be negative) (%s)\n", result, u_errorName(status)); 1206 } 1207 1208 utext_close(&before); 1209 utext_close(&after); 1210 } 1211 1212 /* test empty strings */ 1213 { 1214 UChar zero16 = 0; 1215 char zero8 = 0; 1216 UText emptyUChar = UTEXT_INITIALIZER; 1217 UText emptyUTF8 = UTEXT_INITIALIZER; 1218 UText nullUChar = UTEXT_INITIALIZER; 1219 UText nullUTF8 = UTEXT_INITIALIZER; 1220 1221 utext_openUChars(&emptyUChar, &zero16, -1, &status); 1222 utext_openUTF8(&emptyUTF8, &zero8, -1, &status); 1223 utext_openUChars(&nullUChar, NULL, 0, &status); 1224 utext_openUTF8(&nullUTF8, NULL, 0, &status); 1225 1226 if (utext_compare(&emptyUChar, -1, &emptyUTF8, -1) != 0) { 1227 errln("error: utext_compare(&emptyUChar, -1, &emptyUTF8, -1) != 0"); 1228 } 1229 if (utext_compare(&emptyUChar, -1, &nullUChar, -1) != 0) { 1230 errln("error: utext_compare(&emptyUChar, -1, &nullUChar, -1) != 0"); 1231 } 1232 if (utext_compare(&emptyUChar, -1, &nullUTF8, -1) != 0) { 1233 errln("error: utext_compare(&emptyUChar, -1, &nullUTF8, -1) != 0"); 1234 } 1235 if (utext_compare(&emptyUTF8, -1, &nullUChar, -1) != 0) { 1236 errln("error: utext_compare(&emptyUTF8, -1, &nullUChar, -1) != 0"); 1237 } 1238 if (utext_compare(&emptyUTF8, -1, &nullUTF8, -1) != 0) { 1239 errln("error: utext_compare(&emptyUTF8, -1, &nullUTF8, -1) != 0"); 1240 } 1241 if (utext_compare(&nullUChar, -1, &nullUTF8, -1) != 0) { 1242 errln("error: utext_compare(&nullUChar, -1, &nullUTF8, -1) != 0"); 1243 } 1244 1245 if (utext_compareNativeLimit(&emptyUChar, -1, &emptyUTF8, -1) != 0) { 1246 errln("error: utext_compareNativeLimit(&emptyUChar, -1, &emptyUTF8, -1) != 0"); 1247 } 1248 if (utext_compareNativeLimit(&emptyUChar, -1, &nullUChar, -1) != 0) { 1249 errln("error: utext_compareNativeLimit(&emptyUChar, -1, &nullUChar, -1) != 0"); 1250 } 1251 if (utext_compareNativeLimit(&emptyUChar, -1, &nullUTF8, -1) != 0) { 1252 errln("error: utext_compareNativeLimit(&emptyUChar, -1, &nullUTF8, -1) != 0"); 1253 } 1254 if (utext_compareNativeLimit(&emptyUTF8, -1, &nullUChar, -1) != 0) { 1255 errln("error: utext_compareNativeLimit(&emptyUTF8, -1, &nullUChar, -1) != 0"); 1256 } 1257 if (utext_compareNativeLimit(&emptyUTF8, -1, &nullUTF8, -1) != 0) { 1258 errln("error: utext_compareNativeLimit(&emptyUTF8, -1, &nullUTF8, -1) != 0"); 1259 } 1260 if (utext_compareNativeLimit(&nullUChar, -1, &nullUTF8, -1) != 0) { 1261 errln("error: utext_compareNativeLimit(&nullUChar, -1, &nullUTF8, -1) != 0"); 1262 } 1263 1264 if (utext_caseCompare(&emptyUChar, -1, &emptyUTF8, -1, 0, &status) != 0) { 1265 errln("error: utext_caseCompare(&emptyUChar, -1, &emptyUTF8, -1, 0, &status) != 0"); 1266 } 1267 if (utext_caseCompare(&emptyUChar, -1, &nullUChar, -1, 0, &status) != 0) { 1268 errln("error: utext_caseCompare(&emptyUChar, -1, &nullUChar, -1, 0, &status) != 0"); 1269 } 1270 if (utext_caseCompare(&emptyUChar, -1, &nullUTF8, -1, 0, &status) != 0) { 1271 errln("error: utext_caseCompare(&emptyUChar, -1, &nullUTF8, -1, 0, &status) != 0"); 1272 } 1273 if (utext_caseCompare(&emptyUTF8, -1, &nullUChar, -1, 0, &status) != 0) { 1274 errln("error: utext_caseCompare(&emptyUTF8, -1, &nullUChar, -1, 0, &status) != 0"); 1275 } 1276 if (utext_caseCompare(&emptyUTF8, -1, &nullUTF8, -1, 0, &status) != 0) { 1277 errln("error: utext_caseCompare(&emptyUTF8, -1, &nullUTF8, -1, 0, &status) != 0"); 1278 } 1279 if (utext_caseCompare(&nullUChar, -1, &nullUTF8, -1, 0, &status) != 0) { 1280 errln("error: utext_caseCompare(&nullUChar, -1, &nullUTF8, -1, 0, &status) != 0"); 1281 } 1282 1283 if (utext_caseCompareNativeLimit(&emptyUChar, -1, &emptyUTF8, -1, 0, &status) != 0) { 1284 errln("error: utext_caseCompareNativeLimit(&emptyUChar, -1, &emptyUTF8, -1, 0, &status) != 0"); 1285 } 1286 if (utext_caseCompareNativeLimit(&emptyUChar, -1, &nullUChar, -1, 0, &status) != 0) { 1287 errln("error: utext_caseCompareNativeLimit(&emptyUChar, -1, &nullUChar, -1, 0, &status) != 0"); 1288 } 1289 if (utext_caseCompareNativeLimit(&emptyUChar, -1, &nullUTF8, -1, 0, &status) != 0) { 1290 errln("error: utext_caseCompareNativeLimit(&emptyUChar, -1, &nullUTF8, -1, 0, &status) != 0"); 1291 } 1292 if (utext_caseCompareNativeLimit(&emptyUTF8, -1, &nullUChar, -1, 0, &status) != 0) { 1293 errln("error: utext_caseCompareNativeLimit(&emptyUTF8, -1, &nullUChar, -1, 0, &status) != 0"); 1294 } 1295 if (utext_caseCompareNativeLimit(&emptyUTF8, -1, &nullUTF8, -1, 0, &status) != 0) { 1296 errln("error: utext_caseCompareNativeLimit(&emptyUTF8, -1, &nullUTF8, -1, 0, &status) != 0"); 1297 } 1298 if (utext_caseCompareNativeLimit(&nullUChar, -1, &nullUTF8, -1, 0, &status) != 0) { 1299 errln("error: utext_caseCompareNativeLimit(&nullUChar, -1, &nullUTF8, -1, 0, &status) != 0"); 1300 } 1301 1302 utext_close(&emptyUChar); 1303 utext_close(&emptyUTF8); 1304 utext_close(&nullUChar); 1305 utext_close(&nullUTF8); 1306 utext_close(&charText); 1307 utext_close(&uniCharText); 1308 } 1309 } 1310 1311 1312 1313 // 1314 // ErrorTest() Check various error and edge cases. 1315 // 1316 void UTextTest::ErrorTest() 1317 { 1318 // Close of an unitialized UText. Shouldn't blow up. 1319 { 1320 UText ut; 1321 memset(&ut, 0, sizeof(UText)); 1322 utext_close(&ut); 1323 utext_close(NULL); 1324 } 1325 1326 // Double-close of a UText. Shouldn't blow up. UText should still be usable. 1327 { 1328 UErrorCode status = U_ZERO_ERROR; 1329 UText ut = UTEXT_INITIALIZER; 1330 UnicodeString s("Hello, World"); 1331 UText *ut2 = utext_openUnicodeString(&ut, &s, &status); 1332 TEST_SUCCESS(status); 1333 TEST_ASSERT(ut2 == &ut); 1334 1335 UText *ut3 = utext_close(&ut); 1336 TEST_ASSERT(ut3 == &ut); 1337 1338 UText *ut4 = utext_close(&ut); 1339 TEST_ASSERT(ut4 == &ut); 1340 1341 utext_openUnicodeString(&ut, &s, &status); 1342 TEST_SUCCESS(status); 1343 utext_close(&ut); 1344 } 1345 1346 // Re-use of a UText, chaining through each of the types of UText 1347 // (If it doesn't blow up, and doesn't leak, it's probably working fine) 1348 { 1349 UErrorCode status = U_ZERO_ERROR; 1350 UText ut = UTEXT_INITIALIZER; 1351 UText *utp; 1352 UnicodeString s1("Hello, World"); 1353 UChar s2[] = {(UChar)0x41, (UChar)0x42, (UChar)0}; 1354 const char *s3 = "\x66\x67\x68"; 1355 1356 utp = utext_openUnicodeString(&ut, &s1, &status); 1357 TEST_SUCCESS(status); 1358 TEST_ASSERT(utp == &ut); 1359 1360 utp = utext_openConstUnicodeString(&ut, &s1, &status); 1361 TEST_SUCCESS(status); 1362 TEST_ASSERT(utp == &ut); 1363 1364 utp = utext_openUTF8(&ut, s3, -1, &status); 1365 TEST_SUCCESS(status); 1366 TEST_ASSERT(utp == &ut); 1367 1368 utp = utext_openUChars(&ut, s2, -1, &status); 1369 TEST_SUCCESS(status); 1370 TEST_ASSERT(utp == &ut); 1371 1372 utp = utext_close(&ut); 1373 TEST_ASSERT(utp == &ut); 1374 1375 utp = utext_openUnicodeString(&ut, &s1, &status); 1376 TEST_SUCCESS(status); 1377 TEST_ASSERT(utp == &ut); 1378 } 1379 1380 // Invalid parameters on open 1381 // 1382 { 1383 UErrorCode status = U_ZERO_ERROR; 1384 UText ut = UTEXT_INITIALIZER; 1385 1386 utext_openUChars(&ut, NULL, 5, &status); 1387 TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR); 1388 1389 status = U_ZERO_ERROR; 1390 utext_openUChars(&ut, NULL, -1, &status); 1391 TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR); 1392 1393 status = U_ZERO_ERROR; 1394 utext_openUTF8(&ut, NULL, 4, &status); 1395 TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR); 1396 1397 status = U_ZERO_ERROR; 1398 utext_openUTF8(&ut, NULL, -1, &status); 1399 TEST_ASSERT(status == U_ILLEGAL_ARGUMENT_ERROR); 1400 } 1401 1402 // 1403 // UTF-8 with malformed sequences. 1404 // These should come through as the Unicode replacement char, \ufffd 1405 // 1406 { 1407 UErrorCode status = U_ZERO_ERROR; 1408 UText *ut = NULL; 1409 const char *badUTF8 = "\x41\x81\x42\xf0\x81\x81\x43"; 1410 UChar32 c; 1411 1412 ut = utext_openUTF8(NULL, badUTF8, -1, &status); 1413 TEST_SUCCESS(status); 1414 c = utext_char32At(ut, 1); 1415 TEST_ASSERT(c == 0xfffd); 1416 c = utext_char32At(ut, 3); 1417 TEST_ASSERT(c == 0xfffd); 1418 c = utext_char32At(ut, 5); 1419 TEST_ASSERT(c == 0xfffd); 1420 c = utext_char32At(ut, 6); 1421 TEST_ASSERT(c == 0x43); 1422 1423 UChar buf[10]; 1424 int n = utext_extract(ut, 0, 9, buf, 10, &status); 1425 TEST_SUCCESS(status); 1426 TEST_ASSERT(n==5); 1427 TEST_ASSERT(buf[1] == 0xfffd); 1428 TEST_ASSERT(buf[3] == 0xfffd); 1429 TEST_ASSERT(buf[2] == 0x42); 1430 utext_close(ut); 1431 } 1432 1433 1434 // 1435 // isLengthExpensive - does it make the exptected transitions after 1436 // getting the length of a nul terminated string? 1437 // 1438 { 1439 UErrorCode status = U_ZERO_ERROR; 1440 UnicodeString sa("Hello, this is a string"); 1441 UBool isExpensive; 1442 1443 UChar sb[100]; 1444 memset(sb, 0x20, sizeof(sb)); 1445 sb[99] = 0; 1446 1447 UText *uta = utext_openUnicodeString(NULL, &sa, &status); 1448 TEST_SUCCESS(status); 1449 isExpensive = utext_isLengthExpensive(uta); 1450 TEST_ASSERT(isExpensive == FALSE); 1451 utext_close(uta); 1452 1453 UText *utb = utext_openUChars(NULL, sb, -1, &status); 1454 TEST_SUCCESS(status); 1455 isExpensive = utext_isLengthExpensive(utb); 1456 TEST_ASSERT(isExpensive == TRUE); 1457 int64_t len = utext_nativeLength(utb); 1458 TEST_ASSERT(len == 99); 1459 isExpensive = utext_isLengthExpensive(utb); 1460 TEST_ASSERT(isExpensive == FALSE); 1461 utext_close(utb); 1462 } 1463 1464 // 1465 // Index to positions not on code point boundaries. 1466 // 1467 { 1468 const char *u8str = "\xc8\x81\xe1\x82\x83\xf1\x84\x85\x86"; 1469 int32_t startMap[] = { 0, 0, 2, 2, 2, 5, 5, 5, 5, 9, 9}; 1470 int32_t nextMap[] = { 2, 2, 5, 5, 5, 9, 9, 9, 9, 9, 9}; 1471 int32_t prevMap[] = { 0, 0, 0, 0, 0, 2, 2, 2, 2, 5, 5}; 1472 UChar32 c32Map[] = {0x201, 0x201, 0x1083, 0x1083, 0x1083, 0x044146, 0x044146, 0x044146, 0x044146, -1, -1}; 1473 UChar32 pr32Map[] = { -1, -1, 0x201, 0x201, 0x201, 0x1083, 0x1083, 0x1083, 0x1083, 0x044146, 0x044146}; 1474 1475 // extractLen is the size, in UChars, of what will be extracted between index and index+1. 1476 // is zero when both index positions lie within the same code point. 1477 int32_t exLen[] = { 0, 1, 0, 0, 1, 0, 0, 0, 2, 0, 0}; 1478 1479 1480 UErrorCode status = U_ZERO_ERROR; 1481 UText *ut = utext_openUTF8(NULL, u8str, -1, &status); 1482 TEST_SUCCESS(status); 1483 1484 // Check setIndex 1485 int32_t i; 1486 int32_t startMapLimit = sizeof(startMap) / sizeof(int32_t); 1487 for (i=0; i<startMapLimit; i++) { 1488 utext_setNativeIndex(ut, i); 1489 int64_t cpIndex = utext_getNativeIndex(ut); 1490 TEST_ASSERT(cpIndex == startMap[i]); 1491 cpIndex = UTEXT_GETNATIVEINDEX(ut); 1492 TEST_ASSERT(cpIndex == startMap[i]); 1493 } 1494 1495 // Check char32At 1496 for (i=0; i<startMapLimit; i++) { 1497 UChar32 c32 = utext_char32At(ut, i); 1498 TEST_ASSERT(c32 == c32Map[i]); 1499 int64_t cpIndex = utext_getNativeIndex(ut); 1500 TEST_ASSERT(cpIndex == startMap[i]); 1501 } 1502 1503 // Check utext_next32From 1504 for (i=0; i<startMapLimit; i++) { 1505 UChar32 c32 = utext_next32From(ut, i); 1506 TEST_ASSERT(c32 == c32Map[i]); 1507 int64_t cpIndex = utext_getNativeIndex(ut); 1508 TEST_ASSERT(cpIndex == nextMap[i]); 1509 } 1510 1511 // check utext_previous32From 1512 for (i=0; i<startMapLimit; i++) { 1513 gTestNum++; 1514 UChar32 c32 = utext_previous32From(ut, i); 1515 TEST_ASSERT(c32 == pr32Map[i]); 1516 int64_t cpIndex = utext_getNativeIndex(ut); 1517 TEST_ASSERT(cpIndex == prevMap[i]); 1518 } 1519 1520 // check Extract 1521 // Extract from i to i+1, which may be zero or one code points, 1522 // depending on whether the indices straddle a cp boundary. 1523 for (i=0; i<startMapLimit; i++) { 1524 UChar buf[3]; 1525 status = U_ZERO_ERROR; 1526 int32_t extractedLen = utext_extract(ut, i, i+1, buf, 3, &status); 1527 TEST_SUCCESS(status); 1528 TEST_ASSERT(extractedLen == exLen[i]); 1529 if (extractedLen > 0) { 1530 UChar32 c32; 1531 /* extractedLen-extractedLen == 0 is used to get around a compiler warning. */ 1532 U16_GET(buf, 0, extractedLen-extractedLen, extractedLen, c32); 1533 TEST_ASSERT(c32 == c32Map[i]); 1534 } 1535 } 1536 1537 utext_close(ut); 1538 } 1539 1540 1541 { // Similar test, with utf16 instead of utf8 1542 // TODO: merge the common parts of these tests. 1543 1544 UnicodeString u16str("\\u1000\\U00011000\\u2000\\U00022000", -1, US_INV); 1545 int32_t startMap[] ={ 0, 1, 1, 3, 4, 4, 6, 6}; 1546 int32_t nextMap[] = { 1, 3, 3, 4, 6, 6, 6, 6}; 1547 int32_t prevMap[] = { 0, 0, 0, 1, 3, 3, 4, 4}; 1548 UChar32 c32Map[] = {0x1000, 0x11000, 0x11000, 0x2000, 0x22000, 0x22000, -1, -1}; 1549 UChar32 pr32Map[] = { -1, 0x1000, 0x1000, 0x11000, 0x2000, 0x2000, 0x22000, 0x22000}; 1550 int32_t exLen[] = { 1, 0, 2, 1, 0, 2, 0, 0,}; 1551 1552 u16str = u16str.unescape(); 1553 UErrorCode status = U_ZERO_ERROR; 1554 UText *ut = utext_openUnicodeString(NULL, &u16str, &status); 1555 TEST_SUCCESS(status); 1556 1557 int32_t startMapLimit = sizeof(startMap) / sizeof(int32_t); 1558 int i; 1559 for (i=0; i<startMapLimit; i++) { 1560 utext_setNativeIndex(ut, i); 1561 int64_t cpIndex = utext_getNativeIndex(ut); 1562 TEST_ASSERT(cpIndex == startMap[i]); 1563 } 1564 1565 // Check char32At 1566 for (i=0; i<startMapLimit; i++) { 1567 UChar32 c32 = utext_char32At(ut, i); 1568 TEST_ASSERT(c32 == c32Map[i]); 1569 int64_t cpIndex = utext_getNativeIndex(ut); 1570 TEST_ASSERT(cpIndex == startMap[i]); 1571 } 1572 1573 // Check utext_next32From 1574 for (i=0; i<startMapLimit; i++) { 1575 UChar32 c32 = utext_next32From(ut, i); 1576 TEST_ASSERT(c32 == c32Map[i]); 1577 int64_t cpIndex = utext_getNativeIndex(ut); 1578 TEST_ASSERT(cpIndex == nextMap[i]); 1579 } 1580 1581 // check utext_previous32From 1582 for (i=0; i<startMapLimit; i++) { 1583 UChar32 c32 = utext_previous32From(ut, i); 1584 TEST_ASSERT(c32 == pr32Map[i]); 1585 int64_t cpIndex = utext_getNativeIndex(ut); 1586 TEST_ASSERT(cpIndex == prevMap[i]); 1587 } 1588 1589 // check Extract 1590 // Extract from i to i+1, which may be zero or one code points, 1591 // depending on whether the indices straddle a cp boundary. 1592 for (i=0; i<startMapLimit; i++) { 1593 UChar buf[3]; 1594 status = U_ZERO_ERROR; 1595 int32_t extractedLen = utext_extract(ut, i, i+1, buf, 3, &status); 1596 TEST_SUCCESS(status); 1597 TEST_ASSERT(extractedLen == exLen[i]); 1598 if (extractedLen > 0) { 1599 UChar32 c32; 1600 /* extractedLen-extractedLen == 0 is used to get around a compiler warning. */ 1601 U16_GET(buf, 0, extractedLen-extractedLen, extractedLen, c32); 1602 TEST_ASSERT(c32 == c32Map[i]); 1603 } 1604 } 1605 1606 utext_close(ut); 1607 } 1608 1609 { // Similar test, with UText over Replaceable 1610 // TODO: merge the common parts of these tests. 1611 1612 UnicodeString u16str("\\u1000\\U00011000\\u2000\\U00022000", -1, US_INV); 1613 int32_t startMap[] ={ 0, 1, 1, 3, 4, 4, 6, 6}; 1614 int32_t nextMap[] = { 1, 3, 3, 4, 6, 6, 6, 6}; 1615 int32_t prevMap[] = { 0, 0, 0, 1, 3, 3, 4, 4}; 1616 UChar32 c32Map[] = {0x1000, 0x11000, 0x11000, 0x2000, 0x22000, 0x22000, -1, -1}; 1617 UChar32 pr32Map[] = { -1, 0x1000, 0x1000, 0x11000, 0x2000, 0x2000, 0x22000, 0x22000}; 1618 int32_t exLen[] = { 1, 0, 2, 1, 0, 2, 0, 0,}; 1619 1620 u16str = u16str.unescape(); 1621 UErrorCode status = U_ZERO_ERROR; 1622 UText *ut = utext_openReplaceable(NULL, &u16str, &status); 1623 TEST_SUCCESS(status); 1624 1625 int32_t startMapLimit = sizeof(startMap) / sizeof(int32_t); 1626 int i; 1627 for (i=0; i<startMapLimit; i++) { 1628 utext_setNativeIndex(ut, i); 1629 int64_t cpIndex = utext_getNativeIndex(ut); 1630 TEST_ASSERT(cpIndex == startMap[i]); 1631 } 1632 1633 // Check char32At 1634 for (i=0; i<startMapLimit; i++) { 1635 UChar32 c32 = utext_char32At(ut, i); 1636 TEST_ASSERT(c32 == c32Map[i]); 1637 int64_t cpIndex = utext_getNativeIndex(ut); 1638 TEST_ASSERT(cpIndex == startMap[i]); 1639 } 1640 1641 // Check utext_next32From 1642 for (i=0; i<startMapLimit; i++) { 1643 UChar32 c32 = utext_next32From(ut, i); 1644 TEST_ASSERT(c32 == c32Map[i]); 1645 int64_t cpIndex = utext_getNativeIndex(ut); 1646 TEST_ASSERT(cpIndex == nextMap[i]); 1647 } 1648 1649 // check utext_previous32From 1650 for (i=0; i<startMapLimit; i++) { 1651 UChar32 c32 = utext_previous32From(ut, i); 1652 TEST_ASSERT(c32 == pr32Map[i]); 1653 int64_t cpIndex = utext_getNativeIndex(ut); 1654 TEST_ASSERT(cpIndex == prevMap[i]); 1655 } 1656 1657 // check Extract 1658 // Extract from i to i+1, which may be zero or one code points, 1659 // depending on whether the indices straddle a cp boundary. 1660 for (i=0; i<startMapLimit; i++) { 1661 UChar buf[3]; 1662 status = U_ZERO_ERROR; 1663 int32_t extractedLen = utext_extract(ut, i, i+1, buf, 3, &status); 1664 TEST_SUCCESS(status); 1665 TEST_ASSERT(extractedLen == exLen[i]); 1666 if (extractedLen > 0) { 1667 UChar32 c32; 1668 /* extractedLen-extractedLen == 0 is used to get around a compiler warning. */ 1669 U16_GET(buf, 0, extractedLen-extractedLen, extractedLen, c32); 1670 TEST_ASSERT(c32 == c32Map[i]); 1671 } 1672 } 1673 1674 utext_close(ut); 1675 } 1676 } 1677 1678 1679 void UTextTest::FreezeTest() { 1680 // Check isWritable() and freeze() behavior. 1681 // 1682 1683 UnicodeString ustr("Hello, World."); 1684 const char u8str[] = {char(0x31), (char)0x32, (char)0x33, 0}; 1685 const UChar u16str[] = {(UChar)0x31, (UChar)0x32, (UChar)0x44, 0}; 1686 1687 UErrorCode status = U_ZERO_ERROR; 1688 UText *ut = NULL; 1689 UText *ut2 = NULL; 1690 1691 ut = utext_openUTF8(ut, u8str, -1, &status); 1692 TEST_SUCCESS(status); 1693 UBool writable = utext_isWritable(ut); 1694 TEST_ASSERT(writable == FALSE); 1695 utext_copy(ut, 1, 2, 0, TRUE, &status); 1696 TEST_ASSERT(status == U_NO_WRITE_PERMISSION); 1697 1698 status = U_ZERO_ERROR; 1699 ut = utext_openUChars(ut, u16str, -1, &status); 1700 TEST_SUCCESS(status); 1701 writable = utext_isWritable(ut); 1702 TEST_ASSERT(writable == FALSE); 1703 utext_copy(ut, 1, 2, 0, TRUE, &status); 1704 TEST_ASSERT(status == U_NO_WRITE_PERMISSION); 1705 1706 status = U_ZERO_ERROR; 1707 ut = utext_openUnicodeString(ut, &ustr, &status); 1708 TEST_SUCCESS(status); 1709 writable = utext_isWritable(ut); 1710 TEST_ASSERT(writable == TRUE); 1711 utext_freeze(ut); 1712 writable = utext_isWritable(ut); 1713 TEST_ASSERT(writable == FALSE); 1714 utext_copy(ut, 1, 2, 0, TRUE, &status); 1715 TEST_ASSERT(status == U_NO_WRITE_PERMISSION); 1716 1717 status = U_ZERO_ERROR; 1718 ut = utext_openUnicodeString(ut, &ustr, &status); 1719 TEST_SUCCESS(status); 1720 ut2 = utext_clone(ut2, ut, FALSE, FALSE, &status); // clone with readonly = false 1721 TEST_SUCCESS(status); 1722 writable = utext_isWritable(ut2); 1723 TEST_ASSERT(writable == TRUE); 1724 ut2 = utext_clone(ut2, ut, FALSE, TRUE, &status); // clone with readonly = true 1725 TEST_SUCCESS(status); 1726 writable = utext_isWritable(ut2); 1727 TEST_ASSERT(writable == FALSE); 1728 utext_copy(ut2, 1, 2, 0, TRUE, &status); 1729 TEST_ASSERT(status == U_NO_WRITE_PERMISSION); 1730 1731 status = U_ZERO_ERROR; 1732 ut = utext_openConstUnicodeString(ut, (const UnicodeString *)&ustr, &status); 1733 TEST_SUCCESS(status); 1734 writable = utext_isWritable(ut); 1735 TEST_ASSERT(writable == FALSE); 1736 utext_copy(ut, 1, 2, 0, TRUE, &status); 1737 TEST_ASSERT(status == U_NO_WRITE_PERMISSION); 1738 1739 // Deep Clone of a frozen UText should re-enable writing in the copy. 1740 status = U_ZERO_ERROR; 1741 ut = utext_openUnicodeString(ut, &ustr, &status); 1742 TEST_SUCCESS(status); 1743 utext_freeze(ut); 1744 ut2 = utext_clone(ut2, ut, TRUE, FALSE, &status); // deep clone 1745 TEST_SUCCESS(status); 1746 writable = utext_isWritable(ut2); 1747 TEST_ASSERT(writable == TRUE); 1748 1749 1750 // Deep clone of a frozen UText, where the base type is intrinsically non-writable, 1751 // should NOT enable writing in the copy. 1752 status = U_ZERO_ERROR; 1753 ut = utext_openUChars(ut, u16str, -1, &status); 1754 TEST_SUCCESS(status); 1755 utext_freeze(ut); 1756 ut2 = utext_clone(ut2, ut, TRUE, FALSE, &status); // deep clone 1757 TEST_SUCCESS(status); 1758 writable = utext_isWritable(ut2); 1759 TEST_ASSERT(writable == FALSE); 1760 1761 // cleanup 1762 utext_close(ut); 1763 utext_close(ut2); 1764 } 1765 1766 1767 // 1768 // Fragmented UText 1769 // A UText type that works with a chunk size of 1. 1770 // Intended to test for edge cases. 1771 // Input comes from a UnicodeString. 1772 // 1773 // ut.b the character. Put into both halves. 1774 // 1775 1776 U_CDECL_BEGIN 1777 static UBool U_CALLCONV 1778 fragTextAccess(UText *ut, int64_t index, UBool forward) { 1779 const UnicodeString *us = (const UnicodeString *)ut->context; 1780 UChar c; 1781 int32_t length = us->length(); 1782 if (forward && index>=0 && index<length) { 1783 c = us->charAt((int32_t)index); 1784 ut->b = c | c<<16; 1785 ut->chunkOffset = 0; 1786 ut->chunkLength = 1; 1787 ut->chunkNativeStart = index; 1788 ut->chunkNativeLimit = index+1; 1789 return true; 1790 } 1791 if (!forward && index>0 && index <=length) { 1792 c = us->charAt((int32_t)index-1); 1793 ut->b = c | c<<16; 1794 ut->chunkOffset = 1; 1795 ut->chunkLength = 1; 1796 ut->chunkNativeStart = index-1; 1797 ut->chunkNativeLimit = index; 1798 return true; 1799 } 1800 ut->b = 0; 1801 ut->chunkOffset = 0; 1802 ut->chunkLength = 0; 1803 if (index <= 0) { 1804 ut->chunkNativeStart = 0; 1805 ut->chunkNativeLimit = 0; 1806 } else { 1807 ut->chunkNativeStart = length; 1808 ut->chunkNativeLimit = length; 1809 } 1810 return false; 1811 } 1812 1813 // Function table to be used with this fragmented text provider. 1814 // Initialized in the open function. 1815 static UTextFuncs fragmentFuncs; 1816 1817 // Clone function for fragmented text provider. 1818 // Didn't really want to provide this, but it's easier to provide it than to keep it 1819 // out of the tests. 1820 // 1821 UText * 1822 cloneFragmentedUnicodeString(UText *dest, const UText *src, UBool deep, UErrorCode *status) { 1823 if (U_FAILURE(*status)) { 1824 return NULL; 1825 } 1826 if (deep) { 1827 *status = U_UNSUPPORTED_ERROR; 1828 return NULL; 1829 } 1830 dest = utext_openUnicodeString(dest, (UnicodeString *)src->context, status); 1831 utext_setNativeIndex(dest, utext_getNativeIndex(src)); 1832 return dest; 1833 } 1834 1835 U_CDECL_END 1836 1837 // Open function for the fragmented text provider. 1838 UText * 1839 openFragmentedUnicodeString(UText *ut, UnicodeString *s, UErrorCode *status) { 1840 ut = utext_openUnicodeString(ut, s, status); 1841 if (U_FAILURE(*status)) { 1842 return ut; 1843 } 1844 1845 // Copy of the function table from the stock UnicodeString UText, 1846 // and replace the entry for the access function. 1847 memcpy(&fragmentFuncs, ut->pFuncs, sizeof(fragmentFuncs)); 1848 fragmentFuncs.access = fragTextAccess; 1849 fragmentFuncs.clone = cloneFragmentedUnicodeString; 1850 ut->pFuncs = &fragmentFuncs; 1851 1852 ut->chunkContents = (UChar *)&ut->b; 1853 ut->pFuncs->access(ut, 0, TRUE); 1854 return ut; 1855 } 1856 1857 // Regression test for Ticket 5560 1858 // Clone fails to update chunkContentPointer in the cloned copy. 1859 // This is only an issue for UText types that work in a local buffer, 1860 // (UTF-8 wrapper, for example) 1861 // 1862 // The test: 1863 // 1. Create an inital UText 1864 // 2. Deep clone it. Contents should match original. 1865 // 3. Reset original to something different. 1866 // 4. Check that clone contents did not change. 1867 // 1868 void UTextTest::Ticket5560() { 1869 /* The following two strings are in UTF-8 even on EBCDIC platforms. */ 1870 static const char s1[] = {0x41,0x42,0x43,0x44,0x45,0x46,0}; /* "ABCDEF" */ 1871 static const char s2[] = {0x31,0x32,0x33,0x34,0x35,0x36,0}; /* "123456" */ 1872 UErrorCode status = U_ZERO_ERROR; 1873 1874 UText ut1 = UTEXT_INITIALIZER; 1875 UText ut2 = UTEXT_INITIALIZER; 1876 1877 utext_openUTF8(&ut1, s1, -1, &status); 1878 UChar c = utext_next32(&ut1); 1879 TEST_ASSERT(c == 0x41); // c == 'A' 1880 1881 utext_clone(&ut2, &ut1, TRUE, FALSE, &status); 1882 TEST_SUCCESS(status); 1883 c = utext_next32(&ut2); 1884 TEST_ASSERT(c == 0x42); // c == 'B' 1885 c = utext_next32(&ut1); 1886 TEST_ASSERT(c == 0x42); // c == 'B' 1887 1888 utext_openUTF8(&ut1, s2, -1, &status); 1889 c = utext_next32(&ut1); 1890 TEST_ASSERT(c == 0x31); // c == '1' 1891 c = utext_next32(&ut2); 1892 TEST_ASSERT(c == 0x43); // c == 'C' 1893 1894 utext_close(&ut1); 1895 utext_close(&ut2); 1896 } 1897 1898 1899 // Test for Ticket 6847 1900 // 1901 void UTextTest::Ticket6847() { 1902 const int STRLEN = 90; 1903 UChar s[STRLEN+1]; 1904 u_memset(s, 0x41, STRLEN); 1905 s[STRLEN] = 0; 1906 1907 UErrorCode status = U_ZERO_ERROR; 1908 UText *ut = utext_openUChars(NULL, s, -1, &status); 1909 1910 utext_setNativeIndex(ut, 0); 1911 int32_t count = 0; 1912 UChar32 c = 0; 1913 int64_t nativeIndex = UTEXT_GETNATIVEINDEX(ut); 1914 TEST_ASSERT(nativeIndex == 0); 1915 while ((c = utext_next32(ut)) != U_SENTINEL) { 1916 TEST_ASSERT(c == 0x41); 1917 TEST_ASSERT(count < STRLEN); 1918 if (count >= STRLEN) { 1919 break; 1920 } 1921 count++; 1922 nativeIndex = UTEXT_GETNATIVEINDEX(ut); 1923 TEST_ASSERT(nativeIndex == count); 1924 } 1925 TEST_ASSERT(count == STRLEN); 1926 nativeIndex = UTEXT_GETNATIVEINDEX(ut); 1927 TEST_ASSERT(nativeIndex == STRLEN); 1928 utext_close(ut); 1929 } 1930 1931
