source/test/intltest/tzfmttst.cpp

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 *******************************************************************************
   5 * Copyright (C) 2007-2015, International Business Machines Corporation and    *
   6 * others. All Rights Reserved.                                                *
   7 *******************************************************************************
   8 */
   9 #include "unicode/utypes.h"
  10
  11 #if !UCONFIG_NO_FORMATTING
  12
  13 #include "tzfmttst.h"
  14
  15 #include "unicode/timezone.h"
  16 #include "unicode/simpletz.h"
  17 #include "unicode/calendar.h"
  18 #include "unicode/strenum.h"
  19 #include "unicode/smpdtfmt.h"
  20 #include "unicode/uchar.h"
  21 #include "unicode/basictz.h"
  22 #include "unicode/tzfmt.h"
  23 #include "unicode/localpointer.h"
  24
  25 #include "cstring.h"
  26 #include "cstr.h"
  27 #include "mutex.h"
  28 #include "simplethread.h"
  29 #include "uassert.h"
  30 #include "zonemeta.h"
  31
  32 static const char* PATTERNS[] = {
  33     "z",
  34     "zzzz",
  35     "Z",    // equivalent to "xxxx"
  36     "ZZZZ", // equivalent to "OOOO"
  37     "v",
  38     "vvvv",
  39     "O",
  40     "OOOO",
  41     "X",
  42     "XX",
  43     "XXX",
  44     "XXXX",
  45     "XXXXX",
  46     "x",
  47     "xx",
  48     "xxx",
  49     "xxxx",
  50     "xxxxx",
  51     "V",
  52     "VV",
  53     "VVV",
  54     "VVVV"
  55 };
  56
  57 static const UChar ETC_UNKNOWN[] = {0x45, 0x74, 0x63, 0x2F, 0x55, 0x6E, 0x6B, 0x6E, 0x6F, 0x77, 0x6E, 0};
  58
  59 static const UChar ETC_SLASH[] = { 0x45, 0x74, 0x63, 0x2F, 0 }; // "Etc/"
  60 static const UChar SYSTEMV_SLASH[] = { 0x53, 0x79, 0x73, 0x74, 0x65, 0x6D, 0x56, 0x2F, 0 }; // "SystemV/
  61 static const UChar RIYADH8[] = { 0x52, 0x69, 0x79, 0x61, 0x64, 0x68, 0x38, 0 }; // "Riyadh8"
  62
  63 static UBool contains(const char** list, const char* str) {
  64     for (int32_t i = 0; list[i]; i++) {
  65         if (uprv_strcmp(list[i], str) == 0) {
  66             return TRUE;
  67         }
  68     }
  69     return FALSE;
  70 }
  71
  72 void
  73 TimeZoneFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  74 {
  75     if (exec) {
  76         logln("TestSuite TimeZoneFormatTest");
  77     }
  78     switch (index) {
  79         TESTCASE(0, TestTimeZoneRoundTrip);
  80         TESTCASE(1, TestTimeRoundTrip);
  81         TESTCASE(2, TestParse);
  82         TESTCASE(3, TestISOFormat);
  83         TESTCASE(4, TestFormat);
  84         TESTCASE(5, TestFormatTZDBNames);
  85         default: name = ""; break;
  86     }
  87 }
  88
  89 void
  90 TimeZoneFormatTest::TestTimeZoneRoundTrip(void) {
  91     UErrorCode status = U_ZERO_ERROR;
  92
  93     SimpleTimeZone unknownZone(-31415, ETC_UNKNOWN);
  94     int32_t badDstOffset = -1234;
  95     int32_t badZoneOffset = -2345;
  96
  97     int32_t testDateData[][3] = {
  98         {2007, 1, 15},
  99         {2007, 6, 15},
 100         {1990, 1, 15},
 101         {1990, 6, 15},
 102         {1960, 1, 15},
 103         {1960, 6, 15},
 104     };
 105
 106     Calendar *cal = Calendar::createInstance(TimeZone::createTimeZone((UnicodeString)"UTC"), status);
 107     if (U_FAILURE(status)) {
 108         dataerrln("Calendar::createInstance failed: %s", u_errorName(status));
 109         return;
 110     }
 111
 112     // Set up rule equivalency test range
 113     UDate low, high;
 114     cal->set(1900, UCAL_JANUARY, 1);
 115     low = cal->getTime(status);
 116     cal->set(2040, UCAL_JANUARY, 1);
 117     high = cal->getTime(status);
 118     if (U_FAILURE(status)) {
 119         errln("getTime failed");
 120         return;
 121     }
 122
 123     // Set up test dates
 124     UDate DATES[UPRV_LENGTHOF(testDateData)];
 125     const int32_t nDates = UPRV_LENGTHOF(testDateData);
 126     cal->clear();
 127     for (int32_t i = 0; i < nDates; i++) {
 128         cal->set(testDateData[i][0], testDateData[i][1], testDateData[i][2]);
 129         DATES[i] = cal->getTime(status);
 130         if (U_FAILURE(status)) {
 131             errln("getTime failed");
 132             return;
 133         }
 134     }
 135
 136     // Set up test locales
 137     const Locale testLocales[] = {
 138         Locale("en"),
 139         Locale("en_CA"),
 140         Locale("fr"),
 141         Locale("zh_Hant")
 142     };
 143
 144     const Locale *LOCALES;
 145     int32_t nLocales;
 146
 147     if (quick) {
 148         LOCALES = testLocales;
 149         nLocales = UPRV_LENGTHOF(testLocales);
 150     } else {
 151         LOCALES = Locale::getAvailableLocales(nLocales);
 152     }
 153
 154     StringEnumeration *tzids = TimeZone::createEnumeration();
 155     int32_t inRaw, inDst;
 156     int32_t outRaw, outDst;
 157
 158     // Run the roundtrip test
 159     for (int32_t locidx = 0; locidx < nLocales; locidx++) {
 160         UnicodeString localGMTString;
 161         SimpleDateFormat gmtFmt(UnicodeString("ZZZZ"), LOCALES[locidx], status);
 162         if (U_FAILURE(status)) {
 163             dataerrln("Error creating SimpleDateFormat - %s", u_errorName(status));
 164             continue;
 165         }
 166         gmtFmt.setTimeZone(*TimeZone::getGMT());
 167         gmtFmt.format(0.0, localGMTString);
 168
 169         for (int32_t patidx = 0; patidx < UPRV_LENGTHOF(PATTERNS); patidx++) {
 170
 171             SimpleDateFormat *sdf = new SimpleDateFormat((UnicodeString)PATTERNS[patidx], LOCALES[locidx], status);
 172             if (U_FAILURE(status)) {
 173                 dataerrln((UnicodeString)"new SimpleDateFormat failed for pattern " +
 174                     PATTERNS[patidx] + " for locale " + LOCALES[locidx].getName() + " - " + u_errorName(status));
 175                 status = U_ZERO_ERROR;
 176                 continue;
 177             }
 178
 179             tzids->reset(status);
 180             const UnicodeString *tzid;
 181             while ((tzid = tzids->snext(status))) {
 182                 TimeZone *tz = TimeZone::createTimeZone(*tzid);
 183
 184                 for (int32_t datidx = 0; datidx < nDates; datidx++) {
 185                     UnicodeString tzstr;
 186                     FieldPosition fpos(FieldPosition::DONT_CARE);
 187                     // Format
 188                     sdf->setTimeZone(*tz);
 189                     sdf->format(DATES[datidx], tzstr, fpos);
 190
 191                     // Before parse, set unknown zone to SimpleDateFormat instance
 192                     // just for making sure that it does not depends on the time zone
 193                     // originally set.
 194                     sdf->setTimeZone(unknownZone);
 195
 196                     // Parse
 197                     ParsePosition pos(0);
 198                     Calendar *outcal = Calendar::createInstance(unknownZone, status);
 199                     if (U_FAILURE(status)) {
 200                         errln("Failed to create an instance of calendar for receiving parse result.");
 201                         status = U_ZERO_ERROR;
 202                         continue;
 203                     }
 204                     outcal->set(UCAL_DST_OFFSET, badDstOffset);
 205                     outcal->set(UCAL_ZONE_OFFSET, badZoneOffset);
 206
 207                     sdf->parse(tzstr, *outcal, pos);
 208
 209                     // Check the result
 210                     const TimeZone &outtz = outcal->getTimeZone();
 211                     UnicodeString outtzid;
 212                     outtz.getID(outtzid);
 213
 214                     tz->getOffset(DATES[datidx], false, inRaw, inDst, status);
 215                     if (U_FAILURE(status)) {
 216                         errln((UnicodeString)"Failed to get offsets from time zone" + *tzid);
 217                         status = U_ZERO_ERROR;
 218                     }
 219                     outtz.getOffset(DATES[datidx], false, outRaw, outDst, status);
 220                     if (U_FAILURE(status)) {
 221                         errln((UnicodeString)"Failed to get offsets from time zone" + outtzid);
 222                         status = U_ZERO_ERROR;
 223                     }
 224
 225                     if (uprv_strcmp(PATTERNS[patidx], "V") == 0) {
 226                         // Short zone ID - should support roundtrip for canonical CLDR IDs
 227                         UnicodeString canonicalID;
 228                         TimeZone::getCanonicalID(*tzid, canonicalID, status);
 229                         if (U_FAILURE(status)) {
 230                             // Uknown ID - we should not get here
 231                             errln((UnicodeString)"Unknown ID " + *tzid);
 232                             status = U_ZERO_ERROR;
 233                         } else if (outtzid != canonicalID) {
 234                             if (outtzid.compare(ETC_UNKNOWN, -1) == 0) {
 235                                 // Note that some zones like Asia/Riyadh87 does not have
 236                                 // short zone ID and "unk" is used as fallback
 237                                 logln((UnicodeString)"Canonical round trip failed (probably as expected); tz=" + *tzid
 238                                         + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 239                                         + ", time=" + DATES[datidx] + ", str=" + tzstr
 240                                         + ", outtz=" + outtzid);
 241                             } else {
 242                                 errln((UnicodeString)"Canonical round trip failed; tz=" + *tzid
 243                                     + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 244                                     + ", time=" + DATES[datidx] + ", str=" + tzstr
 245                                     + ", outtz=" + outtzid);
 246                             }
 247                         }
 248                     } else if (uprv_strcmp(PATTERNS[patidx], "VV") == 0) {
 249                         // Zone ID - full roundtrip support
 250                         if (outtzid != *tzid) {
 251                             errln((UnicodeString)"Zone ID round trip failued; tz="  + *tzid
 252                                 + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 253                                 + ", time=" + DATES[datidx] + ", str=" + tzstr
 254                                 + ", outtz=" + outtzid);
 255                         }
 256                     } else if (uprv_strcmp(PATTERNS[patidx], "VVV") == 0 || uprv_strcmp(PATTERNS[patidx], "VVVV") == 0) {
 257                         // Location: time zone rule must be preserved except
 258                         // zones not actually associated with a specific location.
 259                         // Time zones in this category do not have "/" in its ID.
 260                         UnicodeString canonical;
 261                         TimeZone::getCanonicalID(*tzid, canonical, status);
 262                         if (U_FAILURE(status)) {
 263                             // Uknown ID - we should not get here
 264                             errln((UnicodeString)"Unknown ID " + *tzid);
 265                             status = U_ZERO_ERROR;
 266                         } else if (outtzid != canonical) {
 267                             // Canonical ID did not match - check the rules
 268                             if (!((BasicTimeZone*)&outtz)->hasEquivalentTransitions((BasicTimeZone&)*tz, low, high, TRUE, status)) {
 269                                 if (canonical.indexOf((UChar)0x27 /*'/'*/) == -1) {
 270                                     // Exceptional cases, such as CET, EET, MET and WET
 271                                     logln((UnicodeString)"Canonical round trip failed (as expected); tz=" + *tzid
 272                                             + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 273                                             + ", time=" + DATES[datidx] + ", str=" + tzstr
 274                                             + ", outtz=" + outtzid);
 275                                 } else {
 276                                     errln((UnicodeString)"Canonical round trip failed; tz=" + *tzid
 277                                         + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 278                                         + ", time=" + DATES[datidx] + ", str=" + tzstr
 279                                         + ", outtz=" + outtzid);
 280                                 }
 281                                 if (U_FAILURE(status)) {
 282                                     errln("hasEquivalentTransitions failed");
 283                                     status = U_ZERO_ERROR;
 284                                 }
 285                             }
 286                         }
 287
 288                     } else {
 289                         UBool isOffsetFormat = (*PATTERNS[patidx] == 'Z'
 290                                                 || *PATTERNS[patidx] == 'O'
 291                                                 || *PATTERNS[patidx] == 'X'
 292                                                 || *PATTERNS[patidx] == 'x');
 293                         UBool minutesOffset = FALSE;
 294                         if (*PATTERNS[patidx] == 'X' || *PATTERNS[patidx] == 'x') {
 295                             minutesOffset = (uprv_strlen(PATTERNS[patidx]) <= 3);
 296                         }
 297
 298                         if (!isOffsetFormat) {
 299                             // Check if localized GMT format is used as a fallback of name styles
 300                             int32_t numDigits = 0;
 301                             for (int n = 0; n < tzstr.length(); n++) {
 302                                 if (u_isdigit(tzstr.charAt(n))) {
 303                                     numDigits++;
 304                                 }
 305                             }
 306                             isOffsetFormat = (numDigits > 0);
 307                         }
 308                         if (isOffsetFormat || tzstr == localGMTString) {
 309                             // Localized GMT or ISO: total offset (raw + dst) must be preserved.
 310                             int32_t inOffset = inRaw + inDst;
 311                             int32_t outOffset = outRaw + outDst;
 312                             int32_t diff = outOffset - inOffset;
 313                             if (minutesOffset) {
 314                                 diff = (diff / 60000) * 60000;
 315                             }
 316                             if (diff != 0) {
 317                                 errln((UnicodeString)"Offset round trip failed; tz=" + *tzid
 318                                     + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 319                                     + ", time=" + DATES[datidx] + ", str=" + tzstr
 320                                     + ", inOffset=" + inOffset + ", outOffset=" + outOffset);
 321                             }
 322                         } else {
 323                             // Specific or generic: raw offset must be preserved.
 324                             if (inRaw != outRaw) {
 325                                 errln((UnicodeString)"Raw offset round trip failed; tz=" + *tzid
 326                                     + ", locale=" + LOCALES[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 327                                     + ", time=" + DATES[datidx] + ", str=" + tzstr
 328                                     + ", inRawOffset=" + inRaw + ", outRawOffset=" + outRaw);
 329                             }
 330                         }
 331                     }
 332                     delete outcal;
 333                 }
 334                 delete tz;
 335             }
 336             delete sdf;
 337         }
 338     }
 339     delete cal;
 340     delete tzids;
 341 }
 342
 343 // Special exclusions in TestTimeZoneRoundTrip.
 344 // These special cases do not round trip time as designed.
 345 static UBool isSpecialTimeRoundTripCase(const char* loc,
 346                                         const UnicodeString& id,
 347                                         const char* pattern,
 348                                         UDate time) {
 349     struct {
 350         const char* loc;
 351         const char* id;
 352         const char* pattern;
 353         UDate time;
 354     } EXCLUSIONS[] = {
 355         {NULL, "Asia/Chita", "zzzz", 1414252800000.0},
 356         {NULL, "Asia/Chita", "vvvv", 1414252800000.0},
 357         {NULL, "Asia/Srednekolymsk", "zzzz", 1414241999999.0},
 358         {NULL, "Asia/Srednekolymsk", "vvvv", 1414241999999.0},
 359         {NULL, NULL, NULL, U_DATE_MIN}
 360     };
 361
 362     UBool isExcluded = FALSE;
 363     for (int32_t i = 0; EXCLUSIONS[i].id != NULL; i++) {
 364         if (EXCLUSIONS[i].loc == NULL || uprv_strcmp(loc, EXCLUSIONS[i].loc) == 0) {
 365             if (id.compare(EXCLUSIONS[i].id) == 0) {
 366                 if (EXCLUSIONS[i].pattern == NULL || uprv_strcmp(pattern, EXCLUSIONS[i].pattern) == 0) {
 367                     if (EXCLUSIONS[i].time == U_DATE_MIN || EXCLUSIONS[i].time == time) {
 368                         isExcluded = TRUE;
 369                     }
 370                 }
 371             }
 372         }
 373     }
 374     return isExcluded;
 375 }
 376
 377 // LocaleData. Somewhat misnamed. For TestTimeZoneRoundTrip, specifies the locales and patterns
 378 //             to be tested, and provides an iterator over these for the multi-threaded test
 379 //             functions to pick up the next combination to be tested.
 380 //
 381 //             A single global instance of this struct is shared among all
 382 //             the test threads.
 383 //
 384 //             "locales" is an array of locales to be tested.
 385 //             PATTERNS (a global) is an array of patterns to be tested for each locale.
 386 //             "localeIndex" and "patternIndex" keep track of the iteration through the above.
 387 //             Each of the parallel test threads calls LocaleData::nextTest() in a loop
 388 //                to find out what to test next. It must be thread safe.
 389 struct LocaleData {
 390     int32_t localeIndex;
 391     int32_t patternIndex;
 392     int32_t testCounts;
 393     UDate times[UPRV_LENGTHOF(PATTERNS)];    // Performance data, Elapsed time for each pattern.
 394     const Locale* locales;
 395     int32_t nLocales;
 396     UDate START_TIME;
 397     UDate END_TIME;
 398     int32_t numDone;
 399
 400     LocaleData() : localeIndex(0), patternIndex(0), testCounts(0), locales(NULL),
 401                    nLocales(0), START_TIME(0), END_TIME(0), numDone(0) {
 402         for (int i=0; i<UPRV_LENGTHOF(times); i++) {
 403             times[i] = 0;
 404         }
 405     };
 406
 407     void resetTestIteration() {
 408         localeIndex = -1;
 409         patternIndex = UPRV_LENGTHOF(PATTERNS);
 410         numDone = 0;
 411     }
 412
 413     UBool nextTest(int32_t &rLocaleIndex, int32_t &rPatternIndex) {
 414         Mutex lock;
 415         if (patternIndex >= UPRV_LENGTHOF(PATTERNS) - 1) {
 416             if (localeIndex >= nLocales - 1) {
 417                 return FALSE;
 418             }
 419             patternIndex = -1;
 420             ++localeIndex;
 421         }
 422         ++patternIndex;
 423         rLocaleIndex = localeIndex;
 424         rPatternIndex = patternIndex;
 425         ++numDone;
 426         return TRUE;
 427     }
 428
 429     void addTime(UDate amount, int32_t patIdx) {
 430         Mutex lock;
 431         U_ASSERT(patIdx < UPRV_LENGTHOF(PATTERNS));
 432         times[patIdx] += amount;
 433     }
 434 };
 435
 436 static LocaleData *gLocaleData = NULL;
 437
 438 void
 439 TimeZoneFormatTest::TestTimeRoundTrip(void) {
 440     UErrorCode status = U_ZERO_ERROR;
 441     LocalPointer <Calendar> cal(Calendar::createInstance(TimeZone::createTimeZone((UnicodeString) "UTC"), status));
 442     if (U_FAILURE(status)) {
 443         dataerrln("Calendar::createInstance failed: %s", u_errorName(status));
 444         return;
 445     }
 446
 447     const char* testAllProp = getProperty("TimeZoneRoundTripAll");
 448     UBool bTestAll = (testAllProp && uprv_strcmp(testAllProp, "true") == 0);
 449
 450     UDate START_TIME, END_TIME;
 451     if (bTestAll || !quick) {
 452         cal->set(1900, UCAL_JANUARY, 1);
 453     } else {
 454         cal->set(1999, UCAL_JANUARY, 1);
 455     }
 456     START_TIME = cal->getTime(status);
 457
 458     cal->set(2022, UCAL_JANUARY, 1);
 459     END_TIME = cal->getTime(status);
 460
 461     if (U_FAILURE(status)) {
 462         errln("getTime failed");
 463         return;
 464     }
 465
 466     LocaleData localeData;
 467     gLocaleData = &localeData;
 468
 469     // Set up test locales
 470     const Locale locales1[] = {Locale("en")};
 471     const Locale locales2[] = {
 472         Locale("ar_EG"), Locale("bg_BG"), Locale("ca_ES"), Locale("da_DK"), Locale("de"),
 473         Locale("de_DE"), Locale("el_GR"), Locale("en"), Locale("en_AU"), Locale("en_CA"),
 474         Locale("en_US"), Locale("es"), Locale("es_ES"), Locale("es_MX"), Locale("fi_FI"),
 475         Locale("fr"), Locale("fr_CA"), Locale("fr_FR"), Locale("he_IL"), Locale("hu_HU"),
 476         Locale("it"), Locale("it_IT"), Locale("ja"), Locale("ja_JP"), Locale("ko"),
 477         Locale("ko_KR"), Locale("nb_NO"), Locale("nl_NL"), Locale("nn_NO"), Locale("pl_PL"),
 478         Locale("pt"), Locale("pt_BR"), Locale("pt_PT"), Locale("ru_RU"), Locale("sv_SE"),
 479         Locale("th_TH"), Locale("tr_TR"), Locale("zh"), Locale("zh_Hans"), Locale("zh_Hans_CN"),
 480         Locale("zh_Hant"), Locale("zh_Hant_TW")
 481     };
 482
 483     if (bTestAll) {
 484         gLocaleData->locales = Locale::getAvailableLocales(gLocaleData->nLocales);
 485     } else if (quick) {
 486         gLocaleData->locales = locales1;
 487         gLocaleData->nLocales = UPRV_LENGTHOF(locales1);
 488     } else {
 489         gLocaleData->locales = locales2;
 490         gLocaleData->nLocales = UPRV_LENGTHOF(locales2);
 491     }
 492
 493     gLocaleData->START_TIME = START_TIME;
 494     gLocaleData->END_TIME = END_TIME;
 495     gLocaleData->resetTestIteration();
 496
 497     // start IntlTest.threadCount threads, each running the function RunTimeRoundTripTests().
 498
 499     ThreadPool<TimeZoneFormatTest> threads(this, threadCount, &TimeZoneFormatTest::RunTimeRoundTripTests);
 500     threads.start();   // Start all threads.
 501     threads.join();    // Wait for all threads to finish.
 502
 503     UDate total = 0;
 504     logln("### Elapsed time by patterns ###");
 505     for (int32_t i = 0; i < UPRV_LENGTHOF(PATTERNS); i++) {
 506         logln(UnicodeString("") + gLocaleData->times[i] + "ms (" + PATTERNS[i] + ")");
 507         total += gLocaleData->times[i];
 508     }
 509     logln((UnicodeString) "Total: " + total + "ms");
 510     logln((UnicodeString) "Iteration: " + gLocaleData->testCounts);
 511 }
 512
 513
 514 // TimeZoneFormatTest::RunTimeRoundTripTests()
 515 //    This function loops, running time zone format round trip test cases until there are no more, then returns.
 516 //    Threading: multiple invocations of this function are started in parallel
 517 //               by TimeZoneFormatTest::TestTimeRoundTrip()
 518 //
 519 void TimeZoneFormatTest::RunTimeRoundTripTests(int32_t threadNumber) {
 520     UErrorCode status = U_ZERO_ERROR;
 521     UBool REALLY_VERBOSE = FALSE;
 522
 523     // These patterns are ambiguous at DST->STD local time overlap
 524     const char* AMBIGUOUS_DST_DECESSION[] = { "v", "vvvv", "V", "VV", "VVV", "VVVV", 0 };
 525
 526     // These patterns are ambiguous at STD->STD/DST->DST local time overlap
 527     const char* AMBIGUOUS_NEGATIVE_SHIFT[] = { "z", "zzzz", "v", "vvvv", "V", "VV", "VVV", "VVVV", 0 };
 528
 529     // These patterns only support integer minutes offset
 530     const char* MINUTES_OFFSET[] = { "X", "XX", "XXX", "x", "xx", "xxx", 0 };
 531
 532     // Workaround for #6338
 533     //UnicodeString BASEPATTERN("yyyy-MM-dd'T'HH:mm:ss.SSS");
 534     UnicodeString BASEPATTERN("yyyy.MM.dd HH:mm:ss.SSS");
 535
 536     // timer for performance analysis
 537     UDate timer;
 538     UDate testTimes[4];
 539     UBool expectedRoundTrip[4];
 540     int32_t testLen = 0;
 541
 542     StringEnumeration *tzids = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, status);
 543     if (U_FAILURE(status)) {
 544         if (status == U_MISSING_RESOURCE_ERROR) {
 545             // This error is generally caused by data not being present.
 546             dataerrln("TimeZone::createTimeZoneIDEnumeration failed - %s", u_errorName(status));
 547         } else {
 548             errln("TimeZone::createTimeZoneIDEnumeration failed: %s", u_errorName(status));
 549         }
 550         return;
 551     }
 552
 553     int32_t locidx = -1;
 554     int32_t patidx = -1;
 555
 556     while (gLocaleData->nextTest(locidx, patidx)) {
 557
 558         UnicodeString pattern(BASEPATTERN);
 559         pattern.append(" ").append(PATTERNS[patidx]);
 560         logln("    Thread %d, Locale %s, Pattern %s",
 561                 threadNumber, gLocaleData->locales[locidx].getName(), CStr(pattern)());
 562
 563         SimpleDateFormat *sdf = new SimpleDateFormat(pattern, gLocaleData->locales[locidx], status);
 564         if (U_FAILURE(status)) {
 565             errcheckln(status, (UnicodeString) "new SimpleDateFormat failed for pattern " +
 566                 pattern + " for locale " + gLocaleData->locales[locidx].getName() + " - " + u_errorName(status));
 567             status = U_ZERO_ERROR;
 568             continue;
 569         }
 570
 571         UBool minutesOffset = contains(MINUTES_OFFSET, PATTERNS[patidx]);
 572
 573         tzids->reset(status);
 574         const UnicodeString *tzid;
 575
 576         timer = Calendar::getNow();
 577
 578         while ((tzid = tzids->snext(status))) {
 579             if (uprv_strcmp(PATTERNS[patidx], "V") == 0) {
 580                 // Some zones do not have short ID assigned, such as Asia/Riyadh87.
 581                 // The time roundtrip will fail for such zones with pattern "V" (short zone ID).
 582                 // This is expected behavior.
 583                 const UChar* shortZoneID = ZoneMeta::getShortID(*tzid);
 584                 if (shortZoneID == NULL) {
 585                     continue;
 586                 }
 587             } else if (uprv_strcmp(PATTERNS[patidx], "VVV") == 0) {
 588                 // Some zones are not associated with any region, such as Etc/GMT+8.
 589                 // The time roundtrip will fail for such zone with pattern "VVV" (exemplar location).
 590                 // This is expected behavior.
 591                 if (tzid->indexOf((UChar)0x2F) < 0 || tzid->indexOf(ETC_SLASH, -1, 0) >= 0
 592                     || tzid->indexOf(SYSTEMV_SLASH, -1, 0) >= 0 || tzid->indexOf(RIYADH8, -1, 0) >= 0) {
 593                     continue;
 594                 }
 595             }
 596
 597             if (*tzid == "Pacific/Apia" && uprv_strcmp(PATTERNS[patidx], "vvvv") == 0
 598                     && logKnownIssue("11052", "Ambiguous zone name - Samoa Time")) {
 599                 continue;
 600             }
 601
 602             BasicTimeZone *tz = (BasicTimeZone*) TimeZone::createTimeZone(*tzid);
 603             sdf->setTimeZone(*tz);
 604
 605             UDate t = gLocaleData->START_TIME;
 606             TimeZoneTransition tzt;
 607             UBool tztAvail = FALSE;
 608             UBool middle = TRUE;
 609
 610             while (t < gLocaleData->END_TIME) {
 611                 if (!tztAvail) {
 612                     testTimes[0] = t;
 613                     expectedRoundTrip[0] = TRUE;
 614                     testLen = 1;
 615                 } else {
 616                     int32_t fromOffset = tzt.getFrom()->getRawOffset() + tzt.getFrom()->getDSTSavings();
 617                     int32_t toOffset = tzt.getTo()->getRawOffset() + tzt.getTo()->getDSTSavings();
 618                     int32_t delta = toOffset - fromOffset;
 619                     if (delta < 0) {
 620                         UBool isDstDecession = tzt.getFrom()->getDSTSavings() > 0 && tzt.getTo()->getDSTSavings() == 0;
 621                         testTimes[0] = t + delta - 1;
 622                         expectedRoundTrip[0] = TRUE;
 623                         testTimes[1] = t + delta;
 624                         expectedRoundTrip[1] = isDstDecession ?
 625                             !contains(AMBIGUOUS_DST_DECESSION, PATTERNS[patidx]) :
 626                             !contains(AMBIGUOUS_NEGATIVE_SHIFT, PATTERNS[patidx]);
 627                         testTimes[2] = t - 1;
 628                         expectedRoundTrip[2] = isDstDecession ?
 629                             !contains(AMBIGUOUS_DST_DECESSION, PATTERNS[patidx]) :
 630                             !contains(AMBIGUOUS_NEGATIVE_SHIFT, PATTERNS[patidx]);
 631                         testTimes[3] = t;
 632                         expectedRoundTrip[3] = TRUE;
 633                         testLen = 4;
 634                     } else {
 635                         testTimes[0] = t - 1;
 636                         expectedRoundTrip[0] = TRUE;
 637                         testTimes[1] = t;
 638                         expectedRoundTrip[1] = TRUE;
 639                         testLen = 2;
 640                     }
 641                 }
 642                 for (int32_t testidx = 0; testidx < testLen; testidx++) {
 643                     if (quick) {
 644                         // reduce regular test time
 645                         if (!expectedRoundTrip[testidx]) {
 646                             continue;
 647                         }
 648                     }
 649
 650                     {
 651                         Mutex lock;
 652                         gLocaleData->testCounts++;
 653                     }
 654
 655                     UnicodeString text;
 656                     FieldPosition fpos(FieldPosition::DONT_CARE);
 657                     sdf->format(testTimes[testidx], text, fpos);
 658
 659                     UDate parsedDate = sdf->parse(text, status);
 660                     if (U_FAILURE(status)) {
 661                         errln((UnicodeString) "Parse failure for text=" + text + ", tzid=" + *tzid + ", locale=" + gLocaleData->locales[locidx].getName()
 662                                 + ", pattern=" + PATTERNS[patidx] + ", time=" + testTimes[testidx]);
 663                         status = U_ZERO_ERROR;
 664                         continue;
 665                     }
 666
 667                     int32_t timeDiff = (int32_t)(parsedDate - testTimes[testidx]);
 668                     UBool bTimeMatch = minutesOffset ?
 669                         (timeDiff/60000)*60000 == 0 : timeDiff == 0;
 670                     if (!bTimeMatch) {
 671                         UnicodeString msg = (UnicodeString) "Time round trip failed for " + "tzid=" + *tzid
 672                                 + ", locale=" + gLocaleData->locales[locidx].getName() + ", pattern=" + PATTERNS[patidx]
 673                                 + ", text=" + text + ", time=" + testTimes[testidx] + ", restime=" + parsedDate + ", diff=" + (parsedDate - testTimes[testidx]);
 674                         // Timebomb for TZData update
 675                         if (expectedRoundTrip[testidx]
 676                                 && !isSpecialTimeRoundTripCase(gLocaleData->locales[locidx].getName(), *tzid,
 677                                         PATTERNS[patidx], testTimes[testidx])) {
 678                             errln((UnicodeString) "FAIL: " + msg);
 679                         } else if (REALLY_VERBOSE) {
 680                             logln(msg);
 681                         }
 682                     }
 683                 }
 684                 tztAvail = tz->getNextTransition(t, FALSE, tzt);
 685                 if (!tztAvail) {
 686                     break;
 687                 }
 688                 if (middle) {
 689                     // Test the date in the middle of two transitions.
 690                     t += (int64_t) ((tzt.getTime() - t) / 2);
 691                     middle = FALSE;
 692                     tztAvail = FALSE;
 693                 } else {
 694                     t = tzt.getTime();
 695                 }
 696             }
 697             delete tz;
 698         }
 699         UDate elapsedTime = Calendar::getNow() - timer;
 700         gLocaleData->addTime(elapsedTime, patidx);
 701         delete sdf;
 702     }
 703     delete tzids;
 704 }
 705
 706
 707 typedef struct {
 708     const char*     text;
 709     int32_t         inPos;
 710     const char*     locale;
 711     UTimeZoneFormatStyle    style;
 712     uint32_t        parseOptions;
 713     const char*     expected;
 714     int32_t         outPos;
 715     UTimeZoneFormatTimeType timeType;
 716 } ParseTestData;
 717
 718 void
 719 TimeZoneFormatTest::TestParse(void) {
 720     const ParseTestData DATA[] = {
 721         //   text               inPos   locale      style
 722         //      parseOptions                        expected            outPos  timeType
 723             {"Z",               0,      "en_US",    UTZFMT_STYLE_ISO_EXTENDED_FULL,
 724                 UTZFMT_PARSE_OPTION_NONE,           "Etc/GMT",          1,      UTZFMT_TIME_TYPE_UNKNOWN},
 725
 726             {"Z",               0,      "en_US",    UTZFMT_STYLE_SPECIFIC_LONG,
 727                 UTZFMT_PARSE_OPTION_NONE,           "Etc/GMT",          1,      UTZFMT_TIME_TYPE_UNKNOWN},
 728
 729             {"Zambia time",     0,      "en_US",    UTZFMT_STYLE_ISO_EXTENDED_FULL,
 730                 UTZFMT_PARSE_OPTION_ALL_STYLES,     "Etc/GMT",          1,      UTZFMT_TIME_TYPE_UNKNOWN},
 731
 732             {"Zambia time",     0,      "en_US",    UTZFMT_STYLE_GENERIC_LOCATION,
 733                 UTZFMT_PARSE_OPTION_NONE,           "Africa/Lusaka",    11,     UTZFMT_TIME_TYPE_UNKNOWN},
 734
 735             {"Zambia time",     0,      "en_US",    UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,
 736                 UTZFMT_PARSE_OPTION_ALL_STYLES,     "Africa/Lusaka",    11,     UTZFMT_TIME_TYPE_UNKNOWN},
 737
 738             {"+00:00",          0,      "en_US",    UTZFMT_STYLE_ISO_EXTENDED_FULL,
 739                 UTZFMT_PARSE_OPTION_NONE,           "Etc/GMT",          6,      UTZFMT_TIME_TYPE_UNKNOWN},
 740
 741             {"-01:30:45",       0,      "en_US",    UTZFMT_STYLE_ISO_EXTENDED_FULL,
 742                 UTZFMT_PARSE_OPTION_NONE,           "GMT-01:30:45",     9,      UTZFMT_TIME_TYPE_UNKNOWN},
 743
 744             {"-7",              0,      "en_US",    UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,
 745                 UTZFMT_PARSE_OPTION_NONE,           "GMT-07:00",        2,      UTZFMT_TIME_TYPE_UNKNOWN},
 746
 747             {"-2222",           0,      "en_US",    UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,
 748                 UTZFMT_PARSE_OPTION_NONE,           "GMT-22:22",        5,      UTZFMT_TIME_TYPE_UNKNOWN},
 749
 750             {"-3333",           0,      "en_US",    UTZFMT_STYLE_ISO_BASIC_LOCAL_FULL,
 751                 UTZFMT_PARSE_OPTION_NONE,           "GMT-03:33",        4,      UTZFMT_TIME_TYPE_UNKNOWN},
 752
 753             {"XXX+01:30YYY",    3,      "en_US",    UTZFMT_STYLE_LOCALIZED_GMT,
 754                 UTZFMT_PARSE_OPTION_NONE,           "GMT+01:30",        9,      UTZFMT_TIME_TYPE_UNKNOWN},
 755
 756             {"GMT0",            0,      "en_US",    UTZFMT_STYLE_SPECIFIC_SHORT,
 757                 UTZFMT_PARSE_OPTION_NONE,           "Etc/GMT",          3,      UTZFMT_TIME_TYPE_UNKNOWN},
 758
 759             {"EST",             0,      "en_US",    UTZFMT_STYLE_SPECIFIC_SHORT,
 760                 UTZFMT_PARSE_OPTION_NONE,           "America/New_York", 3,      UTZFMT_TIME_TYPE_STANDARD},
 761
 762             {"ESTx",            0,      "en_US",    UTZFMT_STYLE_SPECIFIC_SHORT,
 763                 UTZFMT_PARSE_OPTION_NONE,           "America/New_York", 3,      UTZFMT_TIME_TYPE_STANDARD},
 764
 765             {"EDTx",            0,      "en_US",    UTZFMT_STYLE_SPECIFIC_SHORT,
 766                 UTZFMT_PARSE_OPTION_NONE,           "America/New_York", 3,      UTZFMT_TIME_TYPE_DAYLIGHT},
 767
 768             {"EST",             0,      "en_US",    UTZFMT_STYLE_SPECIFIC_LONG,
 769                 UTZFMT_PARSE_OPTION_NONE,           NULL,               0,      UTZFMT_TIME_TYPE_UNKNOWN},
 770
 771             {"EST",             0,      "en_US",    UTZFMT_STYLE_SPECIFIC_LONG,
 772                 UTZFMT_PARSE_OPTION_ALL_STYLES,     "America/New_York", 3,      UTZFMT_TIME_TYPE_STANDARD},
 773
 774             {"EST",             0,      "en_CA",    UTZFMT_STYLE_SPECIFIC_SHORT,
 775                 UTZFMT_PARSE_OPTION_NONE,           "America/Toronto",  3,      UTZFMT_TIME_TYPE_STANDARD},
 776
 777             {"CST",             0,      "en_US",    UTZFMT_STYLE_SPECIFIC_SHORT,
 778                 UTZFMT_PARSE_OPTION_NONE,           "America/Chicago",  3,      UTZFMT_TIME_TYPE_STANDARD},
 779
 780             {"CST",             0,      "en_GB",    UTZFMT_STYLE_SPECIFIC_SHORT,
 781                 UTZFMT_PARSE_OPTION_NONE,           NULL,               0,      UTZFMT_TIME_TYPE_UNKNOWN},
 782
 783             {"CST",             0,      "en_GB",    UTZFMT_STYLE_SPECIFIC_SHORT,
 784                 UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS,  "America/Chicago",  3,  UTZFMT_TIME_TYPE_STANDARD},
 785
 786             {"--CST--",           2,    "en_GB",    UTZFMT_STYLE_SPECIFIC_SHORT,
 787                 UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS,  "America/Chicago",  5,  UTZFMT_TIME_TYPE_STANDARD},
 788
 789             {"CST",             0,      "zh_CN",    UTZFMT_STYLE_SPECIFIC_SHORT,
 790                 UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS,  "Asia/Shanghai",    3,  UTZFMT_TIME_TYPE_STANDARD},
 791
 792             {"AEST",            0,      "en_AU",    UTZFMT_STYLE_SPECIFIC_SHORT,
 793                 UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS,  "Australia/Sydney", 4,  UTZFMT_TIME_TYPE_STANDARD},
 794
 795             {"AST",             0,      "ar_SA",    UTZFMT_STYLE_SPECIFIC_SHORT,
 796                 UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS,  "Asia/Riyadh",      3,  UTZFMT_TIME_TYPE_STANDARD},
 797
 798             {"AQTST",           0,      "en",       UTZFMT_STYLE_SPECIFIC_LONG,
 799                 UTZFMT_PARSE_OPTION_NONE,           NULL,               0,      UTZFMT_TIME_TYPE_UNKNOWN},
 800
 801             {"AQTST",           0,      "en",       UTZFMT_STYLE_SPECIFIC_LONG,
 802                 UTZFMT_PARSE_OPTION_ALL_STYLES,     NULL,               0,      UTZFMT_TIME_TYPE_UNKNOWN},
 803
 804             {"AQTST",           0,      "en",       UTZFMT_STYLE_SPECIFIC_LONG,
 805                 UTZFMT_PARSE_OPTION_ALL_STYLES | UTZFMT_PARSE_OPTION_TZ_DATABASE_ABBREVIATIONS, "Asia/Aqtobe",  5,  UTZFMT_TIME_TYPE_DAYLIGHT},
 806
 807             {NULL,              0,      NULL,       UTZFMT_STYLE_GENERIC_LOCATION,
 808                 UTZFMT_PARSE_OPTION_NONE,           NULL,               0,      UTZFMT_TIME_TYPE_UNKNOWN}
 809     };
 810
 811     for (int32_t i = 0; DATA[i].text; i++) {
 812         UErrorCode status = U_ZERO_ERROR;
 813         LocalPointer<TimeZoneFormat> tzfmt(TimeZoneFormat::createInstance(Locale(DATA[i].locale), status));
 814         if (U_FAILURE(status)) {
 815             dataerrln("Fail TimeZoneFormat::createInstance: %s", u_errorName(status));
 816             continue;
 817         }
 818         UTimeZoneFormatTimeType ttype = UTZFMT_TIME_TYPE_UNKNOWN;
 819         ParsePosition pos(DATA[i].inPos);
 820         TimeZone* tz = tzfmt->parse(DATA[i].style, DATA[i].text, pos, DATA[i].parseOptions, &ttype);
 821
 822         UnicodeString errMsg;
 823         if (tz) {
 824             UnicodeString outID;
 825             tz->getID(outID);
 826             if (outID != UnicodeString(DATA[i].expected)) {
 827                 errMsg = (UnicodeString)"Time zone ID: " + outID + " - expected: " + DATA[i].expected;
 828             } else if (pos.getIndex() != DATA[i].outPos) {
 829                 errMsg = (UnicodeString)"Parsed pos: " + pos.getIndex() + " - expected: " + DATA[i].outPos;
 830             } else if (ttype != DATA[i].timeType) {
 831                 errMsg = (UnicodeString)"Time type: " + ttype + " - expected: " + DATA[i].timeType;
 832             }
 833             delete tz;
 834         } else {
 835             if (DATA[i].expected) {
 836                 errMsg = (UnicodeString)"Parse failure - expected: " + DATA[i].expected;
 837             }
 838         }
 839         if (errMsg.length() > 0) {
 840             errln((UnicodeString)"Fail: " + errMsg + " [text=" + DATA[i].text + ", pos=" + DATA[i].inPos + ", style=" + DATA[i].style + "]");
 841         }
 842     }
 843 }
 844
 845 void
 846 TimeZoneFormatTest::TestISOFormat(void) {
 847     const int32_t OFFSET[] = {
 848         0,          // 0
 849         999,        // 0.999s
 850         -59999,     // -59.999s
 851         60000,      // 1m
 852         -77777,     // -1m 17.777s
 853         1800000,    // 30m
 854         -3600000,   // -1h
 855         36000000,   // 10h
 856         -37800000,  // -10h 30m
 857         -37845000,  // -10h 30m 45s
 858         108000000,  // 30h
 859     };
 860
 861     const char* ISO_STR[][11] = {
 862         // 0
 863         {
 864             "Z", "Z", "Z", "Z", "Z",
 865             "+00", "+0000", "+00:00", "+0000", "+00:00",
 866             "+0000"
 867         },
 868         // 999
 869         {
 870             "Z", "Z", "Z", "Z", "Z",
 871             "+00", "+0000", "+00:00", "+0000", "+00:00",
 872             "+0000"
 873         },
 874         // -59999
 875         {
 876             "Z", "Z", "Z", "-000059", "-00:00:59",
 877             "+00", "+0000", "+00:00", "-000059", "-00:00:59",
 878             "-000059"
 879         },
 880         // 60000
 881         {
 882             "+0001", "+0001", "+00:01", "+0001", "+00:01",
 883             "+0001", "+0001", "+00:01", "+0001", "+00:01",
 884             "+0001"
 885         },
 886         // -77777
 887         {
 888             "-0001", "-0001", "-00:01", "-000117", "-00:01:17",
 889             "-0001", "-0001", "-00:01", "-000117", "-00:01:17",
 890             "-000117"
 891         },
 892         // 1800000
 893         {
 894             "+0030", "+0030", "+00:30", "+0030", "+00:30",
 895             "+0030", "+0030", "+00:30", "+0030", "+00:30",
 896             "+0030"
 897         },
 898         // -3600000
 899         {
 900             "-01", "-0100", "-01:00", "-0100", "-01:00",
 901             "-01", "-0100", "-01:00", "-0100", "-01:00",
 902             "-0100"
 903         },
 904         // 36000000
 905         {
 906             "+10", "+1000", "+10:00", "+1000", "+10:00",
 907             "+10", "+1000", "+10:00", "+1000", "+10:00",
 908             "+1000"
 909         },
 910         // -37800000
 911         {
 912             "-1030", "-1030", "-10:30", "-1030", "-10:30",
 913             "-1030", "-1030", "-10:30", "-1030", "-10:30",
 914             "-1030"
 915         },
 916         // -37845000
 917         {
 918             "-1030", "-1030", "-10:30", "-103045", "-10:30:45",
 919             "-1030", "-1030", "-10:30", "-103045", "-10:30:45",
 920             "-103045"
 921         },
 922         // 108000000
 923         {
 924             0, 0, 0, 0, 0,
 925             0, 0, 0, 0, 0,
 926             0
 927         }
 928     };
 929
 930     const char* PATTERN[] = {
 931         "X", "XX", "XXX", "XXXX", "XXXXX",
 932         "x", "xx", "xxx", "xxxx", "xxxxx",
 933         "Z", // equivalent to "xxxx"
 934         0
 935     };
 936
 937     const int32_t MIN_OFFSET_UNIT[] = {
 938         60000, 60000, 60000, 1000, 1000,
 939         60000, 60000, 60000, 1000, 1000,
 940         1000,
 941     };
 942
 943     // Formatting
 944     UErrorCode status = U_ZERO_ERROR;
 945     LocalPointer<SimpleDateFormat> sdf(new SimpleDateFormat(status), status);
 946     if (U_FAILURE(status)) {
 947         dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status));
 948         return;
 949     }
 950     UDate d = Calendar::getNow();
 951
 952     for (uint32_t i = 0; i < UPRV_LENGTHOF(OFFSET); i++) {
 953         SimpleTimeZone* tz = new SimpleTimeZone(OFFSET[i], UnicodeString("Zone Offset:") + OFFSET[i] + "ms");
 954         sdf->adoptTimeZone(tz);
 955         for (int32_t j = 0; PATTERN[j] != 0; j++) {
 956             sdf->applyPattern(UnicodeString(PATTERN[j]));
 957             UnicodeString result;
 958             sdf->format(d, result);
 959
 960             if (ISO_STR[i][j]) {
 961                 if (result != UnicodeString(ISO_STR[i][j])) {
 962                     errln((UnicodeString)"FAIL: pattern=" + PATTERN[j] + ", offset=" + OFFSET[i] + " -> "
 963                         + result + " (expected: " + ISO_STR[i][j] + ")");
 964                 }
 965             } else {
 966                 // Offset out of range
 967                 // Note: for now, there is no way to propagate the error status through
 968                 // the SimpleDateFormat::format above.
 969                 if (result.length() > 0) {
 970                     errln((UnicodeString)"FAIL: Non-Empty result for pattern=" + PATTERN[j] + ", offset=" + OFFSET[i]
 971                         + " (expected: empty result)");
 972                 }
 973             }
 974         }
 975     }
 976
 977     // Parsing
 978     LocalPointer<Calendar> outcal(Calendar::createInstance(status));
 979     if (U_FAILURE(status)) {
 980         dataerrln("Fail new Calendar: %s", u_errorName(status));
 981         return;
 982     }
 983     for (int32_t i = 0; ISO_STR[i][0] != NULL; i++) {
 984         for (int32_t j = 0; PATTERN[j] != 0; j++) {
 985             if (ISO_STR[i][j] == 0) {
 986                 continue;
 987             }
 988             ParsePosition pos(0);
 989             SimpleTimeZone* bogusTZ = new SimpleTimeZone(-1, UnicodeString("Zone Offset: -1ms"));
 990             outcal->adoptTimeZone(bogusTZ);
 991             sdf->applyPattern(PATTERN[j]);
 992
 993             sdf->parse(UnicodeString(ISO_STR[i][j]), *(outcal.getAlias()), pos);
 994
 995             if (pos.getIndex() != (int32_t)uprv_strlen(ISO_STR[i][j])) {
 996                 errln((UnicodeString)"FAIL: Failed to parse the entire input string: " + ISO_STR[i][j]);
 997             }
 998
 999             const TimeZone& outtz = outcal->getTimeZone();
1000             int32_t outOffset = outtz.getRawOffset();
1001             int32_t adjustedOffset = OFFSET[i] / MIN_OFFSET_UNIT[j] * MIN_OFFSET_UNIT[j];
1002             if (outOffset != adjustedOffset) {
1003                 errln((UnicodeString)"FAIL: Incorrect offset:" + outOffset + "ms for input string: " + ISO_STR[i][j]
1004                     + " (expected:" + adjustedOffset + "ms)");
1005             }
1006         }
1007     }
1008 }
1009
1010
1011 typedef struct {
1012     const char*     locale;
1013     const char*     tzid;
1014     UDate           date;
1015     UTimeZoneFormatStyle    style;
1016     const char*     expected;
1017     UTimeZoneFormatTimeType timeType;
1018 } FormatTestData;
1019
1020 void
1021 TimeZoneFormatTest::TestFormat(void) {
1022     UDate dateJan = 1358208000000.0;    // 2013-01-15T00:00:00Z
1023     UDate dateJul = 1373846400000.0;    // 2013-07-15T00:00:00Z
1024
1025     const FormatTestData DATA[] = {
1026         {
1027             "en",
1028             "America/Los_Angeles",
1029             dateJan,
1030             UTZFMT_STYLE_GENERIC_LOCATION,
1031             "Los Angeles Time",
1032             UTZFMT_TIME_TYPE_UNKNOWN
1033         },
1034         {
1035             "en",
1036             "America/Los_Angeles",
1037             dateJan,
1038             UTZFMT_STYLE_GENERIC_LONG,
1039             "Pacific Time",
1040             UTZFMT_TIME_TYPE_UNKNOWN
1041         },
1042         {
1043             "en",
1044             "America/Los_Angeles",
1045             dateJan,
1046             UTZFMT_STYLE_SPECIFIC_LONG,
1047             "Pacific Standard Time",
1048             UTZFMT_TIME_TYPE_STANDARD
1049         },
1050         {
1051             "en",
1052             "America/Los_Angeles",
1053             dateJul,
1054             UTZFMT_STYLE_SPECIFIC_LONG,
1055             "Pacific Daylight Time",
1056             UTZFMT_TIME_TYPE_DAYLIGHT
1057         },
1058         {
1059             "ja",
1060             "America/Los_Angeles",
1061             dateJan,
1062             UTZFMT_STYLE_ZONE_ID,
1063             "America/Los_Angeles",
1064             UTZFMT_TIME_TYPE_UNKNOWN
1065         },
1066         {
1067             "fr",
1068             "America/Los_Angeles",
1069             dateJul,
1070             UTZFMT_STYLE_ZONE_ID_SHORT,
1071             "uslax",
1072             UTZFMT_TIME_TYPE_UNKNOWN
1073         },
1074         {
1075             "en",
1076             "America/Los_Angeles",
1077             dateJan,
1078             UTZFMT_STYLE_EXEMPLAR_LOCATION,
1079             "Los Angeles",
1080             UTZFMT_TIME_TYPE_UNKNOWN
1081         },
1082
1083         {
1084             "ja",
1085             "Asia/Tokyo",
1086             dateJan,
1087             UTZFMT_STYLE_GENERIC_LONG,
1088             "\\u65E5\\u672C\\u6A19\\u6E96\\u6642",
1089             UTZFMT_TIME_TYPE_UNKNOWN
1090         },
1091
1092         {0, 0, 0.0, UTZFMT_STYLE_GENERIC_LOCATION, 0, UTZFMT_TIME_TYPE_UNKNOWN}
1093     };
1094
1095     for (int32_t i = 0; DATA[i].locale; i++) {
1096         UErrorCode status = U_ZERO_ERROR;
1097         LocalPointer<TimeZoneFormat> tzfmt(TimeZoneFormat::createInstance(Locale(DATA[i].locale), status));
1098         if (U_FAILURE(status)) {
1099             dataerrln("Fail TimeZoneFormat::createInstance: %s", u_errorName(status));
1100             continue;
1101         }
1102
1103         LocalPointer<TimeZone> tz(TimeZone::createTimeZone(DATA[i].tzid));
1104         UnicodeString out;
1105         UTimeZoneFormatTimeType timeType;
1106
1107         tzfmt->format(DATA[i].style, *(tz.getAlias()), DATA[i].date, out, &timeType);
1108         UnicodeString expected(DATA[i].expected, -1, US_INV);
1109         expected = expected.unescape();
1110
1111         assertEquals(UnicodeString("Format result for ") + DATA[i].tzid + " (Test Case " + i + ")", expected, out);
1112         if (DATA[i].timeType != timeType) {
1113             dataerrln(UnicodeString("Formatted time zone type (Test Case ") + i + "), returned="
1114                 + timeType + ", expected=" + DATA[i].timeType);
1115         }
1116     }
1117 }
1118
1119 void
1120 TimeZoneFormatTest::TestFormatTZDBNames(void) {
1121     UDate dateJan = 1358208000000.0;    // 2013-01-15T00:00:00Z
1122     UDate dateJul = 1373846400000.0;    // 2013-07-15T00:00:00Z
1123
1124     const FormatTestData DATA[] = {
1125         {
1126             "en",
1127             "America/Chicago",
1128             dateJan,
1129             UTZFMT_STYLE_SPECIFIC_SHORT,
1130             "CST",
1131             UTZFMT_TIME_TYPE_STANDARD
1132         },
1133         {
1134             "en",
1135             "Asia/Shanghai",
1136             dateJan,
1137             UTZFMT_STYLE_SPECIFIC_SHORT,
1138             "CST",
1139             UTZFMT_TIME_TYPE_STANDARD
1140         },
1141         {
1142             "zh_Hans",
1143             "Asia/Shanghai",
1144             dateJan,
1145             UTZFMT_STYLE_SPECIFIC_SHORT,
1146             "CST",
1147             UTZFMT_TIME_TYPE_STANDARD
1148         },
1149         {
1150             "en",
1151             "America/Los_Angeles",
1152             dateJul,
1153             UTZFMT_STYLE_SPECIFIC_LONG,
1154             "GMT-07:00",    // No long display names
1155             UTZFMT_TIME_TYPE_DAYLIGHT
1156         },
1157         {
1158             "ja",
1159             "America/Los_Angeles",
1160             dateJul,
1161             UTZFMT_STYLE_SPECIFIC_SHORT,
1162             "PDT",
1163             UTZFMT_TIME_TYPE_DAYLIGHT
1164         },
1165         {
1166             "en",
1167             "Australia/Sydney",
1168             dateJan,
1169             UTZFMT_STYLE_SPECIFIC_SHORT,
1170             "AEDT",
1171             UTZFMT_TIME_TYPE_DAYLIGHT
1172         },
1173         {
1174             "en",
1175             "Australia/Sydney",
1176             dateJul,
1177             UTZFMT_STYLE_SPECIFIC_SHORT,
1178             "AEST",
1179             UTZFMT_TIME_TYPE_STANDARD
1180         },
1181
1182         {0, 0, 0.0, UTZFMT_STYLE_GENERIC_LOCATION, 0, UTZFMT_TIME_TYPE_UNKNOWN}
1183     };
1184
1185     for (int32_t i = 0; DATA[i].locale; i++) {
1186         UErrorCode status = U_ZERO_ERROR;
1187         Locale loc(DATA[i].locale);
1188         LocalPointer<TimeZoneFormat> tzfmt(TimeZoneFormat::createInstance(loc, status));
1189         if (U_FAILURE(status)) {
1190             dataerrln("Fail TimeZoneFormat::createInstance: %s", u_errorName(status));
1191             continue;
1192         }
1193         TimeZoneNames *tzdbNames = TimeZoneNames::createTZDBInstance(loc, status);
1194         if (U_FAILURE(status)) {
1195             dataerrln("Fail TimeZoneNames::createTZDBInstance: %s", u_errorName(status));
1196             continue;
1197         }
1198         tzfmt->adoptTimeZoneNames(tzdbNames);
1199
1200         LocalPointer<TimeZone> tz(TimeZone::createTimeZone(DATA[i].tzid));
1201         UnicodeString out;
1202         UTimeZoneFormatTimeType timeType;
1203
1204         tzfmt->format(DATA[i].style, *(tz.getAlias()), DATA[i].date, out, &timeType);
1205         UnicodeString expected(DATA[i].expected, -1, US_INV);
1206         expected = expected.unescape();
1207
1208         assertEquals(UnicodeString("Format result for ") + DATA[i].tzid + " (Test Case " + i + ")", expected, out);
1209         if (DATA[i].timeType != timeType) {
1210             dataerrln(UnicodeString("Formatted time zone type (Test Case ") + i + "), returned="
1211                 + timeType + ", expected=" + DATA[i].timeType);
1212         }
1213     }
1214 }
1215
1216
1217 #endif /* #if !UCONFIG_NO_FORMATTING */