source/test/intltest/tzfmttst.cpp

   1 /*
   2 *******************************************************************************
   3 * Copyright (C) 2007-2013, International Business Machines Corporation and    *
   4 * others. All Rights Reserved.                                                *
   5 *******************************************************************************
   6 */
   7 #include "unicode/utypes.h"
   8
   9 #if !UCONFIG_NO_FORMATTING
  10
  11 #include "tzfmttst.h"
  12
  13 #include "simplethread.h"
  14 #include "unicode/timezone.h"
  15 #include "unicode/simpletz.h"
  16 #include "unicode/calendar.h"
  17 #include "unicode/strenum.h"
  18 #include "unicode/smpdtfmt.h"
  19 #include "unicode/uchar.h"
  20 #include "unicode/basictz.h"
  21 #include "unicode/tzfmt.h"
  22 #include "unicode/localpointer.h"
  23 #include "cstring.h"
  24 #include "zonemeta.h"
  25
  26 static const char* PATTERNS[] = {
  27     "z",
  28     "zzzz",
  29     "Z",    // equivalent to "xxxx"
  30     "ZZZZ", // equivalent to "OOOO"
  31     "v",
  32     "vvvv",
  33     "O",
  34     "OOOO",
  35     "X",
  36     "XX",
  37     "XXX",
  38     "XXXX",
  39     "XXXXX",
  40     "x",
  41     "xx",
  42     "xxx",
  43     "xxxx",
  44     "xxxxx",
  45     "V",
  46     "VV",
  47     "VVV",
  48     "VVVV"
  49 };
  50 static const int NUM_PATTERNS = sizeof(PATTERNS)/sizeof(const char*);
  51
  52 static const UChar ETC_UNKNOWN[] = {0x45, 0x74, 0x63, 0x2F, 0x55, 0x6E, 0x6B, 0x6E, 0x6F, 0x77, 0x6E, 0};
  53
  54 static const UChar ETC_SLASH[] = { 0x45, 0x74, 0x63, 0x2F, 0 }; // "Etc/"
  55 static const UChar SYSTEMV_SLASH[] = { 0x53, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x56, 0x2F, 0 }; // "SystemV/
  56 static const UChar RIYADH8[] = { 0x52, 0x69, 0x79, 0x61, 0x64, 0x68, 0x38, 0 }; // "Riyadh8"
  57
  58 static UBool contains(const char** list, const char* str) {
  59     for (int32_t i = 0; list[i]; i++) {
  60         if (uprv_strcmp(list[i], str) == 0) {
  61             return TRUE;
  62         }
  63     }
  64     return FALSE;
  65 }
  66
  67 void
  68 TimeZoneFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  69 {
  70     if (exec) {
  71         logln("TestSuite TimeZoneFormatTest");
  72     }
  73     switch (index) {
  74         TESTCASE(0, TestTimeZoneRoundTrip);
  75         TESTCASE(1, TestTimeRoundTrip);
  76         TESTCASE(2, TestParse);
  77         TESTCASE(3, TestISOFormat);
  78         default: name = ""; break;
  79     }
  80 }
  81
  82 void
  83 TimeZoneFormatTest::TestTimeZoneRoundTrip(void) {
  84     UErrorCode status = U_ZERO_ERROR;
  85
  86     SimpleTimeZone unknownZone(-31415, ETC_UNKNOWN);
  87     int32_t badDstOffset = -1234;
  88     int32_t badZoneOffset = -2345;
  89
  90     int32_t testDateData[][3] = {
  91         {2007, 1, 15},
  92         {2007, 6, 15},
  93         {1990, 1, 15},
  94         {1990, 6, 15},
  95         {1960, 1, 15},
  96         {1960, 6, 15},
  97     };
  98
  99     Calendar *cal = Calendar::createInstance(TimeZone::createTimeZone((UnicodeString)"UTC"), status);
 100     if (U_FAILURE(status)) {
 101         dataerrln("Calendar::createInstance failed: %s", u_errorName(status));
 102         return;
 103     }
 104
 105     // Set up rule equivalency test range
 106     UDate low, high;
 107     cal->set(1900, UCAL_JANUARY, 1);
 108     low = cal->getTime(status);
 109     cal->set(2040, UCAL_JANUARY, 1);
 110     high = cal->getTime(status);
 111     if (U_FAILURE(status)) {
 112         errln("getTime failed");
 113         return;
 114     }
 115
 116     // Set up test dates
 117     UDate DATES[(sizeof(testDateData)/sizeof(int32_t))/3];
 118     const int32_t nDates = (sizeof(testDateData)/sizeof(int32_t))/3;
 119     cal->clear();
 120     for (int32_t i = 0; i < nDates; i++) {
 121         cal->set(testDateData[i][0], testDateData[i][1], testDateData[i][2]);
 122         DATES[i] = cal->getTime(status);
 123         if (U_FAILURE(status)) {
 124             errln("getTime failed");
 125             return;
 126         }
 127     }
 128
 129     // Set up test locales
 130     const Locale testLocales[] = {
 131         Locale("en"),
 132         Locale("en_CA"),
 133         Locale("fr"),
 134         Locale("zh_Hant")
 135     };
 136
 137     const Locale *LOCALES;
 138     int32_t nLocales;
 139
 140     if (quick) {
 141         LOCALES = testLocales;
 142         nLocales = sizeof(testLocales)/sizeof(Locale);
 143     } else {
 144         LOCALES = Locale::getAvailableLocales(nLocales);
 145     }
 146
 147     StringEnumeration *tzids = TimeZone::createEnumeration();
 148     int32_t inRaw, inDst;
 149     int32_t outRaw, outDst;
 150
 151     // Run the roundtrip test
 152     for (int32_t locidx = 0; locidx < nLocales; locidx++) {
 153         UnicodeString localGMTString;
 154         SimpleDateFormat gmtFmt(UnicodeString("ZZZZ"), LOCALES[locidx], status);
 155         if (U_FAILURE(status)) {
 156             dataerrln("Error creating SimpleDateFormat - %s", u_errorName(status));
 157             continue;
 158         }
 159         gmtFmt.setTimeZone(*TimeZone::getGMT());
 160         gmtFmt.format(0.0, localGMTString);
 161
 162         for (int32_t patidx = 0; patidx < NUM_PATTERNS; patidx++) {
 163
 164             SimpleDateFormat *sdf = new SimpleDateFormat((UnicodeString)PATTERNS[patidx], LOCALES[locidx], status);
 165             if (U_FAILURE(status)) {
 166                 dataerrln((UnicodeString)"new SimpleDateFormat failed for pattern " +
 167                     PATTERNS[patidx] + " for locale " + LOCALES[locidx].getName() + " - " + u_errorName(status));
 168                 status = U_ZERO_ERROR;
 169                 continue;
 170             }
 171
 172             tzids->reset(status);
 173             const UnicodeString *tzid;
 174             while ((tzid = tzids->snext(status))) {
 175                 TimeZone *tz = TimeZone::createTimeZone(*tzid);
 176
 177                 for (int32_t datidx = 0; datidx < nDates; datidx++) {
 178                     UnicodeString tzstr;
 179                     FieldPosition fpos(0);
 180                     // Format
 181                     sdf->setTimeZone(*tz);
 182                     sdf->format(DATES[datidx], tzstr, fpos);
 183
 184                     // Before parse, set unknown zone to SimpleDateFormat instance
 185                     // just for making sure that it does not depends on the time zone
 186                     // originally set.
 187                     sdf->setTimeZone(unknownZone);
 188
 189                     // Parse
 190                     ParsePosition pos(0);
 191                     Calendar *outcal = Calendar::createInstance(unknownZone, status);
 192                     if (U_FAILURE(status)) {
 193                         errln("Failed to create an instance of calendar for receiving parse result.");
 194                         status = U_ZERO_ERROR;
 195                         continue;
 196                     }
 197                     outcal->set(UCAL_DST_OFFSET, badDstOffset);
 198                     outcal->set(UCAL_ZONE_OFFSET, badZoneOffset);
 199
 200                     sdf->parse(tzstr, *outcal, pos);
 201
 202                     // Check the result
 203                     const TimeZone &outtz = outcal->getTimeZone();
 204                     UnicodeString outtzid;
 205                     outtz.getID(outtzid);
 206
 207                     tz->getOffset(DATES[datidx], false, inRaw, inDst, status);
 208                     if (U_FAILURE(status)) {
 209                         errln((UnicodeString)"Failed to get offsets from time zone" + *tzid);
 210                         status = U_ZERO_ERROR;
 211                     }
 212                     outtz.getOffset(DATES[datidx], false, outRaw, outDst, status);
 213                     if (U_FAILURE(status)) {
 214                         errln((UnicodeString)"Failed to get offsets from time zone" + outtzid);
 215                         status = U_ZERO_ERROR;
 216                     }
 217
 218                     if (uprv_strcmp(PATTERNS[patidx], "V") == 0) {
 219                         // Short zone ID - should support roundtrip for canonical CLDR IDs
 220                         UnicodeString canonicalID;
 221                         TimeZone::getCanonicalID(*tzid, canonicalID, status);
 222                         if (U_FAILURE(status)) {
 223                             // Uknown ID - we should not get here
 224                             errln((UnicodeString)"Unknown ID " + *tzid);
 225                             status = U_ZERO_ERROR;
 226                         } else if (outtzid != canonicalID) {
 227                             if (outtzid.compare(ETC_UNKNOWN, -1) == 0) {
 228                                 // Note that some zones like Asia/Riyadh87 does not have
 229                                 // short zone ID and "unk" is used as fallback
 230                                 logln((UnicodeString)"Canonical round trip failed (probably as expected); tz=" + *tzid
 231                                         + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 232                                         + ", time=" + DATES[datidx] + ", str=" + tzstr
 233                                         + ", outtz=" + outtzid);
 234                             } else {
 235                                 errln((UnicodeString)"Canonical round trip failed; tz=" + *tzid
 236                                     + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 237                                     + ", time=" + DATES[datidx] + ", str=" + tzstr
 238                                     + ", outtz=" + outtzid);
 239                             }
 240                         }
 241                     } else if (uprv_strcmp(PATTERNS[patidx], "VV") == 0) {
 242                         // Zone ID - full roundtrip support
 243                         if (outtzid != *tzid) {
 244                             errln((UnicodeString)"Zone ID round trip failued; tz="  + *tzid
 245                                 + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 246                                 + ", time=" + DATES[datidx] + ", str=" + tzstr
 247                                 + ", outtz=" + outtzid);
 248                         }
 249                     } else if (uprv_strcmp(PATTERNS[patidx], "VVV") == 0 || uprv_strcmp(PATTERNS[patidx], "VVVV") == 0) {
 250                         // Location: time zone rule must be preserved except
 251                         // zones not actually associated with a specific location.
 252                         // Time zones in this category do not have "/" in its ID.
 253                         UnicodeString canonical;
 254                         TimeZone::getCanonicalID(*tzid, canonical, status);
 255                         if (U_FAILURE(status)) {
 256                             // Uknown ID - we should not get here
 257                             errln((UnicodeString)"Unknown ID " + *tzid);
 258                             status = U_ZERO_ERROR;
 259                         } else if (outtzid != canonical) {
 260                             // Canonical ID did not match - check the rules
 261                             if (!((BasicTimeZone*)&outtz)->hasEquivalentTransitions((BasicTimeZone&)*tz, low, high, TRUE, status)) {
 262                                 if (canonical.indexOf((UChar)0x27 /*'/'*/) == -1) {
 263                                     // Exceptional cases, such as CET, EET, MET and WET
 264                                     logln((UnicodeString)"Canonical round trip failed (as expected); tz=" + *tzid
 265                                             + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 266                                             + ", time=" + DATES[datidx] + ", str=" + tzstr
 267                                             + ", outtz=" + outtzid);
 268                                 } else {
 269                                     errln((UnicodeString)"Canonical round trip failed; tz=" + *tzid
 270                                         + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 271                                         + ", time=" + DATES[datidx] + ", str=" + tzstr
 272                                         + ", outtz=" + outtzid);
 273                                 }
 274                                 if (U_FAILURE(status)) {
 275                                     errln("hasEquivalentTransitions failed");
 276                                     status = U_ZERO_ERROR;
 277                                 }
 278                             }
 279                         }
 280
 281                     } else {
 282                         UBool isOffsetFormat = (*PATTERNS[patidx] == 'Z'
 283                                                 || *PATTERNS[patidx] == 'O'
 284                                                 || *PATTERNS[patidx] == 'X'
 285                                                 || *PATTERNS[patidx] == 'x');
 286                         UBool minutesOffset = FALSE;
 287                         if (*PATTERNS[patidx] == 'X' || *PATTERNS[patidx] == 'x') {
 288                             minutesOffset = (uprv_strlen(PATTERNS[patidx]) <= 3);
 289                         }
 290
 291                         if (!isOffsetFormat) {
 292                             // Check if localized GMT format is used as a fallback of name styles
 293                             int32_t numDigits = 0;
 294                             for (int n = 0; n < tzstr.length(); n++) {
 295                                 if (u_isdigit(tzstr.charAt(n))) {
 296                                     numDigits++;
 297                                 }
 298                             }
 299                             isOffsetFormat = (numDigits > 0);
 300                         }
 301                         if (isOffsetFormat || tzstr == localGMTString) {
 302                             // Localized GMT or ISO: total offset (raw + dst) must be preserved.
 303                             int32_t inOffset = inRaw + inDst;
 304                             int32_t outOffset = outRaw + outDst;
 305                             int32_t diff = outOffset - inOffset;
 306                             if (minutesOffset) {
 307                                 diff = (diff / 60000) * 60000;
 308                             }
 309                             if (diff != 0) {
 310                                 errln((UnicodeString)"Offset round trip failed; tz=" + *tzid
 311                                     + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 312                                     + ", time=" + DATES[datidx] + ", str=" + tzstr
 313                                     + ", inOffset=" + inOffset + ", outOffset=" + outOffset);
 314                             }
 315                         } else {
 316                             // Specific or generic: raw offset must be preserved.
 317                             if (inRaw != outRaw) {
 318                                 errln((UnicodeString)"Raw offset round trip failed; tz=" + *tzid
 319                                     + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 320                                     + ", time=" + DATES[datidx] + ", str=" + tzstr
 321                                     + ", inRawOffset=" + inRaw + ", outRawOffset=" + outRaw);
 322                             }
 323                         }
 324                     }
 325                     delete outcal;
 326                 }
 327                 delete tz;
 328             }
 329             delete sdf;
 330         }
 331     }
 332     delete cal;
 333     delete tzids;
 334 }
 335
 336 struct LocaleData {
 337     int32_t index;
 338     int32_t testCounts;
 339     UDate *times;
 340     const Locale* locales; // Static
 341     int32_t nLocales; // Static
 342     UBool quick; // Static
 343     UDate START_TIME; // Static
 344     UDate END_TIME; // Static
 345     int32_t numDone;
 346 };
 347
 348 class TestTimeRoundTripThread: public SimpleThread {
 349 public:
 350     TestTimeRoundTripThread(IntlTest& tlog, LocaleData &ld, int32_t i)
 351         : log(tlog), data(ld), index(i) {}
 352     virtual void run() {
 353         UErrorCode status = U_ZERO_ERROR;
 354         UBool REALLY_VERBOSE = FALSE;
 355
 356         // These patterns are ambiguous at DST->STD local time overlap
 357         const char* AMBIGUOUS_DST_DECESSION[] = { "v", "vvvv", "V", "VV", "VVV", "VVVV", 0 };
 358
 359         // These patterns are ambiguous at STD->STD/DST->DST local time overlap
 360         const char* AMBIGUOUS_NEGATIVE_SHIFT[] = { "z", "zzzz", "v", "vvvv", "V", "VV", "VVV", "VVVV", 0 };
 361
 362         // These patterns only support integer minutes offset
 363         const char* MINUTES_OFFSET[] = { "X", "XX", "XXX", "x", "xx", "xxx", 0 };
 364
 365         // Workaround for #6338
 366         //UnicodeString BASEPATTERN("yyyy-MM-dd'T'HH:mm:ss.SSS");
 367         UnicodeString BASEPATTERN("yyyy.MM.dd HH:mm:ss.SSS");
 368
 369         // timer for performance analysis
 370         UDate timer;
 371         UDate testTimes[4];
 372         UBool expectedRoundTrip[4];
 373         int32_t testLen = 0;
 374
 375         StringEnumeration *tzids = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status);
 376         if (U_FAILURE(status)) {
 377             if (status == U_MISSING_RESOURCE_ERROR) {
 378                 /* This error is generally caused by data not being present. However, an infinite loop will occur
 379                  * because the thread thinks that the test data is never done so we should treat the data as done.
 380                  */
 381                 log.dataerrln("TimeZone::createTimeZoneIDEnumeration failed - %s", u_errorName(status));
 382                 data.numDone = data.nLocales;
 383             } else {
 384                 log.errln("TimeZone::createTimeZoneIDEnumeration failed: %s", u_errorName(status));
 385             }
 386             return;
 387         }
 388
 389         int32_t locidx = -1;
 390         UDate times[NUM_PATTERNS];
 391         for (int32_t i = 0; i < NUM_PATTERNS; i++) {
 392             times[i] = 0;
 393         }
 394
 395         int32_t testCounts = 0;
 396
 397         while (true) {
 398             umtx_lock(NULL); // Lock to increment the index
 399             for (int32_t i = 0; i < NUM_PATTERNS; i++) {
 400                 data.times[i] += times[i];
 401                 data.testCounts += testCounts;
 402             }
 403             if (data.index < data.nLocales) {
 404                 locidx = data.index;
 405                 data.index++;
 406             } else {
 407                 locidx = -1;
 408             }
 409             umtx_unlock(NULL); // Unlock for other threads to use
 410
 411             if (locidx == -1) {
 412                 log.logln((UnicodeString) "Thread " + index + " is done.");
 413                 break;
 414             }
 415
 416             log.logln((UnicodeString) "\nThread " + index + ": Locale: " + UnicodeString(data.locales[locidx].getName()));
 417
 418             for (int32_t patidx = 0; patidx < NUM_PATTERNS; patidx++) {
 419                 log.logln((UnicodeString) "    Pattern: " + PATTERNS[patidx]);
 420                 times[patidx] = 0;
 421
 422                 UnicodeString pattern(BASEPATTERN);
 423                 pattern.append(" ").append(PATTERNS[patidx]);
 424
 425                 SimpleDateFormat *sdf = new SimpleDateFormat(pattern, data.locales[locidx], status);
 426                 if (U_FAILURE(status)) {
 427                     log.errcheckln(status, (UnicodeString) "new SimpleDateFormat failed for pattern " +
 428                         pattern + " for locale " + data.locales[locidx].getName() + " - " + u_errorName(status));
 429                     status = U_ZERO_ERROR;
 430                     continue;
 431                 }
 432
 433                 UBool minutesOffset = contains(MINUTES_OFFSET, PATTERNS[patidx]);
 434
 435                 tzids->reset(status);
 436                 const UnicodeString *tzid;
 437
 438                 timer = Calendar::getNow();
 439
 440                 while ((tzid = tzids->snext(status))) {
 441                     if (uprv_strcmp(PATTERNS[patidx], "V") == 0) {
 442                         // Some zones do not have short ID assigned, such as Asia/Riyadh87.
 443                         // The time roundtrip will fail for such zones with pattern "V" (short zone ID).
 444                         // This is expected behavior.
 445                         const UChar* shortZoneID = ZoneMeta::getShortID(*tzid);
 446                         if (shortZoneID == NULL) {
 447                             continue;
 448                         }
 449                     } else if (uprv_strcmp(PATTERNS[patidx], "VVV") == 0) {
 450                         // Some zones are not associated with any region, such as Etc/GMT+8.
 451                         // The time roundtrip will fail for such zone with pattern "VVV" (exemplar location).
 452                         // This is expected behavior.
 453                         if (tzid->indexOf((UChar)0x2F) < 0 || tzid->indexOf(ETC_SLASH, -1, 0) >= 0
 454                             || tzid->indexOf(SYSTEMV_SLASH, -1, 0) >= 0 || tzid->indexOf(RIYADH8, -1, 0) >= 0) {
 455                             continue;
 456                         }
 457                     }
 458
 459                     BasicTimeZone *tz = (BasicTimeZone*) TimeZone::createTimeZone(*tzid);
 460                     sdf->setTimeZone(*tz);
 461
 462                     UDate t = data.START_TIME;
 463                     TimeZoneTransition tzt;
 464                     UBool tztAvail = FALSE;
 465                     UBool middle = TRUE;
 466
 467                     while (t < data.END_TIME) {
 468                         if (!tztAvail) {
 469                             testTimes[0] = t;
 470                             expectedRoundTrip[0] = TRUE;
 471                             testLen = 1;
 472                         } else {
 473                             int32_t fromOffset = tzt.getFrom()->getRawOffset() + tzt.getFrom()->getDSTSavings();
 474                             int32_t toOffset = tzt.getTo()->getRawOffset() + tzt.getTo()->getDSTSavings();
 475                             int32_t delta = toOffset - fromOffset;
 476                             if (delta < 0) {
 477                                 UBool isDstDecession = tzt.getFrom()->getDSTSavings() > 0 && tzt.getTo()->getDSTSavings() == 0;
 478                                 testTimes[0] = t + delta - 1;
 479                                 expectedRoundTrip[0] = TRUE;
 480                                 testTimes[1] = t + delta;
 481                                 expectedRoundTrip[1] = isDstDecession ?
 482                                     !contains(AMBIGUOUS_DST_DECESSION, PATTERNS[patidx]) :
 483                                     !contains(AMBIGUOUS_NEGATIVE_SHIFT, PATTERNS[patidx]);
 484                                 testTimes[2] = t - 1;
 485                                 expectedRoundTrip[2] = isDstDecession ?
 486                                     !contains(AMBIGUOUS_DST_DECESSION, PATTERNS[patidx]) :
 487                                     !contains(AMBIGUOUS_NEGATIVE_SHIFT, PATTERNS[patidx]);
 488                                 testTimes[3] = t;
 489                                 expectedRoundTrip[3] = TRUE;
 490                                 testLen = 4;
 491                             } else {
 492                                 testTimes[0] = t - 1;
 493                                 expectedRoundTrip[0] = TRUE;
 494                                 testTimes[1] = t;
 495                                 expectedRoundTrip[1] = TRUE;
 496                                 testLen = 2;
 497                             }
 498                         }
 499                         for (int32_t testidx = 0; testidx < testLen; testidx++) {
 500                             if (data.quick) {
 501                                 // reduce regular test time
 502                                 if (!expectedRoundTrip[testidx]) {
 503                                     continue;
 504                                 }
 505                             }
 506
 507                             testCounts++;
 508
 509                             UnicodeString text;
 510                             FieldPosition fpos(0);
 511                             sdf->format(testTimes[testidx], text, fpos);
 512
 513                             UDate parsedDate = sdf->parse(text, status);
 514                             if (U_FAILURE(status)) {
 515                                 log.errln((UnicodeString) "Parse failure for text=" + text + ", tzid=" + *tzid + ", locale=" + data.locales[locidx].getName()
 516                                         + ", pattern=" + PATTERNS[patidx] + ", time=" + testTimes[testidx]);
 517                                 status = U_ZERO_ERROR;
 518                                 continue;
 519                             }
 520
 521                             int32_t timeDiff = (int32_t)(parsedDate - testTimes[testidx]);
 522                             UBool bTimeMatch = minutesOffset ?
 523                                 (timeDiff/60000)*60000 == 0 : timeDiff == 0;
 524                             if (!bTimeMatch) {
 525                                 UnicodeString msg = (UnicodeString) "Time round trip failed for " + "tzid=" + *tzid + ", locale=" + data.locales[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 526                                         + ", text=" + text + ", time=" + testTimes[testidx] + ", restime=" + parsedDate + ", diff=" + (parsedDate - testTimes[testidx]);
 527                                 // Timebomb for TZData update
 528                                 if (expectedRoundTrip[testidx]) {
 529                                     log.errln((UnicodeString) "FAIL: " + msg);
 530                                 } else if (REALLY_VERBOSE) {
 531                                     log.logln(msg);
 532                                 }
 533                             }
 534                         }
 535                         tztAvail = tz->getNextTransition(t, FALSE, tzt);
 536                         if (!tztAvail) {
 537                             break;
 538                         }
 539                         if (middle) {
 540                             // Test the date in the middle of two transitions.
 541                             t += (int64_t) ((tzt.getTime() - t) / 2);
 542                             middle = FALSE;
 543                             tztAvail = FALSE;
 544                         } else {
 545                             t = tzt.getTime();
 546                         }
 547                     }
 548                     delete tz;
 549                 }
 550                 times[patidx] += (Calendar::getNow() - timer);
 551                 delete sdf;
 552             }
 553             umtx_lock(NULL);
 554             data.numDone++;
 555             umtx_unlock(NULL);
 556         }
 557         delete tzids;
 558     }
 559 private:
 560     IntlTest& log;
 561     LocaleData& data;
 562     int32_t index;
 563 };
 564
 565 void
 566 TimeZoneFormatTest::TestTimeRoundTrip(void) {
 567     int32_t nThreads = threadCount;
 568     const Locale *LOCALES;
 569     int32_t nLocales;
 570     int32_t testCounts = 0;
 571
 572     UErrorCode status = U_ZERO_ERROR;
 573     Calendar *cal = Calendar::createInstance(TimeZone::createTimeZone((UnicodeString) "UTC"), status);
 574     if (U_FAILURE(status)) {
 575         dataerrln("Calendar::createInstance failed: %s", u_errorName(status));
 576         return;
 577     }
 578
 579     const char* testAllProp = getProperty("TimeZoneRoundTripAll");
 580     UBool bTestAll = (testAllProp && uprv_strcmp(testAllProp, "true") == 0);
 581
 582     UDate START_TIME, END_TIME;
 583     if (bTestAll || !quick) {
 584         cal->set(1900, UCAL_JANUARY, 1);
 585     } else {
 586         cal->set(1990, UCAL_JANUARY, 1);
 587     }
 588     START_TIME = cal->getTime(status);
 589
 590     cal->set(2015, UCAL_JANUARY, 1);
 591     END_TIME = cal->getTime(status);
 592
 593     if (U_FAILURE(status)) {
 594         errln("getTime failed");
 595         return;
 596     }
 597
 598     UDate times[NUM_PATTERNS];
 599     for (int32_t i = 0; i < NUM_PATTERNS; i++) {
 600         times[i] = 0;
 601     }
 602
 603     // Set up test locales
 604     const Locale locales1[] = {Locale("en")};
 605     const Locale locales2[] = {
 606         Locale("ar_EG"), Locale("bg_BG"), Locale("ca_ES"), Locale("da_DK"), Locale("de"),
 607         Locale("de_DE"), Locale("el_GR"), Locale("en"), Locale("en_AU"), Locale("en_CA"),
 608         Locale("en_US"), Locale("es"), Locale("es_ES"), Locale("es_MX"), Locale("fi_FI"),
 609         Locale("fr"), Locale("fr_CA"), Locale("fr_FR"), Locale("he_IL"), Locale("hu_HU"),
 610         Locale("it"), Locale("it_IT"), Locale("ja"), Locale("ja_JP"), Locale("ko"),
 611         Locale("ko_KR"), Locale("nb_NO"), Locale("nl_NL"), Locale("nn_NO"), Locale("pl_PL"),
 612         Locale("pt"), Locale("pt_BR"), Locale("pt_PT"), Locale("ru_RU"), Locale("sv_SE"),
 613         Locale("th_TH"), Locale("tr_TR"), Locale("zh"), Locale("zh_Hans"), Locale("zh_Hans_CN"),
 614         Locale("zh_Hant"), Locale("zh_Hant_TW")
 615     };
 616
 617     if (bTestAll) {
 618         LOCALES = Locale::getAvailableLocales(nLocales);
 619     } else if (quick) {
 620         LOCALES = locales1;
 621         nLocales = sizeof(locales1)/sizeof(Locale);
 622     } else {
 623         LOCALES = locales2;
 624         nLocales = sizeof(locales2)/sizeof(Locale);
 625     }
 626
 627     LocaleData data;
 628     data.index = 0;
 629     data.testCounts = testCounts;
 630     data.times = times;
 631     data.locales = LOCALES;
 632     data.nLocales = nLocales;
 633     data.quick = quick;
 634     data.START_TIME = START_TIME;
 635     data.END_TIME = END_TIME;
 636     data.numDone = 0;
 637
 638 #if (ICU_USE_THREADS==0)
 639     TestTimeRoundTripThread fakeThread(*this, data, 0);
 640     fakeThread.run();
 641 #else
 642     TestTimeRoundTripThread **threads = new TestTimeRoundTripThread*[threadCount];
 643     int32_t i;
 644     for (i = 0; i < nThreads; i++) {
 645         threads[i] = new TestTimeRoundTripThread(*this, data, i);
 646         if (threads[i]->start() != 0) {
 647             errln("Error starting thread %d", i);
 648         }
 649     }
 650
 651     UBool done = false;
 652     while (true) {
 653         umtx_lock(NULL);
 654         if (data.numDone == nLocales) {
 655             done = true;
 656         }
 657         umtx_unlock(NULL);
 658         if (done)
 659             break;
 660         SimpleThread::sleep(1000);
 661     }
 662
 663     for (i = 0; i < nThreads; i++) {
 664         delete threads[i];
 665     }
 666     delete [] threads;
 667
 668 #endif
 669     UDate total = 0;
 670     logln("### Elapsed time by patterns ###");
 671     for (int32_t i = 0; i < NUM_PATTERNS; i++) {
 672         logln(UnicodeString("") + data.times[i] + "ms (" + PATTERNS[i] + ")");
 673         total += data.times[i];
 674     }
 675     logln((UnicodeString) "Total: " + total + "ms");
 676     logln((UnicodeString) "Iteration: " + data.testCounts);
 677
 678     delete cal;
 679 }
 680
 681
 682 typedef struct {
 683     const char*     text;
 684     int32_t         inPos;
 685     const char*     locale;
 686     UTimeZoneFormatStyle    style;
 687     UBool           parseAll;
 688     const char*     expected;
 689     int32_t         outPos;
 690     UTimeZoneFormatTimeType timeType;
 691 } ParseTestData;
 692
 693 void
 694 TimeZoneFormatTest::TestParse(void) {
 695     const ParseTestData DATA[] = {
 696         //   text               inPos   locale      style                               parseAll    expected            outPos  timeType
 697             {"Z",               0,      "en_US",    UTZFMT_STYLE_ISO_EXTENDED_FULL,     false,      "Etc/GMT",          1,      UTZFMT_TIME_TYPE_UNKNOWN},
 698             {"Z",               0,      "en_US",    UTZFMT_STYLE_SPECIFIC_LONG,         false,      "Etc/GMT",          1,      UTZFMT_TIME_TYPE_UNKNOWN},
 699             {"Zambia time",     0,      "en_US",    UTZFMT_STYLE_ISO_EXTENDED_FULL,     true,       "Etc/GMT",          1,      UTZFMT_TIME_TYPE_UNKNOWN},
 700             {"Zambia time",     0,      "en_US",    UTZFMT_STYLE_GENERIC_LOCATION,      false,      "Africa/Lusaka",    11,     UTZFMT_TIME_TYPE_UNKNOWN},
 701             {"Zambia time",     0,      "en_US",    UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,  true,       "Africa/Lusaka",    11,     UTZFMT_TIME_TYPE_UNKNOWN},
 702             {"+00:00",          0,      "en_US",    UTZFMT_STYLE_ISO_EXTENDED_FULL,     false,      "Etc/GMT",          6,      UTZFMT_TIME_TYPE_UNKNOWN},
 703             {"-01:30:45",       0,      "en_US",    UTZFMT_STYLE_ISO_EXTENDED_FULL,     false,      "GMT-01:30:45",     9,      UTZFMT_TIME_TYPE_UNKNOWN},
 704             {"-7",              0,      "en_US",    UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,  false,      "GMT-07:00",        2,      UTZFMT_TIME_TYPE_UNKNOWN},
 705             {"-2222",           0,      "en_US",    UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,  false,      "GMT-22:22",        5,      UTZFMT_TIME_TYPE_UNKNOWN},
 706             {"-3333",           0,      "en_US",    UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,  false,      "GMT-03:33",        4,      UTZFMT_TIME_TYPE_UNKNOWN},
 707             {"XXX+01:30YYY",    3,      "en_US",    UTZFMT_STYLE_LOCALIZED_GMT,         false,      "GMT+01:30",        9,      UTZFMT_TIME_TYPE_UNKNOWN},
 708             {"GMT0",            0,      "en_US",    UTZFMT_STYLE_SPECIFIC_SHORT,        false,      "Etc/GMT",          3,      UTZFMT_TIME_TYPE_UNKNOWN},
 709             {"EST",             0,      "en_US",    UTZFMT_STYLE_SPECIFIC_SHORT,        false,      "America/New_York", 3,      UTZFMT_TIME_TYPE_STANDARD},
 710             {"ESTx",            0,      "en_US",    UTZFMT_STYLE_SPECIFIC_SHORT,        false,      "America/New_York", 3,      UTZFMT_TIME_TYPE_STANDARD},
 711             {"EDTx",            0,      "en_US",    UTZFMT_STYLE_SPECIFIC_SHORT,        false,      "America/New_York", 3,      UTZFMT_TIME_TYPE_DAYLIGHT},
 712             {"EST",             0,      "en_US",    UTZFMT_STYLE_SPECIFIC_LONG,         false,      NULL,               0,      UTZFMT_TIME_TYPE_UNKNOWN},
 713             {"EST",             0,      "en_US",    UTZFMT_STYLE_SPECIFIC_LONG,         true,       "America/New_York", 3,      UTZFMT_TIME_TYPE_STANDARD},
 714             {"EST",             0,      "en_CA",    UTZFMT_STYLE_SPECIFIC_SHORT,        false,      "America/Toronto",  3,      UTZFMT_TIME_TYPE_STANDARD},
 715             {NULL,              0,      NULL,       UTZFMT_STYLE_GENERIC_LOCATION,      false,      NULL,               0,      UTZFMT_TIME_TYPE_UNKNOWN}
 716     };
 717
 718     for (int32_t i = 0; DATA[i].text; i++) {
 719         UErrorCode status = U_ZERO_ERROR;
 720         LocalPointer<TimeZoneFormat> tzfmt(TimeZoneFormat::createInstance(Locale(DATA[i].locale), status));
 721         if (U_FAILURE(status)) {
 722             dataerrln("Fail TimeZoneFormat::createInstance: %s", u_errorName(status));
 723             continue;
 724         }
 725         UTimeZoneFormatTimeType ttype = UTZFMT_TIME_TYPE_UNKNOWN;
 726         ParsePosition pos(DATA[i].inPos);
 727         int32_t parseOptions = DATA[i].parseAll ? UTZFMT_PARSE_OPTION_ALL_STYLES : UTZFMT_PARSE_OPTION_NONE;
 728         TimeZone* tz = tzfmt->parse(DATA[i].style, DATA[i].text, pos, parseOptions, &ttype);
 729
 730         UnicodeString errMsg;
 731         if (tz) {
 732             UnicodeString outID;
 733             tz->getID(outID);
 734             if (outID != UnicodeString(DATA[i].expected)) {
 735                 errMsg = (UnicodeString)"Time zone ID: " + outID + " - expected: " + DATA[i].expected;
 736             } else if (pos.getIndex() != DATA[i].outPos) {
 737                 errMsg = (UnicodeString)"Parsed pos: " + pos.getIndex() + " - expected: " + DATA[i].outPos;
 738             } else if (ttype != DATA[i].timeType) {
 739                 errMsg = (UnicodeString)"Time type: " + ttype + " - expected: " + DATA[i].timeType;
 740             }
 741             delete tz;
 742         } else {
 743             if (DATA[i].expected) {
 744                 errln((UnicodeString)"Fail: Parse failure - expected: " + DATA[i].expected);
 745             }
 746         }
 747         if (errMsg.length() > 0) {
 748             errln((UnicodeString)"Fail: " + errMsg + " [text=" + DATA[i].text + ", pos=" + DATA[i].inPos + ", style=" + DATA[i].style + "]");
 749         }
 750     }
 751 }
 752
 753 void
 754 TimeZoneFormatTest::TestISOFormat(void) {
 755     const int32_t OFFSET[] = {
 756         0,          // 0
 757         999,        // 0.999s
 758         -59999,     // -59.999s
 759         60000,      // 1m
 760         -77777,     // -1m 17.777s
 761         1800000,    // 30m
 762         -3600000,   // -1h
 763         36000000,   // 10h
 764         -37800000,  // -10h 30m
 765         -37845000,  // -10h 30m 45s
 766         108000000,  // 30h
 767     };
 768
 769     const char* ISO_STR[][11] = {
 770         // 0
 771         {
 772             "Z", "Z", "Z", "Z", "Z",
 773             "+00", "+0000", "+00:00", "+0000", "+00:00",
 774             "+0000"
 775         },
 776         // 999
 777         {
 778             "Z", "Z", "Z", "Z", "Z",
 779             "+00", "+0000", "+00:00", "+0000", "+00:00",
 780             "+0000"
 781         },
 782         // -59999
 783         {
 784             "Z", "Z", "Z", "-000059", "-00:00:59",
 785             "+00", "+0000", "+00:00", "-000059", "-00:00:59",
 786             "-000059"
 787         },
 788         // 60000
 789         {
 790             "+0001", "+0001", "+00:01", "+0001", "+00:01",
 791             "+0001", "+0001", "+00:01", "+0001", "+00:01",
 792             "+0001"
 793         },
 794         // -77777
 795         {
 796             "-0001", "-0001", "-00:01", "-000117", "-00:01:17",
 797             "-0001", "-0001", "-00:01", "-000117", "-00:01:17",
 798             "-000117"
 799         },
 800         // 1800000
 801         {
 802             "+0030", "+0030", "+00:30", "+0030", "+00:30",
 803             "+0030", "+0030", "+00:30", "+0030", "+00:30",
 804             "+0030"
 805         },
 806         // -3600000
 807         {
 808             "-01", "-0100", "-01:00", "-0100", "-01:00",
 809             "-01", "-0100", "-01:00", "-0100", "-01:00",
 810             "-0100"
 811         },
 812         // 36000000
 813         {
 814             "+10", "+1000", "+10:00", "+1000", "+10:00",
 815             "+10", "+1000", "+10:00", "+1000", "+10:00",
 816             "+1000"
 817         },
 818         // -37800000
 819         {
 820             "-1030", "-1030", "-10:30", "-1030", "-10:30",
 821             "-1030", "-1030", "-10:30", "-1030", "-10:30",
 822             "-1030"
 823         },
 824         // -37845000
 825         {
 826             "-1030", "-1030", "-10:30", "-103045", "-10:30:45",
 827             "-1030", "-1030", "-10:30", "-103045", "-10:30:45",
 828             "-103045"
 829         },
 830         // 108000000
 831         {
 832             0, 0, 0, 0, 0,
 833             0, 0, 0, 0, 0,
 834             0
 835         }
 836     };
 837
 838     const char* PATTERN[] = {
 839         "X", "XX", "XXX", "XXXX", "XXXXX",
 840         "x", "xx", "xxx", "xxxx", "xxxxx",
 841         "Z", // equivalent to "xxxx"
 842         0
 843     };
 844
 845     const int32_t MIN_OFFSET_UNIT[] = {
 846         60000, 60000, 60000, 1000, 1000,
 847         60000, 60000, 60000, 1000, 1000,
 848         1000,
 849     };
 850
 851     // Formatting
 852     UErrorCode status = U_ZERO_ERROR;
 853     LocalPointer<SimpleDateFormat> sdf(new SimpleDateFormat(status));
 854     if (U_FAILURE(status)) {
 855         dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status));
 856         return;
 857     }
 858     UDate d = Calendar::getNow();
 859
 860     for (uint32_t i = 0; i < sizeof(OFFSET)/sizeof(OFFSET[0]); i++) {
 861         SimpleTimeZone* tz = new SimpleTimeZone(OFFSET[i], UnicodeString("Zone Offset:") + OFFSET[i] + "ms");
 862         sdf->adoptTimeZone(tz);
 863         for (int32_t j = 0; PATTERN[j] != 0; j++) {
 864             sdf->applyPattern(UnicodeString(PATTERN[j]));
 865             UnicodeString result;
 866             sdf->format(d, result);
 867
 868             if (ISO_STR[i][j]) {
 869                 if (result != UnicodeString(ISO_STR[i][j])) {
 870                     errln((UnicodeString)"FAIL: pattern=" + PATTERN[j] + ", offset=" + OFFSET[i] + " -> "
 871                         + result + " (expected: " + ISO_STR[i][j] + ")");
 872                 }
 873             } else {
 874                 // Offset out of range
 875                 // Note: for now, there is no way to propagate the error status through
 876                 // the SimpleDateFormat::format above.
 877                 if (result.length() > 0) {
 878                     errln((UnicodeString)"FAIL: Non-Empty result for pattern=" + PATTERN[j] + ", offset=" + OFFSET[i]
 879                         + " (expected: empty result)");
 880                 }
 881             }
 882         }
 883     }
 884
 885     // Parsing
 886     LocalPointer<Calendar> outcal(Calendar::createInstance(status));
 887     if (U_FAILURE(status)) {
 888         dataerrln("Fail new Calendar: %s", u_errorName(status));
 889         return;
 890     }
 891     for (int32_t i = 0; ISO_STR[i][0] != NULL; i++) {
 892         for (int32_t j = 0; PATTERN[j] != 0; j++) {
 893             if (ISO_STR[i][j] == 0) {
 894                 continue;
 895             }
 896             ParsePosition pos(0);
 897             SimpleTimeZone* bogusTZ = new SimpleTimeZone(-1, UnicodeString("Zone Offset: -1ms"));
 898             outcal->adoptTimeZone(bogusTZ);
 899             sdf->applyPattern(PATTERN[j]);
 900
 901             sdf->parse(UnicodeString(ISO_STR[i][j]), *(outcal.getAlias()), pos);
 902
 903             if (pos.getIndex() != (int32_t)uprv_strlen(ISO_STR[i][j])) {
 904                 errln((UnicodeString)"FAIL: Failed to parse the entire input string: " + ISO_STR[i][j]);
 905             }
 906
 907             const TimeZone& outtz = outcal->getTimeZone();
 908             int32_t outOffset = outtz.getRawOffset();
 909             int32_t adjustedOffset = OFFSET[i] / MIN_OFFSET_UNIT[j] * MIN_OFFSET_UNIT[j];
 910             if (outOffset != adjustedOffset) {
 911                 errln((UnicodeString)"FAIL: Incorrect offset:" + outOffset + "ms for input string: " + ISO_STR[i][j]
 912                     + " (expected:" + adjustedOffset + "ms)");
 913             }
 914         }
 915     }
 916 }
 917
 918
 919 #endif /* #if !UCONFIG_NO_FORMATTING */