source/test/intltest/tzfmttst.cpp

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