source/test/intltest/itutil.cpp

   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 }