icuSources/test/intltest/itutil.cpp

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 1997-2010, International Business Machines Corporation and
   4  * others. All Rights Reserved.
   5  ********************************************************************/
   6
   7
   8 /**
   9  * IntlTestUtilities is the medium level test class for everything in the directory "utility".
  10  */
  11
  12 #include "unicode/utypes.h"
  13 #include "unicode/errorcode.h"
  14 #include "unicode/localpointer.h"
  15 #include "itutil.h"
  16 #include "strtest.h"
  17 #include "loctest.h"
  18 #include "citrtest.h"
  19 #include "ustrtest.h"
  20 #include "ucdtest.h"
  21 #include "restest.h"
  22 #include "restsnew.h"
  23 #include "tsmthred.h"
  24 #include "tsputil.h"
  25 #include "uobjtest.h"
  26 #include "utxttest.h"
  27 #include "v32test.h"
  28 #include "uvectest.h"
  29 #include "aliastst.h"
  30 #include "usettest.h"
  31
  32 static IntlTest *createLocalPointerTest();
  33
  34 #define CASE(id, test) case id:                               \
  35                           name = #test;                       \
  36                           if (exec) {                         \
  37                               logln(#test "---"); logln();    \
  38                               test t;                         \
  39                               callTest(t, par);               \
  40                           }                                   \
  41                           break
  42
  43 void IntlTestUtilities::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
  44 {
  45     if (exec) logln("TestSuite Utilities: ");
  46     switch (index) {
  47         CASE(0, MultithreadTest);
  48         CASE(1, StringTest);
  49         CASE(2, UnicodeStringTest);
  50         CASE(3, LocaleTest);
  51         CASE(4, CharIterTest);
  52         CASE(5, UObjectTest);
  53         CASE(6, UnicodeTest);
  54         CASE(7, ResourceBundleTest);
  55         CASE(8, NewResourceBundleTest);
  56         CASE(9, PUtilTest);
  57         CASE(10, UVector32Test);
  58         CASE(11, UVectorTest);
  59         CASE(12, UTextTest);
  60         CASE(13, LocaleAliasTest);
  61         CASE(14, UnicodeSetTest);
  62         CASE(15, ErrorCodeTest);
  63         case 16:
  64             name = "LocalPointerTest";
  65             if (exec) {
  66                 logln("TestSuite LocalPointerTest---"); logln();
  67                 LocalPointer<IntlTest> test(createLocalPointerTest());
  68                 callTest(*test, par);
  69             }
  70             break;
  71         default: name = ""; break; //needed to end loop
  72     }
  73 }
  74
  75 void ErrorCodeTest::runIndexedTest(int32_t index, UBool exec, const char* &name, char* /*par*/) {
  76     if (exec) logln("TestSuite Utilities: ");
  77     switch (index) {
  78         case 0: name = "TestErrorCode"; if (exec) TestErrorCode(); break;
  79         case 1: name = "TestSubclass"; if (exec) TestSubclass(); break;
  80         default: name = ""; break; //needed to end loop
  81     }
  82 }
  83
  84 static void RefPlusOne(UErrorCode &code) { code=(UErrorCode)(code+1); }
  85 static void PtrPlusTwo(UErrorCode *code) { *code=(UErrorCode)(*code+2); }
  86
  87 void ErrorCodeTest::TestErrorCode() {
  88     ErrorCode errorCode;
  89     if(errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure()) {
  90         errln("ErrorCode did not initialize properly");
  91         return;
  92     }
  93     errorCode.assertSuccess();
  94     if(errorCode.errorName()!=u_errorName(U_ZERO_ERROR)) {
  95         errln("ErrorCode did not format error message string properly");
  96     }
  97     RefPlusOne(errorCode);
  98     if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
  99         errln("ErrorCode did not yield a writable reference");
 100     }
 101     PtrPlusTwo(errorCode);
 102     if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
 103         errln("ErrorCode did not yield a writable pointer");
 104     }
 105     errorCode.set(U_PARSE_ERROR);
 106     if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
 107         errln("ErrorCode.set() failed");
 108     }
 109     if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR ||
 110         !errorCode.isSuccess() || errorCode.isFailure()
 111     ) {
 112         errln("ErrorCode did not reset properly");
 113     }
 114 }
 115
 116 class MyErrorCode: public ErrorCode {
 117 public:
 118     MyErrorCode(int32_t &countChecks, int32_t &countDests)
 119         : checks(countChecks), dests(countDests) {}
 120     ~MyErrorCode() {
 121         if(isFailure()) {
 122             ++dests;
 123         }
 124     }
 125 private:
 126     virtual void handleFailure() const {
 127         ++checks;
 128     }
 129     int32_t &checks;
 130     int32_t &dests;
 131 };
 132
 133 void ErrorCodeTest::TestSubclass() {
 134     int32_t countChecks=0;
 135     int32_t countDests=0;
 136     {
 137         MyErrorCode errorCode(countChecks, countDests);
 138         if( errorCode.get()!=U_ZERO_ERROR || !errorCode.isSuccess() || errorCode.isFailure() ||
 139             countChecks!=0 || countDests!=0
 140         ) {
 141             errln("ErrorCode did not initialize properly");
 142             return;
 143         }
 144         errorCode.assertSuccess();
 145         if(countChecks!=0) {
 146             errln("ErrorCode.assertSuccess() called handleFailure() despite success");
 147         }
 148         RefPlusOne(errorCode);
 149         if(errorCode.get()!=U_ILLEGAL_ARGUMENT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
 150             errln("ErrorCode did not yield a writable reference");
 151         }
 152         errorCode.assertSuccess();
 153         if(countChecks!=1) {
 154             errln("ErrorCode.assertSuccess() did not handleFailure()");
 155         }
 156         PtrPlusTwo(errorCode);
 157         if(errorCode.get()!=U_INVALID_FORMAT_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
 158             errln("ErrorCode did not yield a writable pointer");
 159         }
 160         errorCode.assertSuccess();
 161         if(countChecks!=2) {
 162             errln("ErrorCode.assertSuccess() did not handleFailure()");
 163         }
 164         errorCode.set(U_PARSE_ERROR);
 165         if(errorCode.get()!=U_PARSE_ERROR || errorCode.isSuccess() || !errorCode.isFailure()) {
 166             errln("ErrorCode.set() failed");
 167         }
 168         if( errorCode.reset()!=U_PARSE_ERROR || errorCode.get()!=U_ZERO_ERROR ||
 169             !errorCode.isSuccess() || errorCode.isFailure()
 170         ) {
 171             errln("ErrorCode did not reset properly");
 172         }
 173         errorCode.assertSuccess();
 174         if(countChecks!=2) {
 175             errln("ErrorCode.assertSuccess() called handleFailure() despite success");
 176         }
 177     }
 178     if(countDests!=0) {
 179         errln("MyErrorCode destructor detected failure despite success");
 180     }
 181     countChecks=countDests=0;
 182     {
 183         MyErrorCode errorCode(countChecks, countDests);
 184         errorCode.set(U_PARSE_ERROR);
 185     }
 186     if(countDests!=1) {
 187         errln("MyErrorCode destructor failed to detect failure");
 188     }
 189 }
 190
 191 class LocalPointerTest : public IntlTest {
 192 public:
 193     LocalPointerTest() {}
 194
 195     void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=NULL);
 196
 197     void TestLocalPointer();
 198     void TestLocalArray();
 199     void TestLocalXyzPointer();
 200     void TestLocalXyzPointerNull();
 201 };
 202
 203 static IntlTest *createLocalPointerTest() {
 204     return new LocalPointerTest();
 205 }
 206
 207 void LocalPointerTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
 208     if(exec) {
 209         logln("TestSuite LocalPointerTest: ");
 210     }
 211     switch (index) {
 212         TESTCASE(0, TestLocalPointer);
 213         TESTCASE(1, TestLocalArray);
 214         TESTCASE(2, TestLocalXyzPointer);
 215         TESTCASE(3, TestLocalXyzPointerNull);
 216         default:
 217             name="";
 218             break; // needed to end the loop
 219     }
 220 }
 221
 222 // Exercise every LocalPointer and LocalPointerBase method.
 223 void LocalPointerTest::TestLocalPointer() {
 224     // constructor
 225     LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
 226     // isNULL(), isValid(), operator==(), operator!=()
 227     if(s.isNull() || !s.isValid() || s==NULL || !(s!=NULL)) {
 228         errln("LocalPointer constructor or NULL test failure");
 229         return;
 230     }
 231     // getAlias(), operator->, operator*
 232     if(s.getAlias()->length()!=2 || s->length()!=2 || (*s).length()!=2) {
 233         errln("LocalPointer access failure");
 234     }
 235     // adoptInstead(), orphan()
 236     s.adoptInstead(new UnicodeString((UChar)0xfffc));
 237     if(s->length()!=1) {
 238         errln("LocalPointer adoptInstead(U+FFFC) failure");
 239     }
 240     UnicodeString *orphan=s.orphan();
 241     if(orphan==NULL || orphan->length()!=1 || s.isValid() || s!=NULL) {
 242         errln("LocalPointer orphan() failure");
 243     }
 244     delete orphan;
 245     // destructor
 246     s.adoptInstead(new UnicodeString());
 247     if(s->length()!=0) {
 248         errln("LocalPointer adoptInstead(empty) failure");
 249     }
 250 }
 251
 252 // Exercise every LocalArray method (but not LocalPointerBase).
 253 void LocalPointerTest::TestLocalArray() {
 254     // constructor
 255     LocalArray<UnicodeString> a(new UnicodeString[2]);
 256     // operator[]()
 257     a[0].append((UChar)0x61);
 258     a[1].append((UChar32)0x60006);
 259     if(a[0].length()!=1 || a[1].length()!=2) {
 260         errln("LocalArray access failure");
 261     }
 262     // adoptInstead()
 263     a.adoptInstead(new UnicodeString[4]);
 264     a[3].append((UChar)0x62).append((UChar)0x63).reverse();
 265     if(a[3].length()!=2 || a[3][1]!=0x62) {
 266         errln("LocalArray adoptInstead() failure");
 267     }
 268     // destructor
 269 }
 270
 271 #include "unicode/ucnvsel.h"
 272 #include "unicode/ucal.h"
 273 #include "unicode/udatpg.h"
 274 #include "unicode/uidna.h"
 275 #include "unicode/uldnames.h"
 276 #include "unicode/umsg.h"
 277 #include "unicode/unorm2.h"
 278 #include "unicode/uregex.h"
 279 #include "unicode/utrans.h"
 280
 281 // Use LocalXyzPointer types that are not covered elsewhere in the intltest suite.
 282 void LocalPointerTest::TestLocalXyzPointer() {
 283     IcuTestErrorCode errorCode(*this, "TestLocalXyzPointer");
 284
 285     static const char *const encoding="ISO-8859-1";
 286     LocalUConverterSelectorPointer sel(
 287         ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
 288     if(errorCode.logIfFailureAndReset("ucnvsel_open()")) {
 289         return;
 290     }
 291     if(sel.isNull()) {
 292         errln("LocalUConverterSelectorPointer failure");
 293         return;
 294     }
 295
 296 #if !UCONFIG_NO_FORMATTING
 297     LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
 298     if(errorCode.logDataIfFailureAndReset("ucal_open()")) {
 299         return;
 300     }
 301     if(cal.isNull()) {
 302         errln("LocalUCalendarPointer failure");
 303         return;
 304     }
 305
 306     LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
 307     if(errorCode.logIfFailureAndReset("udatpg_open()")) {
 308         return;
 309     }
 310     if(patgen.isNull()) {
 311         errln("LocalUDateTimePatternGeneratorPointer failure");
 312         return;
 313     }
 314
 315     LocalULocaleDisplayNamesPointer ldn(uldn_open("de-CH", ULDN_STANDARD_NAMES, errorCode));
 316     if(errorCode.logIfFailureAndReset("uldn_open()")) {
 317         return;
 318     }
 319     if(ldn.isNull()) {
 320         errln("LocalULocaleDisplayNamesPointer failure");
 321         return;
 322     }
 323
 324     UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
 325     LocalUMessageFormatPointer msg(
 326         umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
 327     if(errorCode.logIfFailureAndReset("umsg_open()")) {
 328         return;
 329     }
 330     if(msg.isNull()) {
 331         errln("LocalUMessageFormatPointer failure");
 332         return;
 333     }
 334 #endif  /* UCONFIG_NO_FORMATTING  */
 335
 336 #if !UCONFIG_NO_NORMALIZATION
 337     const UNormalizer2 *nfc=unorm2_getInstance(NULL, "nfc", UNORM2_COMPOSE, errorCode);
 338     UnicodeSet emptySet;
 339     LocalUNormalizer2Pointer fn2(unorm2_openFiltered(nfc, emptySet.toUSet(), errorCode));
 340     if(errorCode.logIfFailureAndReset("unorm2_openFiltered()")) {
 341         return;
 342     }
 343     if(fn2.isNull()) {
 344         errln("LocalUNormalizer2Pointer failure");
 345         return;
 346     }
 347 #endif /* !UCONFIG_NO_NORMALIZATION */
 348
 349 #if !UCONFIG_NO_IDNA
 350     LocalUIDNAPointer idna(uidna_openUTS46(0, errorCode));
 351     if(errorCode.logIfFailureAndReset("uidna_openUTS46()")) {
 352         return;
 353     }
 354     if(idna.isNull()) {
 355         errln("LocalUIDNAPointer failure");
 356         return;
 357     }
 358 #endif  /* !UCONFIG_NO_IDNA */
 359
 360 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
 361     UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
 362     LocalURegularExpressionPointer regex(
 363         uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
 364     if(errorCode.logIfFailureAndReset("uregex_open()")) {
 365         return;
 366     }
 367     if(regex.isNull()) {
 368         errln("LocalURegularExpressionPointer failure");
 369         return;
 370     }
 371 #endif /* UCONFIG_NO_REGULAR_EXPRESSIONS */
 372
 373 #if !UCONFIG_NO_TRANSLITERATION
 374     UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
 375     LocalUTransliteratorPointer trans(
 376         utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
 377     if(errorCode.logIfFailureAndReset("utrans_open()")) {
 378         return;
 379     }
 380     if(trans.isNull()) {
 381         errln("LocalUTransliteratorPointer failure");
 382         return;
 383     }
 384 #endif /* !UCONFIG_NO_TRANSLITERATION */
 385
 386     // destructors
 387 }
 388
 389 // Try LocalXyzPointer types with NULL pointers.
 390 void LocalPointerTest::TestLocalXyzPointerNull() {
 391     {
 392         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUConverterSelectorPointer");
 393         static const char *const encoding="ISO-8859-1";
 394         LocalUConverterSelectorPointer null;
 395         LocalUConverterSelectorPointer sel(
 396             ucnvsel_open(&encoding, 1, NULL, UCNV_ROUNDTRIP_SET, errorCode));
 397         sel.adoptInstead(NULL);
 398     }
 399 #if !UCONFIG_NO_FORMATTING
 400     {
 401         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUCalendarPointer");
 402         LocalUCalendarPointer null;
 403         LocalUCalendarPointer cal(ucal_open(NULL, 0, "root", UCAL_GREGORIAN, errorCode));
 404         if(!errorCode.logDataIfFailureAndReset("ucal_open()")) {
 405             cal.adoptInstead(NULL);
 406         }
 407     }
 408     {
 409         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUDateTimePatternGeneratorPointer");
 410         LocalUDateTimePatternGeneratorPointer null;
 411         LocalUDateTimePatternGeneratorPointer patgen(udatpg_open("root", errorCode));
 412         patgen.adoptInstead(NULL);
 413     }
 414     {
 415         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUMessageFormatPointer");
 416         UnicodeString hello=UNICODE_STRING_SIMPLE("Hello {0}!");
 417         LocalUMessageFormatPointer null;
 418         LocalUMessageFormatPointer msg(
 419             umsg_open(hello.getBuffer(), hello.length(), "root", NULL, errorCode));
 420         msg.adoptInstead(NULL);
 421     }
 422 #endif /* !UCONFIG_NO_FORMATTING */
 423
 424 #if !UCONFIG_NO_REGULAR_EXPRESSIONS
 425     {
 426         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalURegularExpressionPointer");
 427         UnicodeString pattern=UNICODE_STRING_SIMPLE("abc|xy+z");
 428         LocalURegularExpressionPointer null;
 429         LocalURegularExpressionPointer regex(
 430             uregex_open(pattern.getBuffer(), pattern.length(), 0, NULL, errorCode));
 431         if(!errorCode.logDataIfFailureAndReset("urege_open()")) {
 432             regex.adoptInstead(NULL);
 433         }
 434     }
 435 #endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
 436
 437 #if !UCONFIG_NO_TRANSLITERATION
 438     {
 439         IcuTestErrorCode errorCode(*this, "TestLocalXyzPointerNull/LocalUTransliteratorPointer");
 440         UnicodeString id=UNICODE_STRING_SIMPLE("Grek-Latn");
 441         LocalUTransliteratorPointer null;
 442         LocalUTransliteratorPointer trans(
 443             utrans_openU(id.getBuffer(), id.length(), UTRANS_FORWARD, NULL, 0, NULL, errorCode));
 444         if(!errorCode.logDataIfFailureAndReset("utrans_openU()")) {
 445             trans.adoptInstead(NULL);
 446         }
 447     }
 448 #endif /* !UCONFIG_NO_TRANSLITERATION */
 449
 450 }