1 // Copyright (C) 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /******************************************************************** 4 * COPYRIGHT: 5 * Copyright (c) 1997-2016, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ********************************************************************/ 8 9 10 /** 11 * IntlTestUtilities is the medium level test class for everything in the directory "utility". 12 */ 13 14 #include "unicode/utypes.h" 15 #include "unicode/errorcode.h" 16 #include "unicode/localpointer.h" 17 #include "charstr.h" 18 #include "itutil.h" 19 #include "strtest.h" 20 #include "loctest.h" 21 #include "citrtest.h" 22 #include "ustrtest.h" 23 #include "ucdtest.h" 24 #include "restest.h" 25 #include "restsnew.h" 26 #include "tsmthred.h" 27 #include "tsputil.h" 28 #include "uobjtest.h" 29 #include "utxttest.h" 30 #include "v32test.h" 31 #include "uvectest.h" 32 #include "aliastst.h" 33 #include "usettest.h" 34 35 extern IntlTest *createBytesTrieTest(); 36 static IntlTest *createLocalPointerTest(); 37 extern IntlTest *createUCharsTrieTest(); 38 static IntlTest *createEnumSetTest(); 39 extern IntlTest *createSimpleFormatterTest(); 40 extern IntlTest *createUnifiedCacheTest(); 41 extern IntlTest *createQuantityFormatterTest(); 42 extern IntlTest *createPluralMapTest(); 43 44 45 #define CASE(id, test) case id: \ 46 name = #test; \ 47 if (exec) { \ 48 logln(#test "---"); logln(); \ 49 test t; \ 50 callTest(t, par); \ 51 } \ 52 break 53 54 void IntlTestUtilities::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par ) 55 { 56 if (exec) logln("TestSuite Utilities: "); 57 switch (index) { 58 CASE(0, MultithreadTest); 59 CASE(1, StringTest); 60 CASE(2, UnicodeStringTest); 61 CASE(3, LocaleTest); 62 CASE(4, CharIterTest); 63 CASE(5, UObjectTest); 64 CASE(6, UnicodeTest); 65 CASE(7, ResourceBundleTest); 66 CASE(8, NewResourceBundleTest); 67 CASE(9, PUtilTest); 68 CASE(10, UVector32Test); 69 CASE(11, UVectorTest); 70 CASE(12, UTextTest); 71 CASE(13, LocaleAliasTest); 72 CASE(14, UnicodeSetTest); 73 CASE(15, ErrorCodeTest); 74 case 16: 75 name = "LocalPointerTest"; 76 if (exec) { 77 logln("TestSuite LocalPointerTest---"); logln(); 78 LocalPointer<IntlTest> test(createLocalPointerTest()); 79 callTest(*test, par); 80 } 81 break; 82 case 17: 83 name = "BytesTrieTest"; 84 if (exec) { 85 logln("TestSuite BytesTrieTest---"); logln(); 86 LocalPointer<IntlTest> test(createBytesTrieTest()); 87 callTest(*test, par); 88 } 89 break; 90 case 18: 91 name = "UCharsTrieTest"; 92 if (exec) { 93 logln("TestSuite UCharsTrieTest---"); logln(); 94 LocalPointer<IntlTest> test(createUCharsTrieTest()); 95 callTest(*test, par); 96 } 97 break; 98 case 19: 99 name = "EnumSetTest"; 100 if (exec) { 101 logln("TestSuite EnumSetTest---"); logln(); 102 LocalPointer<IntlTest> test(createEnumSetTest()); 103 callTest(*test, par); 104 } 105 break; 106 case 20: 107 name = "SimpleFormatterTest"; 108 if (exec) { 109 logln("TestSuite SimpleFormatterTest---"); logln(); 110 LocalPointer<IntlTest> test(createSimpleFormatterTest()); 111 callTest(*test, par); 112 } 113 break; 114 case 21: 115 name = "UnifiedCacheTest"; 116 if (exec) { 117 logln("TestSuite UnifiedCacheTest---"); logln(); 118 LocalPointer<IntlTest> test(createUnifiedCacheTest()); 119 callTest(*test, par); 120 } 121 break; 122 case 22: 123 name = "QuantityFormatterTest"; 124 if (exec) { 125 logln("TestSuite QuantityFormatterTest---"); logln(); 126 LocalPointer<IntlTest> test(createQuantityFormatterTest()); 127 callTest(*test, par); 128 } 129 break; 130 case 23: 131 name = "PluralMapTest"; 132 if (exec) { 133 logln("TestSuite PluralMapTest---"); logln(); 134 LocalPointer<IntlTest> test(createPluralMapTest()); 135 callTest(*test, par); 136 } 137 break; 138 default: name = ""; break; //needed to end loop 139 } 140 } 141 142 void ErrorCodeTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) { 143 if (exec) logln("TestSuite Utilities: "); 144 switch (index) { 145 case 0: name = "TestErrorCode"; if (exec) TestErrorCode(); break; 146 case 1: name = "TestSubclass"; if (exec) TestSubclass(); break; 147 default: name = ""; break; //needed to end loop 148 } 149 } 150 151 static void RefPlusOne(UErrorCode &code) { code=(UErrorCode)(code+1); } 152 static void PtrPlusTwo(UErrorCode *code) { *code=(UErrorCode)(*code+2); } 153 154 void ErrorCodeTest::TestErrorCode() { 155 ErrorCode errorCode; 156 if(errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure()) { 157 errln("ErrorCode did not initialize properly"); 158 return; 159 } 160 errorCode.assertSuccess(); 161 if(errorCode.errorName()!=u_errorName(U_ZERO_ERROR)) { 162 errln("ErrorCode did not format error message string properly"); 163 } 164 RefPlusOne(errorCode); 165 if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) { 166 errln("ErrorCode did not yield a writable reference"); 167 } 168 PtrPlusTwo(errorCode); 169 if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) { 170 errln("ErrorCode did not yield a writable pointer"); 171 } 172 errorCode.set(U_PARSE_ERROR); 173 if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) { 174 errln("ErrorCode.set() failed"); 175 } 176 if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR || 177 !errorCode.isSuccess() || errorCode.isFailure() 178 ) { 179 errln("ErrorCode did not reset properly"); 180 } 181 } 182 183 class MyErrorCode: public ErrorCode { 184 public: 185 MyErrorCode(int32_t &countChecks, int32_t &countDests) 186 : checks(countChecks), dests(countDests) {} 187 ~MyErrorCode() { 188 if(isFailure()) { 189 ++dests; 190 } 191 } 192 private: 193 virtual void handleFailure() const { 194 ++checks; 195 } 196 int32_t &checks; 197 int32_t &dests; 198 }; 199 200 void ErrorCodeTest::TestSubclass() { 201 int32_t countChecks=0; 202 int32_t countDests=0; 203 { 204 MyErrorCode errorCode(countChecks, countDests); 205 if( errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure() || 206 countChecks!=0 || countDests!=0 207 ) { 208 errln("ErrorCode did not initialize properly"); 209 return; 210 } 211 errorCode.assertSuccess(); 212 if(countChecks!=0) { 213 errln("ErrorCode.assertSuccess() called handleFailure() despite success"); 214 } 215 RefPlusOne(errorCode); 216 if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) { 217 errln("ErrorCode did not yield a writable reference"); 218 } 219 errorCode.assertSuccess(); 220 if(countChecks!=1) { 221 errln("ErrorCode.assertSuccess() did not handleFailure()"); 222 } 223 PtrPlusTwo(errorCode); 224 if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) { 225 errln("ErrorCode did not yield a writable pointer"); 226 } 227 errorCode.assertSuccess(); 228 if(countChecks!=2) { 229 errln("ErrorCode.assertSuccess() did not handleFailure()"); 230 } 231 errorCode.set(U_PARSE_ERROR); 232 if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) { 233 errln("ErrorCode.set() failed"); 234 } 235 if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR || 236 !errorCode.isSuccess() || errorCode.isFailure() 237 ) { 238 errln("ErrorCode did not reset properly"); 239 } 240 errorCode.assertSuccess(); 241 if(countChecks!=2) { 242 errln("ErrorCode.assertSuccess() called handleFailure() despite success"); 243 } 244 } 245 if(countDests!=0) { 246 errln("MyErrorCode destructor detected failure despite success"); 247 } 248 countChecks=countDests=0; 249 { 250 MyErrorCode errorCode(countChecks, countDests); 251 errorCode.set(U_PARSE_ERROR); 252 } 253 if(countDests!=1) { 254 errln("MyErrorCode destructor failed to detect failure"); 255 } 256 } 257 258 class LocalPointerTest : public IntlTest { 259 public: 260 LocalPointerTest() {} 261 262 void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL); 263 264 void TestLocalPointer(); 265 void TestLocalPointerMoveSwap(); 266 void TestLocalArray(); 267 void TestLocalArrayMoveSwap(); 268 void TestLocalXyzPointer(); 269 void TestLocalXyzPointerMoveSwap(); 270 void TestLocalXyzPointerNull(); 271 }; 272 273 static IntlTest *createLocalPointerTest() { 274 return new LocalPointerTest(); 275 } 276 277 void LocalPointerTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) { 278 if(exec) { 279 logln("TestSuite LocalPointerTest: "); 280 } 281 TESTCASE_AUTO_BEGIN; 282 TESTCASE_AUTO(TestLocalPointer); 283 TESTCASE_AUTO(TestLocalPointerMoveSwap); 284 TESTCASE_AUTO(TestLocalArray); 285 TESTCASE_AUTO(TestLocalArrayMoveSwap); 286 TESTCASE_AUTO(TestLocalXyzPointer); 287 TESTCASE_AUTO(TestLocalXyzPointerMoveSwap); 288 TESTCASE_AUTO(TestLocalXyzPointerNull); 289 TESTCASE_AUTO_END; 290 } 291 292 // Exercise almost every LocalPointer and LocalPointerBase method. 293 void LocalPointerTest::TestLocalPointer() { 294 // constructor 295 LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005)); 296 // isNULL(), isValid(), operator==(), operator!=() 297 if(s.isNull() || !s.isValid() || s==NULL || !(s!=NULL)) { 298 errln("LocalPointer constructor or NULL test failure"); 299 return; 300 } 301 // getAlias(), operator->, operator* 302 if(s.getAlias()->length()!=2 || s->length()!=2 || (*s).length()!=2) { 303 errln("LocalPointer access failure"); 304 } 305 // adoptInstead(), orphan() 306 s.adoptInstead(new UnicodeString((UChar)0xfffc)); 307 if(s->length()!=1) { 308 errln("LocalPointer adoptInstead(U+FFFC) failure"); 309 } 310 UnicodeString *orphan=s.orphan(); 311 if(orphan==NULL || orphan->length()!=1 || s.isValid() || s!=NULL) { 312 errln("LocalPointer orphan() failure"); 313 } 314 delete orphan; 315 s.adoptInstead(new UnicodeString()); 316 if(s->length()!=0) { 317 errln("LocalPointer adoptInstead(empty) failure"); 318 } 319 320 // LocalPointer(p, errorCode) sets U_MEMORY_ALLOCATION_ERROR if p==NULL. 321 UErrorCode errorCode = U_ZERO_ERROR; 322 LocalPointer<CharString> csx(new CharString("some chars", errorCode), errorCode); 323 if(csx.isNull() && U_SUCCESS(errorCode)) { 324 errln("LocalPointer(p, errorCode) failure"); 325 return; 326 } 327 errorCode = U_ZERO_ERROR; 328 csx.adoptInsteadAndCheckErrorCode(new CharString("different chars", errorCode), errorCode); 329 if(csx.isNull() && U_SUCCESS(errorCode)) { 330 errln("adoptInsteadAndCheckErrorCode(p, errorCode) failure"); 331 return; 332 } 333 // Incoming failure: Keep the current object and delete the input object. 334 errorCode = U_ILLEGAL_ARGUMENT_ERROR; 335 csx.adoptInsteadAndCheckErrorCode(new CharString("unused", errorCode), errorCode); 336 if(csx.isValid() && strcmp(csx->data(), "different chars") != 0) { 337 errln("adoptInsteadAndCheckErrorCode(p, U_FAILURE) did not retain the old object"); 338 return; 339 } 340 errorCode = U_ZERO_ERROR; 341 csx.adoptInsteadAndCheckErrorCode(NULL, errorCode); 342 if(errorCode != U_MEMORY_ALLOCATION_ERROR) { 343 errln("adoptInsteadAndCheckErrorCode(NULL, errorCode) did not set U_MEMORY_ALLOCATION_ERROR"); 344 return; 345 } 346 if(csx.isValid()) { 347 errln("adoptInsteadAndCheckErrorCode(NULL, errorCode) kept the object"); 348 return; 349 } 350 errorCode = U_ZERO_ERROR; 351 LocalPointer<CharString> null(NULL, errorCode); 352 if(errorCode != U_MEMORY_ALLOCATION_ERROR) { 353 errln("LocalPointer(NULL, errorCode) did not set U_MEMORY_ALLOCATION_ERROR"); 354 return; 355 } 356 357 // destructor 358 } 359 360 void LocalPointerTest::TestLocalPointerMoveSwap() { 361 UnicodeString *p1 = new UnicodeString((UChar)0x61); 362 UnicodeString *p2 = new UnicodeString((UChar)0x62); 363 LocalPointer<UnicodeString> s1(p1); 364 LocalPointer<UnicodeString> s2(p2); 365 s1.swap(s2); 366 if(s1.getAlias() != p2 || s2.getAlias() != p1) { 367 errln("LocalPointer.swap() did not swap"); 368 } 369 swap(s1, s2); 370 if(s1.getAlias() != p1 || s2.getAlias() != p2) { 371 errln("swap(LocalPointer) did not swap back"); 372 } 373 LocalPointer<UnicodeString> s3; 374 s3.moveFrom(s1); 375 if(s3.getAlias() != p1 || s1.isValid()) { 376 errln("LocalPointer.moveFrom() did not move"); 377 } 378 #if U_HAVE_RVALUE_REFERENCES 379 infoln("TestLocalPointerMoveSwap() with rvalue references"); 380 s1 = static_cast<LocalPointer<UnicodeString> &&>(s3); 381 if(s1.getAlias() != p1 || s3.isValid()) { 382 errln("LocalPointer move assignment operator did not move"); 383 } 384 LocalPointer<UnicodeString> s4(static_cast<LocalPointer<UnicodeString> &&>(s2)); 385 if(s4.getAlias() != p2 || s2.isValid()) { 386 errln("LocalPointer move constructor did not move"); 387 } 388 #else 389 infoln("TestLocalPointerMoveSwap() without rvalue references"); 390 #endif 391 392 // Move self assignment leaves the object valid but in an undefined state. 393 // Do it to make sure there is no crash, 394 // but do not check for any particular resulting value. 395 s1.moveFrom(s1); 396 s3.moveFrom(s3); 397 } 398 399 // Exercise almost every LocalArray method (but not LocalPointerBase). 400 void LocalPointerTest::TestLocalArray() { 401 // constructor 402 LocalArray<UnicodeString> a(new UnicodeString[2]); 403 // operator[]() 404 a[0].append((UChar)0x61); 405 a[1].append((UChar32)0x60006); 406 if(a[0].length()!=1 || a[1].length()!=2) { 407 errln("LocalArray access failure"); 408 } 409 // adoptInstead() 410 a.adoptInstead(new UnicodeString[4]); 411 a[3].append((UChar)0x62).append((UChar)0x63).reverse(); 412 if(a[3].length()!=2 || a[3][1]!=0x62) { 413 errln("LocalArray adoptInstead() failure"); 414 } 415 416 // LocalArray(p, errorCode) sets U_MEMORY_ALLOCATION_ERROR if p==NULL. 417 UErrorCode errorCode = U_ZERO_ERROR; 418 LocalArray<UnicodeString> ua(new UnicodeString[3], errorCode); 419 if(ua.isNull() && U_SUCCESS(errorCode)) { 420 errln("LocalArray(p, errorCode) failure"); 421 return; 422 } 423 errorCode = U_ZERO_ERROR; 424 UnicodeString *u4 = new UnicodeString[4]; 425 ua.adoptInsteadAndCheckErrorCode(u4, errorCode); 426 if(ua.isNull() && U_SUCCESS(errorCode)) { 427 errln("adoptInsteadAndCheckErrorCode(p, errorCode) failure"); 428 return; 429 } 430 // Incoming failure: Keep the current object and delete the input object. 431 errorCode = U_ILLEGAL_ARGUMENT_ERROR; 432 ua.adoptInsteadAndCheckErrorCode(new UnicodeString[5], errorCode); 433 if(ua.isValid() && ua.getAlias() != u4) { 434 errln("adoptInsteadAndCheckErrorCode(p, U_FAILURE) did not retain the old array"); 435 return; 436 } 437 errorCode = U_ZERO_ERROR; 438 ua.adoptInsteadAndCheckErrorCode(NULL, errorCode); 439 if(errorCode != U_MEMORY_ALLOCATION_ERROR) { 440 errln("adoptInsteadAndCheckErrorCode(NULL, errorCode) did not set U_MEMORY_ALLOCATION_ERROR"); 441 return; 442 } 443 if(ua.isValid()) { 444 errln("adoptInsteadAndCheckErrorCode(NULL, errorCode) kept the array"); 445 return; 446 } 447 errorCode = U_ZERO_ERROR; 448 LocalArray<UnicodeString> null(NULL, errorCode); 449 if(errorCode != U_MEMORY_ALLOCATION_ERROR) { 450 errln("LocalArray(NULL, errorCode) did not set U_MEMORY_ALLOCATION_ERROR"); 451 return; 452 } 453 454 // destructor 455 } 456 457 void LocalPointerTest::TestLocalArrayMoveSwap() { 458 UnicodeString *p1 = new UnicodeString[2]; 459 UnicodeString *p2 = new UnicodeString[3]; 460 LocalArray<UnicodeString> a1(p1); 461 LocalArray<UnicodeString> a2(p2); 462 a1.swap(a2); 463 if(a1.getAlias() != p2 || a2.getAlias() != p1) { 464 errln("LocalArray.swap() did not swap"); 465 } 466 swap(a1, a2); 467 if(a1.getAlias() != p1 || a2.getAlias() != p2) { 468 errln("swap(LocalArray) did not swap back"); 469 } 470 LocalArray<UnicodeString> a3; 471 a3.moveFrom(a1); 472 if(a3.getAlias() != p1 || a1.isValid()) { 473 errln("LocalArray.moveFrom() did not move"); 474 } 475 #if U_HAVE_RVALUE_REFERENCES 476 infoln("TestLocalArrayMoveSwap() with rvalue references"); 477 a1 = static_cast<LocalArray<UnicodeString> &&>(a3); 478 if(a1.getAlias() != p1 || a3.isValid()) { 479 errln("LocalArray move assignment operator did not move"); 480 } 481 LocalArray<UnicodeString> a4(static_cast<LocalArray<UnicodeString> &&>(a2)); 482 if(a4.getAlias() != p2 || a2.isValid()) { 483 errln("LocalArray move constructor did not move"); 484 } 485 #else 486 infoln("TestLocalArrayMoveSwap() without rvalue references"); 487 #endif 488 489 // Move self assignment leaves the object valid but in an undefined state. 490 // Do it to make sure there is no crash, 491 // but do not check for any particular resulting value. 492 a1.moveFrom(a1); 493 a3.moveFrom(a3); 494 } 495 496 #include "unicode/ucnvsel.h" 497 #include "unicode/ucal.h" 498 #include "unicode/udatpg.h" 499 #include "unicode/uidna.h" 500 #include "unicode/uldnames.h" 501 #include "unicode/umsg.h" 502 #include "unicode/unorm2.h" 503 #include "unicode/uregex.h" 504 #include "unicode/utrans.h" 505 506 // Use LocalXyzPointer types that are not covered elsewhere in the intltest suite. 507 void LocalPointerTest::TestLocalXyzPointer() { 508 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointer"); 509 510 static const char *const encoding="ISO-8859-1"; 511 LocalUConverterSelectorPointer sel( 512 ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode)); 513 if(errorCode.logIfFailureAndReset("ucnvsel_open()")) { 514 return; 515 } 516 if(sel.isNull()) { 517 errln("LocalUConverterSelectorPointer failure"); 518 return; 519 } 520 521 #if !UCONFIG_NO_FORMATTING 522 LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode)); 523 if(errorCode.logDataIfFailureAndReset("ucal_open()")) { 524 return; 525 } 526 if(cal.isNull()) { 527 errln("LocalUCalendarPointer failure"); 528 return; 529 } 530 531 LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode)); 532 if(errorCode.logDataIfFailureAndReset("udatpg_open()")) { 533 return; 534 } 535 if(patgen.isNull()) { 536 errln("LocalUDateTimePatternGeneratorPointer failure"); 537 return; 538 } 539 540 LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode)); 541 if(errorCode.logIfFailureAndReset("uldn_open()")) { 542 return; 543 } 544 if(ldn.isNull()) { 545 errln("LocalULocaleDisplayNamesPointer failure"); 546 return; 547 } 548 549 UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!"); 550 LocalUMessageFormatPointer msg( 551 umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode)); 552 if(errorCode.logIfFailureAndReset("umsg_open()")) { 553 return; 554 } 555 if(msg.isNull()) { 556 errln("LocalUMessageFormatPointer failure"); 557 return; 558 } 559 #endif /* UCONFIG_NO_FORMATTING */ 560 561 #if !UCONFIG_NO_NORMALIZATION 562 const UNormalizer2 *nfc=unorm2_getNFCInstance(errorCode); 563 UnicodeSet emptySet; 564 LocalUNormalizer2Pointer fn2(unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode)); 565 if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) { 566 return; 567 } 568 if(fn2.isNull()) { 569 errln("LocalUNormalizer2Pointer failure"); 570 return; 571 } 572 #endif /* !UCONFIG_NO_NORMALIZATION */ 573 574 #if !UCONFIG_NO_IDNA 575 LocalUIDNAPointer idna(uidna_openUTS46(0, errorCode)); 576 if(errorCode.logIfFailureAndReset("uidna_openUTS46()")) { 577 return; 578 } 579 if(idna.isNull()) { 580 errln("LocalUIDNAPointer failure"); 581 return; 582 } 583 #endif /* !UCONFIG_NO_IDNA */ 584 585 #if !UCONFIG_NO_REGULAR_EXPRESSIONS 586 UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z"); 587 LocalURegularExpressionPointer regex( 588 uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode)); 589 if(errorCode.logIfFailureAndReset("uregex_open()")) { 590 return; 591 } 592 if(regex.isNull()) { 593 errln("LocalURegularExpressionPointer failure"); 594 return; 595 } 596 #endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */ 597 598 #if !UCONFIG_NO_TRANSLITERATION 599 UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn"); 600 LocalUTransliteratorPointer trans( 601 utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode)); 602 if(errorCode.logIfFailureAndReset("utrans_open()")) { 603 return; 604 } 605 if(trans.isNull()) { 606 errln("LocalUTransliteratorPointer failure"); 607 return; 608 } 609 #endif /* !UCONFIG_NO_TRANSLITERATION */ 610 611 // destructors 612 } 613 614 void LocalPointerTest::TestLocalXyzPointerMoveSwap() { 615 #if !UCONFIG_NO_NORMALIZATION 616 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerMoveSwap"); 617 const UNormalizer2 *nfc=unorm2_getNFCInstance(errorCode); 618 const UNormalizer2 *nfd=unorm2_getNFDInstance(errorCode); 619 if(errorCode.logIfFailureAndReset("unorm2_getNF[CD]Instance()")) { 620 return; 621 } 622 UnicodeSet emptySet; 623 UNormalizer2 *p1 = unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode); 624 UNormalizer2 *p2 = unorm2_openFiltered(nfd, emptySet.toUSet(), errorCode); 625 LocalUNormalizer2Pointer f1(p1); 626 LocalUNormalizer2Pointer f2(p2); 627 if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) { 628 return; 629 } 630 if(f1.isNull() || f2.isNull()) { 631 errln("LocalUNormalizer2Pointer failure"); 632 return; 633 } 634 f1.swap(f2); 635 if(f1.getAlias() != p2 || f2.getAlias() != p1) { 636 errln("LocalUNormalizer2Pointer.swap() did not swap"); 637 } 638 swap(f1, f2); 639 if(f1.getAlias() != p1 || f2.getAlias() != p2) { 640 errln("swap(LocalUNormalizer2Pointer) did not swap back"); 641 } 642 LocalUNormalizer2Pointer f3; 643 f3.moveFrom(f1); 644 if(f3.getAlias() != p1 || f1.isValid()) { 645 errln("LocalUNormalizer2Pointer.moveFrom() did not move"); 646 } 647 #if U_HAVE_RVALUE_REFERENCES 648 infoln("TestLocalXyzPointerMoveSwap() with rvalue references"); 649 f1 = static_cast<LocalUNormalizer2Pointer &&>(f3); 650 if(f1.getAlias() != p1 || f3.isValid()) { 651 errln("LocalUNormalizer2Pointer move assignment operator did not move"); 652 } 653 LocalUNormalizer2Pointer f4(static_cast<LocalUNormalizer2Pointer &&>(f2)); 654 if(f4.getAlias() != p2 || f2.isValid()) { 655 errln("LocalUNormalizer2Pointer move constructor did not move"); 656 } 657 #else 658 infoln("TestLocalXyzPointerMoveSwap() without rvalue references"); 659 #endif 660 // Move self assignment leaves the object valid but in an undefined state. 661 // Do it to make sure there is no crash, 662 // but do not check for any particular resulting value. 663 f1.moveFrom(f1); 664 f3.moveFrom(f3); 665 #endif /* !UCONFIG_NO_NORMALIZATION */ 666 } 667 668 // Try LocalXyzPointer types with NULL pointers. 669 void LocalPointerTest::TestLocalXyzPointerNull() { 670 { 671 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUConverterSelectorPointer"); 672 static const char *const encoding="ISO-8859-1"; 673 LocalUConverterSelectorPointer null; 674 LocalUConverterSelectorPointer sel( 675 ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode)); 676 sel.adoptInstead(NULL); 677 } 678 #if !UCONFIG_NO_FORMATTING 679 { 680 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUCalendarPointer"); 681 LocalUCalendarPointer null; 682 LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode)); 683 if(!errorCode.logDataIfFailureAndReset("ucal_open()")) { 684 cal.adoptInstead(NULL); 685 } 686 } 687 { 688 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUDateTimePatternGeneratorPointer"); 689 LocalUDateTimePatternGeneratorPointer null; 690 LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode)); 691 patgen.adoptInstead(NULL); 692 } 693 { 694 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUMessageFormatPointer"); 695 UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!"); 696 LocalUMessageFormatPointer null; 697 LocalUMessageFormatPointer msg( 698 umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode)); 699 msg.adoptInstead(NULL); 700 } 701 #endif /* !UCONFIG_NO_FORMATTING */ 702 703 #if !UCONFIG_NO_REGULAR_EXPRESSIONS 704 { 705 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalURegularExpressionPointer"); 706 UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z"); 707 LocalURegularExpressionPointer null; 708 LocalURegularExpressionPointer regex( 709 uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode)); 710 if(!errorCode.logDataIfFailureAndReset("urege_open()")) { 711 regex.adoptInstead(NULL); 712 } 713 } 714 #endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */ 715 716 #if !UCONFIG_NO_TRANSLITERATION 717 { 718 IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUTransliteratorPointer"); 719 UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn"); 720 LocalUTransliteratorPointer null; 721 LocalUTransliteratorPointer trans( 722 utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode)); 723 if(!errorCode.logDataIfFailureAndReset("utrans_openU()")) { 724 trans.adoptInstead(NULL); 725 } 726 } 727 #endif /* !UCONFIG_NO_TRANSLITERATION */ 728 729 } 730 731 /** EnumSet test **/ 732 #include "unicode/enumset.h" 733 734 class EnumSetTest : public IntlTest { 735 public: 736 EnumSetTest() {} 737 virtual void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL); 738 void TestEnumSet(); 739 }; 740 741 static IntlTest *createEnumSetTest() { 742 return new EnumSetTest(); 743 } 744 745 void EnumSetTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) { 746 TESTCASE_AUTO_BEGIN; 747 TESTCASE_AUTO(TestEnumSet); 748 TESTCASE_AUTO_END; 749 } 750 enum myEnum { 751 MAX_NONBOOLEAN=-1, 752 THING1, 753 THING2, 754 THING3, 755 LIMIT_BOOLEAN 756 }; 757 758 void EnumSetTest::TestEnumSet() { 759 EnumSet<myEnum, 760 MAX_NONBOOLEAN+1, 761 LIMIT_BOOLEAN> 762 flags; 763 764 logln("Enum is from [%d..%d]\n", MAX_NONBOOLEAN+1, 765 LIMIT_BOOLEAN); 766 767 TEST_ASSERT_TRUE(flags.get(THING1) == FALSE); 768 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE); 769 TEST_ASSERT_TRUE(flags.get(THING3) == FALSE); 770 771 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3)); 772 logln("Value now: %d\n", flags.getAll()); 773 flags.clear(); 774 logln("clear -Value now: %d\n", flags.getAll()); 775 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3)); 776 TEST_ASSERT_TRUE(flags.get(THING1) == FALSE); 777 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE); 778 TEST_ASSERT_TRUE(flags.get(THING3) == FALSE); 779 flags.add(THING1); 780 logln("set THING1 -Value now: %d\n", flags.getAll()); 781 TEST_ASSERT_TRUE(flags.get(THING1) == TRUE); 782 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE); 783 TEST_ASSERT_TRUE(flags.get(THING3) == FALSE); 784 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3)); 785 flags.add(THING3); 786 logln("set THING3 -Value now: %d\n", flags.getAll()); 787 TEST_ASSERT_TRUE(flags.get(THING1) == TRUE); 788 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE); 789 TEST_ASSERT_TRUE(flags.get(THING3) == TRUE); 790 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3)); 791 flags.remove(THING2); 792 TEST_ASSERT_TRUE(flags.get(THING1) == TRUE); 793 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE); 794 TEST_ASSERT_TRUE(flags.get(THING3) == TRUE); 795 logln("remove THING2 -Value now: %d\n", flags.getAll()); 796 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3)); 797 flags.remove(THING1); 798 TEST_ASSERT_TRUE(flags.get(THING1) == FALSE); 799 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE); 800 TEST_ASSERT_TRUE(flags.get(THING3) == TRUE); 801 logln("remove THING1 -Value now: %d\n", flags.getAll()); 802 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3)); 803 804 flags.clear(); 805 logln("clear -Value now: %d\n", flags.getAll()); 806 logln("get(thing1)=%d, get(thing2)=%d, get(thing3)=%d\n", flags.get(THING1), flags.get(THING2), flags.get(THING3)); 807 TEST_ASSERT_TRUE(flags.get(THING1) == FALSE); 808 TEST_ASSERT_TRUE(flags.get(THING2) == FALSE); 809 TEST_ASSERT_TRUE(flags.get(THING3) == FALSE); 810 } 811