1 // Copyright (C) 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /******************************************************************** 4 * COPYRIGHT: 5 * Copyright (c) 1997-2016, International Business Machines 6 * Corporation and others. All Rights Reserved. 7 ********************************************************************/ 8 9 #include "unicode/utypes.h" 10 11 #if !UCONFIG_NO_FORMATTING 12 13 #include "dtfmttst.h" 14 #include "unicode/localpointer.h" 15 #include "unicode/timezone.h" 16 #include "unicode/gregocal.h" 17 #include "unicode/smpdtfmt.h" 18 #include "unicode/datefmt.h" 19 #include "unicode/dtptngen.h" 20 #include "unicode/simpletz.h" 21 #include "unicode/strenum.h" 22 #include "unicode/dtfmtsym.h" 23 #include "cmemory.h" 24 #include "cstring.h" 25 #include "caltest.h" // for fieldName 26 #include <stdio.h> // for sprintf 27 28 #if U_PLATFORM_HAS_WIN32_API 29 #include "windttst.h" 30 #endif 31 32 #define ASSERT_OK(status) if(U_FAILURE(status)) {errcheckln(status, #status " = %s @ %s:%d", u_errorName(status), __FILE__, __LINE__); return; } 33 34 // ***************************************************************************** 35 // class DateFormatTest 36 // ***************************************************************************** 37 38 void DateFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) 39 { 40 if(exec) { 41 logln("TestSuite DateFormatTest: "); 42 } 43 TESTCASE_AUTO_BEGIN; 44 TESTCASE_AUTO(TestPatterns); 45 TESTCASE_AUTO(TestEquals); 46 TESTCASE_AUTO(TestTwoDigitYearDSTParse); 47 TESTCASE_AUTO(TestFieldPosition); 48 TESTCASE_AUTO(TestPartialParse994); 49 TESTCASE_AUTO(TestRunTogetherPattern985); 50 TESTCASE_AUTO(TestRunTogetherPattern917); 51 TESTCASE_AUTO(TestCzechMonths459); 52 TESTCASE_AUTO(TestLetterDPattern212); 53 TESTCASE_AUTO(TestDayOfYearPattern195); 54 TESTCASE_AUTO(TestQuotePattern161); 55 TESTCASE_AUTO(TestBadInput135); 56 TESTCASE_AUTO(TestBadInput135a); 57 TESTCASE_AUTO(TestTwoDigitYear); 58 TESTCASE_AUTO(TestDateFormatZone061); 59 TESTCASE_AUTO(TestDateFormatZone146); 60 TESTCASE_AUTO(TestLocaleDateFormat); 61 TESTCASE_AUTO(TestFormattingLocaleTimeSeparator); 62 TESTCASE_AUTO(TestWallyWedel); 63 TESTCASE_AUTO(TestDateFormatCalendar); 64 TESTCASE_AUTO(TestSpaceParsing); 65 TESTCASE_AUTO(TestExactCountFormat); 66 TESTCASE_AUTO(TestWhiteSpaceParsing); 67 TESTCASE_AUTO(TestInvalidPattern); 68 TESTCASE_AUTO(TestGeneral); 69 TESTCASE_AUTO(TestGreekMay); 70 TESTCASE_AUTO(TestGenericTime); 71 TESTCASE_AUTO(TestGenericTimeZoneOrder); 72 TESTCASE_AUTO(TestHost); 73 TESTCASE_AUTO(TestEras); 74 TESTCASE_AUTO(TestNarrowNames); 75 TESTCASE_AUTO(TestShortDays); 76 TESTCASE_AUTO(TestStandAloneDays); 77 TESTCASE_AUTO(TestStandAloneMonths); 78 TESTCASE_AUTO(TestQuarters); 79 TESTCASE_AUTO(TestZTimeZoneParsing); 80 TESTCASE_AUTO(TestRelative); 81 TESTCASE_AUTO(TestRelativeClone); 82 TESTCASE_AUTO(TestHostClone); 83 TESTCASE_AUTO(TestHebrewClone); 84 TESTCASE_AUTO(TestDateFormatSymbolsClone); 85 TESTCASE_AUTO(TestTimeZoneDisplayName); 86 TESTCASE_AUTO(TestRoundtripWithCalendar); 87 TESTCASE_AUTO(Test6338); 88 TESTCASE_AUTO(Test6726); 89 TESTCASE_AUTO(TestGMTParsing); 90 TESTCASE_AUTO(Test6880); 91 TESTCASE_AUTO(TestISOEra); 92 TESTCASE_AUTO(TestFormalChineseDate); 93 TESTCASE_AUTO(TestNumberAsStringParsing); 94 TESTCASE_AUTO(TestStandAloneGMTParse); 95 TESTCASE_AUTO(TestParsePosition); 96 TESTCASE_AUTO(TestMonthPatterns); 97 TESTCASE_AUTO(TestContext); 98 TESTCASE_AUTO(TestNonGregoFmtParse); 99 TESTCASE_AUTO(TestFormatsWithNumberSystems); 100 /* 101 TESTCASE_AUTO(TestRelativeError); 102 TESTCASE_AUTO(TestRelativeOther); 103 */ 104 TESTCASE_AUTO(TestDotAndAtLeniency); 105 TESTCASE_AUTO(TestDateFormatLeniency); 106 TESTCASE_AUTO(TestParseMultiPatternMatch); 107 108 TESTCASE_AUTO(TestParseLeniencyAPIs); 109 TESTCASE_AUTO(TestNumberFormatOverride); 110 TESTCASE_AUTO(TestCreateInstanceForSkeleton); 111 TESTCASE_AUTO(TestCreateInstanceForSkeletonDefault); 112 TESTCASE_AUTO(TestCreateInstanceForSkeletonWithCalendar); 113 TESTCASE_AUTO(TestDFSCreateForLocaleNonGregorianLocale); 114 TESTCASE_AUTO(TestDFSCreateForLocaleWithCalendarInLocale); 115 TESTCASE_AUTO(TestChangeCalendar); 116 117 TESTCASE_AUTO(TestPatternFromSkeleton); 118 119 TESTCASE_AUTO(TestAmPmMidnightNoon); 120 TESTCASE_AUTO(TestFlexibleDayPeriod); 121 TESTCASE_AUTO(TestDayPeriodWithLocales); 122 TESTCASE_AUTO(TestMinuteSecondFieldsInOddPlaces); 123 TESTCASE_AUTO(TestDayPeriodParsing); 124 125 TESTCASE_AUTO_END; 126 } 127 128 void DateFormatTest::TestPatterns() { 129 static const struct { 130 const char *actualPattern; 131 const char *expectedPattern; 132 const char *localeID; 133 const char *expectedLocalPattern; 134 } EXPECTED[] = { 135 {UDAT_YEAR, "y","en","y"}, 136 137 {UDAT_QUARTER, "QQQQ", "en", "QQQQ"}, 138 {UDAT_ABBR_QUARTER, "QQQ", "en", "QQQ"}, 139 {UDAT_YEAR_QUARTER, "yQQQQ", "en", "QQQQ y"}, 140 {UDAT_YEAR_ABBR_QUARTER, "yQQQ", "en", "QQQ y"}, 141 142 {UDAT_NUM_MONTH, "M", "en", "L"}, 143 {UDAT_ABBR_MONTH, "MMM", "en", "LLL"}, 144 {UDAT_MONTH, "MMMM", "en", "LLLL"}, 145 {UDAT_YEAR_NUM_MONTH, "yM","en","M/y"}, 146 {UDAT_YEAR_ABBR_MONTH, "yMMM","en","MMM y"}, 147 {UDAT_YEAR_MONTH, "yMMMM","en","MMMM y"}, 148 149 {UDAT_DAY, "d","en","d"}, 150 {UDAT_YEAR_NUM_MONTH_DAY, "yMd", "en", "M/d/y"}, 151 {UDAT_YEAR_ABBR_MONTH_DAY, "yMMMd", "en", "MMM d, y"}, 152 {UDAT_YEAR_MONTH_DAY, "yMMMMd", "en", "MMMM d, y"}, 153 {UDAT_YEAR_NUM_MONTH_WEEKDAY_DAY, "yMEd", "en", "EEE, M/d/y"}, 154 {UDAT_YEAR_ABBR_MONTH_WEEKDAY_DAY, "yMMMEd", "en", "EEE, MMM d, y"}, 155 {UDAT_YEAR_MONTH_WEEKDAY_DAY, "yMMMMEEEEd", "en", "EEEE, MMMM d, y"}, 156 157 {UDAT_NUM_MONTH_DAY, "Md","en","M/d"}, 158 {UDAT_ABBR_MONTH_DAY, "MMMd","en","MMM d"}, 159 {UDAT_MONTH_DAY, "MMMMd","en","MMMM d"}, 160 {UDAT_NUM_MONTH_WEEKDAY_DAY, "MEd","en","EEE, M/d"}, 161 {UDAT_ABBR_MONTH_WEEKDAY_DAY, "MMMEd","en","EEE, MMM d"}, 162 {UDAT_MONTH_WEEKDAY_DAY, "MMMMEEEEd","en","EEEE, MMMM d"}, 163 164 {UDAT_HOUR, "j", "en", "h a"}, // (fixed expected result per ticket 6872<-6626) 165 {UDAT_HOUR24, "H", "en", "HH"}, // (fixed expected result per ticket 6872<-6626 166 167 {UDAT_MINUTE, "m", "en", "m"}, 168 {UDAT_HOUR_MINUTE, "jm","en","h:mm a"}, // (fixed expected result per ticket 6872<-7180) 169 {UDAT_HOUR24_MINUTE, "Hm", "en", "HH:mm"}, // (fixed expected result per ticket 6872<-6626) 170 171 {UDAT_SECOND, "s", "en", "s"}, 172 {UDAT_HOUR_MINUTE_SECOND, "jms","en","h:mm:ss a"}, // (fixed expected result per ticket 6872<-7180) 173 {UDAT_HOUR24_MINUTE_SECOND, "Hms","en","HH:mm:ss"}, // (fixed expected result per ticket 6872<-6626) 174 {UDAT_MINUTE_SECOND, "ms", "en", "mm:ss"}, // (fixed expected result per ticket 6872<-6626) 175 176 {UDAT_LOCATION_TZ, "VVVV", "en", "VVVV"}, 177 {UDAT_GENERIC_TZ, "vvvv", "en", "vvvv"}, 178 {UDAT_ABBR_GENERIC_TZ, "v", "en", "v"}, 179 {UDAT_SPECIFIC_TZ, "zzzz", "en", "zzzz"}, 180 {UDAT_ABBR_SPECIFIC_TZ, "z", "en", "z"}, 181 {UDAT_ABBR_UTC_TZ, "ZZZZ", "en", "ZZZZ"}, 182 183 {UDAT_YEAR_NUM_MONTH_DAY UDAT_ABBR_UTC_TZ, "yMdZZZZ", "en", "M/d/y, ZZZZ"}, 184 {UDAT_MONTH_DAY UDAT_LOCATION_TZ, "MMMMdVVVV", "en", "MMMM d, VVVV"} 185 }; 186 187 IcuTestErrorCode errorCode(*this, "TestPatterns()"); 188 for (int32_t i = 0; i < UPRV_LENGTHOF(EXPECTED); i++) { 189 // Verify that patterns have the correct values 190 UnicodeString actualPattern(EXPECTED[i].actualPattern, -1, US_INV); 191 UnicodeString expectedPattern(EXPECTED[i].expectedPattern, -1, US_INV); 192 Locale locale(EXPECTED[i].localeID); 193 if (actualPattern != expectedPattern) { 194 errln("FAILURE! Expected pattern: " + expectedPattern + 195 " but was: " + actualPattern); 196 } 197 198 // Verify that DataFormat instances produced contain the correct 199 // localized patterns 200 // TODO: use DateFormat::getInstanceForSkeleton(), ticket #9029 201 // Java test code: 202 // DateFormat date1 = DateFormat.getPatternInstance(actualPattern, 203 // locale); 204 // DateFormat date2 = DateFormat.getPatternInstance(Calendar.getInstance(locale), 205 // actualPattern, locale); 206 LocalPointer<DateTimePatternGenerator> generator( 207 DateTimePatternGenerator::createInstance(locale, errorCode)); 208 if(errorCode.logDataIfFailureAndReset("DateTimePatternGenerator::createInstance() failed for locale ID \"%s\"", EXPECTED[i].localeID)) { 209 continue; 210 } 211 UnicodeString pattern = generator->getBestPattern(actualPattern, errorCode); 212 SimpleDateFormat date1(pattern, locale, errorCode); 213 SimpleDateFormat date2(pattern, locale, errorCode); 214 date2.adoptCalendar(Calendar::createInstance(locale, errorCode)); 215 if(errorCode.logIfFailureAndReset("DateFormat::getInstanceForSkeleton() failed")) { 216 errln(" for actualPattern \"%s\" & locale ID \"%s\"", 217 EXPECTED[i].actualPattern, EXPECTED[i].localeID); 218 continue; 219 } 220 221 UnicodeString expectedLocalPattern(EXPECTED[i].expectedLocalPattern, -1, US_INV); 222 UnicodeString actualLocalPattern1; 223 UnicodeString actualLocalPattern2; 224 date1.toLocalizedPattern(actualLocalPattern1, errorCode); 225 date2.toLocalizedPattern(actualLocalPattern2, errorCode); 226 if (actualLocalPattern1 != expectedLocalPattern) { 227 errln("FAILURE! Expected local pattern: " + expectedLocalPattern 228 + " but was: " + actualLocalPattern1); 229 } 230 if (actualLocalPattern2 != expectedLocalPattern) { 231 errln("FAILURE! Expected local pattern: " + expectedLocalPattern 232 + " but was: " + actualLocalPattern2); 233 } 234 } 235 } 236 237 // Test written by Wally Wedel and emailed to me. 238 void DateFormatTest::TestWallyWedel() 239 { 240 UErrorCode status = U_ZERO_ERROR; 241 /* 242 * Instantiate a TimeZone so we can get the ids. 243 */ 244 TimeZone *tz = new SimpleTimeZone(7,""); 245 /* 246 * Computational variables. 247 */ 248 int32_t offset, hours, minutes, seconds; 249 /* 250 * Instantiate a SimpleDateFormat set up to produce a full time 251 zone name. 252 */ 253 SimpleDateFormat *sdf = new SimpleDateFormat((UnicodeString)"zzzz", status); 254 /* 255 * A String array for the time zone ids. 256 */ 257 int32_t ids_length; 258 StringEnumeration* ids = TimeZone::createEnumeration(); 259 if (ids == NULL) { 260 dataerrln("Unable to create TimeZone enumeration."); 261 if (sdf != NULL) { 262 delete sdf; 263 } 264 return; 265 } 266 ids_length = ids->count(status); 267 /* 268 * How many ids do we have? 269 */ 270 logln("Time Zone IDs size: %d", ids_length); 271 /* 272 * Column headings (sort of) 273 */ 274 logln("Ordinal ID offset(h:m) name"); 275 /* 276 * Loop through the tzs. 277 */ 278 UDate today = Calendar::getNow(); 279 Calendar *cal = Calendar::createInstance(status); 280 for (int32_t i = 0; i < ids_length; i++) { 281 // logln(i + " " + ids[i]); 282 const UnicodeString* id = ids->snext(status); 283 TimeZone *ttz = TimeZone::createTimeZone(*id); 284 // offset = ttz.getRawOffset(); 285 cal->setTimeZone(*ttz); 286 cal->setTime(today, status); 287 offset = cal->get(UCAL_ZONE_OFFSET, status) + cal->get(UCAL_DST_OFFSET, status); 288 // logln(i + " " + ids[i] + " offset " + offset); 289 const char* sign = "+"; 290 if (offset < 0) { 291 sign = "-"; 292 offset = -offset; 293 } 294 hours = offset/3600000; 295 minutes = (offset%3600000)/60000; 296 seconds = (offset%60000)/1000; 297 UnicodeString dstOffset = (UnicodeString)"" + sign + (hours < 10 ? "0" : "") + 298 (int32_t)hours + ":" + (minutes < 10 ? "0" : "") + (int32_t)minutes; 299 if (seconds != 0) { 300 dstOffset = dstOffset + ":" + (seconds < 10 ? "0" : "") + seconds; 301 } 302 /* 303 * Instantiate a date so we can display the time zone name. 304 */ 305 sdf->setTimeZone(*ttz); 306 /* 307 * Format the output. 308 */ 309 UnicodeString fmtOffset; 310 FieldPosition pos(FieldPosition::DONT_CARE); 311 sdf->format(today,fmtOffset, pos); 312 // UnicodeString fmtOffset = tzS.toString(); 313 UnicodeString *fmtDstOffset = 0; 314 if (fmtOffset.startsWith("GMT") && fmtOffset.length() != 3) 315 { 316 //fmtDstOffset = fmtOffset->substring(3); 317 fmtDstOffset = new UnicodeString(); 318 fmtOffset.extract(3, fmtOffset.length(), *fmtDstOffset); 319 } 320 /* 321 * Show our result. 322 */ 323 UBool ok = fmtDstOffset == 0 || *fmtDstOffset == dstOffset; 324 if (ok) 325 { 326 logln(UnicodeString() + i + " " + *id + " " + dstOffset + 327 " " + fmtOffset + 328 (fmtDstOffset != 0 ? " ok" : " ?")); 329 } 330 else 331 { 332 errln(UnicodeString() + i + " " + *id + " " + dstOffset + 333 " " + fmtOffset + " *** FAIL ***"); 334 } 335 delete ttz; 336 delete fmtDstOffset; 337 } 338 delete cal; 339 // delete ids; // TODO: BAD API 340 delete ids; 341 delete sdf; 342 delete tz; 343 } 344 345 // ------------------------------------- 346 347 /** 348 * Test operator== 349 */ 350 void 351 DateFormatTest::TestEquals() 352 { 353 DateFormat* fmtA = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::FULL); 354 DateFormat* fmtB = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::FULL); 355 if ( fmtA == NULL || fmtB == NULL){ 356 dataerrln("Error calling DateFormat::createDateTimeInstance"); 357 delete fmtA; 358 delete fmtB; 359 return; 360 } 361 362 if (!(*fmtA == *fmtB)) errln((UnicodeString)"FAIL"); 363 delete fmtA; 364 delete fmtB; 365 366 TimeZone* test = TimeZone::createTimeZone("PDT"); 367 delete test; 368 } 369 370 // ------------------------------------- 371 372 /** 373 * Test the parsing of 2-digit years. 374 */ 375 void 376 DateFormatTest::TestTwoDigitYearDSTParse(void) 377 { 378 UErrorCode status = U_ZERO_ERROR; 379 SimpleDateFormat* fullFmt = new SimpleDateFormat((UnicodeString)"EEE MMM dd HH:mm:ss.SSS zzz yyyy G", status); 380 SimpleDateFormat *fmt = new SimpleDateFormat((UnicodeString)"dd-MMM-yy h:mm:ss 'o''clock' a z", Locale::getEnglish(), status); 381 //DateFormat* fmt = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::FULL, Locale::ENGLISH); 382 UnicodeString* s = new UnicodeString("03-Apr-04 2:20:47 o'clock AM PST", ""); 383 TimeZone* defaultTZ = TimeZone::createDefault(); 384 TimeZone* PST = TimeZone::createTimeZone("PST"); 385 int32_t defaultOffset = defaultTZ->getRawOffset(); 386 int32_t PSTOffset = PST->getRawOffset(); 387 int32_t hour = 2 + (defaultOffset - PSTOffset) / (60*60*1000); 388 // hour is the expected hour of day, in units of seconds 389 hour = ((hour < 0) ? hour + 24 : hour) * 60*60; 390 391 UnicodeString str; 392 393 if(U_FAILURE(status)) { 394 dataerrln("Could not set up test. exitting - %s", u_errorName(status)); 395 return; 396 } 397 398 UDate d = fmt->parse(*s, status); 399 logln(*s + " P> " + ((DateFormat*)fullFmt)->format(d, str)); 400 int32_t y, m, day, hr, min, sec; 401 dateToFields(d, y, m, day, hr, min, sec); 402 hour += defaultTZ->inDaylightTime(d, status) ? 1 : 0; 403 hr = hr*60*60; 404 if (hr != hour) 405 errln((UnicodeString)"FAIL: Should parse to hour " + hour + " but got " + hr); 406 407 if (U_FAILURE(status)) 408 errln((UnicodeString)"FAIL: " + (int32_t)status); 409 410 delete s; 411 delete fmt; 412 delete fullFmt; 413 delete PST; 414 delete defaultTZ; 415 } 416 417 // ------------------------------------- 418 419 UChar toHexString(int32_t i) { return (UChar)(i + (i < 10 ? 0x30 : (0x41 - 10))); } 420 421 UnicodeString& 422 DateFormatTest::escape(UnicodeString& s) 423 { 424 UnicodeString buf; 425 for (int32_t i=0; i<s.length(); ++i) 426 { 427 UChar c = s[(int32_t)i]; 428 if (c <= (UChar)0x7F) buf += c; 429 else { 430 buf += (UChar)0x5c; buf += (UChar)0x55; 431 buf += toHexString((c & 0xF000) >> 12); 432 buf += toHexString((c & 0x0F00) >> 8); 433 buf += toHexString((c & 0x00F0) >> 4); 434 buf += toHexString(c & 0x000F); 435 } 436 } 437 return (s = buf); 438 } 439 440 // ------------------------------------- 441 442 /** 443 * This MUST be kept in sync with DateFormatSymbols.gPatternChars. 444 */ 445 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 446 static const char* PATTERN_CHARS = "GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB:"; 447 #else 448 static const char* PATTERN_CHARS = "GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB"; 449 #endif 450 451 /** 452 * A list of the names of all the fields in DateFormat. 453 * This MUST be kept in sync with DateFormat. 454 */ 455 static const char* DATEFORMAT_FIELD_NAMES[] = { 456 "ERA_FIELD", 457 "YEAR_FIELD", 458 "MONTH_FIELD", 459 "DATE_FIELD", 460 "HOUR_OF_DAY1_FIELD", 461 "HOUR_OF_DAY0_FIELD", 462 "MINUTE_FIELD", 463 "SECOND_FIELD", 464 "MILLISECOND_FIELD", 465 "DAY_OF_WEEK_FIELD", 466 "DAY_OF_YEAR_FIELD", 467 "DAY_OF_WEEK_IN_MONTH_FIELD", 468 "WEEK_OF_YEAR_FIELD", 469 "WEEK_OF_MONTH_FIELD", 470 "AM_PM_FIELD", 471 "HOUR1_FIELD", 472 "HOUR0_FIELD", 473 "TIMEZONE_FIELD", 474 "YEAR_WOY_FIELD", 475 "DOW_LOCAL_FIELD", 476 "EXTENDED_YEAR_FIELD", 477 "JULIAN_DAY_FIELD", 478 "MILLISECONDS_IN_DAY_FIELD", 479 "TIMEZONE_RFC_FIELD", 480 "GENERIC_TIMEZONE_FIELD", 481 "STAND_ALONE_DAY_FIELD", 482 "STAND_ALONE_MONTH_FIELD", 483 "QUARTER_FIELD", 484 "STAND_ALONE_QUARTER_FIELD", 485 "TIMEZONE_SPECIAL_FIELD", 486 "YEAR_NAME_FIELD", 487 "TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD", 488 "TIMEZONE_ISO_FIELD", 489 "TIMEZONE_ISO_LOCAL_FIELD", 490 "RELATED_YEAR_FIELD", 491 "AM_PM_MIDNIGHT_NOON_FIELD", 492 "FLEXIBLE_DAY_PERIOD_FIELD", 493 "UDAT_TIME_SEPARATOR_FIELD", 494 }; 495 496 static const int32_t DATEFORMAT_FIELD_NAMES_LENGTH = 497 UPRV_LENGTHOF(DATEFORMAT_FIELD_NAMES); 498 499 /** 500 * Verify that returned field position indices are correct. 501 */ 502 void DateFormatTest::TestFieldPosition() { 503 UErrorCode ec = U_ZERO_ERROR; 504 int32_t i, j, exp; 505 UnicodeString buf; 506 507 // Verify data 508 DateFormatSymbols rootSyms(Locale(""), ec); 509 if (U_FAILURE(ec)) { 510 dataerrln("Unable to create DateFormatSymbols - %s", u_errorName(ec)); 511 return; 512 } 513 514 // local pattern chars data is not longer loaded 515 // from icu locale bundle 516 assertEquals("patternChars", PATTERN_CHARS, rootSyms.getLocalPatternChars(buf)); 517 assertEquals("patternChars", PATTERN_CHARS, DateFormatSymbols::getPatternUChars()); 518 assertTrue("DATEFORMAT_FIELD_NAMES", DATEFORMAT_FIELD_NAMES_LENGTH == UDAT_FIELD_COUNT); 519 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 520 assertTrue("Data", UDAT_FIELD_COUNT == uprv_strlen(PATTERN_CHARS)); 521 #else 522 assertTrue("Data", UDAT_FIELD_COUNT == uprv_strlen(PATTERN_CHARS) + 1); // +1 for missing TIME_SEPARATOR pattern char 523 #endif 524 525 // Create test formatters 526 const int32_t COUNT = 4; 527 DateFormat* dateFormats[COUNT]; 528 dateFormats[0] = DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale::getUS()); 529 dateFormats[1] = DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale::getFrance()); 530 // Make the pattern "G y M d..." 531 buf.remove().append(PATTERN_CHARS); 532 for (j=buf.length()-1; j>=0; --j) buf.insert(j, (UChar)32/*' '*/); 533 dateFormats[2] = new SimpleDateFormat(buf, Locale::getUS(), ec); 534 // Make the pattern "GGGG yyyy MMMM dddd..." 535 for (j=buf.length()-1; j>=0; j-=2) { 536 for (i=0; i<3; ++i) { 537 buf.insert(j, buf.charAt(j)); 538 } 539 } 540 dateFormats[3] = new SimpleDateFormat(buf, Locale::getUS(), ec); 541 if(U_FAILURE(ec)){ 542 errln(UnicodeString("Could not create SimpleDateFormat object for locale en_US. Error: " )+ UnicodeString(u_errorName(ec))); 543 return; 544 } 545 UDate aug13 = 871508052513.0; 546 547 // Expected output field values for above DateFormats on aug13 548 // Fields are given in order of DateFormat field number 549 const char* EXPECTED[] = { 550 "", "1997", "August", "13", "", "", "34", "12", "", "Wednesday", 551 "", "", "", "", "PM", "2", "", "Pacific Daylight Time", "", "", 552 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 553 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 554 ":", 555 #else 556 "", 557 #endif 558 559 "", "1997", "ao\\u00FBt", "13", "", "14", "34", "12", "", "mercredi", 560 "", "", "", "", "", "", "", "heure d\\u2019\\u00E9t\\u00E9 du Pacifique", "", "", 561 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 562 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 563 ":", 564 #else 565 "", 566 #endif 567 568 "AD", "1997", "8", "13", "14", "14", "34", "12", "5", "Wed", 569 "225", "2", "33", "3", "PM", "2", "2", "PDT", "1997", "4", 570 "1997", "2450674", "52452513", "-0700", "PT", "4", "8", "3", "3", "uslax", 571 "1997", "GMT-7", "-07", "-07", "1997", "PM", "in the afternoon", 572 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 573 ":", 574 #else 575 "", 576 #endif 577 578 "Anno Domini", "1997", "August", "0013", "0014", "0014", "0034", "0012", "5130", "Wednesday", 579 "0225", "0002", "0033", "0003", "PM", "0002", "0002", "Pacific Daylight Time", "1997", "Wednesday", 580 "1997", "2450674", "52452513", "GMT-07:00", "Pacific Time", "Wednesday", "August", "3rd quarter", "3rd quarter", "Los Angeles Time", 581 "1997", "GMT-07:00", "-0700", "-0700", "1997", "PM", "in the afternoon", 582 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 583 ":", 584 #else 585 "", 586 #endif 587 }; 588 589 const int32_t EXPECTED_LENGTH = UPRV_LENGTHOF(EXPECTED); 590 591 assertTrue("data size", EXPECTED_LENGTH == COUNT * UDAT_FIELD_COUNT); 592 593 TimeZone* PT = TimeZone::createTimeZone("America/Los_Angeles"); 594 for (j = 0, exp = 0; j < COUNT; ++j) { 595 // String str; 596 DateFormat* df = dateFormats[j]; 597 df->setTimeZone(*PT); 598 SimpleDateFormat* sdtfmt = dynamic_cast<SimpleDateFormat*>(df); 599 if (sdtfmt != NULL) { 600 logln(" Pattern = " + sdtfmt->toPattern(buf.remove())); 601 } else { 602 logln(" Pattern = ? (not a SimpleDateFormat)"); 603 } 604 logln((UnicodeString)" Result = " + df->format(aug13, buf.remove())); 605 606 int32_t expBase = exp; // save for later 607 for (i = 0; i < UDAT_FIELD_COUNT; ++i, ++exp) { 608 FieldPosition pos(i); 609 buf.remove(); 610 df->format(aug13, buf, pos); 611 UnicodeString field; 612 buf.extractBetween(pos.getBeginIndex(), pos.getEndIndex(), field); 613 assertEquals((UnicodeString)"field #" + i + " " + DATEFORMAT_FIELD_NAMES[i], 614 ctou(EXPECTED[exp]), field); 615 } 616 617 // test FieldPositionIterator API 618 logln("FieldPositionIterator"); 619 { 620 UErrorCode status = U_ZERO_ERROR; 621 FieldPositionIterator posIter; 622 FieldPosition fp; 623 624 buf.remove(); 625 df->format(aug13, buf, &posIter, status); 626 while (posIter.next(fp)) { 627 int32_t i = fp.getField(); 628 UnicodeString field; 629 buf.extractBetween(fp.getBeginIndex(), fp.getEndIndex(), field); 630 assertEquals((UnicodeString)"field #" + i + " " + DATEFORMAT_FIELD_NAMES[i], 631 ctou(EXPECTED[expBase + i]), field); 632 } 633 634 } 635 } 636 637 638 // test null posIter 639 buf.remove(); 640 UErrorCode status = U_ZERO_ERROR; 641 dateFormats[0]->format(aug13, buf, NULL, status); 642 // if we didn't crash, we succeeded. 643 644 for (i=0; i<COUNT; ++i) { 645 delete dateFormats[i]; 646 } 647 delete PT; 648 } 649 650 // ------------------------------------- 651 652 /** 653 * General parse/format tests. Add test cases as needed. 654 */ 655 void DateFormatTest::TestGeneral() { 656 const char* DATA[] = { 657 "yyyy MM dd HH:mm:ss.SSS", 658 659 // Milliseconds are left-justified, since they format as fractions of a second 660 "y/M/d H:mm:ss.S", "fp", "2004 03 10 16:36:31.567", "2004/3/10 16:36:31.5", "2004 03 10 16:36:31.500", 661 "y/M/d H:mm:ss.SS", "fp", "2004 03 10 16:36:31.567", "2004/3/10 16:36:31.56", "2004 03 10 16:36:31.560", 662 "y/M/d H:mm:ss.SSS", "F", "2004 03 10 16:36:31.567", "2004/3/10 16:36:31.567", 663 "y/M/d H:mm:ss.SSSS", "pf", "2004/3/10 16:36:31.5679", "2004 03 10 16:36:31.567", "2004/3/10 16:36:31.5670", 664 }; 665 expect(DATA, UPRV_LENGTHOF(DATA), Locale("en", "", "")); 666 } 667 668 // ------------------------------------- 669 670 /** 671 * Verify that strings which contain incomplete specifications are parsed 672 * correctly. In some instances, this means not being parsed at all, and 673 * returning an appropriate error. 674 */ 675 void 676 DateFormatTest::TestPartialParse994() 677 { 678 UErrorCode status = U_ZERO_ERROR; 679 SimpleDateFormat* f = new SimpleDateFormat(status); 680 if (U_FAILURE(status)) { 681 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 682 delete f; 683 return; 684 } 685 UDate null = 0; 686 tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/17 10:11:42", date(97, 1 - 1, 17, 10, 11, 42)); 687 tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/17 10:", null); 688 tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/17 10", null); 689 tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/17 ", null); 690 tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/17", null); 691 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 692 delete f; 693 } 694 695 // ------------------------------------- 696 697 void 698 DateFormatTest::tryPat994(SimpleDateFormat* format, const char* pat, const char* str, UDate expected) 699 { 700 UErrorCode status = U_ZERO_ERROR; 701 UDate null = 0; 702 logln(UnicodeString("Pattern \"") + pat + "\" String \"" + str + "\""); 703 //try { 704 format->applyPattern(pat); 705 UDate date = format->parse(str, status); 706 if (U_FAILURE(status) || date == null) 707 { 708 logln((UnicodeString)"ParseException: " + (int32_t)status); 709 if (expected != null) errln((UnicodeString)"FAIL: Expected " + dateToString(expected)); 710 } 711 else 712 { 713 UnicodeString f; 714 ((DateFormat*)format)->format(date, f); 715 logln(UnicodeString(" parse(") + str + ") -> " + dateToString(date)); 716 logln((UnicodeString)" format -> " + f); 717 if (expected == null || 718 !(date == expected)) errln((UnicodeString)"FAIL: Expected null");//" + expected); 719 if (!(f == str)) errln(UnicodeString("FAIL: Expected ") + str); 720 } 721 //} 722 //catch(ParseException e) { 723 // logln((UnicodeString)"ParseException: " + e.getMessage()); 724 // if (expected != null) errln((UnicodeString)"FAIL: Expected " + dateToString(expected)); 725 //} 726 //catch(Exception e) { 727 // errln((UnicodeString)"*** Exception:"); 728 // e.printStackTrace(); 729 //} 730 } 731 732 // ------------------------------------- 733 734 /** 735 * Verify the behavior of patterns in which digits for different fields run together 736 * without intervening separators. 737 */ 738 void 739 DateFormatTest::TestRunTogetherPattern985() 740 { 741 UErrorCode status = U_ZERO_ERROR; 742 UnicodeString format("yyyyMMddHHmmssSSS"); 743 UnicodeString now, then; 744 //UBool flag; 745 SimpleDateFormat *formatter = new SimpleDateFormat(format, status); 746 if (U_FAILURE(status)) { 747 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 748 delete formatter; 749 return; 750 } 751 UDate date1 = Calendar::getNow(); 752 ((DateFormat*)formatter)->format(date1, now); 753 logln(now); 754 ParsePosition pos(0); 755 UDate date2 = formatter->parse(now, pos); 756 if (date2 == 0) then = UnicodeString("Parse stopped at ") + pos.getIndex(); 757 else ((DateFormat*)formatter)->format(date2, then); 758 logln(then); 759 if (!(date2 == date1)) errln((UnicodeString)"FAIL"); 760 delete formatter; 761 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 762 } 763 764 // ------------------------------------- 765 766 /** 767 * Verify the behavior of patterns in which digits for different fields run together 768 * without intervening separators. 769 */ 770 void 771 DateFormatTest::TestRunTogetherPattern917() 772 { 773 UErrorCode status = U_ZERO_ERROR; 774 SimpleDateFormat* fmt; 775 UnicodeString myDate; 776 fmt = new SimpleDateFormat((UnicodeString)"yyyy/MM/dd", status); 777 if (U_FAILURE(status)) { 778 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 779 delete fmt; 780 return; 781 } 782 myDate = "1997/02/03"; 783 testIt917(fmt, myDate, date(97, 2 - 1, 3)); 784 delete fmt; 785 fmt = new SimpleDateFormat((UnicodeString)"yyyyMMdd", status); 786 myDate = "19970304"; 787 testIt917(fmt, myDate, date(97, 3 - 1, 4)); 788 delete fmt; 789 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 790 } 791 792 // ------------------------------------- 793 794 void 795 DateFormatTest::testIt917(SimpleDateFormat* fmt, UnicodeString& str, UDate expected) 796 { 797 UErrorCode status = U_ZERO_ERROR; 798 UnicodeString pattern; 799 logln((UnicodeString)"pattern=" + fmt->toPattern(pattern) + " string=" + str); 800 Formattable o; 801 //try { 802 ((Format*)fmt)->parseObject(str, o, status); 803 //} 804 if (U_FAILURE(status)) return; 805 //catch(ParseException e) { 806 // e.printStackTrace(); 807 // return; 808 //} 809 logln((UnicodeString)"Parsed object: " + dateToString(o.getDate())); 810 if (!(o.getDate() == expected)) errln((UnicodeString)"FAIL: Expected " + dateToString(expected)); 811 UnicodeString formatted; ((Format*)fmt)->format(o, formatted, status); 812 logln((UnicodeString)"Formatted string: " + formatted); 813 if (!(formatted == str)) errln((UnicodeString)"FAIL: Expected " + str); 814 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 815 } 816 817 // ------------------------------------- 818 819 /** 820 * Verify the handling of Czech June and July, which have the unique attribute that 821 * one is a proper prefix substring of the other. 822 */ 823 void 824 DateFormatTest::TestCzechMonths459() 825 { 826 UErrorCode status = U_ZERO_ERROR; 827 DateFormat* fmt = DateFormat::createDateInstance(DateFormat::FULL, Locale("cs", "", "")); 828 if (fmt == NULL){ 829 dataerrln("Error calling DateFormat::createDateInstance()"); 830 return; 831 } 832 833 UnicodeString pattern; 834 logln((UnicodeString)"Pattern " + ((SimpleDateFormat*) fmt)->toPattern(pattern)); 835 UDate june = date(97, UCAL_JUNE, 15); 836 UDate july = date(97, UCAL_JULY, 15); 837 UnicodeString juneStr; fmt->format(june, juneStr); 838 UnicodeString julyStr; fmt->format(july, julyStr); 839 //try { 840 logln((UnicodeString)"format(June 15 1997) = " + juneStr); 841 UDate d = fmt->parse(juneStr, status); 842 UnicodeString s; fmt->format(d, s); 843 int32_t month,yr,day,hr,min,sec; dateToFields(d,yr,month,day,hr,min,sec); 844 logln((UnicodeString)" -> parse -> " + s + " (month = " + month + ")"); 845 if (month != UCAL_JUNE) errln((UnicodeString)"FAIL: Month should be June"); 846 logln((UnicodeString)"format(July 15 1997) = " + julyStr); 847 d = fmt->parse(julyStr, status); 848 fmt->format(d, s); 849 dateToFields(d,yr,month,day,hr,min,sec); 850 logln((UnicodeString)" -> parse -> " + s + " (month = " + month + ")"); 851 if (month != UCAL_JULY) errln((UnicodeString)"FAIL: Month should be July"); 852 //} 853 //catch(ParseException e) { 854 if (U_FAILURE(status)) 855 errln((UnicodeString)"Exception: " + (int32_t)status); 856 //} 857 delete fmt; 858 } 859 860 // ------------------------------------- 861 862 /** 863 * Test the handling of 'D' in patterns. 864 */ 865 void 866 DateFormatTest::TestLetterDPattern212() 867 { 868 UErrorCode status = U_ZERO_ERROR; 869 UnicodeString dateString("1995-040.05:01:29"); 870 UnicodeString bigD("yyyy-DDD.hh:mm:ss"); 871 UnicodeString littleD("yyyy-ddd.hh:mm:ss"); 872 UDate expLittleD = date(95, 0, 1, 5, 1, 29); 873 UDate expBigD = expLittleD + 39 * 24 * 3600000.0; 874 expLittleD = expBigD; // Expect the same, with default lenient parsing 875 logln((UnicodeString)"dateString= " + dateString); 876 SimpleDateFormat *formatter = new SimpleDateFormat(bigD, status); 877 if (U_FAILURE(status)) { 878 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 879 delete formatter; 880 return; 881 } 882 ParsePosition pos(0); 883 UDate myDate = formatter->parse(dateString, pos); 884 logln((UnicodeString)"Using " + bigD + " -> " + myDate); 885 if (myDate != expBigD) errln((UnicodeString)"FAIL: bigD - Expected " + dateToString(expBigD)); 886 delete formatter; 887 formatter = new SimpleDateFormat(littleD, status); 888 ASSERT_OK(status); 889 pos = ParsePosition(0); 890 myDate = formatter->parse(dateString, pos); 891 logln((UnicodeString)"Using " + littleD + " -> " + dateToString(myDate)); 892 if (myDate != expLittleD) errln((UnicodeString)"FAIL: littleD - Expected " + dateToString(expLittleD)); 893 delete formatter; 894 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 895 } 896 897 // ------------------------------------- 898 899 /** 900 * Test the day of year pattern. 901 */ 902 void 903 DateFormatTest::TestDayOfYearPattern195() 904 { 905 UErrorCode status = U_ZERO_ERROR; 906 UDate today = Calendar::getNow(); 907 int32_t year,month,day,hour,min,sec; dateToFields(today,year,month,day,hour,min,sec); 908 UDate expected = date(year, month, day); 909 logln((UnicodeString)"Test Date: " + dateToString(today)); 910 SimpleDateFormat* sdf = (SimpleDateFormat*)DateFormat::createDateInstance(); 911 if (sdf == NULL){ 912 dataerrln("Error calling DateFormat::createDateInstance()"); 913 return; 914 } 915 tryPattern(*sdf, today, 0, expected); 916 tryPattern(*sdf, today, "G yyyy DDD", expected); 917 delete sdf; 918 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 919 } 920 921 // ------------------------------------- 922 923 void 924 DateFormatTest::tryPattern(SimpleDateFormat& sdf, UDate d, const char* pattern, UDate expected) 925 { 926 UErrorCode status = U_ZERO_ERROR; 927 if (pattern != 0) sdf.applyPattern(pattern); 928 UnicodeString thePat; 929 logln((UnicodeString)"pattern: " + sdf.toPattern(thePat)); 930 UnicodeString formatResult; (*(DateFormat*)&sdf).format(d, formatResult); 931 logln((UnicodeString)" format -> " + formatResult); 932 // try { 933 UDate d2 = sdf.parse(formatResult, status); 934 logln((UnicodeString)" parse(" + formatResult + ") -> " + dateToString(d2)); 935 if (d2 != expected) errln((UnicodeString)"FAIL: Expected " + dateToString(expected)); 936 UnicodeString format2; (*(DateFormat*)&sdf).format(d2, format2); 937 logln((UnicodeString)" format -> " + format2); 938 if (!(formatResult == format2)) errln((UnicodeString)"FAIL: Round trip drift"); 939 //} 940 //catch(Exception e) { 941 if (U_FAILURE(status)) 942 errln((UnicodeString)"Error: " + (int32_t)status); 943 //} 944 } 945 946 // ------------------------------------- 947 948 /** 949 * Test the handling of single quotes in patterns. 950 */ 951 void 952 DateFormatTest::TestQuotePattern161() 953 { 954 UErrorCode status = U_ZERO_ERROR; 955 SimpleDateFormat* formatter = new SimpleDateFormat((UnicodeString)"MM/dd/yyyy 'at' hh:mm:ss a zzz", status); 956 if (U_FAILURE(status)) { 957 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 958 delete formatter; 959 return; 960 } 961 UDate currentTime_1 = date(97, UCAL_AUGUST, 13, 10, 42, 28); 962 UnicodeString dateString; ((DateFormat*)formatter)->format(currentTime_1, dateString); 963 UnicodeString exp("08/13/1997 at 10:42:28 AM "); 964 logln((UnicodeString)"format(" + dateToString(currentTime_1) + ") = " + dateString); 965 if (0 != dateString.compareBetween(0, exp.length(), exp, 0, exp.length())) errln((UnicodeString)"FAIL: Expected " + exp); 966 delete formatter; 967 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 968 } 969 970 // ------------------------------------- 971 972 /** 973 * Verify the correct behavior when handling invalid input strings. 974 */ 975 void 976 DateFormatTest::TestBadInput135() 977 { 978 UErrorCode status = U_ZERO_ERROR; 979 DateFormat::EStyle looks[] = { 980 DateFormat::SHORT, DateFormat::MEDIUM, DateFormat::LONG, DateFormat::FULL 981 }; 982 int32_t looks_length = UPRV_LENGTHOF(looks); 983 const char* strings[] = { 984 "Mar 15", "Mar 15 1997", "asdf", "3/1/97 1:23:", "3/1/00 1:23:45 AM" 985 }; 986 int32_t strings_length = UPRV_LENGTHOF(strings); 987 DateFormat *full = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::LONG); 988 if(full==NULL) { 989 dataerrln("could not create date time instance"); 990 return; 991 } 992 UnicodeString expected("March 1, 2000 at 1:23:45 AM "); 993 for (int32_t i = 0; i < strings_length;++i) { 994 const char* text = strings[i]; 995 for (int32_t j = 0; j < looks_length;++j) { 996 DateFormat::EStyle dateLook = looks[j]; 997 for (int32_t k = 0; k < looks_length;++k) { 998 DateFormat::EStyle timeLook = looks[k]; 999 DateFormat *df = DateFormat::createDateTimeInstance(dateLook, timeLook); 1000 if (df == NULL){ 1001 dataerrln("Error calling DateFormat::createDateTimeInstance()"); 1002 continue; 1003 } 1004 UnicodeString prefix = UnicodeString(text) + ", " + dateLook + "/" + timeLook + ": "; 1005 //try { 1006 UDate when = df->parse(text, status); 1007 if (when == 0 && U_SUCCESS(status)) { 1008 errln(prefix + "SHOULD NOT HAPPEN: parse returned 0."); 1009 continue; 1010 } 1011 if (U_SUCCESS(status)) 1012 { 1013 UnicodeString format; 1014 UnicodeString pattern; 1015 SimpleDateFormat* sdtfmt = dynamic_cast<SimpleDateFormat*>(df); 1016 if (sdtfmt != NULL) { 1017 sdtfmt->toPattern(pattern); 1018 } 1019 full->format(when, format); 1020 logln(prefix + "OK: " + format); 1021 if (0!=format.compareBetween(0, expected.length(), expected, 0, expected.length())) 1022 errln((UnicodeString)"FAIL: Parse \"" + text + "\", pattern \"" + pattern + "\", expected " + expected + " got " + format); 1023 } 1024 //} 1025 //catch(ParseException e) { 1026 else 1027 status = U_ZERO_ERROR; 1028 //} 1029 //catch(StringIndexOutOfBoundsException e) { 1030 // errln(prefix + "SHOULD NOT HAPPEN: " + (int)status); 1031 //} 1032 delete df; 1033 } 1034 } 1035 } 1036 delete full; 1037 if (U_FAILURE(status)) 1038 errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 1039 } 1040 1041 static const char* const parseFormats[] = { 1042 "MMMM d, yyyy", 1043 "MMMM d yyyy", 1044 "M/d/yy", 1045 "d MMMM, yyyy", 1046 "d MMMM yyyy", 1047 "d MMMM", 1048 "MMMM d", 1049 "yyyy", 1050 "h:mm a MMMM d, yyyy" 1051 }; 1052 1053 #if 0 1054 // strict inputStrings 1055 static const char* const inputStrings[] = { 1056 "bogus string", 0, 0, 0, 0, 0, 0, 0, 0, 0, 1057 "April 1, 1997", "April 1, 1997", 0, 0, 0, 0, 0, "April 1", 0, 0, 1058 "Jan 1, 1970", "January 1, 1970", 0, 0, 0, 0, 0, "January 1", 0, 0, 1059 "Jan 1 2037", 0, "January 1 2037", 0, 0, 0, 0, "January 1", 0, 0, 1060 "1/1/70", 0, 0, "1/1/70", 0, 0, 0, 0, "0001", 0, 1061 "5 May 1997", 0, 0, 0, 0, "5 May 1997", "5 May", 0, "0005", 0, 1062 "16 May", 0, 0, 0, 0, 0, "16 May", 0, "0016", 0, 1063 "April 30", 0, 0, 0, 0, 0, 0, "April 30", 0, 0, 1064 "1998", 0, 0, 0, 0, 0, 0, 0, "1998", 0, 1065 "1", 0, 0, 0, 0, 0, 0, 0, "0001", 0, 1066 "3:00 pm Jan 1, 1997", 0, 0, 0, 0, 0, 0, 0, "0003", "3:00 PM January 1, 1997", 1067 }; 1068 #else 1069 // lenient inputStrings 1070 static const char* const inputStrings[] = { 1071 "bogus string", 0, 0, 0, 0, 0, 0, 0, 0, 0, 1072 "April 1, 1997", "April 1, 1997", "April 1 1997", "4/1/97", 0, 0, 0, "April 1", 0, 0, 1073 "Jan 1, 1970", "January 1, 1970", "January 1 1970", "1/1/70", 0, 0, 0, "January 1", 0, 0, 1074 "Jan 1 2037", "January 1, 2037", "January 1 2037", "1/1/37", 0, 0, 0, "January 1", 0, 0, 1075 "1/1/70", "January 1, 0070", "January 1 0070", "1/1/70", "1 January, 0070", "1 January 0070", "1 January", "January 1", "0001", 0, 1076 "5 May 1997", 0, 0, 0, "5 May, 1997", "5 May 1997", "5 May", 0, "0005", 0, 1077 "16 May", 0, 0, 0, 0, 0, "16 May", 0, "0016", 0, 1078 "April 30", 0, 0, 0, 0, 0, 0, "April 30", 0, 0, 1079 "1998", 0, 0, 0, 0, 0, 0, 0, "1998", 0, 1080 "1", 0, 0, 0, 0, 0, 0, 0, "0001", 0, 1081 "3:00 pm Jan 1, 1997", 0, 0, 0, 0, 0, 0, 0, "0003", "3:00 PM January 1, 1997", 1082 }; 1083 #endif 1084 1085 // ------------------------------------- 1086 1087 /** 1088 * Verify the correct behavior when parsing an array of inputs against an 1089 * array of patterns, with known results. The results are encoded after 1090 * the input strings in each row. 1091 */ 1092 void 1093 DateFormatTest::TestBadInput135a() 1094 { 1095 UErrorCode status = U_ZERO_ERROR; 1096 SimpleDateFormat* dateParse = new SimpleDateFormat(status); 1097 if(U_FAILURE(status)) { 1098 dataerrln("Failed creating SimpleDateFormat with %s. Quitting test", u_errorName(status)); 1099 delete dateParse; 1100 return; 1101 } 1102 const char* s; 1103 UDate date; 1104 const uint32_t PF_LENGTH = UPRV_LENGTHOF(parseFormats); 1105 const uint32_t INPUT_LENGTH = UPRV_LENGTHOF(inputStrings); 1106 1107 dateParse->applyPattern("d MMMM, yyyy"); 1108 dateParse->adoptTimeZone(TimeZone::createDefault()); 1109 s = "not parseable"; 1110 UnicodeString thePat; 1111 logln(UnicodeString("Trying to parse \"") + s + "\" with " + dateParse->toPattern(thePat)); 1112 //try { 1113 date = dateParse->parse(s, status); 1114 if (U_SUCCESS(status)) 1115 errln((UnicodeString)"FAIL: Expected exception during parse"); 1116 //} 1117 //catch(Exception ex) { 1118 else 1119 logln((UnicodeString)"Exception during parse: " + (int32_t)status); 1120 status = U_ZERO_ERROR; 1121 //} 1122 for (uint32_t i = 0; i < INPUT_LENGTH; i += (PF_LENGTH + 1)) { 1123 ParsePosition parsePosition(0); 1124 UnicodeString s( inputStrings[i]); 1125 for (uint32_t index = 0; index < PF_LENGTH;++index) { 1126 const char* expected = inputStrings[i + 1 + index]; 1127 dateParse->applyPattern(parseFormats[index]); 1128 dateParse->adoptTimeZone(TimeZone::createDefault()); 1129 //try { 1130 parsePosition.setIndex(0); 1131 date = dateParse->parse(s, parsePosition); 1132 if (parsePosition.getIndex() != 0) { 1133 UnicodeString s1, s2; 1134 s.extract(0, parsePosition.getIndex(), s1); 1135 s.extract(parsePosition.getIndex(), s.length(), s2); 1136 if (date == 0) { 1137 errln((UnicodeString)"ERROR: null result fmt=\"" + 1138 parseFormats[index] + 1139 "\" pos=" + parsePosition.getIndex() + " " + 1140 s1 + "|" + s2); 1141 } 1142 else { 1143 UnicodeString result; 1144 ((DateFormat*)dateParse)->format(date, result); 1145 logln((UnicodeString)"Parsed \"" + s + "\" using \"" + dateParse->toPattern(thePat) + "\" to: " + result); 1146 if (expected == 0) 1147 errln((UnicodeString)"FAIL: Expected parse failure, got " + result); 1148 else if (!(result == expected)) 1149 errln(UnicodeString("FAIL: Parse \"") + s + UnicodeString("\", expected ") + expected + UnicodeString(", got ") + result); 1150 } 1151 } 1152 else if (expected != 0) { 1153 errln(UnicodeString("FAIL: Expected ") + expected + " from \"" + 1154 s + "\" with \"" + dateParse->toPattern(thePat) + "\""); 1155 } 1156 //} 1157 //catch(Exception ex) { 1158 if (U_FAILURE(status)) 1159 errln((UnicodeString)"An exception was thrown during parse: " + (int32_t)status); 1160 //} 1161 } 1162 } 1163 delete dateParse; 1164 if (U_FAILURE(status)) 1165 errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 1166 } 1167 1168 // ------------------------------------- 1169 1170 /** 1171 * Test the parsing of two-digit years. 1172 */ 1173 void 1174 DateFormatTest::TestTwoDigitYear() 1175 { 1176 UErrorCode ec = U_ZERO_ERROR; 1177 SimpleDateFormat fmt("dd/MM/yy", Locale::getUK(), ec); 1178 if (U_FAILURE(ec)) { 1179 dataerrln("FAIL: SimpleDateFormat constructor - %s", u_errorName(ec)); 1180 return; 1181 } 1182 parse2DigitYear(fmt, "5/6/30", date(130, UCAL_JUNE, 5)); 1183 parse2DigitYear(fmt, "4/6/50", date(50, UCAL_JUNE, 4)); 1184 } 1185 1186 // ------------------------------------- 1187 1188 void 1189 DateFormatTest::parse2DigitYear(DateFormat& fmt, const char* str, UDate expected) 1190 { 1191 UErrorCode status = U_ZERO_ERROR; 1192 //try { 1193 UDate d = fmt.parse(str, status); 1194 UnicodeString thePat; 1195 logln(UnicodeString("Parsing \"") + str + "\" with " + ((SimpleDateFormat*)&fmt)->toPattern(thePat) + 1196 " => " + dateToString(d)); 1197 if (d != expected) errln((UnicodeString)"FAIL: Expected " + expected); 1198 //} 1199 //catch(ParseException e) { 1200 if (U_FAILURE(status)) 1201 errln((UnicodeString)"FAIL: Got exception"); 1202 //} 1203 } 1204 1205 // ------------------------------------- 1206 1207 /** 1208 * Test the formatting of time zones. 1209 */ 1210 void 1211 DateFormatTest::TestDateFormatZone061() 1212 { 1213 UErrorCode status = U_ZERO_ERROR; 1214 UDate date; 1215 DateFormat *formatter; 1216 date= 859248000000.0; 1217 logln((UnicodeString)"Date 1997/3/25 00:00 GMT: " + date); 1218 formatter = new SimpleDateFormat((UnicodeString)"dd-MMM-yyyyy HH:mm", Locale::getUK(), status); 1219 if(U_FAILURE(status)) { 1220 dataerrln("Failed creating SimpleDateFormat with %s. Quitting test", u_errorName(status)); 1221 delete formatter; 1222 return; 1223 } 1224 formatter->adoptTimeZone(TimeZone::createTimeZone("GMT")); 1225 UnicodeString temp; formatter->format(date, temp); 1226 logln((UnicodeString)"Formatted in GMT to: " + temp); 1227 //try { 1228 UDate tempDate = formatter->parse(temp, status); 1229 logln((UnicodeString)"Parsed to: " + dateToString(tempDate)); 1230 if (tempDate != date) errln((UnicodeString)"FAIL: Expected " + dateToString(date)); 1231 //} 1232 //catch(Throwable t) { 1233 if (U_FAILURE(status)) 1234 errln((UnicodeString)"Date Formatter throws: " + (int32_t)status); 1235 //} 1236 delete formatter; 1237 } 1238 1239 // ------------------------------------- 1240 1241 /** 1242 * Test the formatting of time zones. 1243 */ 1244 void 1245 DateFormatTest::TestDateFormatZone146() 1246 { 1247 TimeZone *saveDefault = TimeZone::createDefault(); 1248 1249 //try { 1250 TimeZone *thedefault = TimeZone::createTimeZone("GMT"); 1251 TimeZone::setDefault(*thedefault); 1252 // java.util.Locale.setDefault(new java.util.Locale("ar", "", "")); 1253 1254 // check to be sure... its GMT all right 1255 TimeZone *testdefault = TimeZone::createDefault(); 1256 UnicodeString testtimezone; 1257 testdefault->getID(testtimezone); 1258 if (testtimezone == "GMT") 1259 logln("Test timezone = " + testtimezone); 1260 else 1261 dataerrln("Test timezone should be GMT, not " + testtimezone); 1262 1263 UErrorCode status = U_ZERO_ERROR; 1264 // now try to use the default GMT time zone 1265 GregorianCalendar *greenwichcalendar = 1266 new GregorianCalendar(1997, 3, 4, 23, 0, status); 1267 if (U_FAILURE(status)) { 1268 dataerrln("Fail new GregorianCalendar: %s", u_errorName(status)); 1269 } else { 1270 //*****************************greenwichcalendar.setTimeZone(TimeZone.getDefault()); 1271 //greenwichcalendar.set(1997, 3, 4, 23, 0); 1272 // try anything to set hour to 23:00 !!! 1273 greenwichcalendar->set(UCAL_HOUR_OF_DAY, 23); 1274 // get time 1275 UDate greenwichdate = greenwichcalendar->getTime(status); 1276 // format every way 1277 UnicodeString DATA [] = { 1278 UnicodeString("simple format: "), UnicodeString("04/04/97 23:00 GMT"), 1279 UnicodeString("MM/dd/yy HH:mm z"), 1280 UnicodeString("full format: "), UnicodeString("Friday, April 4, 1997 11:00:00 o'clock PM GMT"), 1281 UnicodeString("EEEE, MMMM d, yyyy h:mm:ss 'o''clock' a z"), 1282 UnicodeString("long format: "), UnicodeString("April 4, 1997 11:00:00 PM GMT"), 1283 UnicodeString("MMMM d, yyyy h:mm:ss a z"), 1284 UnicodeString("default format: "), UnicodeString("04-Apr-97 11:00:00 PM"), 1285 UnicodeString("dd-MMM-yy h:mm:ss a"), 1286 UnicodeString("short format: "), UnicodeString("4/4/97 11:00 PM"), 1287 UnicodeString("M/d/yy h:mm a") 1288 }; 1289 int32_t DATA_length = UPRV_LENGTHOF(DATA); 1290 1291 for (int32_t i=0; i<DATA_length; i+=3) { 1292 DateFormat *fmt = new SimpleDateFormat(DATA[i+2], Locale::getEnglish(), status); 1293 if (U_FAILURE(status)) { 1294 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 1295 break; 1296 } 1297 fmt->setCalendar(*greenwichcalendar); 1298 UnicodeString result; 1299 result = fmt->format(greenwichdate, result); 1300 logln(DATA[i] + result); 1301 if (result != DATA[i+1]) 1302 errln("FAIL: Expected " + DATA[i+1] + ", got " + result); 1303 delete fmt; 1304 } 1305 } 1306 //} 1307 //finally { 1308 TimeZone::adoptDefault(saveDefault); 1309 //} 1310 delete testdefault; 1311 delete greenwichcalendar; 1312 delete thedefault; 1313 1314 1315 } 1316 1317 // ------------------------------------- 1318 1319 /** 1320 * Test the formatting of dates in different locales. 1321 */ 1322 void 1323 DateFormatTest::TestLocaleDateFormat() // Bug 495 1324 { 1325 UDate testDate = date(97, UCAL_SEPTEMBER, 15); 1326 DateFormat *dfFrench = DateFormat::createDateTimeInstance(DateFormat::FULL, 1327 DateFormat::FULL, Locale::getFrench()); 1328 DateFormat *dfUS = DateFormat::createDateTimeInstance(DateFormat::FULL, 1329 DateFormat::FULL, Locale::getUS()); 1330 UnicodeString expectedFRENCH ( "lundi 15 septembre 1997 \\u00E0 00:00:00 heure d\\u2019\\u00E9t\\u00E9 du Pacifique", -1, US_INV ); 1331 expectedFRENCH = expectedFRENCH.unescape(); 1332 UnicodeString expectedUS ( "Monday, September 15, 1997 at 12:00:00 AM Pacific Daylight Time" ); 1333 logln((UnicodeString)"Date set to : " + dateToString(testDate)); 1334 UnicodeString out; 1335 if (dfUS == NULL || dfFrench == NULL){ 1336 dataerrln("Error calling DateFormat::createDateTimeInstance)"); 1337 delete dfUS; 1338 delete dfFrench; 1339 return; 1340 } 1341 1342 dfFrench->format(testDate, out); 1343 logln((UnicodeString)"Date Formated with French Locale " + out); 1344 if (!(out == expectedFRENCH)) 1345 errln((UnicodeString)"FAIL: Expected " + expectedFRENCH); 1346 out.truncate(0); 1347 dfUS->format(testDate, out); 1348 logln((UnicodeString)"Date Formated with US Locale " + out); 1349 if (!(out == expectedUS)) 1350 errln((UnicodeString)"FAIL: Expected " + expectedUS); 1351 delete dfUS; 1352 delete dfFrench; 1353 } 1354 1355 void 1356 DateFormatTest::TestFormattingLocaleTimeSeparator() 1357 { 1358 // This test not as useful is it once was, since timeSeparator 1359 // in the Arabic is changed back to ":" in CLDR 28. 1360 const UDate testDate = 874266720000.; // Sun Sep 14 21:52:00 CET 1997 1361 logln((UnicodeString)"Date set to : " + dateToString(testDate)); 1362 1363 const LocalPointer<const TimeZone> tz(TimeZone::createTimeZone("CET")); 1364 1365 const LocalPointer<DateFormat> dfArab(DateFormat::createTimeInstance( 1366 DateFormat::SHORT, Locale("ar"))); 1367 1368 const LocalPointer<DateFormat> dfLatn(DateFormat::createTimeInstance( 1369 DateFormat::SHORT, Locale("ar", NULL, NULL, "numbers=latn"))); 1370 1371 if (dfLatn.isNull() || dfArab.isNull()) { 1372 dataerrln("Error calling DateFormat::createTimeInstance()"); 1373 return; 1374 } 1375 1376 dfArab->setTimeZone(*tz); 1377 dfLatn->setTimeZone(*tz); 1378 1379 const UnicodeString expectedArab = UnicodeString( 1380 "\\u0669:\\u0665\\u0662 \\u0645", -1, US_INV).unescape(); 1381 1382 const UnicodeString expectedLatn = UnicodeString( 1383 "9:52 \\u0645", -1, US_INV).unescape(); 1384 1385 UnicodeString actualArab; 1386 UnicodeString actualLatn; 1387 1388 dfArab->format(testDate, actualArab); 1389 dfLatn->format(testDate, actualLatn); 1390 1391 assertEquals("Arab", expectedArab, actualArab); 1392 assertEquals("Latn", expectedLatn, actualLatn); 1393 } 1394 1395 /** 1396 * Test DateFormat(Calendar) API 1397 */ 1398 void DateFormatTest::TestDateFormatCalendar() { 1399 DateFormat *date=0, *time=0, *full=0; 1400 Calendar *cal=0; 1401 UnicodeString str; 1402 ParsePosition pos; 1403 UDate when; 1404 UErrorCode ec = U_ZERO_ERROR; 1405 1406 /* Create a formatter for date fields. */ 1407 date = DateFormat::createDateInstance(DateFormat::kShort, Locale::getUS()); 1408 if (date == NULL) { 1409 dataerrln("FAIL: createDateInstance failed"); 1410 goto FAIL; 1411 } 1412 1413 /* Create a formatter for time fields. */ 1414 time = DateFormat::createTimeInstance(DateFormat::kShort, Locale::getUS()); 1415 if (time == NULL) { 1416 errln("FAIL: createTimeInstance failed"); 1417 goto FAIL; 1418 } 1419 1420 /* Create a full format for output */ 1421 full = DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, 1422 Locale::getUS()); 1423 if (full == NULL) { 1424 errln("FAIL: createInstance failed"); 1425 goto FAIL; 1426 } 1427 1428 /* Create a calendar */ 1429 cal = Calendar::createInstance(Locale::getUS(), ec); 1430 if (cal == NULL || U_FAILURE(ec)) { 1431 errln((UnicodeString)"FAIL: Calendar::createInstance failed with " + 1432 u_errorName(ec)); 1433 goto FAIL; 1434 } 1435 1436 /* Parse the date */ 1437 cal->clear(); 1438 str = UnicodeString("4/5/2001", ""); 1439 pos.setIndex(0); 1440 date->parse(str, *cal, pos); 1441 if (pos.getIndex() != str.length()) { 1442 errln((UnicodeString)"FAIL: DateFormat::parse(4/5/2001) failed at " + 1443 pos.getIndex()); 1444 goto FAIL; 1445 } 1446 1447 /* Parse the time */ 1448 str = UnicodeString("5:45 PM", ""); 1449 pos.setIndex(0); 1450 time->parse(str, *cal, pos); 1451 if (pos.getIndex() != str.length()) { 1452 errln((UnicodeString)"FAIL: DateFormat::parse(17:45) failed at " + 1453 pos.getIndex()); 1454 goto FAIL; 1455 } 1456 1457 /* Check result */ 1458 when = cal->getTime(ec); 1459 if (U_FAILURE(ec)) { 1460 errln((UnicodeString)"FAIL: cal->getTime() failed with " + u_errorName(ec)); 1461 goto FAIL; 1462 } 1463 str.truncate(0); 1464 full->format(when, str); 1465 // Thursday, April 5, 2001 5:45:00 PM PDT 986517900000 1466 if (when == 986517900000.0) { 1467 logln("Ok: Parsed result: " + str); 1468 } else { 1469 errln("FAIL: Parsed result: " + str + ", exp 4/5/2001 5:45 PM"); 1470 } 1471 1472 FAIL: 1473 delete date; 1474 delete time; 1475 delete full; 1476 delete cal; 1477 } 1478 1479 /** 1480 * Test DateFormat's parsing of space characters. See jitterbug 1916. 1481 */ 1482 void DateFormatTest::TestSpaceParsing() { 1483 const char* DATA[] = { 1484 "yyyy MM dd HH:mm:ss", 1485 1486 // pattern, input, expected parse or NULL if expect parse failure 1487 "MMMM d yy", " 04 05 06", "2006 04 05 00:00:00", 1488 NULL, "04 05 06", "2006 04 05 00:00:00", 1489 1490 "MM d yy", " 04 05 06", "2006 04 05 00:00:00", 1491 NULL, "04 05 06", "2006 04 05 00:00:00", 1492 NULL, "04/05/06", "2006 04 05 00:00:00", 1493 NULL, "04-05-06", "2006 04 05 00:00:00", 1494 NULL, "04.05.06", "2006 04 05 00:00:00", 1495 NULL, "04 / 05 / 06", "2006 04 05 00:00:00", 1496 NULL, "Apr / 05/ 06", "2006 04 05 00:00:00", 1497 NULL, "Apr-05-06", "2006 04 05 00:00:00", 1498 NULL, "Apr 05, 2006", "2006 04 05 00:00:00", 1499 1500 "MMMM d yy", " Apr 05 06", "2006 04 05 00:00:00", 1501 NULL, "Apr 05 06", "2006 04 05 00:00:00", 1502 NULL, "Apr05 06", "2006 04 05 00:00:00", 1503 1504 "hh:mm:ss a", "12:34:56 PM", "1970 01 01 12:34:56", 1505 NULL, "12:34:56PM", "1970 01 01 12:34:56", 1506 NULL, "12.34.56PM", "1970 01 01 12:34:56", 1507 NULL, "12 : 34 : 56 PM", "1970 01 01 12:34:56", 1508 1509 "MM d yy 'at' hh:mm:ss a", "04/05/06 12:34:56 PM", "2006 04 05 12:34:56", 1510 1511 "MMMM dd yyyy hh:mm a", "September 27, 1964 21:56 PM", "1964 09 28 09:56:00", 1512 NULL, "November 4, 2008 0:13 AM", "2008 11 04 00:13:00", 1513 1514 "HH'h'mm'min'ss's'", "12h34min56s", "1970 01 01 12:34:56", 1515 NULL, "12h34mi56s", "1970 01 01 12:34:56", 1516 NULL, "12h34m56s", "1970 01 01 12:34:56", 1517 NULL, "12:34:56", "1970 01 01 12:34:56" 1518 }; 1519 const int32_t DATA_len = UPRV_LENGTHOF(DATA); 1520 1521 expectParse(DATA, DATA_len, Locale("en")); 1522 } 1523 1524 /** 1525 * Test handling of "HHmmss" pattern. 1526 */ 1527 void DateFormatTest::TestExactCountFormat() { 1528 const char* DATA[] = { 1529 "yyyy MM dd HH:mm:ss", 1530 1531 // pattern, input, expected parse or NULL if expect parse failure 1532 "HHmmss", "123456", "1970 01 01 12:34:56", 1533 NULL, "12345", "1970 01 01 01:23:45", 1534 NULL, "1234", NULL, 1535 NULL, "00-05", NULL, 1536 NULL, "12-34", NULL, 1537 NULL, "00+05", NULL, 1538 "ahhmm", "PM730", "1970 01 01 19:30:00", 1539 }; 1540 const int32_t DATA_len = UPRV_LENGTHOF(DATA); 1541 1542 expectParse(DATA, DATA_len, Locale("en")); 1543 } 1544 1545 /** 1546 * Test handling of white space. 1547 */ 1548 void DateFormatTest::TestWhiteSpaceParsing() { 1549 const char* DATA[] = { 1550 "yyyy MM dd", 1551 1552 // pattern, input, expected parse or null if expect parse failure 1553 1554 // Pattern space run should parse input text space run 1555 "MM d yy", " 04 01 03", "2003 04 01", 1556 NULL, " 04 01 03 ", "2003 04 01", 1557 }; 1558 const int32_t DATA_len = UPRV_LENGTHOF(DATA); 1559 1560 expectParse(DATA, DATA_len, Locale("en")); 1561 } 1562 1563 1564 void DateFormatTest::TestInvalidPattern() { 1565 UErrorCode ec = U_ZERO_ERROR; 1566 SimpleDateFormat f(UnicodeString("Yesterday"), ec); 1567 if (U_FAILURE(ec)) { 1568 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(ec)); 1569 return; 1570 } 1571 UnicodeString out; 1572 FieldPosition pos; 1573 f.format((UDate)0, out, pos); 1574 logln(out); 1575 // The bug is that the call to format() will crash. By not 1576 // crashing, the test passes. 1577 } 1578 1579 void DateFormatTest::TestGreekMay() { 1580 UErrorCode ec = U_ZERO_ERROR; 1581 UDate date = -9896080848000.0; 1582 SimpleDateFormat fmt("EEEE, dd MMMM yyyy h:mm:ss a", Locale("el", "", ""), ec); 1583 if (U_FAILURE(ec)) { 1584 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(ec)); 1585 return; 1586 } 1587 UnicodeString str; 1588 fmt.format(date, str); 1589 ParsePosition pos(0); 1590 UDate d2 = fmt.parse(str, pos); 1591 if (date != d2) { 1592 errln("FAIL: unable to parse strings where case-folding changes length"); 1593 } 1594 } 1595 1596 void DateFormatTest::TestStandAloneMonths() 1597 { 1598 const char *EN_DATA[] = { 1599 "yyyy MM dd HH:mm:ss", 1600 1601 "yyyy LLLL dd H:mm:ss", "fp", "2004 03 10 16:36:31", "2004 March 10 16:36:31", "2004 03 10 16:36:31", 1602 "yyyy LLL dd H:mm:ss", "fp", "2004 03 10 16:36:31", "2004 Mar 10 16:36:31", "2004 03 10 16:36:31", 1603 "yyyy LLLL dd H:mm:ss", "F", "2004 03 10 16:36:31", "2004 March 10 16:36:31", 1604 "yyyy LLL dd H:mm:ss", "pf", "2004 Mar 10 16:36:31", "2004 03 10 16:36:31", "2004 Mar 10 16:36:31", 1605 1606 "LLLL", "fp", "1970 01 01 0:00:00", "January", "1970 01 01 0:00:00", 1607 "LLLL", "fp", "1970 02 01 0:00:00", "February", "1970 02 01 0:00:00", 1608 "LLLL", "fp", "1970 03 01 0:00:00", "March", "1970 03 01 0:00:00", 1609 "LLLL", "fp", "1970 04 01 0:00:00", "April", "1970 04 01 0:00:00", 1610 "LLLL", "fp", "1970 05 01 0:00:00", "May", "1970 05 01 0:00:00", 1611 "LLLL", "fp", "1970 06 01 0:00:00", "June", "1970 06 01 0:00:00", 1612 "LLLL", "fp", "1970 07 01 0:00:00", "July", "1970 07 01 0:00:00", 1613 "LLLL", "fp", "1970 08 01 0:00:00", "August", "1970 08 01 0:00:00", 1614 "LLLL", "fp", "1970 09 01 0:00:00", "September", "1970 09 01 0:00:00", 1615 "LLLL", "fp", "1970 10 01 0:00:00", "October", "1970 10 01 0:00:00", 1616 "LLLL", "fp", "1970 11 01 0:00:00", "November", "1970 11 01 0:00:00", 1617 "LLLL", "fp", "1970 12 01 0:00:00", "December", "1970 12 01 0:00:00", 1618 1619 "LLL", "fp", "1970 01 01 0:00:00", "Jan", "1970 01 01 0:00:00", 1620 "LLL", "fp", "1970 02 01 0:00:00", "Feb", "1970 02 01 0:00:00", 1621 "LLL", "fp", "1970 03 01 0:00:00", "Mar", "1970 03 01 0:00:00", 1622 "LLL", "fp", "1970 04 01 0:00:00", "Apr", "1970 04 01 0:00:00", 1623 "LLL", "fp", "1970 05 01 0:00:00", "May", "1970 05 01 0:00:00", 1624 "LLL", "fp", "1970 06 01 0:00:00", "Jun", "1970 06 01 0:00:00", 1625 "LLL", "fp", "1970 07 01 0:00:00", "Jul", "1970 07 01 0:00:00", 1626 "LLL", "fp", "1970 08 01 0:00:00", "Aug", "1970 08 01 0:00:00", 1627 "LLL", "fp", "1970 09 01 0:00:00", "Sep", "1970 09 01 0:00:00", 1628 "LLL", "fp", "1970 10 01 0:00:00", "Oct", "1970 10 01 0:00:00", 1629 "LLL", "fp", "1970 11 01 0:00:00", "Nov", "1970 11 01 0:00:00", 1630 "LLL", "fp", "1970 12 01 0:00:00", "Dec", "1970 12 01 0:00:00", 1631 }; 1632 1633 const char *CS_DATA[] = { 1634 "yyyy MM dd HH:mm:ss", 1635 1636 "yyyy LLLL dd H:mm:ss", "fp", "2004 04 10 16:36:31", "2004 duben 10 16:36:31", "2004 04 10 16:36:31", 1637 "yyyy MMMM dd H:mm:ss", "fp", "2004 04 10 16:36:31", "2004 dubna 10 16:36:31", "2004 04 10 16:36:31", 1638 "yyyy LLL dd H:mm:ss", "fp", "2004 04 10 16:36:31", "2004 dub 10 16:36:31", "2004 04 10 16:36:31", 1639 "yyyy LLLL dd H:mm:ss", "F", "2004 04 10 16:36:31", "2004 duben 10 16:36:31", 1640 "yyyy MMMM dd H:mm:ss", "F", "2004 04 10 16:36:31", "2004 dubna 10 16:36:31", 1641 "yyyy LLLL dd H:mm:ss", "pf", "2004 duben 10 16:36:31", "2004 04 10 16:36:31", "2004 duben 10 16:36:31", 1642 "yyyy MMMM dd H:mm:ss", "pf", "2004 dubna 10 16:36:31", "2004 04 10 16:36:31", "2004 dubna 10 16:36:31", 1643 1644 "LLLL", "fp", "1970 01 01 0:00:00", "leden", "1970 01 01 0:00:00", 1645 "LLLL", "fp", "1970 02 01 0:00:00", "\\u00FAnor", "1970 02 01 0:00:00", 1646 "LLLL", "fp", "1970 03 01 0:00:00", "b\\u0159ezen", "1970 03 01 0:00:00", 1647 "LLLL", "fp", "1970 04 01 0:00:00", "duben", "1970 04 01 0:00:00", 1648 "LLLL", "fp", "1970 05 01 0:00:00", "kv\\u011Bten", "1970 05 01 0:00:00", 1649 "LLLL", "fp", "1970 06 01 0:00:00", "\\u010Derven", "1970 06 01 0:00:00", 1650 "LLLL", "fp", "1970 07 01 0:00:00", "\\u010Dervenec", "1970 07 01 0:00:00", 1651 "LLLL", "fp", "1970 08 01 0:00:00", "srpen", "1970 08 01 0:00:00", 1652 "LLLL", "fp", "1970 09 01 0:00:00", "z\\u00E1\\u0159\\u00ED", "1970 09 01 0:00:00", 1653 "LLLL", "fp", "1970 10 01 0:00:00", "\\u0159\\u00EDjen", "1970 10 01 0:00:00", 1654 "LLLL", "fp", "1970 11 01 0:00:00", "listopad", "1970 11 01 0:00:00", 1655 "LLLL", "fp", "1970 12 01 0:00:00", "prosinec", "1970 12 01 0:00:00", 1656 1657 "LLL", "fp", "1970 01 01 0:00:00", "led", "1970 01 01 0:00:00", 1658 "LLL", "fp", "1970 02 01 0:00:00", "\\u00FAno", "1970 02 01 0:00:00", 1659 "LLL", "fp", "1970 03 01 0:00:00", "b\\u0159e", "1970 03 01 0:00:00", 1660 "LLL", "fp", "1970 04 01 0:00:00", "dub", "1970 04 01 0:00:00", 1661 "LLL", "fp", "1970 05 01 0:00:00", "kv\\u011B", "1970 05 01 0:00:00", 1662 "LLL", "fp", "1970 06 01 0:00:00", "\\u010Dvn", "1970 06 01 0:00:00", 1663 "LLL", "fp", "1970 07 01 0:00:00", "\\u010Dvc", "1970 07 01 0:00:00", 1664 "LLL", "fp", "1970 08 01 0:00:00", "srp", "1970 08 01 0:00:00", 1665 "LLL", "fp", "1970 09 01 0:00:00", "z\\u00E1\\u0159", "1970 09 01 0:00:00", 1666 "LLL", "fp", "1970 10 01 0:00:00", "\\u0159\\u00EDj", "1970 10 01 0:00:00", 1667 "LLL", "fp", "1970 11 01 0:00:00", "lis", "1970 11 01 0:00:00", 1668 "LLL", "fp", "1970 12 01 0:00:00", "pro", "1970 12 01 0:00:00", 1669 }; 1670 1671 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1672 expect(CS_DATA, UPRV_LENGTHOF(CS_DATA), Locale("cs", "", "")); 1673 } 1674 1675 void DateFormatTest::TestStandAloneDays() 1676 { 1677 const char *EN_DATA[] = { 1678 "yyyy MM dd HH:mm:ss", 1679 1680 "cccc", "fp", "1970 01 04 0:00:00", "Sunday", "1970 01 04 0:00:00", 1681 "cccc", "fp", "1970 01 05 0:00:00", "Monday", "1970 01 05 0:00:00", 1682 "cccc", "fp", "1970 01 06 0:00:00", "Tuesday", "1970 01 06 0:00:00", 1683 "cccc", "fp", "1970 01 07 0:00:00", "Wednesday", "1970 01 07 0:00:00", 1684 "cccc", "fp", "1970 01 01 0:00:00", "Thursday", "1970 01 01 0:00:00", 1685 "cccc", "fp", "1970 01 02 0:00:00", "Friday", "1970 01 02 0:00:00", 1686 "cccc", "fp", "1970 01 03 0:00:00", "Saturday", "1970 01 03 0:00:00", 1687 1688 "ccc", "fp", "1970 01 04 0:00:00", "Sun", "1970 01 04 0:00:00", 1689 "ccc", "fp", "1970 01 05 0:00:00", "Mon", "1970 01 05 0:00:00", 1690 "ccc", "fp", "1970 01 06 0:00:00", "Tue", "1970 01 06 0:00:00", 1691 "ccc", "fp", "1970 01 07 0:00:00", "Wed", "1970 01 07 0:00:00", 1692 "ccc", "fp", "1970 01 01 0:00:00", "Thu", "1970 01 01 0:00:00", 1693 "ccc", "fp", "1970 01 02 0:00:00", "Fri", "1970 01 02 0:00:00", 1694 "ccc", "fp", "1970 01 03 0:00:00", "Sat", "1970 01 03 0:00:00", 1695 }; 1696 1697 const char *CS_DATA[] = { 1698 "yyyy MM dd HH:mm:ss", 1699 1700 "cccc", "fp", "1970 01 04 0:00:00", "ned\\u011Ble", "1970 01 04 0:00:00", 1701 "cccc", "fp", "1970 01 05 0:00:00", "pond\\u011Bl\\u00ED", "1970 01 05 0:00:00", 1702 "cccc", "fp", "1970 01 06 0:00:00", "\\u00FAter\\u00FD", "1970 01 06 0:00:00", 1703 "cccc", "fp", "1970 01 07 0:00:00", "st\\u0159eda", "1970 01 07 0:00:00", 1704 "cccc", "fp", "1970 01 01 0:00:00", "\\u010Dtvrtek", "1970 01 01 0:00:00", 1705 "cccc", "fp", "1970 01 02 0:00:00", "p\\u00E1tek", "1970 01 02 0:00:00", 1706 "cccc", "fp", "1970 01 03 0:00:00", "sobota", "1970 01 03 0:00:00", 1707 1708 "ccc", "fp", "1970 01 04 0:00:00", "ne", "1970 01 04 0:00:00", 1709 "ccc", "fp", "1970 01 05 0:00:00", "po", "1970 01 05 0:00:00", 1710 "ccc", "fp", "1970 01 06 0:00:00", "\\u00FAt", "1970 01 06 0:00:00", 1711 "ccc", "fp", "1970 01 07 0:00:00", "st", "1970 01 07 0:00:00", 1712 "ccc", "fp", "1970 01 01 0:00:00", "\\u010Dt", "1970 01 01 0:00:00", 1713 "ccc", "fp", "1970 01 02 0:00:00", "p\\u00E1", "1970 01 02 0:00:00", 1714 "ccc", "fp", "1970 01 03 0:00:00", "so", "1970 01 03 0:00:00", 1715 }; 1716 1717 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1718 expect(CS_DATA, UPRV_LENGTHOF(CS_DATA), Locale("cs", "", "")); 1719 } 1720 1721 void DateFormatTest::TestShortDays() 1722 { 1723 const char *EN_DATA[] = { 1724 "yyyy MM dd HH:mm:ss", 1725 1726 "EEEEEE, MMM d y", "fp", "2013 01 13 0:00:00", "Su, Jan 13 2013", "2013 01 13 0:00:00", 1727 "EEEEEE, MMM d y", "fp", "2013 01 16 0:00:00", "We, Jan 16 2013", "2013 01 16 0:00:00", 1728 "EEEEEE d", "fp", "1970 01 17 0:00:00", "Sa 17", "1970 01 17 0:00:00", 1729 "cccccc d", "fp", "1970 01 17 0:00:00", "Sa 17", "1970 01 17 0:00:00", 1730 "cccccc", "fp", "1970 01 03 0:00:00", "Sa", "1970 01 03 0:00:00", 1731 }; 1732 const char *SV_DATA[] = { 1733 "yyyy MM dd HH:mm:ss", 1734 1735 "EEEEEE d MMM y", "fp", "2013 01 13 0:00:00", "s\\u00F6 13 jan. 2013", "2013 01 13 0:00:00", 1736 "EEEEEE d MMM y", "fp", "2013 01 16 0:00:00", "on 16 jan. 2013", "2013 01 16 0:00:00", 1737 "EEEEEE d", "fp", "1970 01 17 0:00:00", "l\\u00F6 17", "1970 01 17 0:00:00", 1738 "cccccc d", "fp", "1970 01 17 0:00:00", "l\\u00F6 17", "1970 01 17 0:00:00", 1739 "cccccc", "fp", "1970 01 03 0:00:00", "l\\u00F6", "1970 01 03 0:00:00", 1740 }; 1741 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1742 expect(SV_DATA, UPRV_LENGTHOF(SV_DATA), Locale("sv", "", "")); 1743 } 1744 1745 void DateFormatTest::TestNarrowNames() 1746 { 1747 const char *EN_DATA[] = { 1748 "yyyy MM dd HH:mm:ss", 1749 1750 "yyyy MMMMM dd H:mm:ss", "2004 03 10 16:36:31", "2004 M 10 16:36:31", 1751 "yyyy LLLLL dd H:mm:ss", "2004 03 10 16:36:31", "2004 M 10 16:36:31", 1752 1753 "MMMMM", "1970 01 01 0:00:00", "J", 1754 "MMMMM", "1970 02 01 0:00:00", "F", 1755 "MMMMM", "1970 03 01 0:00:00", "M", 1756 "MMMMM", "1970 04 01 0:00:00", "A", 1757 "MMMMM", "1970 05 01 0:00:00", "M", 1758 "MMMMM", "1970 06 01 0:00:00", "J", 1759 "MMMMM", "1970 07 01 0:00:00", "J", 1760 "MMMMM", "1970 08 01 0:00:00", "A", 1761 "MMMMM", "1970 09 01 0:00:00", "S", 1762 "MMMMM", "1970 10 01 0:00:00", "O", 1763 "MMMMM", "1970 11 01 0:00:00", "N", 1764 "MMMMM", "1970 12 01 0:00:00", "D", 1765 1766 "LLLLL", "1970 01 01 0:00:00", "J", 1767 "LLLLL", "1970 02 01 0:00:00", "F", 1768 "LLLLL", "1970 03 01 0:00:00", "M", 1769 "LLLLL", "1970 04 01 0:00:00", "A", 1770 "LLLLL", "1970 05 01 0:00:00", "M", 1771 "LLLLL", "1970 06 01 0:00:00", "J", 1772 "LLLLL", "1970 07 01 0:00:00", "J", 1773 "LLLLL", "1970 08 01 0:00:00", "A", 1774 "LLLLL", "1970 09 01 0:00:00", "S", 1775 "LLLLL", "1970 10 01 0:00:00", "O", 1776 "LLLLL", "1970 11 01 0:00:00", "N", 1777 "LLLLL", "1970 12 01 0:00:00", "D", 1778 1779 "EEEEE", "1970 01 04 0:00:00", "S", 1780 "EEEEE", "1970 01 05 0:00:00", "M", 1781 "EEEEE", "1970 01 06 0:00:00", "T", 1782 "EEEEE", "1970 01 07 0:00:00", "W", 1783 "EEEEE", "1970 01 01 0:00:00", "T", 1784 "EEEEE", "1970 01 02 0:00:00", "F", 1785 "EEEEE", "1970 01 03 0:00:00", "S", 1786 1787 "ccccc", "1970 01 04 0:00:00", "S", 1788 "ccccc", "1970 01 05 0:00:00", "M", 1789 "ccccc", "1970 01 06 0:00:00", "T", 1790 "ccccc", "1970 01 07 0:00:00", "W", 1791 "ccccc", "1970 01 01 0:00:00", "T", 1792 "ccccc", "1970 01 02 0:00:00", "F", 1793 "ccccc", "1970 01 03 0:00:00", "S", 1794 1795 "h:mm a", "2015 01 01 10:00:00", "10:00 AM", 1796 "h:mm a", "2015 01 01 22:00:00", "10:00 PM", 1797 "h:mm aaaaa", "2015 01 01 10:00:00", "10:00 a", 1798 "h:mm aaaaa", "2015 01 01 22:00:00", "10:00 p", 1799 }; 1800 1801 const char *CS_DATA[] = { 1802 "yyyy MM dd HH:mm:ss", 1803 1804 "yyyy LLLLL dd H:mm:ss", "2004 04 10 16:36:31", "2004 4 10 16:36:31", 1805 "yyyy MMMMM dd H:mm:ss", "2004 04 10 16:36:31", "2004 4 10 16:36:31", 1806 1807 "MMMMM", "1970 01 01 0:00:00", "1", 1808 "MMMMM", "1970 02 01 0:00:00", "2", 1809 "MMMMM", "1970 03 01 0:00:00", "3", 1810 "MMMMM", "1970 04 01 0:00:00", "4", 1811 "MMMMM", "1970 05 01 0:00:00", "5", 1812 "MMMMM", "1970 06 01 0:00:00", "6", 1813 "MMMMM", "1970 07 01 0:00:00", "7", 1814 "MMMMM", "1970 08 01 0:00:00", "8", 1815 "MMMMM", "1970 09 01 0:00:00", "9", 1816 "MMMMM", "1970 10 01 0:00:00", "10", 1817 "MMMMM", "1970 11 01 0:00:00", "11", 1818 "MMMMM", "1970 12 01 0:00:00", "12", 1819 1820 "LLLLL", "1970 01 01 0:00:00", "1", 1821 "LLLLL", "1970 02 01 0:00:00", "2", 1822 "LLLLL", "1970 03 01 0:00:00", "3", 1823 "LLLLL", "1970 04 01 0:00:00", "4", 1824 "LLLLL", "1970 05 01 0:00:00", "5", 1825 "LLLLL", "1970 06 01 0:00:00", "6", 1826 "LLLLL", "1970 07 01 0:00:00", "7", 1827 "LLLLL", "1970 08 01 0:00:00", "8", 1828 "LLLLL", "1970 09 01 0:00:00", "9", 1829 "LLLLL", "1970 10 01 0:00:00", "10", 1830 "LLLLL", "1970 11 01 0:00:00", "11", 1831 "LLLLL", "1970 12 01 0:00:00", "12", 1832 1833 "EEEEE", "1970 01 04 0:00:00", "N", 1834 "EEEEE", "1970 01 05 0:00:00", "P", 1835 "EEEEE", "1970 01 06 0:00:00", "\\u00DA", 1836 "EEEEE", "1970 01 07 0:00:00", "S", 1837 "EEEEE", "1970 01 01 0:00:00", "\\u010C", 1838 "EEEEE", "1970 01 02 0:00:00", "P", 1839 "EEEEE", "1970 01 03 0:00:00", "S", 1840 1841 "ccccc", "1970 01 04 0:00:00", "N", 1842 "ccccc", "1970 01 05 0:00:00", "P", 1843 "ccccc", "1970 01 06 0:00:00", "\\u00DA", 1844 "ccccc", "1970 01 07 0:00:00", "S", 1845 "ccccc", "1970 01 01 0:00:00", "\\u010C", 1846 "ccccc", "1970 01 02 0:00:00", "P", 1847 "ccccc", "1970 01 03 0:00:00", "S", 1848 1849 "h:mm a", "2015 01 01 10:00:00", "10:00 dop.", 1850 "h:mm a", "2015 01 01 22:00:00", "10:00 odp.", 1851 "h:mm aaaaa", "2015 01 01 10:00:00", "10:00 dop.", 1852 "h:mm aaaaa", "2015 01 01 22:00:00", "10:00 odp.", 1853 }; 1854 1855 const char *CA_DATA[] = { 1856 "yyyy MM dd HH:mm:ss", 1857 1858 "h:mm a", "2015 01 01 10:00:00", "10:00 a. m.", 1859 "h:mm a", "2015 01 01 22:00:00", "10:00 p. m.", 1860 "h:mm aaaaa", "2015 01 01 10:00:00", "10:00 a. m.", 1861 "h:mm aaaaa", "2015 01 01 22:00:00", "10:00 p. m.", 1862 }; 1863 1864 expectFormat(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1865 expectFormat(CS_DATA, UPRV_LENGTHOF(CS_DATA), Locale("cs", "", "")); 1866 expectFormat(CA_DATA, UPRV_LENGTHOF(CA_DATA), Locale("ca", "", "")); 1867 } 1868 1869 void DateFormatTest::TestEras() 1870 { 1871 const char *EN_DATA[] = { 1872 "yyyy MM dd", 1873 1874 "MMMM dd yyyy G", "fp", "1951 07 17", "July 17 1951 AD", "1951 07 17", 1875 "MMMM dd yyyy GG", "fp", "1951 07 17", "July 17 1951 AD", "1951 07 17", 1876 "MMMM dd yyyy GGG", "fp", "1951 07 17", "July 17 1951 AD", "1951 07 17", 1877 "MMMM dd yyyy GGGG", "fp", "1951 07 17", "July 17 1951 Anno Domini", "1951 07 17", 1878 1879 "MMMM dd yyyy G", "fp", "-438 07 17", "July 17 0439 BC", "-438 07 17", 1880 "MMMM dd yyyy GG", "fp", "-438 07 17", "July 17 0439 BC", "-438 07 17", 1881 "MMMM dd yyyy GGG", "fp", "-438 07 17", "July 17 0439 BC", "-438 07 17", 1882 "MMMM dd yyyy GGGG", "fp", "-438 07 17", "July 17 0439 Before Christ", "-438 07 17", 1883 }; 1884 1885 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1886 } 1887 1888 void DateFormatTest::TestQuarters() 1889 { 1890 const char *EN_DATA[] = { 1891 "yyyy MM dd", 1892 1893 "Q", "fp", "1970 01 01", "1", "1970 01 01", 1894 "QQ", "fp", "1970 04 01", "02", "1970 04 01", 1895 "QQQ", "fp", "1970 07 01", "Q3", "1970 07 01", 1896 "QQQQ", "fp", "1970 10 01", "4th quarter", "1970 10 01", 1897 1898 "q", "fp", "1970 01 01", "1", "1970 01 01", 1899 "qq", "fp", "1970 04 01", "02", "1970 04 01", 1900 "qqq", "fp", "1970 07 01", "Q3", "1970 07 01", 1901 "qqqq", "fp", "1970 10 01", "4th quarter", "1970 10 01", 1902 1903 "Qyy", "fp", "2015 04 01", "215", "2015 04 01", 1904 "QQyy", "fp", "2015 07 01", "0315", "2015 07 01", 1905 }; 1906 1907 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1908 } 1909 1910 /** 1911 * Test parsing. Input is an array that starts with the following 1912 * header: 1913 * 1914 * [0] = pattern string to parse [i+2] with 1915 * 1916 * followed by test cases, each of which is 3 array elements: 1917 * 1918 * [i] = pattern, or NULL to reuse prior pattern 1919 * [i+1] = input string 1920 * [i+2] = expected parse result (parsed with pattern [0]) 1921 * 1922 * If expect parse failure, then [i+2] should be NULL. 1923 */ 1924 void DateFormatTest::expectParse(const char** data, int32_t data_length, 1925 const Locale& loc) { 1926 const UDate FAIL = (UDate) -1; 1927 const UnicodeString FAIL_STR("parse failure"); 1928 int32_t i = 0; 1929 1930 UErrorCode ec = U_ZERO_ERROR; 1931 SimpleDateFormat fmt("", loc, ec); 1932 SimpleDateFormat ref(data[i++], loc, ec); 1933 SimpleDateFormat gotfmt("G yyyy MM dd HH:mm:ss z", loc, ec); 1934 if (U_FAILURE(ec)) { 1935 dataerrln("FAIL: SimpleDateFormat constructor - %s", u_errorName(ec)); 1936 return; 1937 } 1938 1939 const char* currentPat = NULL; 1940 while (i<data_length) { 1941 const char* pattern = data[i++]; 1942 const char* input = data[i++]; 1943 const char* expected = data[i++]; 1944 1945 ec = U_ZERO_ERROR; 1946 if (pattern != NULL) { 1947 fmt.applyPattern(pattern); 1948 currentPat = pattern; 1949 } 1950 UDate got = fmt.parse(input, ec); 1951 UnicodeString gotstr(FAIL_STR); 1952 if (U_FAILURE(ec)) { 1953 got = FAIL; 1954 } else { 1955 gotstr.remove(); 1956 gotfmt.format(got, gotstr); 1957 } 1958 1959 UErrorCode ec2 = U_ZERO_ERROR; 1960 UDate exp = FAIL; 1961 UnicodeString expstr(FAIL_STR); 1962 if (expected != NULL) { 1963 expstr = expected; 1964 exp = ref.parse(expstr, ec2); 1965 if (U_FAILURE(ec2)) { 1966 // This only happens if expected is in wrong format -- 1967 // should never happen once test is debugged. 1968 errln("FAIL: Internal test error"); 1969 return; 1970 } 1971 } 1972 1973 if (got == exp) { 1974 logln((UnicodeString)"Ok: " + input + " x " + 1975 currentPat + " => " + gotstr); 1976 } else { 1977 errln((UnicodeString)"FAIL: " + input + " x " + 1978 currentPat + " => " + gotstr + ", expected " + 1979 expstr); 1980 } 1981 } 1982 } 1983 1984 /** 1985 * Test formatting and parsing. Input is an array that starts 1986 * with the following header: 1987 * 1988 * [0] = pattern string to parse [i+2] with 1989 * 1990 * followed by test cases, each of which is 3 array elements: 1991 * 1992 * [i] = pattern, or null to reuse prior pattern 1993 * [i+1] = control string, either "fp", "pf", or "F". 1994 * [i+2..] = data strings 1995 * 1996 * The number of data strings depends on the control string. 1997 * Examples: 1998 * 1. "y/M/d H:mm:ss.SS", "fp", "2004 03 10 16:36:31.567", "2004/3/10 16:36:31.56", "2004 03 10 16:36:31.560", 1999 * 'f': Format date [i+2] (as parsed using pattern [0]) and expect string [i+3]. 2000 * 'p': Parse string [i+3] and expect date [i+4]. 2001 * 2002 * 2. "y/M/d H:mm:ss.SSS", "F", "2004 03 10 16:36:31.567", "2004/3/10 16:36:31.567" 2003 * 'F': Format date [i+2] and expect string [i+3], 2004 * then parse string [i+3] and expect date [i+2]. 2005 * 2006 * 3. "y/M/d H:mm:ss.SSSS", "pf", "2004/3/10 16:36:31.5679", "2004 03 10 16:36:31.567", "2004/3/10 16:36:31.5670", 2007 * 'p': Parse string [i+2] and expect date [i+3]. 2008 * 'f': Format date [i+3] and expect string [i+4]. 2009 */ 2010 void DateFormatTest::expect(const char** data, int32_t data_length, 2011 const Locale& loc) { 2012 int32_t i = 0; 2013 UErrorCode ec = U_ZERO_ERROR; 2014 UnicodeString str, str2; 2015 SimpleDateFormat fmt("", loc, ec); 2016 SimpleDateFormat ref(data[i++], loc, ec); 2017 SimpleDateFormat univ("EE G yyyy MM dd HH:mm:ss.SSS z", loc, ec); 2018 if (U_FAILURE(ec)) { 2019 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(ec)); 2020 return; 2021 } 2022 2023 UnicodeString currentPat; 2024 while (i<data_length) { 2025 const char* pattern = data[i++]; 2026 if (pattern != NULL) { 2027 fmt.applyPattern(pattern); 2028 currentPat = pattern; 2029 } 2030 2031 const char* control = data[i++]; 2032 2033 if (uprv_strcmp(control, "fp") == 0) { 2034 // 'f' 2035 const char* datestr = data[i++]; 2036 const char* string = data[i++]; 2037 UDate date = ref.parse(ctou(datestr), ec); 2038 if (!assertSuccess("parse", ec)) return; 2039 assertEquals((UnicodeString)"\"" + currentPat + "\".format(" + datestr + ")", 2040 ctou(string), 2041 fmt.format(date, str.remove())); 2042 // 'p' 2043 datestr = data[i++]; 2044 date = ref.parse(ctou(datestr), ec); 2045 if (!assertSuccess("parse", ec)) return; 2046 UDate parsedate = fmt.parse(ctou(string), ec); 2047 if (assertSuccess((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", ec)) { 2048 assertEquals((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", 2049 univ.format(date, str.remove()), 2050 univ.format(parsedate, str2.remove())); 2051 } 2052 } 2053 2054 else if (uprv_strcmp(control, "pf") == 0) { 2055 // 'p' 2056 const char* string = data[i++]; 2057 const char* datestr = data[i++]; 2058 UDate date = ref.parse(ctou(datestr), ec); 2059 if (!assertSuccess("parse", ec)) return; 2060 UDate parsedate = fmt.parse(ctou(string), ec); 2061 if (assertSuccess((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", ec)) { 2062 assertEquals((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", 2063 univ.format(date, str.remove()), 2064 univ.format(parsedate, str2.remove())); 2065 } 2066 // 'f' 2067 string = data[i++]; 2068 assertEquals((UnicodeString)"\"" + currentPat + "\".format(" + datestr + ")", 2069 ctou(string), 2070 fmt.format(date, str.remove())); 2071 } 2072 2073 else if (uprv_strcmp(control, "F") == 0) { 2074 const char* datestr = data[i++]; 2075 const char* string = data[i++]; 2076 UDate date = ref.parse(ctou(datestr), ec); 2077 if (!assertSuccess("parse", ec)) return; 2078 assertEquals((UnicodeString)"\"" + currentPat + "\".format(" + datestr + ")", 2079 ctou(string), 2080 fmt.format(date, str.remove())); 2081 2082 UDate parsedate = fmt.parse(string, ec); 2083 if (assertSuccess((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", ec)) { 2084 assertEquals((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", 2085 univ.format(date, str.remove()), 2086 univ.format(parsedate, str2.remove())); 2087 } 2088 } 2089 2090 else { 2091 errln((UnicodeString)"FAIL: Invalid control string " + control); 2092 return; 2093 } 2094 } 2095 } 2096 2097 /** 2098 * Test formatting. Input is an array that starts 2099 * with the following header: 2100 * 2101 * [0] = pattern string to parse [i+2] with 2102 * 2103 * followed by test cases, each of which is 3 array elements: 2104 * 2105 * [i] = pattern, or null to reuse prior pattern 2106 * [i+1] = data string a 2107 * [i+2] = data string b 2108 * 2109 * Examples: 2110 * Format date [i+1] and expect string [i+2]. 2111 * 2112 * "y/M/d H:mm:ss.SSSS", "2004/3/10 16:36:31.5679", "2004 03 10 16:36:31.567" 2113 */ 2114 void DateFormatTest::expectFormat(const char** data, int32_t data_length, 2115 const Locale& loc) { 2116 int32_t i = 0; 2117 UErrorCode ec = U_ZERO_ERROR; 2118 UnicodeString str, str2; 2119 SimpleDateFormat fmt("", loc, ec); 2120 SimpleDateFormat ref(data[i++], loc, ec); 2121 SimpleDateFormat univ("EE G yyyy MM dd HH:mm:ss.SSS z", loc, ec); 2122 if (U_FAILURE(ec)) { 2123 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(ec)); 2124 return; 2125 } 2126 2127 UnicodeString currentPat; 2128 2129 while (i<data_length) { 2130 const char* pattern = data[i++]; 2131 if (pattern != NULL) { 2132 fmt.applyPattern(pattern); 2133 currentPat = pattern; 2134 } 2135 2136 const char* datestr = data[i++]; 2137 const char* string = data[i++]; 2138 UDate date = ref.parse(ctou(datestr), ec); 2139 if (!assertSuccess("parse", ec)) return; 2140 assertEquals((UnicodeString)"\"" + currentPat + "\".format(" + datestr + ")", 2141 ctou(string), 2142 fmt.format(date, str.remove())); 2143 } 2144 } 2145 2146 void DateFormatTest::TestGenericTime() { 2147 const Locale en("en"); 2148 // Note: We no longer parse strings in different styles. 2149 /* 2150 const char* ZDATA[] = { 2151 "yyyy MM dd HH:mm zzz", 2152 // round trip 2153 "y/M/d H:mm zzzz", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Standard Time", 2154 "y/M/d H:mm zzz", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 PST", 2155 "y/M/d H:mm vvvv", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Time", 2156 "y/M/d H:mm v", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 PT", 2157 // non-generic timezone string influences dst offset even if wrong for date/time 2158 "y/M/d H:mm zzz", "pf", "2004/1/1 1:00 PDT", "2004 01 01 01:00 PDT", "2004/1/1 0:00 PST", 2159 "y/M/d H:mm vvvv", "pf", "2004/1/1 1:00 PDT", "2004 01 01 01:00 PDT", "2004/1/1 0:00 Pacific Time", 2160 "y/M/d H:mm zzz", "pf", "2004/7/1 1:00 PST", "2004 07 01 02:00 PDT", "2004/7/1 2:00 PDT", 2161 "y/M/d H:mm vvvv", "pf", "2004/7/1 1:00 PST", "2004 07 01 02:00 PDT", "2004/7/1 2:00 Pacific Time", 2162 // generic timezone generates dst offset appropriate for local time 2163 "y/M/d H:mm zzz", "pf", "2004/1/1 1:00 PT", "2004 01 01 01:00 PST", "2004/1/1 1:00 PST", 2164 "y/M/d H:mm vvvv", "pf", "2004/1/1 1:00 PT", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Time", 2165 "y/M/d H:mm zzz", "pf", "2004/7/1 1:00 PT", "2004 07 01 01:00 PDT", "2004/7/1 1:00 PDT", 2166 "y/M/d H:mm vvvv", "pf", "2004/7/1 1:00 PT", "2004 07 01 01:00 PDT", "2004/7/1 1:00 Pacific Time", 2167 // daylight savings time transition edge cases. 2168 // time to parse does not really exist, PT interpreted as earlier time 2169 "y/M/d H:mm zzz", "pf", "2005/4/3 2:30 PT", "2005 04 03 03:30 PDT", "2005/4/3 3:30 PDT", 2170 "y/M/d H:mm zzz", "pf", "2005/4/3 2:30 PST", "2005 04 03 03:30 PDT", "2005/4/3 3:30 PDT", 2171 "y/M/d H:mm zzz", "pf", "2005/4/3 2:30 PDT", "2005 04 03 01:30 PST", "2005/4/3 1:30 PST", 2172 "y/M/d H:mm v", "pf", "2005/4/3 2:30 PT", "2005 04 03 03:30 PDT", "2005/4/3 3:30 PT", 2173 "y/M/d H:mm v", "pf", "2005/4/3 2:30 PST", "2005 04 03 03:30 PDT", "2005/4/3 3:30 PT", 2174 "y/M/d H:mm v", "pf", "2005/4/3 2:30 PDT", "2005 04 03 01:30 PST", "2005/4/3 1:30 PT", 2175 "y/M/d H:mm", "pf", "2005/4/3 2:30", "2005 04 03 03:30 PDT", "2005/4/3 3:30", 2176 // time to parse is ambiguous, PT interpreted as later time 2177 "y/M/d H:mm zzz", "pf", "2005/10/30 1:30 PT", "2005 10 30 01:30 PST", "2005/10/30 1:30 PST", 2178 "y/M/d H:mm v", "pf", "2005/10/30 1:30 PT", "2005 10 30 01:30 PST", "2005/10/30 1:30 PT", 2179 "y/M/d H:mm", "pf", "2005/10/30 1:30 PT", "2005 10 30 01:30 PST", "2005/10/30 1:30", 2180 2181 "y/M/d H:mm zzz", "pf", "2004/10/31 1:30 PT", "2004 10 31 01:30 PST", "2004/10/31 1:30 PST", 2182 "y/M/d H:mm zzz", "pf", "2004/10/31 1:30 PST", "2004 10 31 01:30 PST", "2004/10/31 1:30 PST", 2183 "y/M/d H:mm zzz", "pf", "2004/10/31 1:30 PDT", "2004 10 31 01:30 PDT", "2004/10/31 1:30 PDT", 2184 "y/M/d H:mm v", "pf", "2004/10/31 1:30 PT", "2004 10 31 01:30 PST", "2004/10/31 1:30 PT", 2185 "y/M/d H:mm v", "pf", "2004/10/31 1:30 PST", "2004 10 31 01:30 PST", "2004/10/31 1:30 PT", 2186 "y/M/d H:mm v", "pf", "2004/10/31 1:30 PDT", "2004 10 31 01:30 PDT", "2004/10/31 1:30 PT", 2187 "y/M/d H:mm", "pf", "2004/10/31 1:30", "2004 10 31 01:30 PST", "2004/10/31 1:30", 2188 }; 2189 */ 2190 const char* ZDATA[] = { 2191 "yyyy MM dd HH:mm zzz", 2192 // round trip 2193 "y/M/d H:mm zzzz", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Standard Time", 2194 "y/M/d H:mm zzz", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 PST", 2195 "y/M/d H:mm vvvv", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Time", 2196 "y/M/d H:mm v", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 PT", 2197 // non-generic timezone string influences dst offset even if wrong for date/time 2198 "y/M/d H:mm zzz", "pf", "2004/1/1 1:00 PDT", "2004 01 01 01:00 PDT", "2004/1/1 0:00 PST", 2199 "y/M/d H:mm zzz", "pf", "2004/7/1 1:00 PST", "2004 07 01 02:00 PDT", "2004/7/1 2:00 PDT", 2200 // generic timezone generates dst offset appropriate for local time 2201 "y/M/d H:mm zzz", "pf", "2004/1/1 1:00 PST", "2004 01 01 01:00 PST", "2004/1/1 1:00 PST", 2202 "y/M/d H:mm vvvv", "pf", "2004/1/1 1:00 Pacific Time", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Time", 2203 "y/M/d H:mm zzz", "pf", "2004/7/1 1:00 PDT", "2004 07 01 01:00 PDT", "2004/7/1 1:00 PDT", 2204 "y/M/d H:mm vvvv", "pf", "2004/7/1 1:00 Pacific Time", "2004 07 01 01:00 PDT", "2004/7/1 1:00 Pacific Time", 2205 // daylight savings time transition edge cases. 2206 // time to parse does not really exist, PT interpreted as earlier time 2207 "y/M/d H:mm zzz", "pf", "2005/4/3 2:30 PST", "2005 04 03 03:30 PDT", "2005/4/3 3:30 PDT", 2208 "y/M/d H:mm zzz", "pf", "2005/4/3 2:30 PDT", "2005 04 03 01:30 PST", "2005/4/3 1:30 PST", 2209 "y/M/d H:mm v", "pf", "2005/4/3 2:30 PT", "2005 04 03 03:30 PDT", "2005/4/3 3:30 PT", 2210 "y/M/d H:mm", "pf", "2005/4/3 2:30", "2005 04 03 03:30 PDT", "2005/4/3 3:30", 2211 // time to parse is ambiguous, PT interpreted as later time 2212 "y/M/d H:mm v", "pf", "2005/10/30 1:30 PT", "2005 10 30 01:30 PST", "2005/10/30 1:30 PT", 2213 "y/M/d H:mm", "pf", "2005/10/30 1:30 PT", "2005 10 30 01:30 PST", "2005/10/30 1:30", 2214 2215 "y/M/d H:mm zzz", "pf", "2004/10/31 1:30 PST", "2004 10 31 01:30 PST", "2004/10/31 1:30 PST", 2216 "y/M/d H:mm zzz", "pf", "2004/10/31 1:30 PDT", "2004 10 31 01:30 PDT", "2004/10/31 1:30 PDT", 2217 "y/M/d H:mm v", "pf", "2004/10/31 1:30 PT", "2004 10 31 01:30 PST", "2004/10/31 1:30 PT", 2218 "y/M/d H:mm", "pf", "2004/10/31 1:30", "2004 10 31 01:30 PST", "2004/10/31 1:30", 2219 }; 2220 2221 const int32_t ZDATA_length = UPRV_LENGTHOF(ZDATA); 2222 expect(ZDATA, ZDATA_length, en); 2223 2224 UErrorCode status = U_ZERO_ERROR; 2225 2226 logln("cross format/parse tests"); // Note: We no longer support cross format/parse 2227 UnicodeString basepat("yy/MM/dd H:mm "); 2228 SimpleDateFormat formats[] = { 2229 SimpleDateFormat(basepat + "vvv", en, status), 2230 SimpleDateFormat(basepat + "vvvv", en, status), 2231 SimpleDateFormat(basepat + "zzz", en, status), 2232 SimpleDateFormat(basepat + "zzzz", en, status) 2233 }; 2234 if (U_FAILURE(status)) { 2235 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(status)); 2236 return; 2237 } 2238 const int32_t formats_length = UPRV_LENGTHOF(formats); 2239 2240 UnicodeString test; 2241 SimpleDateFormat univ("yyyy MM dd HH:mm zzz", en, status); 2242 ASSERT_OK(status); 2243 const UnicodeString times[] = { 2244 "2004 01 02 03:04 PST", 2245 "2004 07 08 09:10 PDT" 2246 }; 2247 int32_t times_length = UPRV_LENGTHOF(times); 2248 for (int i = 0; i < times_length; ++i) { 2249 UDate d = univ.parse(times[i], status); 2250 logln(UnicodeString("\ntime: ") + d); 2251 for (int j = 0; j < formats_length; ++j) { 2252 test.remove(); 2253 formats[j].format(d, test); 2254 logln("\ntest: '" + test + "'"); 2255 for (int k = 0; k < formats_length; ++k) { 2256 UDate t = formats[k].parse(test, status); 2257 if (U_SUCCESS(status)) { 2258 if (d != t) { 2259 errln((UnicodeString)"FAIL: format " + k + 2260 " incorrectly parsed output of format " + j + 2261 " (" + test + "), returned " + 2262 dateToString(t) + " instead of " + dateToString(d)); 2263 } else { 2264 logln((UnicodeString)"OK: format " + k + " parsed ok"); 2265 } 2266 } else if (status == U_PARSE_ERROR) { 2267 errln((UnicodeString)"FAIL: format " + k + 2268 " could not parse output of format " + j + 2269 " (" + test + ")"); 2270 } 2271 } 2272 } 2273 } 2274 } 2275 2276 void DateFormatTest::TestGenericTimeZoneOrder() { 2277 // generic times should parse the same no matter what the placement of the time zone string 2278 2279 // Note: We no longer support cross style format/parse 2280 2281 //const char* XDATA[] = { 2282 // "yyyy MM dd HH:mm zzz", 2283 // // standard time, explicit daylight/standard 2284 // "y/M/d H:mm zzz", "pf", "2004/1/1 1:00 PT", "2004 01 01 01:00 PST", "2004/1/1 1:00 PST", 2285 // "y/M/d zzz H:mm", "pf", "2004/1/1 PT 1:00", "2004 01 01 01:00 PST", "2004/1/1 PST 1:00", 2286 // "zzz y/M/d H:mm", "pf", "PT 2004/1/1 1:00", "2004 01 01 01:00 PST", "PST 2004/1/1 1:00", 2287 2288 // // standard time, generic 2289 // "y/M/d H:mm vvvv", "pf", "2004/1/1 1:00 PT", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Time", 2290 // "y/M/d vvvv H:mm", "pf", "2004/1/1 PT 1:00", "2004 01 01 01:00 PST", "2004/1/1 Pacific Time 1:00", 2291 // "vvvv y/M/d H:mm", "pf", "PT 2004/1/1 1:00", "2004 01 01 01:00 PST", "Pacific Time 2004/1/1 1:00", 2292 2293 // // dahylight time, explicit daylight/standard 2294 // "y/M/d H:mm zzz", "pf", "2004/7/1 1:00 PT", "2004 07 01 01:00 PDT", "2004/7/1 1:00 PDT", 2295 // "y/M/d zzz H:mm", "pf", "2004/7/1 PT 1:00", "2004 07 01 01:00 PDT", "2004/7/1 PDT 1:00", 2296 // "zzz y/M/d H:mm", "pf", "PT 2004/7/1 1:00", "2004 07 01 01:00 PDT", "PDT 2004/7/1 1:00", 2297 2298 // // daylight time, generic 2299 // "y/M/d H:mm vvvv", "pf", "2004/7/1 1:00 PT", "2004 07 01 01:00 PDT", "2004/7/1 1:00 Pacific Time", 2300 // "y/M/d vvvv H:mm", "pf", "2004/7/1 PT 1:00", "2004 07 01 01:00 PDT", "2004/7/1 Pacific Time 1:00", 2301 // "vvvv y/M/d H:mm", "pf", "PT 2004/7/1 1:00", "2004 07 01 01:00 PDT", "Pacific Time 2004/7/1 1:00", 2302 //}; 2303 const char* XDATA[] = { 2304 "yyyy MM dd HH:mm zzz", 2305 // standard time, explicit daylight/standard 2306 "y/M/d H:mm zzz", "pf", "2004/1/1 1:00 PST", "2004 01 01 01:00 PST", "2004/1/1 1:00 PST", 2307 "y/M/d zzz H:mm", "pf", "2004/1/1 PST 1:00", "2004 01 01 01:00 PST", "2004/1/1 PST 1:00", 2308 "zzz y/M/d H:mm", "pf", "PST 2004/1/1 1:00", "2004 01 01 01:00 PST", "PST 2004/1/1 1:00", 2309 2310 // standard time, generic 2311 "y/M/d H:mm vvvv", "pf", "2004/1/1 1:00 Pacific Time", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Time", 2312 "y/M/d vvvv H:mm", "pf", "2004/1/1 Pacific Time 1:00", "2004 01 01 01:00 PST", "2004/1/1 Pacific Time 1:00", 2313 "vvvv y/M/d H:mm", "pf", "Pacific Time 2004/1/1 1:00", "2004 01 01 01:00 PST", "Pacific Time 2004/1/1 1:00", 2314 2315 // dahylight time, explicit daylight/standard 2316 "y/M/d H:mm zzz", "pf", "2004/7/1 1:00 PDT", "2004 07 01 01:00 PDT", "2004/7/1 1:00 PDT", 2317 "y/M/d zzz H:mm", "pf", "2004/7/1 PDT 1:00", "2004 07 01 01:00 PDT", "2004/7/1 PDT 1:00", 2318 "zzz y/M/d H:mm", "pf", "PDT 2004/7/1 1:00", "2004 07 01 01:00 PDT", "PDT 2004/7/1 1:00", 2319 2320 // daylight time, generic 2321 "y/M/d H:mm v", "pf", "2004/7/1 1:00 PT", "2004 07 01 01:00 PDT", "2004/7/1 1:00 PT", 2322 "y/M/d v H:mm", "pf", "2004/7/1 PT 1:00", "2004 07 01 01:00 PDT", "2004/7/1 PT 1:00", 2323 "v y/M/d H:mm", "pf", "PT 2004/7/1 1:00", "2004 07 01 01:00 PDT", "PT 2004/7/1 1:00", 2324 }; 2325 const int32_t XDATA_length = UPRV_LENGTHOF(XDATA); 2326 Locale en("en"); 2327 expect(XDATA, XDATA_length, en); 2328 } 2329 2330 void DateFormatTest::TestZTimeZoneParsing(void) { 2331 UErrorCode status = U_ZERO_ERROR; 2332 const Locale en("en"); 2333 UnicodeString test; 2334 //SimpleDateFormat univ("yyyy-MM-dd'T'HH:mm Z", en, status); 2335 SimpleDateFormat univ("HH:mm Z", en, status); 2336 if (failure(status, "construct SimpleDateFormat", TRUE)) return; 2337 const TimeZone *t = TimeZone::getGMT(); 2338 univ.setTimeZone(*t); 2339 2340 univ.setLenient(false); 2341 ParsePosition pp(0); 2342 struct { 2343 UnicodeString input; 2344 UnicodeString expected_result; 2345 } tests[] = { 2346 { "11:00 -0200", "13:00 +0000" }, 2347 { "11:00 +0200", "09:00 +0000" }, 2348 { "11:00 +0400", "07:00 +0000" }, 2349 { "11:00 +0530", "05:30 +0000" } 2350 }; 2351 2352 UnicodeString result; 2353 int32_t tests_length = UPRV_LENGTHOF(tests); 2354 for (int i = 0; i < tests_length; ++i) { 2355 pp.setIndex(0); 2356 UDate d = univ.parse(tests[i].input, pp); 2357 if(pp.getIndex() != tests[i].input.length()){ 2358 errln("Test %i: setZoneString() did not succeed. Consumed: %i instead of %i", 2359 i, pp.getIndex(), tests[i].input.length()); 2360 return; 2361 } 2362 result.remove(); 2363 univ.format(d, result); 2364 if(result != tests[i].expected_result) { 2365 errln("Expected " + tests[i].expected_result 2366 + " got " + result); 2367 return; 2368 } 2369 logln("SUCCESS: Parsed " + tests[i].input 2370 + " got " + result 2371 + " expected " + tests[i].expected_result); 2372 } 2373 } 2374 2375 void DateFormatTest::TestHost(void) 2376 { 2377 #if U_PLATFORM_HAS_WIN32_API 2378 Win32DateTimeTest::testLocales(this); 2379 #endif 2380 } 2381 2382 // Relative Date Tests 2383 2384 void DateFormatTest::TestRelative(int daysdelta, 2385 const Locale& loc, 2386 const char *expectChars) { 2387 char banner[25]; 2388 sprintf(banner, "%d", daysdelta); 2389 UnicodeString bannerStr(banner, ""); 2390 2391 UErrorCode status = U_ZERO_ERROR; 2392 2393 FieldPosition pos(FieldPosition::DONT_CARE); 2394 UnicodeString test; 2395 Locale en("en"); 2396 DateFormat *fullrelative = DateFormat::createDateInstance(DateFormat::kFullRelative, loc); 2397 2398 if (fullrelative == NULL) { 2399 dataerrln("DateFormat::createDateInstance(DateFormat::kFullRelative, %s) returned NULL", loc.getName()); 2400 return; 2401 } 2402 2403 DateFormat *full = DateFormat::createDateInstance(DateFormat::kFull , loc); 2404 2405 if (full == NULL) { 2406 errln("DateFormat::createDateInstance(DateFormat::kFull, %s) returned NULL", loc.getName()); 2407 return; 2408 } 2409 2410 DateFormat *en_full = DateFormat::createDateInstance(DateFormat::kFull, en); 2411 2412 if (en_full == NULL) { 2413 errln("DateFormat::createDateInstance(DateFormat::kFull, en) returned NULL"); 2414 return; 2415 } 2416 2417 DateFormat *en_fulltime = DateFormat::createDateTimeInstance(DateFormat::kFull,DateFormat::kFull,en); 2418 2419 if (en_fulltime == NULL) { 2420 errln("DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, en) returned NULL"); 2421 return; 2422 } 2423 2424 UnicodeString result; 2425 UnicodeString normalResult; 2426 UnicodeString expect; 2427 UnicodeString parseResult; 2428 2429 Calendar *c = Calendar::createInstance(status); 2430 2431 // Today = Today 2432 c->setTime(Calendar::getNow(), status); 2433 if(daysdelta != 0) { 2434 c->add(Calendar::DATE,daysdelta,status); 2435 } 2436 ASSERT_OK(status); 2437 2438 // calculate the expected string 2439 if(expectChars != NULL) { 2440 expect = expectChars; 2441 } else { 2442 full->format(*c, expect, pos); // expected = normal full 2443 } 2444 2445 fullrelative ->format(*c, result, pos); 2446 en_full ->format(*c, normalResult, pos); 2447 2448 if(result != expect) { 2449 errln("FAIL: Relative Format ["+bannerStr+"] of "+normalResult+" failed, expected "+expect+" but got " + result); 2450 } else { 2451 logln("PASS: Relative Format ["+bannerStr+"] of "+normalResult+" got " + result); 2452 } 2453 2454 2455 //verify 2456 UDate d = fullrelative->parse(result, status); 2457 ASSERT_OK(status); 2458 2459 UnicodeString parseFormat; // parse rel->format full 2460 en_full->format(d, parseFormat, status); 2461 2462 UnicodeString origFormat; 2463 en_full->format(*c, origFormat, pos); 2464 2465 if(parseFormat!=origFormat) { 2466 errln("FAIL: Relative Parse ["+bannerStr+"] of "+result+" failed, expected "+parseFormat+" but got "+origFormat); 2467 } else { 2468 logln("PASS: Relative Parse ["+bannerStr+"] of "+result+" passed, got "+parseFormat); 2469 } 2470 2471 delete full; 2472 delete fullrelative; 2473 delete en_fulltime; 2474 delete en_full; 2475 delete c; 2476 } 2477 2478 2479 void DateFormatTest::TestRelative(void) 2480 { 2481 Locale en("en"); 2482 TestRelative( 0, en, "today"); 2483 TestRelative(-1, en, "yesterday"); 2484 TestRelative( 1, en, "tomorrow"); 2485 TestRelative( 2, en, NULL); 2486 TestRelative( -2, en, NULL); 2487 TestRelative( 3, en, NULL); 2488 TestRelative( -3, en, NULL); 2489 TestRelative( 300, en, NULL); 2490 TestRelative( -300, en, NULL); 2491 } 2492 2493 void DateFormatTest::TestRelativeClone(void) 2494 { 2495 /* 2496 Verify that a cloned formatter gives the same results 2497 and is useable after the original has been deleted. 2498 */ 2499 UErrorCode status = U_ZERO_ERROR; 2500 Locale loc("en"); 2501 UDate now = Calendar::getNow(); 2502 DateFormat *full = DateFormat::createDateInstance(DateFormat::kFullRelative, loc); 2503 if (full == NULL) { 2504 dataerrln("FAIL: Can't create Relative date instance"); 2505 return; 2506 } 2507 UnicodeString result1; 2508 full->format(now, result1, status); 2509 Format *fullClone = full->clone(); 2510 delete full; 2511 full = NULL; 2512 2513 UnicodeString result2; 2514 fullClone->format(now, result2, status); 2515 ASSERT_OK(status); 2516 if (result1 != result2) { 2517 errln("FAIL: Clone returned different result from non-clone."); 2518 } 2519 delete fullClone; 2520 } 2521 2522 void DateFormatTest::TestHostClone(void) 2523 { 2524 /* 2525 Verify that a cloned formatter gives the same results 2526 and is useable after the original has been deleted. 2527 */ 2528 // This is mainly important on Windows. 2529 UErrorCode status = U_ZERO_ERROR; 2530 Locale loc("en_US@compat=host"); 2531 UDate now = Calendar::getNow(); 2532 DateFormat *full = DateFormat::createDateInstance(DateFormat::kFull, loc); 2533 if (full == NULL) { 2534 dataerrln("FAIL: Can't create host date instance"); 2535 return; 2536 } 2537 UnicodeString result1; 2538 full->format(now, result1, status); 2539 Format *fullClone = full->clone(); 2540 delete full; 2541 full = NULL; 2542 2543 UnicodeString result2; 2544 fullClone->format(now, result2, status); 2545 ASSERT_OK(status); 2546 if (result1 != result2) { 2547 errln("FAIL: Clone returned different result from non-clone."); 2548 } 2549 delete fullClone; 2550 } 2551 2552 void DateFormatTest::TestHebrewClone(void) 2553 { 2554 /* 2555 Verify that a cloned formatter gives the same results 2556 and is useable after the original has been deleted. 2557 */ 2558 UErrorCode status = U_ZERO_ERROR; 2559 Locale loc("he@calendar=hebrew"); 2560 UDate now = Calendar::getNow(); 2561 LocalPointer<DateFormat> fmt( 2562 DateFormat::createDateInstance(DateFormat::kLong, loc)); 2563 if (fmt.isNull()) { 2564 dataerrln("FAIL: Can't create Hebrew date instance"); 2565 return; 2566 } 2567 UnicodeString result1; 2568 fmt->format(now, result1, status); 2569 LocalPointer<Format> fmtClone(fmt->clone()); 2570 2571 // free fmt to be sure that fmtClone is independent of fmt. 2572 fmt.adoptInstead(NULL); 2573 2574 UnicodeString result2; 2575 fmtClone->format(now, result2, status); 2576 ASSERT_OK(status); 2577 if (result1 != result2) { 2578 errln("FAIL: Clone returned different result from non-clone."); 2579 } 2580 } 2581 2582 static UBool getActualAndValidLocales( 2583 const Format &fmt, Locale &valid, Locale &actual) { 2584 const SimpleDateFormat* dat = dynamic_cast<const SimpleDateFormat*>(&fmt); 2585 if (dat == NULL) { 2586 return FALSE; 2587 } 2588 const DateFormatSymbols *sym = dat->getDateFormatSymbols(); 2589 if (sym == NULL) { 2590 return FALSE; 2591 } 2592 UErrorCode status = U_ZERO_ERROR; 2593 valid = sym->getLocale(ULOC_VALID_LOCALE, status); 2594 actual = sym->getLocale(ULOC_ACTUAL_LOCALE, status); 2595 return U_SUCCESS(status); 2596 } 2597 2598 void DateFormatTest::TestDateFormatSymbolsClone(void) 2599 { 2600 /* 2601 Verify that a cloned formatter gives the same results 2602 and is useable after the original has been deleted. 2603 */ 2604 Locale loc("de_CH_LUCERNE"); 2605 LocalPointer<DateFormat> fmt( 2606 DateFormat::createDateInstance(DateFormat::kDefault, loc)); 2607 Locale valid1; 2608 Locale actual1; 2609 if (!getActualAndValidLocales(*fmt, valid1, actual1)) { 2610 dataerrln("FAIL: Could not fetch valid + actual locales"); 2611 return; 2612 } 2613 LocalPointer<Format> fmtClone(fmt->clone()); 2614 2615 // Free fmt to be sure that fmtClone is really independent of fmt. 2616 fmt.adoptInstead(NULL); 2617 Locale valid2; 2618 Locale actual2; 2619 if (!getActualAndValidLocales(*fmtClone, valid2, actual2)) { 2620 errln("FAIL: Could not fetch valid + actual locales"); 2621 return; 2622 } 2623 if (valid1 != valid2 || actual1 != actual2) { 2624 errln("Date format symbol locales of clone don't match original"); 2625 } 2626 } 2627 2628 void DateFormatTest::TestTimeZoneDisplayName() 2629 { 2630 // This test data was ported from ICU4J. Don't know why the 6th column in there because it's not being 2631 // used currently. 2632 const char *fallbackTests[][6] = { 2633 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 2634 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 2635 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZZ", "-08:00", "-8:00" }, 2636 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "PST", "America/Los_Angeles" }, 2637 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "Pacific Standard Time", "America/Los_Angeles" }, 2638 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2639 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2640 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "PDT", "America/Los_Angeles" }, 2641 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "Pacific Daylight Time", "America/Los_Angeles" }, 2642 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "PT", "America/Los_Angeles" }, 2643 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "Pacific Time", "America/Los_Angeles" }, 2644 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "VVVV", "Los Angeles Time", "America/Los_Angeles" }, 2645 { "en_GB", "America/Los_Angeles", "2004-01-15T12:00:00Z", "z", "GMT-8", "America/Los_Angeles" }, 2646 { "en", "America/Phoenix", "2004-01-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2647 { "en", "America/Phoenix", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2648 { "en", "America/Phoenix", "2004-01-15T00:00:00Z", "z", "MST", "America/Phoenix" }, 2649 { "en", "America/Phoenix", "2004-01-15T00:00:00Z", "zzzz", "Mountain Standard Time", "America/Phoenix" }, 2650 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2651 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2652 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "z", "MST", "America/Phoenix" }, 2653 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "zzzz", "Mountain Standard Time", "America/Phoenix" }, 2654 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "v", "MST", "America/Phoenix" }, 2655 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "vvvv", "Mountain Standard Time", "America/Phoenix" }, 2656 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "VVVV", "Phoenix Time", "America/Phoenix" }, 2657 2658 { "en", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2659 { "en", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2660 { "en", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2661 { "en", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "Argentina Standard Time", "-3:00" }, 2662 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2663 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2664 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2665 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "Argentina Standard Time", "-3:00" }, 2666 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires Time", "America/Buenos_Aires" }, 2667 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Argentina Standard Time", "America/Buenos_Aires" }, 2668 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "VVVV", "Buenos Aires Time", "America/Buenos_Aires" }, 2669 2670 { "en", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2671 { "en", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2672 { "en", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2673 { "en", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "Argentina Standard Time", "-3:00" }, 2674 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2675 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2676 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2677 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "Argentina Standard Time", "-3:00" }, 2678 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires Time", "America/Buenos_Aires" }, 2679 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Argentina Standard Time", "America/Buenos_Aires" }, 2680 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "VVVV", "Buenos Aires Time", "America/Buenos_Aires" }, 2681 2682 { "en", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 2683 { "en", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 2684 { "en", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 2685 { "en", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "Cuba Standard Time", "-5:00" }, 2686 { "en", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 2687 { "en", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 2688 { "en", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 2689 { "en", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "Cuba Daylight Time", "-4:00" }, 2690 { "en", "America/Havana", "2004-07-15T00:00:00Z", "v", "Cuba Time", "America/Havana" }, 2691 { "en", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "Cuba Time", "America/Havana" }, 2692 { "en", "America/Havana", "2004-07-15T00:00:00Z", "VVVV", "Cuba Time", "America/Havana" }, 2693 2694 { "en", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2695 { "en", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2696 { "en", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2697 { "en", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "Australian Eastern Daylight Time", "+11:00" }, 2698 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2699 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2700 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2701 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "Australian Eastern Standard Time", "+10:00" }, 2702 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "Sydney Time", "Australia/Sydney" }, 2703 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "Eastern Australia Time", "Australia/Sydney" }, 2704 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "VVVV", "Sydney Time", "Australia/Sydney" }, 2705 2706 { "en", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2707 { "en", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2708 { "en", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2709 { "en", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "Australian Eastern Daylight Time", "+11:00" }, 2710 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2711 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2712 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2713 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "Australian Eastern Standard Time", "+10:00" }, 2714 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "Sydney Time", "Australia/Sydney" }, 2715 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "Eastern Australia Time", "Australia/Sydney" }, 2716 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "VVVV", "Sydney Time", "Australia/Sydney" }, 2717 2718 { "en", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 2719 { "en", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 2720 { "en", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 2721 { "en", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "Greenwich Mean Time", "+0:00" }, 2722 { "en", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 2723 { "en", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 2724 { "en", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "Europe/London" }, 2725 { "en", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "British Summer Time", "Europe/London" }, 2726 // icu en.txt has exemplar city for this time zone 2727 { "en", "Europe/London", "2004-07-15T00:00:00Z", "v", "United Kingdom Time", "Europe/London" }, 2728 { "en", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "United Kingdom Time", "Europe/London" }, 2729 { "en", "Europe/London", "2004-07-15T00:00:00Z", "VVVV", "United Kingdom Time", "Europe/London" }, 2730 2731 { "en", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2732 { "en", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2733 { "en", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2734 { "en", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2735 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2736 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2737 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2738 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2739 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 2740 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 2741 2742 // JB#5150 2743 { "en", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2744 { "en", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2745 { "en", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 2746 { "en", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "India Standard Time", "+5:30" }, 2747 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2748 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2749 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 2750 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "India Standard Time", "+5:30" }, 2751 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "India Time", "Asia/Calcutta" }, 2752 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "India Standard Time", "Asia/Calcutta" }, 2753 2754 // Proper CLDR primary zone support #9733 2755 { "en", "America/Santiago", "2013-01-01T00:00:00Z", "VVVV", "Chile Time", "America/Santiago" }, 2756 { "en", "Pacific/Easter", "2013-01-01T00:00:00Z", "VVVV", "Easter Time", "Pacific/Easter" }, 2757 2758 // ========== 2759 2760 { "de", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 2761 { "de", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 2762 { "de", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "-8:00" }, 2763 { "de", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "Nordamerikanische Westk\\u00fcsten-Normalzeit", "-8:00" }, 2764 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2765 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2766 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "-7:00" }, 2767 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "Nordamerikanische Westk\\u00fcsten-Sommerzeit", "-7:00" }, 2768 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "Los Angeles Zeit", "America/Los_Angeles" }, 2769 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "Nordamerikanische Westk\\u00fcstenzeit", "America/Los_Angeles" }, 2770 2771 { "de", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2772 { "de", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2773 { "de", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2774 { "de", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "Argentinische Normalzeit", "-3:00" }, 2775 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2776 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2777 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2778 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "Argentinische Normalzeit", "-3:00" }, 2779 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires Zeit", "America/Buenos_Aires" }, 2780 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Argentinische Normalzeit", "America/Buenos_Aires" }, 2781 2782 { "de", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2783 { "de", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2784 { "de", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2785 { "de", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "Argentinische Normalzeit", "-3:00" }, 2786 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2787 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2788 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2789 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "Argentinische Normalzeit", "-3:00" }, 2790 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires Zeit", "America/Buenos_Aires" }, 2791 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Argentinische Normalzeit", "America/Buenos_Aires" }, 2792 2793 { "de", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 2794 { "de", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 2795 { "de", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 2796 { "de", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "Kubanische Normalzeit", "-5:00" }, 2797 { "de", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 2798 { "de", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 2799 { "de", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 2800 { "de", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "Kubanische Sommerzeit", "-4:00" }, 2801 { "de", "America/Havana", "2004-07-15T00:00:00Z", "v", "Kuba Zeit", "America/Havana" }, 2802 { "de", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "Kubanische Zeit", "America/Havana" }, 2803 // added to test proper fallback of country name 2804 { "de_CH", "America/Havana", "2004-07-15T00:00:00Z", "v", "Kuba Zeit", "America/Havana" }, 2805 { "de_CH", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "Kubanische Zeit", "America/Havana" }, 2806 2807 { "de", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2808 { "de", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2809 { "de", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2810 { "de", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "Ostaustralische Sommerzeit", "+11:00" }, 2811 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2812 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2813 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2814 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "Ostaustralische Normalzeit", "+10:00" }, 2815 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "Sydney Zeit", "Australia/Sydney" }, 2816 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "Ostaustralische Zeit", "Australia/Sydney" }, 2817 2818 { "de", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2819 { "de", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2820 { "de", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2821 { "de", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "Ostaustralische Sommerzeit", "+11:00" }, 2822 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2823 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2824 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2825 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "Ostaustralische Normalzeit", "+10:00" }, 2826 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "Sydney Zeit", "Australia/Sydney" }, 2827 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "Ostaustralische Zeit", "Australia/Sydney" }, 2828 2829 { "de", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 2830 { "de", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 2831 { "de", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 2832 { "de", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "Mittlere Greenwich-Zeit", "+0:00" }, 2833 { "de", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 2834 { "de", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 2835 { "de", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 2836 { "de", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "Britische Sommerzeit", "+1:00" }, 2837 { "de", "Europe/London", "2004-07-15T00:00:00Z", "v", "Vereinigtes K\\u00f6nigreich Zeit", "Europe/London" }, 2838 { "de", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "Vereinigtes K\\u00f6nigreich Zeit", "Europe/London" }, 2839 2840 { "de", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2841 { "de", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2842 { "de", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2843 { "de", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2844 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2845 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2846 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2847 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2848 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 2849 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 2850 2851 // JB#5150 2852 { "de", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2853 { "de", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2854 { "de", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 2855 { "de", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "Indische Zeit", "+5:30" }, 2856 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2857 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2858 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 2859 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "Indische Zeit", "+5:30" }, 2860 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "Indien Zeit", "Asia/Calcutta" }, 2861 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "Indische Zeit", "Asia/Calcutta" }, 2862 2863 // ========== 2864 2865 { "zh", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 2866 { "zh", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 2867 { "zh", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "America/Los_Angeles" }, 2868 { "zh", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "\\u5317\\u7f8e\\u592a\\u5e73\\u6d0b\\u6807\\u51c6\\u65f6\\u95f4", "America/Los_Angeles" }, 2869 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2870 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2871 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "America/Los_Angeles" }, 2872 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "\\u5317\\u7f8e\\u592a\\u5e73\\u6d0b\\u590f\\u4ee4\\u65f6\\u95f4", "America/Los_Angeles" }, 2873 // icu zh.txt has exemplar city for this time zone 2874 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "\\u6D1B\\u6749\\u77F6\\u65F6\\u95F4", "America/Los_Angeles" }, 2875 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "\\u5317\\u7f8e\\u592a\\u5e73\\u6d0b\\u65f6\\u95f4", "America/Los_Angeles" }, 2876 2877 { "zh", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2878 { "zh", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2879 { "zh", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2880 { "zh", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "-3:00" }, 2881 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2882 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2883 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2884 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "-3:00" }, 2885 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u5E03\\u5B9C\\u8BFA\\u65AF\\u827E\\u5229\\u65AF\\u65F6\\u95F4", "America/Buenos_Aires" }, 2886 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "America/Buenos_Aires" }, 2887 2888 { "zh", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2889 { "zh", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2890 { "zh", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2891 { "zh", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "-3:00" }, 2892 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2893 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2894 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2895 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "-3:00" }, 2896 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u5E03\\u5B9C\\u8BFA\\u65AF\\u827E\\u5229\\u65AF\\u65F6\\u95F4", "America/Buenos_Aires" }, 2897 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "America/Buenos_Aires" }, 2898 2899 { "zh", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 2900 { "zh", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 2901 { "zh", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 2902 { "zh", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "\\u53e4\\u5df4\\u6807\\u51c6\\u65f6\\u95f4", "-5:00" }, 2903 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 2904 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 2905 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 2906 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "\\u53e4\\u5df4\\u590f\\u4ee4\\u65f6\\u95f4", "-4:00" }, 2907 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "v", "\\u53e4\\u5df4\\u65f6\\u95f4", "America/Havana" }, 2908 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "\\u53e4\\u5df4\\u65f6\\u95f4", "America/Havana" }, 2909 2910 { "zh", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2911 { "zh", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2912 { "zh", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2913 { "zh", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u590f\\u4ee4\\u65f6\\u95f4", "+11:00" }, 2914 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2915 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2916 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2917 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u6807\\u51c6\\u65f6\\u95f4", "+10:00" }, 2918 // icu zh.txt does not have info for this time zone 2919 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "\\u6089\\u5C3C\\u65F6\\u95F4", "Australia/Sydney" }, 2920 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u65f6\\u95f4", "Australia/Sydney" }, 2921 2922 { "zh", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2923 { "zh", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2924 { "zh", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2925 { "zh", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u590f\\u4ee4\\u65f6\\u95f4", "+11:00" }, 2926 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2927 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2928 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2929 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u6807\\u51c6\\u65f6\\u95f4", "+10:00" }, 2930 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "\\u6089\\u5C3C\\u65F6\\u95F4", "Australia/Sydney" }, 2931 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u65f6\\u95f4", "Australia/Sydney" }, 2932 2933 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 2934 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 2935 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 2936 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 2937 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 2938 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "\\u683C\\u6797\\u5C3C\\u6CBB\\u6807\\u51C6\\u65F6\\u95F4", "+0:00" }, 2939 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 2940 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 2941 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 2942 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "\\u82f1\\u56fd\\u590f\\u4ee4\\u65f6\\u95f4", "+1:00" }, 2943 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "v", "\\u82f1\\u56fd\\u65f6\\u95f4", "Europe/London" }, 2944 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "\\u82f1\\u56fd\\u65f6\\u95f4", "Europe/London" }, 2945 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "VVVV", "\\u82f1\\u56fd\\u65f6\\u95f4", "Europe/London" }, 2946 2947 { "zh", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2948 { "zh", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2949 { "zh", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2950 { "zh", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2951 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2952 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2953 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2954 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2955 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 2956 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 2957 2958 // JB#5150 2959 { "zh", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2960 { "zh", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2961 { "zh", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 2962 { "zh", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "\\u5370\\u5ea6\\u65f6\\u95f4", "+5:30" }, 2963 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2964 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2965 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 2966 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "\\u5370\\u5ea6\\u65f6\\u95f4", "+5:30" }, 2967 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "\\u5370\\u5ea6\\u65f6\\u95f4", "Asia/Calcutta" }, 2968 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "\\u5370\\u5ea6\\u65f6\\u95f4", "Asia/Calcutta" }, 2969 2970 // ========== 2971 2972 { "hi", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 2973 { "hi", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 2974 { "hi", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "-8:00" }, 2975 { "hi", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "\\u0909\\u0924\\u094d\\u0924\\u0930\\u0940 \\u0905\\u092e\\u0947\\u0930\\u093f\\u0915\\u0940 \\u092a\\u094d\\u0930\\u0936\\u093e\\u0902\\u0924 \\u092e\\u093e\\u0928\\u0915 \\u0938\\u092e\\u092f", "-8:00" }, 2976 { "hi", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2977 { "hi", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2978 { "hi", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "-7:00" }, 2979 { "hi", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "\\u0909\\u0924\\u094d\\u0924\\u0930\\u0940 \\u0905\\u092e\\u0947\\u0930\\u093f\\u0915\\u0940 \\u092a\\u094d\\u0930\\u0936\\u093e\\u0902\\u0924 \\u0921\\u0947\\u0932\\u093e\\u0907\\u091f \\u0938\\u092e\\u092f", "-7:00" }, 2980 { "hi", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "\\u0932\\u0949\\u0938 \\u090f\\u0902\\u091c\\u093f\\u0932\\u094d\\u0938 \\u0938\\u092e\\u092f", "America/Los_Angeles" }, 2981 { "hi", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "\\u0909\\u0924\\u094d\\u0924\\u0930\\u0940 \\u0905\\u092e\\u0947\\u0930\\u093f\\u0915\\u0940 \\u092a\\u094d\\u0930\\u0936\\u093e\\u0902\\u0924 \\u0938\\u092e\\u092f", "America/Los_Angeles" }, 2982 2983 { "hi", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2984 { "hi", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2985 { "hi", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2986 { "hi", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u0905\\u0930\\u094D\\u091C\\u0947\\u0902\\u091F\\u0940\\u0928\\u093E \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "-3:00" }, 2987 { "hi", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2988 { "hi", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2989 { "hi", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2990 { "hi", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u0905\\u0930\\u094D\\u091C\\u0947\\u0902\\u091F\\u0940\\u0928\\u093E \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "-3:00" }, 2991 { "hi", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u092C\\u094D\\u092F\\u0942\\u0928\\u0938 \\u0906\\u092F\\u0930\\u0938 \\u0938\\u092E\\u092F", "America/Buenos_Aires" }, 2992 { "hi", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u0905\\u0930\\u094D\\u091C\\u0947\\u0902\\u091F\\u0940\\u0928\\u093E \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "America/Buenos_Aires" }, 2993 2994 { "hi", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2995 { "hi", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2996 { "hi", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2997 { "hi", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u0905\\u0930\\u094D\\u091C\\u0947\\u0902\\u091F\\u0940\\u0928\\u093E \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "-3:00" }, 2998 { "hi", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2999 { "hi", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3000 { "hi", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3001 { "hi", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u0905\\u0930\\u094D\\u091C\\u0947\\u0902\\u091F\\u0940\\u0928\\u093E \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "-3:00" }, 3002 { "hi", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u092C\\u094D\\u092F\\u0942\\u0928\\u0938 \\u0906\\u092F\\u0930\\u0938 \\u0938\\u092E\\u092F", "America/Buenos_Aires" }, 3003 { "hi", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u0905\\u0930\\u094D\\u091C\\u0947\\u0902\\u091F\\u0940\\u0928\\u093E \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "America/Buenos_Aires" }, 3004 3005 { "hi", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 3006 { "hi", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 3007 { "hi", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 3008 { "hi", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "\\u0915\\u094d\\u092f\\u0942\\u092c\\u093e \\u092e\\u093e\\u0928\\u0915 \\u0938\\u092e\\u092f", "-5:00" }, 3009 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 3010 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 3011 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 3012 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "\\u0915\\u094d\\u092f\\u0942\\u092c\\u093e \\u0921\\u0947\\u0932\\u093e\\u0907\\u091f \\u0938\\u092e\\u092f", "-4:00" }, 3013 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "v", "\\u0915\\u094d\\u092f\\u0942\\u092c\\u093e \\u0938\\u092E\\u092F", "America/Havana" }, 3014 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "\\u0915\\u094d\\u092f\\u0942\\u092c\\u093e \\u0938\\u092e\\u092f", "America/Havana" }, 3015 3016 { "hi", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3017 { "hi", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3018 { "hi", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3019 { "hi", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "\\u0911\\u0938\\u094d\\u200d\\u091f\\u094d\\u0930\\u0947\\u0932\\u093f\\u092f\\u093e\\u0908 \\u092a\\u0942\\u0930\\u094d\\u0935\\u0940 \\u0921\\u0947\\u0932\\u093e\\u0907\\u091f \\u0938\\u092e\\u092f", "+11:00" }, 3020 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3021 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3022 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3023 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "\\u0911\\u0938\\u094d\\u200d\\u091f\\u094d\\u0930\\u0947\\u0932\\u093f\\u092f\\u093e\\u0908 \\u092a\\u0942\\u0930\\u094d\\u0935\\u0940 \\u092e\\u093e\\u0928\\u0915 \\u0938\\u092e\\u092f", "+10:00" }, 3024 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "\\u0938\\u093F\\u0921\\u0928\\u0940 \\u0938\\u092E\\u092F", "Australia/Sydney" }, 3025 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "\\u092a\\u0942\\u0930\\u094d\\u0935\\u0940 \\u0911\\u0938\\u094d\\u091f\\u094d\\u0930\\u0947\\u0932\\u093f\\u092f\\u093e \\u0938\\u092e\\u092f", "Australia/Sydney" }, 3026 3027 { "hi", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3028 { "hi", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3029 { "hi", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3030 { "hi", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "\\u0911\\u0938\\u094d\\u200d\\u091f\\u094d\\u0930\\u0947\\u0932\\u093f\\u092f\\u093e\\u0908 \\u092a\\u0942\\u0930\\u094d\\u0935\\u0940 \\u0921\\u0947\\u0932\\u093e\\u0907\\u091f \\u0938\\u092e\\u092f", "+11:00" }, 3031 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3032 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3033 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3034 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "\\u0911\\u0938\\u094d\\u200d\\u091f\\u094d\\u0930\\u0947\\u0932\\u093f\\u092f\\u093e\\u0908 \\u092a\\u0942\\u0930\\u094d\\u0935\\u0940 \\u092e\\u093e\\u0928\\u0915 \\u0938\\u092e\\u092f", "+10:00" }, 3035 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "\\u0938\\u093F\\u0921\\u0928\\u0940 \\u0938\\u092E\\u092F", "Australia/Sydney" }, 3036 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "\\u092a\\u0942\\u0930\\u094d\\u0935\\u0940 \\u0911\\u0938\\u094d\\u091f\\u094d\\u0930\\u0947\\u0932\\u093f\\u092f\\u093e \\u0938\\u092e\\u092f", "Australia/Sydney" }, 3037 3038 { "hi", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 3039 { "hi", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 3040 { "hi", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 3041 { "hi", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "\\u0917\\u094d\\u0930\\u0940\\u0928\\u0935\\u093f\\u091a \\u092e\\u0940\\u0928 \\u091f\\u093e\\u0907\\u092e", "+0:00" }, 3042 { "hi", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 3043 { "hi", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 3044 { "hi", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 3045 { "hi", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "\\u092c\\u094d\\u0930\\u093f\\u091f\\u093f\\u0936 \\u0917\\u094d\\u0930\\u0940\\u0937\\u094d\\u092e\\u0915\\u093e\\u0932\\u0940\\u0928 \\u0938\\u092e\\u092f", "+1:00" }, 3046 { "hi", "Europe/London", "2004-07-15T00:00:00Z", "v", "\\u092f\\u0942\\u0928\\u093e\\u0907\\u091f\\u0947\\u0921 \\u0915\\u093f\\u0902\\u0917\\u0921\\u092e \\u0938\\u092e\\u092f", "Europe/London" }, 3047 { "hi", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "\\u092f\\u0942\\u0928\\u093e\\u0907\\u091f\\u0947\\u0921 \\u0915\\u093f\\u0902\\u0917\\u0921\\u092e \\u0938\\u092e\\u092f", "Europe/London" }, 3048 3049 { "hi", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3050 { "hi", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3051 { "hi", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3052 { "hi", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3053 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3054 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3055 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3056 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3057 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 3058 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 3059 3060 { "hi", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3061 { "hi", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3062 { "hi", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "IST", "+5:30" }, 3063 { "hi", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "\\u092D\\u093E\\u0930\\u0924\\u0940\\u092F \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "+5:30" }, 3064 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3065 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3066 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "IST", "+05:30" }, 3067 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "\\u092D\\u093E\\u0930\\u0924\\u0940\\u092F \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "+5:30" }, 3068 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "IST", "Asia/Calcutta" }, 3069 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "\\u092D\\u093E\\u0930\\u0924\\u0940\\u092F \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "Asia/Calcutta" }, 3070 3071 // ========== 3072 3073 { "bg", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 3074 { "bg", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-08:00", "-8:00" }, 3075 { "bg", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-8", "America/Los_Angeles" }, 3076 { "bg", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "\\u0421\\u0435\\u0432\\u0435\\u0440\\u043d\\u043e\\u0430\\u043c\\u0435\\u0440\\u0438\\u043a\\u0430\\u043d\\u0441\\u043a\\u043e \\u0442\\u0438\\u0445\\u043e\\u043e\\u043a\\u0435\\u0430\\u043d\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043d\\u0434\\u0430\\u0440\\u0442\\u043d\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "America/Los_Angeles" }, 3077 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 3078 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-07:00", "-7:00" }, 3079 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-7", "America/Los_Angeles" }, 3080 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "\\u0421\\u0435\\u0432\\u0435\\u0440\\u043d\\u043e\\u0430\\u043c\\u0435\\u0440\\u0438\\u043a\\u0430\\u043d\\u0441\\u043a\\u043e \\u0442\\u0438\\u0445\\u043e\\u043e\\u043a\\u0435\\u0430\\u043d\\u0441\\u043a\\u043e \\u043b\\u044f\\u0442\\u043d\\u043e \\u0447\\u0430\\u0441\\u043e\\u0432\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "America/Los_Angeles" }, 3081 // icu bg.txt has exemplar city for this time zone 3082 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "\\u041B\\u043E\\u0441 \\u0410\\u043D\\u0434\\u0436\\u0435\\u043B\\u0438\\u0441", "America/Los_Angeles" }, 3083 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "\\u0421\\u0435\\u0432\\u0435\\u0440\\u043d\\u043e\\u0430\\u043c\\u0435\\u0440\\u0438\\u043a\\u0430\\u043d\\u0441\\u043a\\u043e \\u0442\\u0438\\u0445\\u043e\\u043e\\u043a\\u0435\\u0430\\u043d\\u0441\\u043a\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "America/Los_Angeles" }, 3084 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "VVVV", "\\u041B\\u043E\\u0441 \\u0410\\u043D\\u0434\\u0436\\u0435\\u043B\\u0438\\u0441", "America/Los_Angeles" }, 3085 3086 { "bg", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3087 { "bg", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3088 { "bg", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3089 { "bg", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u0410\\u0440\\u0436\\u0435\\u043D\\u0442\\u0438\\u043D\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043d\\u0434\\u0430\\u0440\\u0442\\u043d\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "-3:00" }, 3090 { "bg", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3091 { "bg", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3092 { "bg", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3093 { "bg", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u0410\\u0440\\u0436\\u0435\\u043D\\u0442\\u0438\\u043D\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043d\\u0434\\u0430\\u0440\\u0442\\u043d\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "-3:00" }, 3094 { "bg", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u0411\\u0443\\u0435\\u043D\\u043E\\u0441 \\u0410\\u0439\\u0440\\u0435\\u0441", "America/Buenos_Aires" }, 3095 { "bg", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u0410\\u0440\\u0436\\u0435\\u043D\\u0442\\u0438\\u043D\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043d\\u0434\\u0430\\u0440\\u0442\\u043d\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "America/Buenos_Aires" }, 3096 3097 { "bg", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3098 { "bg", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3099 { "bg", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3100 { "bg", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u0410\\u0440\\u0436\\u0435\\u043D\\u0442\\u0438\\u043D\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043d\\u0434\\u0430\\u0440\\u0442\\u043d\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "-3:00" }, 3101 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3102 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3103 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3104 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u0410\\u0440\\u0436\\u0435\\u043D\\u0442\\u0438\\u043D\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043d\\u0434\\u0430\\u0440\\u0442\\u043d\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "-3:00" }, 3105 // icu bg.txt does not have info for this time zone 3106 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u0411\\u0443\\u0435\\u043D\\u043E\\u0441 \\u0410\\u0439\\u0440\\u0435\\u0441", "America/Buenos_Aires" }, 3107 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u0410\\u0440\\u0436\\u0435\\u043D\\u0442\\u0438\\u043D\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043d\\u0434\\u0430\\u0440\\u0442\\u043d\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "America/Buenos_Aires" }, 3108 3109 { "bg", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 3110 { "bg", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-05:00", "-5:00" }, 3111 { "bg", "America/Havana", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-5", "-5:00" }, 3112 { "bg", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "\\u041a\\u0443\\u0431\\u0438\\u043d\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043d\\u0434\\u0430\\u0440\\u0442\\u043d\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "-5:00" }, 3113 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 3114 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-04:00", "-4:00" }, 3115 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-4", "-4:00" }, 3116 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "\\u041a\\u0443\\u0431\\u0438\\u043d\\u0441\\u043a\\u043e \\u043b\\u044f\\u0442\\u043d\\u043e \\u0447\\u0430\\u0441\\u043e\\u0432\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "-4:00" }, 3117 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "v", "\\u041a\\u0443\\u0431\\u0430", "America/Havana" }, 3118 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "\\u041a\\u0443\\u0431\\u0438\\u043d\\u0441\\u043a\\u043e \\u0432\\u0440\\u0435\\u043C\\u0435", "America/Havana" }, 3119 3120 { "bg", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3121 { "bg", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+11:00", "+11:00" }, 3122 { "bg", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+11", "+11:00" }, 3123 { "bg", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "\\u0410\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u044F \\u2013 \\u0438\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E \\u043B\\u044F\\u0442\\u043D\\u043E \\u0447\\u0430\\u0441\\u043E\\u0432\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "+11:00" }, 3124 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3125 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+10:00", "+10:00" }, 3126 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+10", "+10:00" }, 3127 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "\\u0410\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u044F \\u2013 \\u0438\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E \\u0441\\u0442\\u0430\\u043D\\u0434\\u0430\\u0440\\u0442\\u043D\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "+10:00" }, 3128 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "\\u0421\\u0438\\u0434\\u043D\\u0438", "Australia/Sydney" }, 3129 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "\\u0410\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u044F \\u2013 \\u0438\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "Australia/Sydney" }, 3130 3131 { "bg", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3132 { "bg", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+11:00", "+11:00" }, 3133 { "bg", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+11", "+11:00" }, 3134 { "bg", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "\\u0410\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u044F \\u2013 \\u0438\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E \\u043B\\u044F\\u0442\\u043D\\u043E \\u0447\\u0430\\u0441\\u043E\\u0432\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "+11:00" }, 3135 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3136 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+10:00", "+10:00" }, 3137 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+10", "+10:00" }, 3138 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "\\u0410\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u044F \\u2013 \\u0438\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E \\u0441\\u0442\\u0430\\u043D\\u0434\\u0430\\u0440\\u0442\\u043D\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "+10:00" }, 3139 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "\\u0421\\u0438\\u0434\\u043D\\u0438", "Australia/Sydney" }, 3140 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "\\u0410\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u044F \\u2013 \\u0438\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "Australia/Sydney" }, 3141 3142 { "bg", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 3143 { "bg", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447", "+0:00" }, 3144 { "bg", "Europe/London", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447", "+0:00" }, 3145 { "bg", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "\\u0421\\u0440\\u0435\\u0434\\u043d\\u043e \\u0433\\u0440\\u0438\\u043d\\u0443\\u0438\\u0447\\u043a\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "+0:00" }, 3146 { "bg", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 3147 { "bg", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+01:00", "+1:00" }, 3148 { "bg", "Europe/London", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+1", "+1:00" }, 3149 { "bg", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "\\u0411\\u0440\\u0438\\u0442\\u0430\\u043d\\u0441\\u043a\\u043e \\u043b\\u044f\\u0442\\u043d\\u043e \\u0447\\u0430\\u0441\\u043e\\u0432\\u043e \\u0432\\u0440\\u0435\\u043c\\u0435", "+1:00" }, 3150 { "bg", "Europe/London", "2004-07-15T00:00:00Z", "v", "\\u041E\\u0431\\u0435\\u0434\\u0438\\u043D\\u0435\\u043D\\u043E\\u0442\\u043E \\u043A\\u0440\\u0430\\u043B\\u0441\\u0442\\u0432\\u043E", "Europe/London" }, 3151 { "bg", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "\\u041E\\u0431\\u0435\\u0434\\u0438\\u043D\\u0435\\u043D\\u043E\\u0442\\u043E \\u043A\\u0440\\u0430\\u043B\\u0441\\u0442\\u0432\\u043E", "Europe/London" }, 3152 3153 { "bg", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3154 { "bg", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3155 { "bg", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3156 { "bg", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3157 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3158 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3159 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3160 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3161 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3162 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3163 3164 // JB#5150 3165 { "bg", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3166 { "bg", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+05:30", "+5:30" }, 3167 { "bg", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+5:30", "+5:30" }, 3168 { "bg", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "\\u0418\\u043d\\u0434\\u0438\\u0439\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043D\\u0434\\u0430\\u0440\\u0442\\u043D\\u043E \\u0432\\u0440\\u0435\\u043c\\u0435", "+5:30" }, 3169 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3170 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+05:30", "+5:30" }, 3171 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+5:30", "+05:30" }, 3172 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "\\u0418\\u043d\\u0434\\u0438\\u0439\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043D\\u0434\\u0430\\u0440\\u0442\\u043D\\u043E \\u0432\\u0440\\u0435\\u043c\\u0435", "+5:30" }, 3173 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "\\u0418\\u043D\\u0434\\u0438\\u044F", "Asia/Calcutta" }, 3174 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "\\u0418\\u043d\\u0434\\u0438\\u0439\\u0441\\u043a\\u043e \\u0441\\u0442\\u0430\\u043D\\u0434\\u0430\\u0440\\u0442\\u043D\\u043E \\u0432\\u0440\\u0435\\u043c\\u0435", "Asia/Calcutta" }, 3175 // ========== 3176 3177 { "ja", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 3178 { "ja", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 3179 { "ja", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "America/Los_Angeles" }, 3180 { "ja", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "\\u30a2\\u30e1\\u30ea\\u30ab\\u592a\\u5e73\\u6d0b\\u6a19\\u6e96\\u6642", "America/Los_Angeles" }, 3181 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-700" }, 3182 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 3183 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "America/Los_Angeles" }, 3184 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "\\u30a2\\u30e1\\u30ea\\u30ab\\u592a\\u5e73\\u6d0b\\u590f\\u6642\\u9593", "America/Los_Angeles" }, 3185 // icu ja.txt has exemplar city for this time zone 3186 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "\\u30ED\\u30B5\\u30F3\\u30BC\\u30EB\\u30B9\\u6642\\u9593", "America/Los_Angeles" }, 3187 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "\\u30A2\\u30E1\\u30EA\\u30AB\\u592A\\u5e73\\u6D0B\\u6642\\u9593", "America/Los_Angeles" }, 3188 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "VVVV", "\\u30ED\\u30B5\\u30F3\\u30BC\\u30EB\\u30B9\\u6642\\u9593", "America/Los_Angeles" }, 3189 3190 { "ja", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3191 { "ja", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3192 { "ja", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3193 { "ja", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "-3:00" }, 3194 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3195 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3196 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3197 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "-3:00" }, 3198 // icu ja.txt does not have info for this time zone 3199 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u30D6\\u30A8\\u30CE\\u30B9\\u30A2\\u30A4\\u30EC\\u30B9\\u6642\\u9593", "America/Buenos_Aires" }, 3200 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "America/Buenos_Aires" }, 3201 3202 { "ja", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3203 { "ja", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3204 { "ja", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3205 { "ja", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "-3:00" }, 3206 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3207 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3208 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3209 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "-3:00" }, 3210 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u30D6\\u30A8\\u30CE\\u30B9\\u30A2\\u30A4\\u30EC\\u30B9\\u6642\\u9593", "America/Buenos_Aires" }, 3211 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "America/Buenos_Aires" }, 3212 3213 { "ja", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 3214 { "ja", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 3215 { "ja", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 3216 { "ja", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "\\u30AD\\u30E5\\u30FC\\u30D0\\u6A19\\u6E96\\u6642", "-5:00" }, 3217 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 3218 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 3219 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 3220 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "\\u30AD\\u30E5\\u30FC\\u30D0\\u590F\\u6642\\u9593", "-4:00" }, 3221 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "v", "\\u30ad\\u30e5\\u30fc\\u30d0\\u6642\\u9593", "America/Havana" }, 3222 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "\\u30ad\\u30e5\\u30fc\\u30d0\\u6642\\u9593", "America/Havana" }, 3223 3224 { "ja", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3225 { "ja", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3226 { "ja", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3227 { "ja", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u590F\\u6642\\u9593", "+11:00" }, 3228 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3229 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3230 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3231 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u6A19\\u6E96\\u6642", "+10:00" }, 3232 // icu ja.txt does not have info for this time zone 3233 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "\\u30B7\\u30C9\\u30CB\\u30FC\\u6642\\u9593", "Australia/Sydney" }, 3234 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u6642\\u9593", "Australia/Sydney" }, 3235 3236 { "ja", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3237 { "ja", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3238 { "ja", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3239 { "ja", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u590F\\u6642\\u9593", "+11:00" }, 3240 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3241 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3242 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3243 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u6A19\\u6E96\\u6642", "+10:00" }, 3244 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "\\u30B7\\u30C9\\u30CB\\u30FC\\u6642\\u9593", "Australia/Sydney" }, 3245 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u6642\\u9593", "Australia/Sydney" }, 3246 3247 { "ja", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 3248 { "ja", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 3249 { "ja", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 3250 { "ja", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "\\u30B0\\u30EA\\u30CB\\u30C3\\u30B8\\u6A19\\u6E96\\u6642", "+0:00" }, 3251 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 3252 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 3253 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 3254 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "\\u82f1\\u56fd\\u590f\\u6642\\u9593", "+1:00" }, 3255 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "v", "\\u30a4\\u30ae\\u30ea\\u30b9\\u6642\\u9593", "Europe/London" }, 3256 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "\\u30a4\\u30ae\\u30ea\\u30b9\\u6642\\u9593", "Europe/London" }, 3257 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "VVVV", "\\u30a4\\u30ae\\u30ea\\u30b9\\u6642\\u9593", "Europe/London" }, 3258 3259 { "ja", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3260 { "ja", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3261 { "ja", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3262 { "ja", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3263 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3264 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3265 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3266 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3267 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 3268 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 3269 3270 // JB#5150 3271 { "ja", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3272 { "ja", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3273 { "ja", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 3274 { "ja", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "\\u30A4\\u30F3\\u30C9\\u6A19\\u6E96\\u6642", "+5:30" }, 3275 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3276 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3277 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 3278 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "\\u30A4\\u30F3\\u30C9\\u6A19\\u6E96\\u6642", "+5:30" }, 3279 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "\\u30A4\\u30F3\\u30C9\\u6642\\u9593", "Asia/Calcutta" }, 3280 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "\\u30A4\\u30F3\\u30C9\\u6A19\\u6E96\\u6642", "Asia/Calcutta" }, 3281 3282 // ========== 3283 3284 { "ti", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 3285 { "ti", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 3286 { "ti", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "-8:00" }, 3287 { "ti", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "GMT-08:00", "-8:00" }, 3288 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 3289 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 3290 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "-7:00" }, 3291 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "GMT-07:00", "-7:00" }, 3292 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "Los Angeles", "America/Los_Angeles" }, 3293 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "Los Angeles", "America/Los_Angeles" }, 3294 3295 { "ti", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3296 { "ti", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3297 { "ti", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3298 { "ti", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3299 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3300 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3301 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3302 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3303 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires", "America/Buenos_Aires" }, 3304 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Buenos Aires", "America/Buenos_Aires" }, 3305 3306 { "ti", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3307 { "ti", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3308 { "ti", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3309 { "ti", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3310 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3311 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3312 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3313 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3314 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires", "America/Buenos_Aires" }, 3315 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Buenos Aires", "America/Buenos_Aires" }, 3316 3317 { "ti", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 3318 { "ti", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 3319 { "ti", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 3320 { "ti", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "GMT-05:00", "-5:00" }, 3321 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 3322 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 3323 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 3324 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "GMT-04:00", "-4:00" }, 3325 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "v", "CU", "America/Havana" }, 3326 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "CU", "America/Havana" }, 3327 3328 { "ti", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3329 { "ti", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3330 { "ti", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3331 { "ti", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "GMT+11:00", "+11:00" }, 3332 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3333 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3334 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3335 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "GMT+10:00", "+10:00" }, 3336 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "Sydney", "Australia/Sydney" }, 3337 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "Sydney", "Australia/Sydney" }, 3338 3339 { "ti", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3340 { "ti", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3341 { "ti", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3342 { "ti", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "GMT+11:00", "+11:00" }, 3343 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3344 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3345 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3346 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "GMT+10:00", "+10:00" }, 3347 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "Sydney", "Australia/Sydney" }, 3348 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "Sydney", "Australia/Sydney" }, 3349 3350 { "ti", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 3351 { "ti", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 3352 { "ti", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 3353 { "ti", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "GMT", "+0:00" }, 3354 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 3355 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 3356 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 3357 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "GMT+01:00", "+1:00" }, 3358 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "v", "GB", "Europe/London" }, 3359 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "GB", "Europe/London" }, 3360 3361 { "ti", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3362 { "ti", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3363 { "ti", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3364 { "ti", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3365 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3366 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3367 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3368 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3369 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 3370 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 3371 3372 // JB#5150 3373 { "ti", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3374 { "ti", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3375 { "ti", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 3376 { "ti", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "GMT+05:30", "+5:30" }, 3377 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3378 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3379 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 3380 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "GMT+05:30", "+5:30" }, 3381 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "IN", "Alna/Calcutta" }, 3382 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "IN", "Asia/Calcutta" }, 3383 3384 // Ticket#8589 Partial location name to use country name if the zone is the golden 3385 // zone for the time zone's country. 3386 { "en_MX", "America/Chicago", "1995-07-15T00:00:00Z", "vvvv", "Central Time (United States)", "America/Chicago"}, 3387 3388 // Tests proper handling of time zones that should have empty sets when inherited from the parent. 3389 // For example, en_GB understands CET as Central European Time, but en_HK, which inherits from en_GB 3390 // does not 3391 { "en_GB", "Europe/Paris", "2004-01-15T00:00:00Z", "zzzz", "Central European Standard Time", "+1:00"}, 3392 { "en_GB", "Europe/Paris", "2004-07-15T00:00:00Z", "zzzz", "Central European Summer Time", "+2:00"}, 3393 { "en_GB", "Europe/Paris", "2004-01-15T00:00:00Z", "z", "CET", "+1:00"}, 3394 { "en_GB", "Europe/Paris", "2004-07-15T00:00:00Z", "z", "CEST", "+2:00"}, 3395 { "en_HK", "Europe/Paris", "2004-01-15T00:00:00Z", "zzzz", "Central European Standard Time", "+1:00"}, 3396 { "en_HK", "Europe/Paris", "2004-07-15T00:00:00Z", "zzzz", "Central European Summer Time", "+2:00"}, 3397 { "en_HK", "Europe/Paris", "2004-01-15T00:00:00Z", "z", "GMT+1", "+1:00"}, 3398 { "en_HK", "Europe/Paris", "2004-07-15T00:00:00Z", "z", "GMT+2", "+2:00"}, 3399 3400 { NULL, NULL, NULL, NULL, NULL, NULL }, 3401 }; 3402 3403 UErrorCode status = U_ZERO_ERROR; 3404 Calendar *cal = GregorianCalendar::createInstance(status); 3405 if (failure(status, "GregorianCalendar::createInstance", TRUE)) return; 3406 SimpleDateFormat testfmt(UnicodeString("yyyy-MM-dd'T'HH:mm:ss'Z'"), status); 3407 if (failure(status, "SimpleDateFormat constructor", TRUE)) return; 3408 testfmt.setTimeZone(*TimeZone::getGMT()); 3409 3410 for (int i = 0; fallbackTests[i][0]; i++) { 3411 const char **testLine = fallbackTests[i]; 3412 UnicodeString info[5]; 3413 for ( int j = 0 ; j < 5 ; j++ ) { 3414 info[j] = UnicodeString(testLine[j], -1, US_INV); 3415 } 3416 info[4] = info[4].unescape(); 3417 logln("%s;%s;%s;%s", testLine[0], testLine[1], testLine[2], testLine[3]); 3418 3419 TimeZone *tz = TimeZone::createTimeZone(info[1]); 3420 3421 UDate d = testfmt.parse(testLine[2], status); 3422 cal->setTime(d, status); 3423 if (U_FAILURE(status)) { 3424 errln(UnicodeString("Failed to set date: ") + testLine[2]); 3425 } 3426 3427 SimpleDateFormat fmt(info[3], Locale(testLine[0]),status); 3428 ASSERT_OK(status); 3429 cal->adoptTimeZone(tz); 3430 UnicodeString result; 3431 FieldPosition pos(FieldPosition::DONT_CARE); 3432 fmt.format(*cal,result,pos); 3433 if (result != info[4]) { 3434 errln(info[0] + ";" + info[1] + ";" + info[2] + ";" + info[3] + " expected: '" + 3435 info[4] + "' but got: '" + result + "'"); 3436 } 3437 } 3438 delete cal; 3439 } 3440 3441 void DateFormatTest::TestRoundtripWithCalendar(void) { 3442 UErrorCode status = U_ZERO_ERROR; 3443 3444 TimeZone *tz = TimeZone::createTimeZone("Europe/Paris"); 3445 TimeZone *gmt = TimeZone::createTimeZone("Etc/GMT"); 3446 3447 Calendar *calendars[] = { 3448 Calendar::createInstance(*tz, Locale("und@calendar=gregorian"), status), 3449 Calendar::createInstance(*tz, Locale("und@calendar=buddhist"), status), 3450 // Calendar::createInstance(*tz, Locale("und@calendar=hebrew"), status), 3451 Calendar::createInstance(*tz, Locale("und@calendar=islamic"), status), 3452 Calendar::createInstance(*tz, Locale("und@calendar=japanese"), status), 3453 NULL 3454 }; 3455 if (U_FAILURE(status)) { 3456 dataerrln("Failed to initialize calendars: %s", u_errorName(status)); 3457 for (int i = 0; calendars[i] != NULL; i++) { 3458 delete calendars[i]; 3459 } 3460 return; 3461 } 3462 3463 //FIXME The formatters commented out below are currently failing because of 3464 // the calendar calculation problem reported by #6691 3465 3466 // The order of test formatters must match the order of calendars above. 3467 DateFormat *formatters[] = { 3468 DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("en_US")), //calendar=gregorian 3469 DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("th_TH")), //calendar=buddhist 3470 // DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("he_IL@calendar=hebrew")), 3471 DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("ar_EG@calendar=islamic")), 3472 // DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("ja_JP@calendar=japanese")), 3473 NULL 3474 }; 3475 3476 UDate d = Calendar::getNow(); 3477 UnicodeString buf; 3478 FieldPosition fpos; 3479 ParsePosition ppos; 3480 3481 for (int i = 0; formatters[i] != NULL; i++) { 3482 buf.remove(); 3483 fpos.setBeginIndex(0); 3484 fpos.setEndIndex(0); 3485 calendars[i]->setTime(d, status); 3486 3487 // Normal case output - the given calendar matches the calendar 3488 // used by the formatter 3489 formatters[i]->format(*calendars[i], buf, fpos); 3490 UnicodeString refStr(buf); 3491 3492 for (int j = 0; calendars[j] != NULL; j++) { 3493 if (j == i) { 3494 continue; 3495 } 3496 buf.remove(); 3497 fpos.setBeginIndex(0); 3498 fpos.setEndIndex(0); 3499 calendars[j]->setTime(d, status); 3500 3501 // Even the different calendar type is specified, 3502 // we should get the same result. 3503 formatters[i]->format(*calendars[j], buf, fpos); 3504 if (refStr != buf) { 3505 errln((UnicodeString)"FAIL: Different format result with a different calendar for the same time -" 3506 + "\n Reference calendar type=" + calendars[i]->getType() 3507 + "\n Another calendar type=" + calendars[j]->getType() 3508 + "\n Expected result=" + refStr 3509 + "\n Actual result=" + buf); 3510 } 3511 } 3512 3513 calendars[i]->setTimeZone(*gmt); 3514 calendars[i]->clear(); 3515 ppos.setErrorIndex(-1); 3516 ppos.setIndex(0); 3517 3518 // Normal case parse result - the given calendar matches the calendar 3519 // used by the formatter 3520 formatters[i]->parse(refStr, *calendars[i], ppos); 3521 3522 for (int j = 0; calendars[j] != NULL; j++) { 3523 if (j == i) { 3524 continue; 3525 } 3526 calendars[j]->setTimeZone(*gmt); 3527 calendars[j]->clear(); 3528 ppos.setErrorIndex(-1); 3529 ppos.setIndex(0); 3530 3531 // Even the different calendar type is specified, 3532 // we should get the same time and time zone. 3533 formatters[i]->parse(refStr, *calendars[j], ppos); 3534 if (calendars[i]->getTime(status) != calendars[j]->getTime(status) 3535 || calendars[i]->getTimeZone() != calendars[j]->getTimeZone()) { 3536 UnicodeString tzid; 3537 errln((UnicodeString)"FAIL: Different parse result with a different calendar for the same string -" 3538 + "\n Reference calendar type=" + calendars[i]->getType() 3539 + "\n Another calendar type=" + calendars[j]->getType() 3540 + "\n Date string=" + refStr 3541 + "\n Expected time=" + calendars[i]->getTime(status) 3542 + "\n Expected time zone=" + calendars[i]->getTimeZone().getID(tzid) 3543 + "\n Actual time=" + calendars[j]->getTime(status) 3544 + "\n Actual time zone=" + calendars[j]->getTimeZone().getID(tzid)); 3545 } 3546 } 3547 if (U_FAILURE(status)) { 3548 errln((UnicodeString)"FAIL: " + u_errorName(status)); 3549 break; 3550 } 3551 } 3552 3553 delete tz; 3554 delete gmt; 3555 for (int i = 0; calendars[i] != NULL; i++) { 3556 delete calendars[i]; 3557 } 3558 for (int i = 0; formatters[i] != NULL; i++) { 3559 delete formatters[i]; 3560 } 3561 } 3562 3563 /* 3564 void DateFormatTest::TestRelativeError(void) 3565 { 3566 UErrorCode status; 3567 Locale en("en"); 3568 3569 DateFormat *en_reltime_reldate = DateFormat::createDateTimeInstance(DateFormat::kFullRelative,DateFormat::kFullRelative,en); 3570 if(en_reltime_reldate == NULL) { 3571 logln("PASS: rel date/rel time failed"); 3572 } else { 3573 errln("FAIL: rel date/rel time created, should have failed."); 3574 delete en_reltime_reldate; 3575 } 3576 } 3577 3578 void DateFormatTest::TestRelativeOther(void) 3579 { 3580 logln("Nothing in this test. When we get more data from CLDR, put in some tests of -2, +2, etc. "); 3581 } 3582 */ 3583 3584 void DateFormatTest::Test6338(void) 3585 { 3586 UErrorCode status = U_ZERO_ERROR; 3587 3588 SimpleDateFormat *fmt1 = new SimpleDateFormat(UnicodeString("y-M-d"), Locale("ar"), status); 3589 if (failure(status, "new SimpleDateFormat", TRUE)) return; 3590 3591 UDate dt1 = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3592 UnicodeString str1; 3593 str1 = fmt1->format(dt1, str1); 3594 logln(str1); 3595 3596 UDate dt11 = fmt1->parse(str1, status); 3597 failure(status, "fmt->parse"); 3598 3599 UnicodeString str11; 3600 str11 = fmt1->format(dt11, str11); 3601 logln(str11); 3602 3603 if (str1 != str11) { 3604 errln((UnicodeString)"FAIL: Different dates str1:" + str1 3605 + " str2:" + str11); 3606 } 3607 delete fmt1; 3608 3609 ///////////////// 3610 3611 status = U_ZERO_ERROR; 3612 SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("y M d"), Locale("ar"), status); 3613 failure(status, "new SimpleDateFormat"); 3614 3615 UDate dt2 = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3616 UnicodeString str2; 3617 str2 = fmt2->format(dt2, str2); 3618 logln(str2); 3619 3620 UDate dt22 = fmt2->parse(str2, status); 3621 failure(status, "fmt->parse"); 3622 3623 UnicodeString str22; 3624 str22 = fmt2->format(dt22, str22); 3625 logln(str22); 3626 3627 if (str2 != str22) { 3628 errln((UnicodeString)"FAIL: Different dates str1:" + str2 3629 + " str2:" + str22); 3630 } 3631 delete fmt2; 3632 3633 ///////////////// 3634 3635 status = U_ZERO_ERROR; 3636 SimpleDateFormat *fmt3 = new SimpleDateFormat(UnicodeString("y-M-d"), Locale("en-us"), status); 3637 failure(status, "new SimpleDateFormat"); 3638 3639 UDate dt3 = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3640 UnicodeString str3; 3641 str3 = fmt3->format(dt3, str3); 3642 logln(str3); 3643 3644 UDate dt33 = fmt3->parse(str3, status); 3645 failure(status, "fmt->parse"); 3646 3647 UnicodeString str33; 3648 str33 = fmt3->format(dt33, str33); 3649 logln(str33); 3650 3651 if (str3 != str33) { 3652 errln((UnicodeString)"FAIL: Different dates str1:" + str3 3653 + " str2:" + str33); 3654 } 3655 delete fmt3; 3656 3657 ///////////////// 3658 3659 status = U_ZERO_ERROR; 3660 SimpleDateFormat *fmt4 = new SimpleDateFormat(UnicodeString("y M d"), Locale("en-us"), status); 3661 failure(status, "new SimpleDateFormat"); 3662 3663 UDate dt4 = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3664 UnicodeString str4; 3665 str4 = fmt4->format(dt4, str4); 3666 logln(str4); 3667 3668 UDate dt44 = fmt4->parse(str4, status); 3669 failure(status, "fmt->parse"); 3670 3671 UnicodeString str44; 3672 str44 = fmt4->format(dt44, str44); 3673 logln(str44); 3674 3675 if (str4 != str44) { 3676 errln((UnicodeString)"FAIL: Different dates str1:" + str4 3677 + " str2:" + str44); 3678 } 3679 delete fmt4; 3680 3681 } 3682 3683 void DateFormatTest::Test6726(void) 3684 { 3685 // status 3686 // UErrorCode status = U_ZERO_ERROR; 3687 3688 // fmtf, fmtl, fmtm, fmts; 3689 UnicodeString strf, strl, strm, strs; 3690 UDate dt = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3691 3692 Locale loc("ja"); 3693 DateFormat* fmtf = DateFormat::createDateTimeInstance(DateFormat::FULL, DateFormat::FULL, loc); 3694 DateFormat* fmtl = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::FULL, loc); 3695 DateFormat* fmtm = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::FULL, loc); 3696 DateFormat* fmts = DateFormat::createDateTimeInstance(DateFormat::SHORT, DateFormat::FULL, loc); 3697 if (fmtf == NULL || fmtl == NULL || fmtm == NULL || fmts == NULL) { 3698 dataerrln("Unable to create DateFormat. got NULL."); 3699 /* It may not be true that if one is NULL all is NULL. Just to be safe. */ 3700 delete fmtf; 3701 delete fmtl; 3702 delete fmtm; 3703 delete fmts; 3704 3705 return; 3706 } 3707 strf = fmtf->format(dt, strf); 3708 strl = fmtl->format(dt, strl); 3709 strm = fmtm->format(dt, strm); 3710 strs = fmts->format(dt, strs); 3711 3712 3713 logln("strm.charAt(10)=%04X wanted 0x20\n", strm.charAt(10)); 3714 if (strm.charAt(10) != UChar(0x0020)) { 3715 errln((UnicodeString)"FAIL: Improper formatted date: " + strm ); 3716 } 3717 logln("strs.charAt(10)=%04X wanted 0x20\n", strs.charAt(8)); 3718 if (strs.charAt(10) != UChar(0x0020)) { 3719 errln((UnicodeString)"FAIL: Improper formatted date: " + strs); 3720 } 3721 3722 delete fmtf; 3723 delete fmtl; 3724 delete fmtm; 3725 delete fmts; 3726 3727 return; 3728 } 3729 3730 /** 3731 * Test DateFormat's parsing of default GMT variants. See ticket#6135 3732 */ 3733 void DateFormatTest::TestGMTParsing() { 3734 const char* DATA[] = { 3735 "HH:mm:ss Z", 3736 3737 // pattern, input, expected output (in quotes) 3738 "HH:mm:ss Z", "10:20:30 GMT+03:00", "10:20:30 +0300", 3739 "HH:mm:ss Z", "10:20:30 UT-02:00", "10:20:30 -0200", 3740 "HH:mm:ss Z", "10:20:30 GMT", "10:20:30 +0000", 3741 "HH:mm:ss vvvv", "10:20:30 UT+10:00", "10:20:30 +1000", 3742 "HH:mm:ss zzzz", "10:20:30 UTC", "10:20:30 +0000", // standalone "UTC" 3743 "ZZZZ HH:mm:ss", "UT 10:20:30", "10:20:30 +0000", 3744 "z HH:mm:ss", "UT+0130 10:20:30", "10:20:30 +0130", 3745 "z HH:mm:ss", "UTC+0130 10:20:30", "10:20:30 +0130", 3746 // Note: GMT-1100 no longer works because of the introduction of the short 3747 // localized GMT support. Previous implementation support this level of 3748 // leniency (no separator char in localized GMT format), but the new 3749 // implementation handles GMT-11 as the legitimate short localized GMT format 3750 // and stop at there. Otherwise, roundtrip would be broken. 3751 //"HH mm Z ss", "10 20 GMT-1100 30", "10:20:30 -1100", 3752 "HH mm Z ss", "10 20 GMT-11 30", "10:20:30 -1100", 3753 "HH:mm:ssZZZZZ", "14:25:45Z", "14:25:45 +0000", 3754 "HH:mm:ssZZZZZ", "15:00:00-08:00", "15:00:00 -0800", 3755 }; 3756 const int32_t DATA_len = UPRV_LENGTHOF(DATA); 3757 expectParse(DATA, DATA_len, Locale("en")); 3758 } 3759 3760 // Test case for localized GMT format parsing 3761 // with no delimitters in offset format (Chinese locale) 3762 void DateFormatTest::Test6880() { 3763 UErrorCode status = U_ZERO_ERROR; 3764 UDate d1, d2, dp1, dp2, dexp1, dexp2; 3765 UnicodeString s1, s2; 3766 3767 TimeZone *tz = TimeZone::createTimeZone("Asia/Shanghai"); 3768 GregorianCalendar gcal(*tz, status); 3769 if (failure(status, "construct GregorianCalendar", TRUE)) return; 3770 3771 gcal.clear(); 3772 gcal.set(1900, UCAL_JULY, 1, 12, 00); // offset 8:05:43 3773 d1 = gcal.getTime(status); 3774 3775 gcal.clear(); 3776 gcal.set(1950, UCAL_JULY, 1, 12, 00); // offset 8:00 3777 d2 = gcal.getTime(status); 3778 3779 gcal.clear(); 3780 gcal.set(1970, UCAL_JANUARY, 1, 12, 00); 3781 dexp2 = gcal.getTime(status); 3782 dexp1 = dexp2 - (5*60 + 43)*1000; // subtract 5m43s 3783 3784 if (U_FAILURE(status)) { 3785 errln("FAIL: Gregorian calendar error"); 3786 } 3787 3788 DateFormat *fmt = DateFormat::createTimeInstance(DateFormat::kFull, Locale("zh")); 3789 if (fmt == NULL) { 3790 dataerrln("Unable to create DateFormat. Got NULL."); 3791 return; 3792 } 3793 fmt->adoptTimeZone(tz); 3794 3795 fmt->format(d1, s1); 3796 fmt->format(d2, s2); 3797 3798 dp1 = fmt->parse(s1, status); 3799 dp2 = fmt->parse(s2, status); 3800 3801 if (U_FAILURE(status)) { 3802 errln("FAIL: Parse failure"); 3803 } 3804 3805 if (dp1 != dexp1) { 3806 errln("FAIL: Failed to parse " + s1 + " parsed: " + dp1 + " expected: " + dexp1); 3807 } 3808 if (dp2 != dexp2) { 3809 errln("FAIL: Failed to parse " + s2 + " parsed: " + dp2 + " expected: " + dexp2); 3810 } 3811 3812 delete fmt; 3813 } 3814 3815 typedef struct { 3816 const char * localeStr; 3817 UBool lenient; 3818 UBool expectFail; 3819 UnicodeString datePattern; 3820 UnicodeString dateString; 3821 } NumAsStringItem; 3822 3823 void DateFormatTest::TestNumberAsStringParsing() 3824 { 3825 const NumAsStringItem items[] = { 3826 // loc lenient fail? datePattern dateString 3827 { "", FALSE, TRUE, UnicodeString("y MMMM d HH:mm:ss"), UnicodeString("2009 7 14 08:43:57") }, 3828 { "", TRUE, FALSE, UnicodeString("y MMMM d HH:mm:ss"), UnicodeString("2009 7 14 08:43:57") }, 3829 { "en", FALSE, FALSE, UnicodeString("MMM d, y"), UnicodeString("Jul 14, 2009") }, 3830 { "en", TRUE, FALSE, UnicodeString("MMM d, y"), UnicodeString("Jul 14, 2009") }, 3831 { "en", FALSE, TRUE, UnicodeString("MMM d, y"), UnicodeString("7 14, 2009") }, 3832 { "en", TRUE, FALSE, UnicodeString("MMM d, y"), UnicodeString("7 14, 2009") }, 3833 { "ja", FALSE, FALSE, UnicodeString("yyyy/MM/dd"), UnicodeString("2009/07/14") }, 3834 { "ja", TRUE, FALSE, UnicodeString("yyyy/MM/dd"), UnicodeString("2009/07/14") }, 3835 //{ "ja", FALSE, FALSE, UnicodeString("yyyy/MMMMM/d"), UnicodeString("2009/7/14") }, // #8860 covers test failure 3836 { "ja", TRUE, FALSE, UnicodeString("yyyy/MMMMM/d"), UnicodeString("2009/7/14") }, 3837 { "ja", FALSE, FALSE, CharsToUnicodeString("y\\u5E74M\\u6708d\\u65E5"), CharsToUnicodeString("2009\\u5E747\\u670814\\u65E5") }, 3838 { "ja", TRUE, FALSE, CharsToUnicodeString("y\\u5E74M\\u6708d\\u65E5"), CharsToUnicodeString("2009\\u5E747\\u670814\\u65E5") }, 3839 { "ja", FALSE, FALSE, CharsToUnicodeString("y\\u5E74MMMd\\u65E5"), CharsToUnicodeString("2009\\u5E747\\u670814\\u65E5") }, 3840 { "ja", TRUE, FALSE, CharsToUnicodeString("y\\u5E74MMMd\\u65E5"), CharsToUnicodeString("2009\\u5E747\\u670814\\u65E5") }, // #8820 fixes test failure 3841 { "ko", FALSE, FALSE, UnicodeString("yyyy. M. d."), UnicodeString("2009. 7. 14.") }, 3842 { "ko", TRUE, FALSE, UnicodeString("yyyy. M. d."), UnicodeString("2009. 7. 14.") }, 3843 { "ko", FALSE, FALSE, UnicodeString("yyyy. MMMMM d."), CharsToUnicodeString("2009. 7\\uC6D4 14.") }, 3844 { "ko", TRUE, FALSE, UnicodeString("yyyy. MMMMM d."), CharsToUnicodeString("2009. 7\\uC6D4 14.") }, // #8820 fixes test failure 3845 { "ko", FALSE, FALSE, CharsToUnicodeString("y\\uB144 M\\uC6D4 d\\uC77C"), CharsToUnicodeString("2009\\uB144 7\\uC6D4 14\\uC77C") }, 3846 { "ko", TRUE, FALSE, CharsToUnicodeString("y\\uB144 M\\uC6D4 d\\uC77C"), CharsToUnicodeString("2009\\uB144 7\\uC6D4 14\\uC77C") }, 3847 { "ko", FALSE, FALSE, CharsToUnicodeString("y\\uB144 MMM d\\uC77C"), CharsToUnicodeString("2009\\uB144 7\\uC6D4 14\\uC77C") }, 3848 { "ko", TRUE, FALSE, CharsToUnicodeString("y\\uB144 MMM d\\uC77C"), CharsToUnicodeString("2009\\uB144 7\\uC6D4 14\\uC77C") }, // #8820 fixes test failure 3849 { NULL, FALSE, FALSE, UnicodeString(""), UnicodeString("") } 3850 }; 3851 const NumAsStringItem * itemPtr; 3852 for (itemPtr = items; itemPtr->localeStr != NULL; itemPtr++ ) { 3853 Locale locale = Locale::createFromName(itemPtr->localeStr); 3854 UErrorCode status = U_ZERO_ERROR; 3855 SimpleDateFormat *formatter = new SimpleDateFormat(itemPtr->datePattern, locale, status); 3856 if (formatter == NULL || U_FAILURE(status)) { 3857 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 3858 return; 3859 } 3860 3861 formatter->setLenient(itemPtr->lenient); 3862 formatter->setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, itemPtr->lenient, status).setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, itemPtr->lenient, status); 3863 UDate date1 = formatter->parse(itemPtr->dateString, status); 3864 if (U_FAILURE(status)) { 3865 if (!itemPtr->expectFail) { 3866 errln("FAIL, err when expected success: Locale \"" + UnicodeString(itemPtr->localeStr) + "\", lenient " + itemPtr->lenient + 3867 ": using pattern \"" + itemPtr->datePattern + "\", could not parse \"" + itemPtr->dateString + "\"; err: " + u_errorName(status) ); 3868 } 3869 } else if (itemPtr->expectFail) { 3870 errln("FAIL, expected err but got none: Locale \"" + UnicodeString(itemPtr->localeStr) + "\", lenient " + itemPtr->lenient + 3871 ": using pattern \"" + itemPtr->datePattern + "\", did parse \"" + itemPtr->dateString + "\"." ); 3872 } else if (!itemPtr->lenient) { 3873 UnicodeString formatted; 3874 formatter->format(date1, formatted); 3875 if (formatted != itemPtr->dateString) { 3876 errln("FAIL, mismatch formatting parsed date: Locale \"" + UnicodeString(itemPtr->localeStr) + "\", lenient " + itemPtr->lenient + 3877 ": using pattern \"" + itemPtr->datePattern + "\", did parse \"" + itemPtr->dateString + "\", formatted result \"" + formatted + "\"."); 3878 } 3879 } 3880 3881 delete formatter; 3882 } 3883 } 3884 3885 void DateFormatTest::TestISOEra() { 3886 3887 const char* data[] = { 3888 // input, output 3889 "BC 4004-10-23T07:00:00Z", "BC 4004-10-23T07:00:00Z", 3890 "AD 4004-10-23T07:00:00Z", "AD 4004-10-23T07:00:00Z", 3891 "-4004-10-23T07:00:00Z" , "BC 4005-10-23T07:00:00Z", 3892 "4004-10-23T07:00:00Z" , "AD 4004-10-23T07:00:00Z", 3893 }; 3894 3895 int32_t numData = 8; 3896 3897 UErrorCode status = U_ZERO_ERROR; 3898 3899 // create formatter 3900 SimpleDateFormat *fmt1 = new SimpleDateFormat(UnicodeString("GGG yyyy-MM-dd'T'HH:mm:ss'Z"), status); 3901 failure(status, "new SimpleDateFormat", TRUE); 3902 if (status == U_MISSING_RESOURCE_ERROR) { 3903 if (fmt1 != NULL) { 3904 delete fmt1; 3905 } 3906 return; 3907 } 3908 for(int i=0; i < numData; i+=2) { 3909 // create input string 3910 UnicodeString in = data[i]; 3911 3912 // parse string to date 3913 UDate dt1 = fmt1->parse(in, status); 3914 failure(status, "fmt->parse", TRUE); 3915 3916 // format date back to string 3917 UnicodeString out; 3918 out = fmt1->format(dt1, out); 3919 logln(out); 3920 3921 // check that roundtrip worked as expected 3922 UnicodeString expected = data[i+1]; 3923 if (out != expected) { 3924 dataerrln((UnicodeString)"FAIL: " + in + " -> " + out + " expected -> " + expected); 3925 } 3926 } 3927 3928 delete fmt1; 3929 } 3930 void DateFormatTest::TestFormalChineseDate() { 3931 3932 UErrorCode status = U_ZERO_ERROR; 3933 UnicodeString pattern ("y\\u5e74M\\u6708d\\u65e5", -1, US_INV ); 3934 pattern = pattern.unescape(); 3935 UnicodeString override ("y=hanidec;M=hans;d=hans", -1, US_INV ); 3936 3937 // create formatter 3938 SimpleDateFormat *sdf = new SimpleDateFormat(pattern,override,Locale::getChina(),status); 3939 if (failure(status, "new SimpleDateFormat with override", TRUE)) { 3940 return; 3941 } 3942 3943 UDate thedate = date(2009-1900, UCAL_JULY, 28); 3944 FieldPosition pos(FieldPosition::DONT_CARE); 3945 UnicodeString result; 3946 sdf->format(thedate,result,pos); 3947 3948 UnicodeString expected = "\\u4e8c\\u3007\\u3007\\u4e5d\\u5e74\\u4e03\\u6708\\u4e8c\\u5341\\u516b\\u65e5"; 3949 expected = expected.unescape(); 3950 if (result != expected) { 3951 dataerrln((UnicodeString)"FAIL: -> " + result + " expected -> " + expected); 3952 } 3953 3954 UDate parsedate = sdf->parse(expected,status); 3955 if ( parsedate != thedate ) { 3956 UnicodeString pat1 ("yyyy-MM-dd'T'HH:mm:ss'Z'", -1, US_INV ); 3957 SimpleDateFormat *usf = new SimpleDateFormat(pat1,Locale::getEnglish(),status); 3958 UnicodeString parsedres,expres; 3959 usf->format(parsedate,parsedres,pos); 3960 usf->format(thedate,expres,pos); 3961 dataerrln((UnicodeString)"FAIL: parsed -> " + parsedres + " expected -> " + expres); 3962 delete usf; 3963 } 3964 delete sdf; 3965 } 3966 3967 // Test case for #8675 3968 // Incorrect parse offset with stand alone GMT string on 2nd or later iteration. 3969 void DateFormatTest::TestStandAloneGMTParse() { 3970 UErrorCode status = U_ZERO_ERROR; 3971 SimpleDateFormat *sdf = new SimpleDateFormat("ZZZZ", Locale(""), status); 3972 3973 if (U_SUCCESS(status)) { 3974 3975 UnicodeString inText("GMT$$$"); 3976 for (int32_t i = 0; i < 10; i++) { 3977 ParsePosition pos(0); 3978 sdf->parse(inText, pos); 3979 if (pos.getIndex() != 3) { 3980 errln((UnicodeString)"FAIL: Incorrect output parse position: actual=" + pos.getIndex() + " expected=3"); 3981 } 3982 } 3983 3984 delete sdf; 3985 } else { 3986 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 3987 } 3988 } 3989 3990 void DateFormatTest::TestParsePosition() { 3991 const char* TestData[][4] = { 3992 // {<pattern>, <lead>, <date string>, <trail>} 3993 {"yyyy-MM-dd HH:mm:ssZ", "", "2010-01-10 12:30:00+0500", ""}, 3994 {"yyyy-MM-dd HH:mm:ss ZZZZ", "", "2010-01-10 12:30:00 GMT+05:00", ""}, 3995 {"Z HH:mm:ss", "", "-0100 13:20:30", ""}, 3996 {"y-M-d Z", "", "2011-8-25 -0400", " Foo"}, 3997 {"y/M/d H:mm:ss z", "", "2011/7/1 12:34:00 PDT", ""}, 3998 {"y/M/d H:mm:ss z", "+123", "2011/7/1 12:34:00 PDT", " PST"}, 3999 {"vvvv a h:mm:ss", "", "Pacific Time AM 10:21:45", ""}, 4000 {"HH:mm v M/d", "111", "14:15 PT 8/10", " 12345"}, 4001 {"'time zone:' VVVV 'date:' yyyy-MM-dd", "xxxx", "time zone: Los Angeles Time date: 2010-02-25", "xxxx"}, 4002 {"yG", "", "2012AD", ""}, 4003 {"yG", "", "2012", "x"}, 4004 {0, 0, 0, 0}, 4005 }; 4006 4007 for (int32_t i = 0; TestData[i][0]; i++) { 4008 UErrorCode status = U_ZERO_ERROR; 4009 SimpleDateFormat *sdf = new SimpleDateFormat(UnicodeString(TestData[i][0]), status); 4010 if (failure(status, "new SimpleDateFormat", TRUE)) return; 4011 4012 int32_t startPos, resPos; 4013 4014 // lead text 4015 UnicodeString input(TestData[i][1]); 4016 startPos = input.length(); 4017 4018 // date string 4019 input += TestData[i][2]; 4020 resPos = input.length(); 4021 4022 // trail text 4023 input += TestData[i][3]; 4024 4025 ParsePosition pos(startPos); 4026 //UDate d = sdf->parse(input, pos); 4027 (void)sdf->parse(input, pos); 4028 4029 if (pos.getIndex() != resPos) { 4030 errln(UnicodeString("FAIL: Parsing [") + input + "] with pattern [" + TestData[i][0] + "] returns position - " 4031 + pos.getIndex() + ", expected - " + resPos); 4032 } 4033 4034 delete sdf; 4035 } 4036 } 4037 4038 4039 typedef struct { 4040 int32_t era; 4041 int32_t year; 4042 int32_t month; // 1-based 4043 int32_t isLeapMonth; 4044 int32_t day; 4045 } ChineseCalTestDate; 4046 4047 #define NUM_TEST_DATES 3 4048 4049 typedef struct { 4050 const char * locale; 4051 int32_t style; // <0 => custom 4052 UnicodeString dateString[NUM_TEST_DATES]; 4053 } MonthPatternItem; 4054 4055 void DateFormatTest::TestMonthPatterns() 4056 { 4057 const ChineseCalTestDate dates[NUM_TEST_DATES] = { 4058 // era yr mo lp da 4059 { 78, 29, 4, 0, 2 }, // (in chinese era 78) gregorian 2012-4-22 4060 { 78, 29, 4, 1, 2 }, // (in chinese era 78) gregorian 2012-5-22 4061 { 78, 29, 5, 0, 2 }, // (in chinese era 78) gregorian 2012-6-20 4062 }; 4063 4064 const MonthPatternItem items[] = { 4065 // locale date style; expected formats for the 3 dates above 4066 { "root@calendar=chinese", DateFormat::kLong, { UnicodeString("2012(ren-chen) M04 2"), UnicodeString("2012(ren-chen) M04bis 2"), UnicodeString("2012(ren-chen) M05 2") } }, 4067 { "root@calendar=chinese", DateFormat::kShort, { UnicodeString("2012-04-02"), UnicodeString("2012-04bis-02"), UnicodeString("2012-05-02") } }, 4068 { "root@calendar=chinese", -1, { UnicodeString("29-4-2"), UnicodeString("29-4bis-2"), UnicodeString("29-5-2") } }, 4069 { "root@calendar=chinese", -2, { UnicodeString("78x29-4-2"), UnicodeString("78x29-4bis-2"), UnicodeString("78x29-5-2") } }, 4070 { "root@calendar=chinese", -3, { UnicodeString("ren-chen-4-2"), UnicodeString("ren-chen-4bis-2"), UnicodeString("ren-chen-5-2") } }, 4071 { "root@calendar=chinese", -4, { UnicodeString("ren-chen M04 2"), UnicodeString("ren-chen M04bis 2"), UnicodeString("ren-chen M05 2") } }, 4072 { "en@calendar=gregorian", -3, { UnicodeString("2012-4-22"), UnicodeString("2012-5-22"), UnicodeString("2012-6-20") } }, 4073 { "en@calendar=chinese", DateFormat::kLong, { UnicodeString("Fourth Month 2, 2012(ren-chen)"), UnicodeString("Fourth Monthbis 2, 2012(ren-chen)"), UnicodeString("Fifth Month 2, 2012(ren-chen)") } }, 4074 { "en@calendar=chinese", DateFormat::kShort, { UnicodeString("4/2/2012"), UnicodeString("4bis/2/2012"), UnicodeString("5/2/2012") } }, 4075 { "zh@calendar=chinese", DateFormat::kLong, { CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u56DB\\u6708\\u521D\\u4E8C"), 4076 CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u95F0\\u56DB\\u6708\\u521D\\u4E8C"), 4077 CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u4E94\\u6708\\u521D\\u4E8C") } }, 4078 { "zh@calendar=chinese", DateFormat::kShort, { CharsToUnicodeString("2012/4/2"), 4079 CharsToUnicodeString("2012/\\u95F04/2"), 4080 CharsToUnicodeString("2012/5/2") } }, 4081 { "zh@calendar=chinese", -3, { CharsToUnicodeString("\\u58EC\\u8FB0-4-2"), 4082 CharsToUnicodeString("\\u58EC\\u8FB0-\\u95F04-2"), 4083 CharsToUnicodeString("\\u58EC\\u8FB0-5-2") } }, 4084 { "zh@calendar=chinese", -4, { CharsToUnicodeString("\\u58EC\\u8FB0 \\u56DB\\u6708 2"), 4085 CharsToUnicodeString("\\u58EC\\u8FB0 \\u95F0\\u56DB\\u6708 2"), 4086 CharsToUnicodeString("\\u58EC\\u8FB0 \\u4E94\\u6708 2") } }, 4087 { "zh_Hant@calendar=chinese", DateFormat::kLong, { CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u56DB\\u6708\\u521D\\u4E8C"), 4088 CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u958F\\u56DB\\u6708\\u521D\\u4E8C"), 4089 CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u4E94\\u6708\\u521D\\u4E8C") } }, 4090 { "zh_Hant@calendar=chinese", DateFormat::kShort, { CharsToUnicodeString("2012/4/2"), 4091 CharsToUnicodeString("2012/\\u958F4/2"), 4092 CharsToUnicodeString("2012/5/2") } }, 4093 { "fr@calendar=chinese", DateFormat::kLong, { CharsToUnicodeString("2 s\\u00ECyu\\u00E8 ren-chen"), 4094 CharsToUnicodeString("2 s\\u00ECyu\\u00E8bis ren-chen"), 4095 CharsToUnicodeString("2 w\\u01D4yu\\u00E8 ren-chen") } }, 4096 { "fr@calendar=chinese", DateFormat::kShort, { UnicodeString("2/4/29"), UnicodeString("2/4bis/29"), UnicodeString("2/5/29") } }, 4097 { "en@calendar=dangi", DateFormat::kLong, { UnicodeString("Third Monthbis 2, 2012(ren-chen)"), UnicodeString("Fourth Month 2, 2012(ren-chen)"), UnicodeString("Fifth Month 1, 2012(ren-chen)") } }, 4098 { "en@calendar=dangi", DateFormat::kShort, { UnicodeString("3bis/2/2012"), UnicodeString("4/2/2012"), UnicodeString("5/1/2012") } }, 4099 { "en@calendar=dangi", -2, { UnicodeString("78x29-3bis-2"), UnicodeString("78x29-4-2"), UnicodeString("78x29-5-1") } }, 4100 { "ko@calendar=dangi", DateFormat::kLong, { CharsToUnicodeString("\\uC784\\uC9C4\\uB144 \\uC7243\\uC6D4 2\\uC77C"), 4101 CharsToUnicodeString("\\uC784\\uC9C4\\uB144 4\\uC6D4 2\\uC77C"), 4102 CharsToUnicodeString("\\uC784\\uC9C4\\uB144 5\\uC6D4 1\\uC77C") } }, 4103 { "ko@calendar=dangi", DateFormat::kShort, { CharsToUnicodeString("29. \\uC7243. 2."), 4104 CharsToUnicodeString("29. 4. 2."), 4105 CharsToUnicodeString("29. 5. 1.") } }, 4106 // terminator 4107 { NULL, 0, { UnicodeString(""), UnicodeString(""), UnicodeString("") } } 4108 }; 4109 4110 //. style: -1 -2 -3 -4 4111 const UnicodeString customPatterns[] = { "y-Ml-d", "G'x'y-Ml-d", "U-M-d", "U MMM d" }; // like old root pattern, using 'l' 4112 4113 UErrorCode status = U_ZERO_ERROR; 4114 Locale rootChineseCalLocale = Locale::createFromName("root@calendar=chinese"); 4115 Calendar * rootChineseCalendar = Calendar::createInstance(rootChineseCalLocale, status); 4116 if (U_SUCCESS(status)) { 4117 const MonthPatternItem * itemPtr; 4118 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) { 4119 Locale locale = Locale::createFromName(itemPtr->locale); 4120 DateFormat * dmft = (itemPtr->style >= 0)? 4121 DateFormat::createDateInstance((DateFormat::EStyle)itemPtr->style, locale): 4122 new SimpleDateFormat(customPatterns[-itemPtr->style - 1], locale, status); 4123 if ( dmft != NULL ) { 4124 if (U_SUCCESS(status)) { 4125 const ChineseCalTestDate * datePtr = dates; 4126 int32_t idate; 4127 for (idate = 0; idate < NUM_TEST_DATES; idate++, datePtr++) { 4128 rootChineseCalendar->clear(); 4129 rootChineseCalendar->set(UCAL_ERA, datePtr->era); 4130 rootChineseCalendar->set(datePtr->year, datePtr->month-1, datePtr->day); 4131 rootChineseCalendar->set(UCAL_IS_LEAP_MONTH, datePtr->isLeapMonth); 4132 UnicodeString result; 4133 FieldPosition fpos(FieldPosition::DONT_CARE); 4134 dmft->format(*rootChineseCalendar, result, fpos); 4135 if ( result.compare(itemPtr->dateString[idate]) != 0 ) { 4136 errln( UnicodeString("FAIL: Chinese calendar format for locale ") + UnicodeString(itemPtr->locale) + ", style " + itemPtr->style + 4137 ", expected \"" + itemPtr->dateString[idate] + "\", got \"" + result + "\""); 4138 } else { 4139 // formatted OK, try parse 4140 ParsePosition ppos(0); 4141 // ensure we are really parsing the fields we should be 4142 rootChineseCalendar->set(UCAL_YEAR, 1); 4143 rootChineseCalendar->set(UCAL_MONTH, 0); 4144 rootChineseCalendar->set(UCAL_IS_LEAP_MONTH, 0); 4145 rootChineseCalendar->set(UCAL_DATE, 1); 4146 // 4147 dmft->parse(result, *rootChineseCalendar, ppos); 4148 int32_t year = rootChineseCalendar->get(UCAL_YEAR, status); 4149 int32_t month = rootChineseCalendar->get(UCAL_MONTH, status) + 1; 4150 int32_t isLeapMonth = rootChineseCalendar->get(UCAL_IS_LEAP_MONTH, status); 4151 int32_t day = rootChineseCalendar->get(UCAL_DATE, status); 4152 if ( ppos.getIndex() < result.length() || year != datePtr->year || month != datePtr->month || isLeapMonth != datePtr->isLeapMonth || day != datePtr->day ) { 4153 errln( UnicodeString("FAIL: Chinese calendar parse for locale ") + UnicodeString(itemPtr->locale) + ", style " + itemPtr->style + 4154 ", string \"" + result + "\", expected " + datePtr->year +"-"+datePtr->month+"("+datePtr->isLeapMonth+")-"+datePtr->day + ", got pos " + 4155 ppos.getIndex() + " " + year +"-"+month+"("+isLeapMonth+")-"+day); 4156 } 4157 } 4158 } 4159 } else { 4160 dataerrln("Error creating SimpleDateFormat for Chinese calendar- %s", u_errorName(status)); 4161 } 4162 delete dmft; 4163 } else { 4164 dataerrln("FAIL: Unable to create DateFormat for Chinese calendar- %s", u_errorName(status)); 4165 } 4166 } 4167 delete rootChineseCalendar; 4168 } else { 4169 errln(UnicodeString("FAIL: Unable to create Calendar for root@calendar=chinese")); 4170 } 4171 } 4172 4173 typedef struct { 4174 const char * locale; 4175 UnicodeString pattern; 4176 UDisplayContext capitalizationContext; 4177 UnicodeString expectedFormat; 4178 } TestContextItem; 4179 4180 void DateFormatTest::TestContext() 4181 { 4182 const UDate july022008 = 1215000001979.0; 4183 const TestContextItem items[] = { 4184 //locale pattern capitalizationContext expected formatted date 4185 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_NONE, UnicodeString("juillet 2008") }, 4186 #if !UCONFIG_NO_BREAK_ITERATION 4187 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UnicodeString("juillet 2008") }, 4188 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UnicodeString("Juillet 2008") }, 4189 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UnicodeString("juillet 2008") }, 4190 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UnicodeString("Juillet 2008") }, 4191 #endif 4192 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_NONE, CharsToUnicodeString("\\u010Dervenec 2008") }, 4193 #if !UCONFIG_NO_BREAK_ITERATION 4194 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, CharsToUnicodeString("\\u010Dervenec 2008") }, 4195 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, CharsToUnicodeString("\\u010Cervenec 2008") }, 4196 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, CharsToUnicodeString("\\u010Cervenec 2008") }, 4197 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_FOR_STANDALONE, CharsToUnicodeString("\\u010Dervenec 2008") }, 4198 #endif 4199 // terminator 4200 { NULL, UnicodeString(""), (UDisplayContext)0, UnicodeString("") } 4201 }; 4202 UErrorCode status = U_ZERO_ERROR; 4203 Calendar* cal = Calendar::createInstance(status); 4204 if (U_FAILURE(status)) { 4205 dataerrln(UnicodeString("FAIL: Unable to create Calendar for default timezone and locale.")); 4206 } else { 4207 cal->setTime(july022008, status); 4208 const TestContextItem * itemPtr; 4209 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) { 4210 Locale locale = Locale::createFromName(itemPtr->locale); 4211 status = U_ZERO_ERROR; 4212 SimpleDateFormat * sdmft = new SimpleDateFormat(itemPtr->pattern, locale, status); 4213 if (U_FAILURE(status)) { 4214 dataerrln(UnicodeString("FAIL: Unable to create SimpleDateFormat for specified pattern with locale ") + UnicodeString(itemPtr->locale)); 4215 } else { 4216 sdmft->setContext(itemPtr->capitalizationContext, status); 4217 UnicodeString result; 4218 FieldPosition pos(FieldPosition::DONT_CARE); 4219 sdmft->format(*cal, result, pos); 4220 if (result.compare(itemPtr->expectedFormat) != 0) { 4221 errln(UnicodeString("FAIL: format for locale ") + UnicodeString(itemPtr->locale) + 4222 ", status " + (int)status + 4223 ", capitalizationContext " + (int)itemPtr->capitalizationContext + 4224 ", expected " + itemPtr->expectedFormat + ", got " + result); 4225 } 4226 } 4227 if (sdmft) { 4228 delete sdmft; 4229 } 4230 } 4231 } 4232 if (cal) { 4233 delete cal; 4234 } 4235 } 4236 4237 // test item for a particular locale + calendar and date format 4238 typedef struct { 4239 int32_t era; 4240 int32_t year; 4241 int32_t month; 4242 int32_t day; 4243 int32_t hour; 4244 int32_t minute; 4245 UnicodeString formattedDate; 4246 } CalAndFmtTestItem; 4247 4248 // test item giving locale + calendar, date format, and CalAndFmtTestItems 4249 typedef struct { 4250 const char * locale; // with calendar 4251 DateFormat::EStyle style; 4252 UnicodeString pattern; // ignored unless style == DateFormat::kNone 4253 const CalAndFmtTestItem *caftItems; 4254 } TestNonGregoItem; 4255 4256 void DateFormatTest::TestNonGregoFmtParse() 4257 { 4258 // test items for he@calendar=hebrew, long date format 4259 const CalAndFmtTestItem cafti_he_hebrew_long[] = { 4260 { 0, 4999, 12, 29, 12, 0, CharsToUnicodeString("\\u05DB\\u05F4\\u05D8 \\u05D1\\u05D0\\u05DC\\u05D5\\u05DC \\u05D3\\u05F3\\u05EA\\u05EA\\u05E7\\u05E6\\u05F4\\u05D8") }, 4261 { 0, 5100, 0, 1, 12, 0, CharsToUnicodeString("\\u05D0\\u05F3 \\u05D1\\u05EA\\u05E9\\u05E8\\u05D9 \\u05E7\\u05F3") }, 4262 { 0, 5774, 5, 1, 12, 0, CharsToUnicodeString("\\u05D0\\u05F3 \\u05D1\\u05D0\\u05D3\\u05E8 \\u05D0\\u05F3 \\u05EA\\u05E9\\u05E2\\u05F4\\u05D3") }, 4263 { 0, 5999, 12, 29, 12, 0, CharsToUnicodeString("\\u05DB\\u05F4\\u05D8 \\u05D1\\u05D0\\u05DC\\u05D5\\u05DC \\u05EA\\u05EA\\u05E7\\u05E6\\u05F4\\u05D8") }, 4264 { 0, 6100, 0, 1, 12, 0, CharsToUnicodeString("\\u05D0\\u05F3 \\u05D1\\u05EA\\u05E9\\u05E8\\u05D9 \\u05D5\\u05F3\\u05E7\\u05F3") }, 4265 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4266 }; 4267 const CalAndFmtTestItem cafti_zh_chinese_custU[] = { 4268 { 78, 31, 0, 1, 12, 0, CharsToUnicodeString("2014\\u7532\\u5348\\u5E74\\u6B63\\u67081") }, 4269 { 77, 31, 0, 1, 12, 0, CharsToUnicodeString("1954\\u7532\\u5348\\u5E74\\u6B63\\u67081") }, 4270 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4271 }; 4272 const CalAndFmtTestItem cafti_zh_chinese_custNoU[] = { 4273 { 78, 31, 0, 1, 12, 0, CharsToUnicodeString("2014\\u5E74\\u6B63\\u67081") }, 4274 { 77, 31, 0, 1, 12, 0, CharsToUnicodeString("1954\\u5E74\\u6B63\\u67081") }, 4275 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4276 }; 4277 const CalAndFmtTestItem cafti_ja_japanese_custGy[] = { 4278 {235, 26, 2, 5, 12, 0, CharsToUnicodeString("2014(\\u5E73\\u621026)\\u5E743\\u67085\\u65E5") }, 4279 {234, 60, 2, 5, 12, 0, CharsToUnicodeString("1985(\\u662D\\u548C60)\\u5E743\\u67085\\u65E5") }, 4280 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4281 }; 4282 const CalAndFmtTestItem cafti_ja_japanese_custNoGy[] = { 4283 {235, 26, 2, 5, 12, 0, CharsToUnicodeString("2014\\u5E743\\u67085\\u65E5") }, 4284 {234, 60, 2, 5, 12, 0, CharsToUnicodeString("1985\\u5E743\\u67085\\u65E5") }, 4285 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4286 }; 4287 const CalAndFmtTestItem cafti_en_islamic_cust[] = { 4288 { 0, 1384, 0, 1, 12, 0, UnicodeString("1 Muh. 1384 AH, 1964") }, 4289 { 0, 1436, 0, 1, 12, 0, UnicodeString("1 Muh. 1436 AH, 2014") }, 4290 { 0, 1487, 0, 1, 12, 0, UnicodeString("1 Muh. 1487 AH, 2064") }, 4291 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4292 }; 4293 // overal test items 4294 const TestNonGregoItem items[] = { 4295 { "he@calendar=hebrew", DateFormat::kLong, UnicodeString(""), cafti_he_hebrew_long }, 4296 { "zh@calendar=chinese", DateFormat::kNone, CharsToUnicodeString("rU\\u5E74MMMd"), cafti_zh_chinese_custU }, 4297 { "zh@calendar=chinese", DateFormat::kNone, CharsToUnicodeString("r\\u5E74MMMd"), cafti_zh_chinese_custNoU }, 4298 { "ja@calendar=japanese", DateFormat::kNone, CharsToUnicodeString("r(Gy)\\u5E74M\\u6708d\\u65E5"), cafti_ja_japanese_custGy }, 4299 { "ja@calendar=japanese", DateFormat::kNone, CharsToUnicodeString("r\\u5E74M\\u6708d\\u65E5"), cafti_ja_japanese_custNoGy }, 4300 { "en@calendar=islamic", DateFormat::kNone, UnicodeString("d MMM y G, r"), cafti_en_islamic_cust }, 4301 { NULL, DateFormat::kNone, UnicodeString(""), NULL } // terminator 4302 }; 4303 const TestNonGregoItem * itemPtr; 4304 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++) { 4305 Locale locale = Locale::createFromName(itemPtr->locale); 4306 DateFormat * dfmt = NULL; 4307 UErrorCode status = U_ZERO_ERROR; 4308 if (itemPtr->style != DateFormat::kNone) { 4309 dfmt = DateFormat::createDateInstance(itemPtr->style, locale); 4310 } else { 4311 dfmt = new SimpleDateFormat(itemPtr->pattern, locale, status); 4312 } 4313 if (U_FAILURE(status)) { 4314 dataerrln("new SimpleDateFormat fails for locale %s", itemPtr->locale); 4315 } else if (dfmt == NULL) { 4316 dataerrln("DateFormat::createDateInstance fails for locale %s", itemPtr->locale); 4317 } else { 4318 Calendar * cal = (dfmt->getCalendar())->clone(); 4319 if (cal == NULL) { 4320 dataerrln("(DateFormat::getCalendar)->clone() fails for locale %s", itemPtr->locale); 4321 } else { 4322 const CalAndFmtTestItem * caftItemPtr; 4323 for (caftItemPtr = itemPtr->caftItems; caftItemPtr->year != 0; caftItemPtr++) { 4324 cal->clear(); 4325 cal->set(UCAL_ERA, caftItemPtr->era); 4326 cal->set(UCAL_YEAR, caftItemPtr->year); 4327 cal->set(UCAL_MONTH, caftItemPtr->month); 4328 cal->set(UCAL_DATE, caftItemPtr->day); 4329 cal->set(UCAL_HOUR_OF_DAY, caftItemPtr->hour); 4330 cal->set(UCAL_MINUTE, caftItemPtr->minute); 4331 UnicodeString result; 4332 FieldPosition fpos(FieldPosition::DONT_CARE); 4333 dfmt->format(*cal, result, fpos); 4334 if ( result.compare(caftItemPtr->formattedDate) != 0 ) { 4335 errln( UnicodeString("FAIL: date format for locale ") + UnicodeString(itemPtr->locale) + ", style " + itemPtr->style + 4336 ", expected \"" + caftItemPtr->formattedDate + "\", got \"" + result + "\""); 4337 } else { 4338 // formatted OK, try parse 4339 ParsePosition ppos(0); 4340 dfmt->parse(result, *cal, ppos); 4341 status = U_ZERO_ERROR; 4342 int32_t era = cal->get(UCAL_ERA, status); 4343 int32_t year = cal->get(UCAL_YEAR, status); 4344 int32_t month = cal->get(UCAL_MONTH, status); 4345 int32_t day = cal->get(UCAL_DATE, status); 4346 if ( U_FAILURE(status) || ppos.getIndex() < result.length() || era != caftItemPtr->era || 4347 year != caftItemPtr->year || month != caftItemPtr->month || day != caftItemPtr->day ) { 4348 errln( UnicodeString("FAIL: date parse for locale ") + UnicodeString(itemPtr->locale) + 4349 ", style " + itemPtr->style + ", string \"" + result + "\", expected " + 4350 caftItemPtr->era +":"+caftItemPtr->year +"-"+caftItemPtr->month+"-"+caftItemPtr->day + ", got pos " + 4351 ppos.getIndex() + " " + year +"-"+month+"-"+day + " status " + UnicodeString(u_errorName(status)) ); 4352 } 4353 } 4354 } 4355 delete cal; 4356 } 4357 delete dfmt; 4358 } 4359 } 4360 } 4361 4362 typedef struct { 4363 const char* localeID; 4364 DateFormat::EStyle style; 4365 UnicodeString expectPattern; 4366 UnicodeString expectFormat; 4367 } TestFmtWithNumSysItem; 4368 enum { kBBufMax = 128 }; 4369 void DateFormatTest::TestFormatsWithNumberSystems() 4370 { 4371 LocalPointer<TimeZone> zone(TimeZone::createTimeZone(UnicodeString("UTC"))); 4372 const UDate date = 1451556000000.0; // for UTC: grego 31-Dec-2015 10 AM, hebrew 19 tevet 5776, chinese yi-wei 11mo 21day 4373 const TestFmtWithNumSysItem items[] = { 4374 { "haw@calendar=gregorian", DateFormat::kShort, UnicodeString("d/M/yy"), UnicodeString("31/xii/15") }, 4375 { "he@calendar=hebrew", DateFormat::kLong, CharsToUnicodeString("d \\u05D1MMMM y"), CharsToUnicodeString("\\u05D9\\u05F4\\u05D8 \\u05D1\\u05D8\\u05D1\\u05EA \\u05EA\\u05E9\\u05E2\\u05F4\\u05D5") }, 4376 { "zh@calendar=chinese", DateFormat::kLong, CharsToUnicodeString("rU\\u5E74MMMd"), CharsToUnicodeString("2015\\u4E59\\u672A\\u5E74\\u5341\\u4E00\\u6708\\u5EFF\\u4E00") }, 4377 { "zh_Hant@calendar=chinese", DateFormat::kLong, CharsToUnicodeString("rU\\u5E74MMMd"), CharsToUnicodeString("2015\\u4E59\\u672A\\u5E74\\u51AC\\u6708\\u5EFF\\u4E00") }, 4378 { "ja@calendar=chinese", DateFormat::kLong, CharsToUnicodeString("U\\u5E74MMMd\\u65E5"), CharsToUnicodeString("\\u4E59\\u672A\\u5E74\\u5341\\u4E00\\u6708\\u4E8C\\u4E00\\u65E5") }, 4379 { NULL, DateFormat::kNone, UnicodeString(""), UnicodeString("") }, 4380 }; 4381 const TestFmtWithNumSysItem * itemPtr; 4382 for (itemPtr = items; itemPtr->localeID != NULL; itemPtr++) { 4383 char bExpected[kBBufMax]; 4384 char bResult[kBBufMax]; 4385 UErrorCode status = U_ZERO_ERROR; 4386 Locale locale = Locale::createFromName(itemPtr->localeID); 4387 LocalPointer<Calendar> cal(Calendar::createInstance(zone.orphan(), locale, status)); 4388 if (U_FAILURE(status)) { 4389 dataerrln("Calendar::createInstance fails for locale %s, status %s", itemPtr->localeID, u_errorName(status)); 4390 continue; 4391 } 4392 cal->setTime(date, status); 4393 if (U_FAILURE(status)) { 4394 dataerrln("Calendar::setTime fails for locale %s, date %.1f, status %s", itemPtr->localeID, date, u_errorName(status)); 4395 continue; 4396 } 4397 LocalPointer<SimpleDateFormat> sdfmt(static_cast<SimpleDateFormat *>(DateFormat::createDateInstance(itemPtr->style, locale))); 4398 if (sdfmt.isNull()) { 4399 dataerrln("DateFormat::createDateInstance fails for locale %s", itemPtr->localeID); 4400 continue; 4401 } 4402 UnicodeString getFormat; 4403 sdfmt->format(*(cal.getAlias()), getFormat, NULL, status); 4404 if (U_FAILURE(status)) { 4405 errln("DateFormat::format fails for locale %s, status %s", itemPtr->localeID, u_errorName(status)); 4406 continue; 4407 } 4408 if (getFormat.compare(itemPtr->expectFormat) != 0) { 4409 itemPtr->expectFormat.extract(0, itemPtr->expectFormat.length(), bExpected, kBBufMax); 4410 getFormat.extract(0, getFormat.length(), bResult, kBBufMax); 4411 errln("DateFormat::format for locale %s, expected \"%s\", got \"%s\"", itemPtr->localeID, bExpected, bResult); 4412 } 4413 UnicodeString getPattern; 4414 sdfmt->toPattern(getPattern); 4415 if (getPattern.compare(itemPtr->expectPattern) != 0) { 4416 itemPtr->expectPattern.extract(0, itemPtr->expectPattern.length(), bExpected, kBBufMax); 4417 getPattern.extract(0, getPattern.length(), bResult, kBBufMax); 4418 errln("DateFormat::toPattern() for locale %s, expected \"%s\", got \"%s\"", itemPtr->localeID, bExpected, bResult); 4419 } 4420 } 4421 } 4422 4423 static const UDate TEST_DATE = 1326585600000.; // 2012-jan-15 4424 4425 void DateFormatTest::TestDotAndAtLeniency() { 4426 // Test for date/time parsing regression with CLDR 22.1/ICU 50 pattern strings. 4427 // For details see http://bugs.icu-project.org/trac/ticket/9789 4428 static const char *locales[] = { "en", "fr" }; 4429 for (int32_t i = 0; i < UPRV_LENGTHOF(locales); ++i) { 4430 Locale locale(locales[i]); 4431 4432 for (DateFormat::EStyle dateStyle = DateFormat::FULL; dateStyle <= DateFormat::SHORT; 4433 dateStyle = static_cast<DateFormat::EStyle>(dateStyle + 1)) { 4434 LocalPointer<DateFormat> dateFormat(DateFormat::createDateInstance(dateStyle, locale)); 4435 4436 for (DateFormat::EStyle timeStyle = DateFormat::FULL; timeStyle <= DateFormat::SHORT; 4437 timeStyle = static_cast<DateFormat::EStyle>(timeStyle + 1)) { 4438 LocalPointer<DateFormat> format(DateFormat::createDateTimeInstance(dateStyle, timeStyle, locale)); 4439 LocalPointer<DateFormat> timeFormat(DateFormat::createTimeInstance(timeStyle, locale)); 4440 UnicodeString formattedString; 4441 if (format.isNull()) { 4442 dataerrln("Unable to create DateFormat"); 4443 continue; 4444 } 4445 format->format(TEST_DATE, formattedString); 4446 4447 if (!showParse(*format, formattedString)) { 4448 errln(UnicodeString(" with date-time: dateStyle=") + dateStyle + " timeStyle=" + timeStyle); 4449 } 4450 4451 UnicodeString ds, ts; 4452 formattedString = dateFormat->format(TEST_DATE, ds) + " " + timeFormat->format(TEST_DATE, ts); 4453 if (!showParse(*format, formattedString)) { 4454 errln(UnicodeString(" with date sp sp time: dateStyle=") + dateStyle + " timeStyle=" + timeStyle); 4455 } 4456 if (formattedString.indexOf("n ") >= 0) { // will add "." after the end of text ending in 'n', like Jan. 4457 UnicodeString plusDot(formattedString); 4458 plusDot.findAndReplace("n ", "n. ").append("."); 4459 if (!showParse(*format, plusDot)) { 4460 errln(UnicodeString(" with date plus-dot time: dateStyle=") + dateStyle + " timeStyle=" + timeStyle); 4461 } 4462 } 4463 if (formattedString.indexOf(". ") >= 0) { // will subtract "." at the end of strings. 4464 UnicodeString minusDot(formattedString); 4465 minusDot.findAndReplace(". ", " "); 4466 if (!showParse(*format, minusDot)) { 4467 errln(UnicodeString(" with date minus-dot time: dateStyle=") + dateStyle + " timeStyle=" + timeStyle); 4468 } 4469 } 4470 } 4471 } 4472 } 4473 } 4474 4475 UBool DateFormatTest::showParse(DateFormat &format, const UnicodeString &formattedString) { 4476 ParsePosition parsePosition; 4477 UDate parsed = format.parse(formattedString, parsePosition); 4478 UBool ok = TEST_DATE == parsed && parsePosition.getIndex() == formattedString.length(); 4479 UnicodeString pattern; 4480 static_cast<SimpleDateFormat &>(format).toPattern(pattern); 4481 if (ok) { 4482 logln(pattern + " parsed: " + formattedString); 4483 } else { 4484 errln(pattern + " fails to parse: " + formattedString); 4485 } 4486 return ok; 4487 } 4488 4489 4490 typedef struct { 4491 const char * locale; 4492 UBool leniency; 4493 UnicodeString parseString; 4494 UnicodeString pattern; 4495 UnicodeString expectedResult; // empty string indicates expected error 4496 } TestDateFormatLeniencyItem; 4497 4498 void DateFormatTest::TestDateFormatLeniency() { 4499 // For details see http://bugs.icu-project.org/trac/ticket/10261 4500 4501 const UDate july022008 = 1215000001979.0; 4502 const TestDateFormatLeniencyItem items[] = { 4503 //locale leniency parse String pattern expected result 4504 { "en", true, UnicodeString("2008-07 02"), UnicodeString("yyyy-LLLL dd"), UnicodeString("2008-July 02") }, 4505 { "en", false, UnicodeString("2008-07 02"), UnicodeString("yyyy-LLLL dd"), UnicodeString("") }, 4506 { "en", true, UnicodeString("2008-Jan 02"), UnicodeString("yyyy-LLL. dd"), UnicodeString("2008-Jan. 02") }, 4507 { "en", false, UnicodeString("2008-Jan 02"), UnicodeString("yyyy-LLL. dd"), UnicodeString("") }, 4508 { "en", true, UnicodeString("2008-Jan--02"), UnicodeString("yyyy-MMM' -- 'dd"), UnicodeString("2008-Jan -- 02") }, 4509 { "en", false, UnicodeString("2008-Jan--02"), UnicodeString("yyyy-MMM' -- 'dd"), UnicodeString("") }, 4510 // terminator 4511 { NULL, true, UnicodeString(""), UnicodeString(""), UnicodeString("") } 4512 }; 4513 UErrorCode status = U_ZERO_ERROR; 4514 LocalPointer<Calendar> cal(Calendar::createInstance(status)); 4515 if (U_FAILURE(status)) { 4516 dataerrln(UnicodeString("FAIL: Unable to create Calendar for default timezone and locale.")); 4517 return; 4518 } 4519 cal->setTime(july022008, status); 4520 const TestDateFormatLeniencyItem * itemPtr; 4521 LocalPointer<SimpleDateFormat> sdmft; 4522 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) { 4523 4524 Locale locale = Locale::createFromName(itemPtr->locale); 4525 status = U_ZERO_ERROR; 4526 ParsePosition pos(0); 4527 sdmft.adoptInsteadAndCheckErrorCode(new SimpleDateFormat(itemPtr->pattern, locale, status), status); 4528 if (U_FAILURE(status)) { 4529 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 4530 continue; 4531 } 4532 sdmft->setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, itemPtr->leniency, status). 4533 setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, itemPtr->leniency, status). 4534 setBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, itemPtr->leniency, status); 4535 UDate d = sdmft->parse(itemPtr->parseString, pos); 4536 4537 if(itemPtr->expectedResult.length() == 0) { 4538 if(pos.getErrorIndex() != -1) { 4539 continue; 4540 } else { 4541 errln("error: unexpected parse success - " + itemPtr->parseString + 4542 " - pattern " + itemPtr->pattern + 4543 " - error index " + pos.getErrorIndex() + 4544 " - leniency " + itemPtr->leniency); 4545 continue; 4546 } 4547 } 4548 if(pos.getErrorIndex() != -1) { 4549 errln("error: parse error for string - " + itemPtr->parseString + 4550 " - pattern " + itemPtr->pattern + 4551 " - idx " + pos.getIndex() + 4552 " - error index "+pos.getErrorIndex() + 4553 " - leniency " + itemPtr->leniency); 4554 continue; 4555 } 4556 4557 UnicodeString formatResult(""); 4558 sdmft->format(d, formatResult); 4559 if(formatResult.compare(itemPtr->expectedResult) != 0) { 4560 errln("error: unexpected format result. pattern["+itemPtr->pattern+"] expected[" + itemPtr->expectedResult + "] but result was[" + formatResult + "]"); 4561 continue; 4562 } else { 4563 logln("formatted results match! - " + formatResult); 4564 } 4565 4566 } 4567 } 4568 4569 4570 typedef struct { 4571 UBool leniency; 4572 UnicodeString parseString; 4573 UnicodeString pattern; 4574 UnicodeString expectedResult; // empty string indicates expected error 4575 } TestMultiPatternMatchItem; 4576 4577 void DateFormatTest::TestParseMultiPatternMatch() { 4578 // For details see http://bugs.icu-project.org/trac/ticket/10336 4579 const TestMultiPatternMatchItem items[] = { 4580 // leniency parse String pattern expected result 4581 {true, UnicodeString("2013-Sep 13"), UnicodeString("yyyy-MMM dd"), UnicodeString("2013-Sep 13")}, 4582 {true, UnicodeString("2013-September 14"), UnicodeString("yyyy-MMM dd"), UnicodeString("2013-Sep 14")}, 4583 {false, UnicodeString("2013-September 15"), UnicodeString("yyyy-MMM dd"), UnicodeString("")}, 4584 {false, UnicodeString("2013-September 16"), UnicodeString("yyyy-MMMM dd"), UnicodeString("2013-September 16")}, 4585 {true, UnicodeString("2013-Sep 17"), UnicodeString("yyyy-LLL dd"), UnicodeString("2013-Sep 17")}, 4586 {true, UnicodeString("2013-September 18"), UnicodeString("yyyy-LLL dd"), UnicodeString("2013-Sep 18")}, 4587 {false, UnicodeString("2013-September 19"), UnicodeString("yyyy-LLL dd"), UnicodeString("")}, 4588 {false, UnicodeString("2013-September 20"), UnicodeString("yyyy-LLLL dd"), UnicodeString("2013-September 20")}, 4589 {true, UnicodeString("2013 Sat Sep 21"), UnicodeString("yyyy EEE MMM dd"), UnicodeString("2013 Sat Sep 21")}, 4590 {true, UnicodeString("2013 Sunday Sep 22"), UnicodeString("yyyy EEE MMM dd"), UnicodeString("2013 Sun Sep 22")}, 4591 {false, UnicodeString("2013 Monday Sep 23"), UnicodeString("yyyy EEE MMM dd"), UnicodeString("")}, 4592 {false, UnicodeString("2013 Tuesday Sep 24"), UnicodeString("yyyy EEEE MMM dd"), UnicodeString("2013 Tuesday Sep 24")}, 4593 {true, UnicodeString("2013 Wed Sep 25"), UnicodeString("yyyy eee MMM dd"), UnicodeString("2013 Wed Sep 25")}, 4594 {true, UnicodeString("2013 Thu Sep 26"), UnicodeString("yyyy eee MMM dd"), UnicodeString("2013 Thu Sep 26")}, 4595 {false, UnicodeString("2013 Friday Sep 27"), UnicodeString("yyyy eee MMM dd"), UnicodeString("")}, 4596 {false, UnicodeString("2013 Saturday Sep 28"), UnicodeString("yyyy eeee MMM dd"), UnicodeString("2013 Saturday Sep 28")}, 4597 {true, UnicodeString("2013 Sun Sep 29"), UnicodeString("yyyy ccc MMM dd"), UnicodeString("2013 Sun Sep 29")}, 4598 {true, UnicodeString("2013 Monday Sep 30"), UnicodeString("yyyy ccc MMM dd"), UnicodeString("2013 Mon Sep 30")}, 4599 {false, UnicodeString("2013 Sunday Oct 13"), UnicodeString("yyyy ccc MMM dd"), UnicodeString("")}, 4600 {false, UnicodeString("2013 Monday Oct 14"), UnicodeString("yyyy cccc MMM dd"), UnicodeString("2013 Monday Oct 14")}, 4601 {true, UnicodeString("2013 Oct 15 Q4"), UnicodeString("yyyy MMM dd QQQ"), UnicodeString("2013 Oct 15 Q4")}, 4602 {true, UnicodeString("2013 Oct 16 4th quarter"), UnicodeString("yyyy MMM dd QQQ"), UnicodeString("2013 Oct 16 Q4")}, 4603 {false, UnicodeString("2013 Oct 17 4th quarter"), UnicodeString("yyyy MMM dd QQQ"), UnicodeString("")}, 4604 {false, UnicodeString("2013 Oct 18 Q4"), UnicodeString("yyyy MMM dd QQQ"), UnicodeString("2013 Oct 18 Q4")}, 4605 {true, UnicodeString("2013 Oct 19 Q4"), UnicodeString("yyyy MMM dd qqqq"), UnicodeString("2013 Oct 19 4th quarter")}, 4606 {true, UnicodeString("2013 Oct 20 4th quarter"), UnicodeString("yyyy MMM dd qqqq"), UnicodeString("2013 Oct 20 4th quarter")}, 4607 {false, UnicodeString("2013 Oct 21 Q4"), UnicodeString("yyyy MMM dd qqqq"), UnicodeString("")}, 4608 {false, UnicodeString("2013 Oct 22 4th quarter"), UnicodeString("yyyy MMM dd qqqq"), UnicodeString("2013 Oct 22 4th quarter")}, 4609 {false, UnicodeString("--end--"), UnicodeString(""), UnicodeString("")}, 4610 }; 4611 4612 UErrorCode status = U_ZERO_ERROR; 4613 LocalPointer<Calendar> cal(Calendar::createInstance(status)); 4614 if (U_FAILURE(status)) { 4615 dataerrln(UnicodeString("FAIL: Unable to create Calendar for default timezone and locale.")); 4616 return; 4617 } 4618 const TestMultiPatternMatchItem * itemPtr; 4619 DateFormat* sdmft = DateFormat::createDateInstance(); 4620 if (sdmft == NULL) { 4621 dataerrln(UnicodeString("FAIL: Unable to create DateFormat")); 4622 return; 4623 } 4624 for (itemPtr = items; itemPtr->parseString != "--end--"; itemPtr++ ) { 4625 status = U_ZERO_ERROR; 4626 ParsePosition pos(0); 4627 ((SimpleDateFormat*) sdmft)->applyPattern(itemPtr->pattern); 4628 if (U_FAILURE(status)) { 4629 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 4630 continue; 4631 } 4632 sdmft->setBooleanAttribute(UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH, itemPtr->leniency, status); 4633 UDate d = sdmft->parse(itemPtr->parseString, pos); 4634 4635 if(itemPtr->expectedResult.length() == 0) { 4636 if(pos.getErrorIndex() != -1) { 4637 continue; 4638 } else { 4639 errln("error: unexpected parse success - " + itemPtr->parseString + 4640 " - error index " + pos.getErrorIndex() + 4641 " - leniency " + itemPtr->leniency); 4642 continue; 4643 } 4644 } 4645 if(pos.getErrorIndex() != -1) { 4646 errln("error: parse error for string - " +itemPtr->parseString + " -- idx["+pos.getIndex()+"] errIdx["+pos.getErrorIndex()+"]"); 4647 continue; 4648 } 4649 4650 UnicodeString formatResult(""); 4651 sdmft->format(d, formatResult); 4652 if(formatResult.compare(itemPtr->expectedResult) != 0) { 4653 errln("error: unexpected format result. expected[" + itemPtr->expectedResult + "] but result was[" + formatResult + "]"); 4654 } else { 4655 logln("formatted results match! - " + formatResult); 4656 } 4657 } 4658 delete sdmft; 4659 } 4660 4661 void DateFormatTest::TestParseLeniencyAPIs() { 4662 UErrorCode status = U_ZERO_ERROR; 4663 LocalPointer<DateFormat> dateFormat(DateFormat::createDateInstance()); 4664 DateFormat *fmt = dateFormat.getAlias(); 4665 if (fmt == NULL) { 4666 dataerrln("Failed calling dateFormat.getAlias()"); 4667 return; 4668 } 4669 4670 assertTrue("isLenient default", fmt->isLenient()); 4671 assertTrue("isCalendarLenient default", fmt->isCalendarLenient()); 4672 assertTrue("ALLOW_WHITESPACE default", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4673 assertTrue("ALLOW_NUMERIC default", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4674 assertTrue("PARTIAL_MATCH default", fmt->getBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, status)); 4675 assertTrue("MULTIPLE_PATTERNS default", fmt->getBooleanAttribute(UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH, status)); 4676 4677 // Set calendar to strict 4678 fmt->setCalendarLenient(FALSE); 4679 4680 assertFalse("isLeninent after setCalendarLenient(FALSE)", fmt->isLenient()); 4681 assertFalse("isCalendarLenient after setCalendarLenient(FALSE)", fmt->isCalendarLenient()); 4682 assertTrue("ALLOW_WHITESPACE after setCalendarLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4683 assertTrue("ALLOW_NUMERIC after setCalendarLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4684 4685 // Set to strict 4686 fmt->setLenient(FALSE); 4687 4688 assertFalse("isLeninent after setLenient(FALSE)", fmt->isLenient()); 4689 assertFalse("isCalendarLenient after setLenient(FALSE)", fmt->isCalendarLenient()); 4690 assertFalse("ALLOW_WHITESPACE after setLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4691 assertFalse("ALLOW_NUMERIC after setLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4692 // These two boolean attributes are NOT affected according to the API specification 4693 assertTrue("PARTIAL_MATCH after setLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, status)); 4694 assertTrue("MULTIPLE_PATTERNS after setLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH, status)); 4695 4696 // Allow white space leniency 4697 fmt->setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, TRUE, status); 4698 4699 assertFalse("isLeninent after ALLOW_WHITESPACE/TRUE", fmt->isLenient()); 4700 assertFalse("isCalendarLenient after ALLOW_WHITESPACE/TRUE", fmt->isCalendarLenient()); 4701 assertTrue("ALLOW_WHITESPACE after ALLOW_WHITESPACE/TRUE", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4702 assertFalse("ALLOW_NUMERIC after ALLOW_WHITESPACE/TRUE", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4703 4704 // Set to lenient 4705 fmt->setLenient(TRUE); 4706 4707 assertTrue("isLenient after setLenient(TRUE)", fmt->isLenient()); 4708 assertTrue("isCalendarLenient after setLenient(TRUE)", fmt->isCalendarLenient()); 4709 assertTrue("ALLOW_WHITESPACE after setLenient(TRUE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4710 assertTrue("ALLOW_NUMERIC after setLenient(TRUE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4711 } 4712 4713 void DateFormatTest::TestNumberFormatOverride() { 4714 UErrorCode status = U_ZERO_ERROR; 4715 UnicodeString fields = (UnicodeString) "M"; 4716 4717 LocalPointer<SimpleDateFormat> fmt; 4718 fmt.adoptInsteadAndCheckErrorCode(new SimpleDateFormat((UnicodeString)"MM d", status), status); 4719 if (!assertSuccess("SimpleDateFormat with pattern MM d", status)) { 4720 return; 4721 } 4722 4723 4724 for(int i=0; i<3; i++){ 4725 NumberFormat* check_nf = NumberFormat::createInstance(Locale("en_US"), status); 4726 assertSuccess("NumberFormat en_US", status); 4727 fmt->adoptNumberFormat(fields, check_nf, status); 4728 assertSuccess("adoptNumberFormat check_nf", status); 4729 4730 const NumberFormat* get_nf = fmt->getNumberFormatForField((UChar)0x004D /*'M'*/); 4731 if (get_nf != check_nf) errln("FAIL: getter and setter do not work"); 4732 } 4733 NumberFormat* check_nf = NumberFormat::createInstance(Locale("en_US"), status); 4734 assertSuccess("NumberFormat en_US", status); 4735 fmt->adoptNumberFormat(check_nf); // make sure using the same NF will not crash 4736 4737 const char * DATA [][2] = { 4738 { "", "\\u521D\\u516D \\u5341\\u4E94"}, 4739 { "M", "\\u521D\\u516D 15"}, 4740 { "Mo", "\\u521D\\u516D 15"}, 4741 { "Md", "\\u521D\\u516D \\u5341\\u4E94"}, 4742 { "MdMMd", "\\u521D\\u516D \\u5341\\u4E94"}, 4743 { "mixed", "\\u521D\\u516D \\u5341\\u4E94"} 4744 }; 4745 4746 UDate test_date = date(97, 6 - 1, 15); 4747 4748 for(int i=0; i < UPRV_LENGTHOF(DATA); i++){ 4749 fields = DATA[i][0]; 4750 4751 LocalPointer<SimpleDateFormat> fmt; 4752 fmt.adoptInsteadAndCheckErrorCode(new SimpleDateFormat((UnicodeString)"MM d", status), status); 4753 assertSuccess("SimpleDateFormat with pattern MM d", status); 4754 NumberFormat* overrideNF = NumberFormat::createInstance(Locale::createFromName("zh@numbers=hanidays"),status); 4755 assertSuccess("NumberFormat zh@numbers=hanidays", status); 4756 4757 if (fields == (UnicodeString) "") { // use the one w/o fields 4758 fmt->adoptNumberFormat(overrideNF); 4759 } else if (fields == (UnicodeString) "mixed") { // set 1 field at first but then full override, both(M & d) should be override 4760 NumberFormat* singleOverrideNF = NumberFormat::createInstance(Locale::createFromName("en@numbers=hebr"),status); 4761 assertSuccess("NumberFormat en@numbers=hebr", status); 4762 4763 fields = (UnicodeString) "M"; 4764 fmt->adoptNumberFormat(fields, singleOverrideNF, status); 4765 assertSuccess("adoptNumberFormat singleOverrideNF", status); 4766 4767 fmt->adoptNumberFormat(overrideNF); 4768 } else if (fields == (UnicodeString) "Mo"){ // o is invlid field 4769 fmt->adoptNumberFormat(fields, overrideNF, status); 4770 if(status == U_INVALID_FORMAT_ERROR) { 4771 status = U_ZERO_ERROR; 4772 continue; 4773 } 4774 } else { 4775 fmt->adoptNumberFormat(fields, overrideNF, status); 4776 assertSuccess("adoptNumberFormat overrideNF", status); 4777 } 4778 4779 UnicodeString result; 4780 FieldPosition pos(FieldPosition::DONT_CARE); 4781 fmt->format(test_date,result, pos); 4782 4783 UnicodeString expected = ((UnicodeString)DATA[i][1]).unescape();; 4784 4785 if (result != expected) 4786 errln("FAIL: Expected " + expected + " get: " + result); 4787 } 4788 } 4789 4790 void DateFormatTest::TestCreateInstanceForSkeleton() { 4791 UErrorCode status = U_ZERO_ERROR; 4792 LocalPointer<DateFormat> fmt(DateFormat::createInstanceForSkeleton( 4793 "yMMMMd", "en", status)); 4794 if (!assertSuccess("Create with pattern yMMMMd", status)) { 4795 return; 4796 } 4797 UnicodeString result; 4798 FieldPosition pos(FieldPosition::DONT_CARE); 4799 fmt->format(date(98, 5-1, 25), result, pos); 4800 assertEquals("format yMMMMd", "May 25, 1998", result); 4801 fmt.adoptInstead(DateFormat::createInstanceForSkeleton( 4802 "yMd", "en", status)); 4803 if (!assertSuccess("Create with pattern yMd", status)) { 4804 return; 4805 } 4806 result.remove(); 4807 fmt->format(date(98, 5-1, 25), result, pos); 4808 assertEquals("format yMd", "5/25/1998", result); 4809 } 4810 4811 void DateFormatTest::TestCreateInstanceForSkeletonDefault() { 4812 UErrorCode status = U_ZERO_ERROR; 4813 Locale savedLocale; 4814 Locale::setDefault(Locale::getUS(), status); 4815 LocalPointer<DateFormat> fmt(DateFormat::createInstanceForSkeleton( 4816 "yMMMd", status)); 4817 Locale::setDefault(savedLocale, status); 4818 if (!assertSuccess("Create with pattern yMMMd", status)) { 4819 return; 4820 } 4821 UnicodeString result; 4822 FieldPosition pos(FieldPosition::DONT_CARE); 4823 fmt->format(date(98, 5-1, 25), result, pos); 4824 assertEquals("format yMMMd", "May 25, 1998", result); 4825 } 4826 4827 void DateFormatTest::TestCreateInstanceForSkeletonWithCalendar() { 4828 UErrorCode status = U_ZERO_ERROR; 4829 LocalPointer<DateFormat> fmt( 4830 DateFormat::createInstanceForSkeleton( 4831 Calendar::createInstance( 4832 TimeZone::createTimeZone("GMT-3:00"), 4833 status), 4834 "yMdHm", "en", status)); 4835 if (!assertSuccess("Create with pattern yMMMMd", status)) { 4836 return; 4837 } 4838 UnicodeString result; 4839 FieldPosition pos(FieldPosition::DONT_CARE); 4840 4841 LocalPointer<Calendar> cal(Calendar::createInstance( 4842 TimeZone::createTimeZone("GMT-7:00"), 4843 status)); 4844 if (!assertSuccess("Creating GMT-7 time zone failed", status)) { 4845 return; 4846 } 4847 cal->clear(); 4848 cal->set(1998, 5-1, 25, 0, 0, 0); 4849 4850 // date format time zone should be 4 hours ahead. 4851 fmt->format(cal->getTime(status), result, pos); 4852 assertEquals("format yMdHm", "5/25/1998, 04:00", result); 4853 assertSuccess("", status); 4854 } 4855 4856 void DateFormatTest::TestDFSCreateForLocaleNonGregorianLocale() { 4857 UErrorCode status = U_ZERO_ERROR; 4858 Locale fa("fa"); 4859 LocalPointer<DateFormatSymbols> sym( 4860 DateFormatSymbols::createForLocale(fa, status)); 4861 if (!assertSuccess("", status)) { 4862 return; 4863 } 4864 4865 // Android: All locales default to Gregorian calendar: 4866 int32_t count; 4867 const UnicodeString *months = sym->getShortMonths(count); 4868 4869 // First persian month. 4870 UnicodeString expected("\\u0698\\u0627\\u0646\\u0648\\u06CC\\u0647\\u0654"); // Android-changed 4871 assertEquals("", expected.unescape(), months[0]); 4872 } 4873 4874 void DateFormatTest::TestDFSCreateForLocaleWithCalendarInLocale() { 4875 UErrorCode status = U_ZERO_ERROR; 4876 Locale en_heb("en@calendar=hebrew"); 4877 LocalPointer<DateFormatSymbols> sym( 4878 DateFormatSymbols::createForLocale(en_heb, status)); 4879 if (!assertSuccess("", status)) { 4880 return; 4881 } 4882 4883 // We should get the months of the hebrew calendar, not the gregorian 4884 // calendar. 4885 int32_t count; 4886 const UnicodeString *months = sym->getShortMonths(count); 4887 4888 // First hebrew month. 4889 UnicodeString expected("Tishri"); 4890 assertEquals("", expected, months[0]); 4891 } 4892 4893 void DateFormatTest::TestChangeCalendar() { 4894 UErrorCode status = U_ZERO_ERROR; 4895 Locale en("en"); 4896 Locale en_heb("en@calendar=hebrew"); 4897 LocalPointer<DateFormat> fmt( 4898 DateFormat::createInstanceForSkeleton("yMMMd", en, status)); 4899 if (!assertSuccess("", status)) { 4900 return; 4901 } 4902 fmt->adoptCalendar(Calendar::createInstance(en_heb, status)); 4903 if (!assertSuccess("", status)) { 4904 return; 4905 } 4906 UnicodeString result; 4907 FieldPosition pos(FieldPosition::DONT_CARE); 4908 fmt->format(date(98, 5-1, 25), result, pos); 4909 assertEquals("format yMMMd", "Iyar 29, 5758", result); 4910 } 4911 4912 void DateFormatTest::TestPatternFromSkeleton() { 4913 static const struct { 4914 const Locale& locale; 4915 const char* const skeleton; 4916 const char* const pattern; 4917 } TESTDATA[] = { 4918 // Ticket #11985 4919 {Locale::getEnglish(), "jjmm", "h:mm a"}, 4920 {Locale::getEnglish(), "JJmm", "hh:mm"}, 4921 {Locale::getGerman(), "jjmm", "HH:mm"}, 4922 {Locale::getGerman(), "JJmm", "HH:mm"} 4923 }; 4924 4925 for (size_t i = 0; i < UPRV_LENGTHOF(TESTDATA); i++) { 4926 UErrorCode status = U_ZERO_ERROR; 4927 LocalPointer<DateFormat> fmt( 4928 DateFormat::createInstanceForSkeleton( 4929 TESTDATA[i].skeleton, TESTDATA[i].locale, status)); 4930 if (!assertSuccess("createInstanceForSkeleton", status)) { 4931 return; 4932 } 4933 UnicodeString pattern; 4934 static_cast<const SimpleDateFormat*>(fmt.getAlias())->toPattern(pattern); 4935 assertEquals("Format pattern", TESTDATA[i].pattern, pattern); 4936 } 4937 } 4938 4939 void DateFormatTest::TestAmPmMidnightNoon() { 4940 // Some times on 2015-11-13 (UTC+0). 4941 UDate k000000 = 1447372800000.0; 4942 UDate k000030 = 1447372830000.0; 4943 UDate k003000 = 1447374600000.0; 4944 UDate k060000 = 1447394400000.0; 4945 UDate k120000 = 1447416000000.0; 4946 UDate k180000 = 1447437600000.0; 4947 4948 UErrorCode errorCode = U_ZERO_ERROR; 4949 SimpleDateFormat sdf(UnicodeString(), errorCode); 4950 if (U_FAILURE(errorCode)) { 4951 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 4952 return; 4953 } 4954 const TimeZone *tz = TimeZone::getGMT(); 4955 sdf.setTimeZone(*tz); 4956 UnicodeString out; 4957 4958 // Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day. 4959 // For ICU 57 output of "midnight" is temporarily suppressed. 4960 4961 // Short. 4962 sdf.applyPattern(UnicodeString("hh:mm:ss bbb")); 4963 4964 // assertEquals("hh:mm:ss bbb | 00:00:00", "12:00:00 midnight", sdf.format(k000000, out.remove())); 4965 assertEquals("hh:mm:ss bbb | 00:00:00", "12:00:00 AM", sdf.format(k000000, out.remove())); 4966 assertEquals("hh:mm:ss bbb | 00:00:30", "12:00:30 AM", sdf.format(k000030, out.remove())); 4967 assertEquals("hh:mm:ss bbb | 00:30:00", "12:30:00 AM", sdf.format(k003000, out.remove())); 4968 assertEquals("hh:mm:ss bbb | 06:00:00", "06:00:00 AM", sdf.format(k060000, out.remove())); 4969 assertEquals("hh:mm:ss bbb | 12:00:00", "12:00:00 noon", sdf.format(k120000, out.remove())); 4970 assertEquals("hh:mm:ss bbb | 18:00:00", "06:00:00 PM", sdf.format(k180000, out.remove())); 4971 4972 sdf.applyPattern(UnicodeString("hh:mm bbb")); 4973 4974 // assertEquals("hh:mm bbb | 00:00:00", "12:00 midnight", sdf.format(k000000, out.remove())); 4975 assertEquals("hh:mm bbb | 00:00:00", "12:00 AM", sdf.format(k000000, out.remove())); 4976 // assertEquals("hh:mm bbb | 00:00:30", "12:00 midnight", sdf.format(k000030, out.remove())); 4977 assertEquals("hh:mm bbb | 00:00:30", "12:00 AM", sdf.format(k000030, out.remove())); 4978 assertEquals("hh:mm bbb | 00:30:00", "12:30 AM", sdf.format(k003000, out.remove())); 4979 4980 sdf.applyPattern(UnicodeString("hh bbb")); 4981 4982 // assertEquals("hh bbb | 00:00:00", "12 midnight", sdf.format(k000000, out.remove())); 4983 assertEquals("hh bbb | 00:00:00", "12 AM", sdf.format(k000000, out.remove())); 4984 // assertEquals("hh bbb | 00:00:30", "12 midnight", sdf.format(k000030, out.remove())); 4985 assertEquals("hh bbb | 00:00:30", "12 AM", sdf.format(k000030, out.remove())); 4986 // assertEquals("hh bbb | 00:30:00", "12 midnight", sdf.format(k003000, out.remove())); 4987 assertEquals("hh bbb | 00:30:00", "12 AM", sdf.format(k003000, out.remove())); 4988 4989 // Wide. 4990 sdf.applyPattern(UnicodeString("hh:mm:ss bbbb")); 4991 4992 // assertEquals("hh:mm:ss bbbb | 00:00:00", "12:00:00 midnight", sdf.format(k000000, out.remove())); 4993 assertEquals("hh:mm:ss bbbb | 00:00:00", "12:00:00 AM", sdf.format(k000000, out.remove())); 4994 assertEquals("hh:mm:ss bbbb | 00:00:30", "12:00:30 AM", sdf.format(k000030, out.remove())); 4995 assertEquals("hh:mm:ss bbbb | 00:30:00", "12:30:00 AM", sdf.format(k003000, out.remove())); 4996 assertEquals("hh:mm:ss bbbb | 06:00:00", "06:00:00 AM", sdf.format(k060000, out.remove())); 4997 assertEquals("hh:mm:ss bbbb | 12:00:00", "12:00:00 noon", sdf.format(k120000, out.remove())); 4998 assertEquals("hh:mm:ss bbbb | 18:00:00", "06:00:00 PM", sdf.format(k180000, out.remove())); 4999 5000 sdf.applyPattern(UnicodeString("hh:mm bbbb")); 5001 5002 // assertEquals("hh:mm bbbb | 00:00:00", "12:00 midnight", sdf.format(k000000, out.remove())); 5003 assertEquals("hh:mm bbbb | 00:00:00", "12:00 AM", sdf.format(k000000, out.remove())); 5004 // assertEquals("hh:mm bbbb | 00:00:30", "12:00 midnight", sdf.format(k000030, out.remove())); 5005 assertEquals("hh:mm bbbb | 00:00:30", "12:00 AM", sdf.format(k000030, out.remove())); 5006 assertEquals("hh:mm bbbb | 00:30:00", "12:30 AM", sdf.format(k003000, out.remove())); 5007 5008 sdf.applyPattern(UnicodeString("hh bbbb")); 5009 5010 // assertEquals("hh bbbb | 00:00:00", "12 midnight", sdf.format(k000000, out.remove())); 5011 assertEquals("hh bbbb | 00:00:00", "12 AM", sdf.format(k000000, out.remove())); 5012 // assertEquals("hh bbbb | 00:00:30", "12 midnight", sdf.format(k000030, out.remove())); 5013 assertEquals("hh bbbb | 00:00:30", "12 AM", sdf.format(k000030, out.remove())); 5014 // assertEquals("hh bbbb | 00:30:00", "12 midnight", sdf.format(k003000, out.remove())); 5015 assertEquals("hh bbbb | 00:30:00", "12 AM", sdf.format(k003000, out.remove())); 5016 5017 // Narrow. 5018 sdf.applyPattern(UnicodeString("hh:mm:ss bbbbb")); 5019 5020 // assertEquals("hh:mm:ss bbbbb | 00:00:00", "12:00:00 mi", sdf.format(k000000, out.remove())); 5021 assertEquals("hh:mm:ss bbbbb | 00:00:00", "12:00:00 a", sdf.format(k000000, out.remove())); 5022 assertEquals("hh:mm:ss bbbbb | 00:00:30", "12:00:30 a", sdf.format(k000030, out.remove())); 5023 assertEquals("hh:mm:ss bbbbb | 00:30:00", "12:30:00 a", sdf.format(k003000, out.remove())); 5024 assertEquals("hh:mm:ss bbbbb | 06:00:00", "06:00:00 a", sdf.format(k060000, out.remove())); 5025 assertEquals("hh:mm:ss bbbbb | 12:00:00", "12:00:00 n", sdf.format(k120000, out.remove())); 5026 assertEquals("hh:mm:ss bbbbb | 18:00:00", "06:00:00 p", sdf.format(k180000, out.remove())); 5027 5028 sdf.applyPattern(UnicodeString("hh:mm bbbbb")); 5029 5030 // assertEquals("hh:mm bbbbb | 00:00:00", "12:00 mi", sdf.format(k000000, out.remove())); 5031 assertEquals("hh:mm bbbbb | 00:00:00", "12:00 a", sdf.format(k000000, out.remove())); 5032 // assertEquals("hh:mm bbbbb | 00:00:30", "12:00 mi", sdf.format(k000030, out.remove())); 5033 assertEquals("hh:mm bbbbb | 00:00:30", "12:00 a", sdf.format(k000030, out.remove())); 5034 assertEquals("hh:mm bbbbb | 00:30:00", "12:30 a", sdf.format(k003000, out.remove())); 5035 5036 sdf.applyPattern(UnicodeString("hh bbbbb")); 5037 5038 // assertEquals("hh bbbbb | 00:00:00", "12 mi", sdf.format(k000000, out.remove())); 5039 assertEquals("hh bbbbb | 00:00:00", "12 a", sdf.format(k000000, out.remove())); 5040 // assertEquals("hh bbbbb | 00:00:30", "12 mi", sdf.format(k000030, out.remove())); 5041 assertEquals("hh bbbbb | 00:00:30", "12 a", sdf.format(k000030, out.remove())); 5042 // assertEquals("hh bbbbb | 00:30:00", "12 mi", sdf.format(k003000, out.remove())); 5043 assertEquals("hh bbbbb | 00:30:00", "12 a", sdf.format(k003000, out.remove())); 5044 } 5045 5046 void DateFormatTest::TestFlexibleDayPeriod() { 5047 // Some times on 2015-11-13 (UTC+0). 5048 UDate k000000 = 1447372800000.0; 5049 UDate k000030 = 1447372830000.0; 5050 UDate k003000 = 1447374600000.0; 5051 UDate k060000 = 1447394400000.0; 5052 UDate k120000 = 1447416000000.0; 5053 UDate k180000 = 1447437600000.0; 5054 5055 UErrorCode errorCode = U_ZERO_ERROR; 5056 SimpleDateFormat sdf(UnicodeString(), errorCode); 5057 if (U_FAILURE(errorCode)) { 5058 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 5059 return; 5060 } 5061 const TimeZone *tz = TimeZone::getGMT(); 5062 sdf.setTimeZone(*tz); 5063 UnicodeString out; 5064 5065 // Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day. 5066 // For ICU 57 output of "midnight" is temporarily suppressed. 5067 5068 // Short. 5069 sdf.applyPattern(UnicodeString("hh:mm:ss BBB")); 5070 5071 // assertEquals("hh:mm:ss BBB | 00:00:00", "12:00:00 midnight", sdf.format(k000000, out.remove())); 5072 assertEquals("hh:mm:ss BBB | 00:00:00", "12:00:00 at night", sdf.format(k000000, out.remove())); 5073 assertEquals("hh:mm:ss BBB | 00:00:30", "12:00:30 at night", sdf.format(k000030, out.remove())); 5074 assertEquals("hh:mm:ss BBB | 00:30:00", "12:30:00 at night", sdf.format(k003000, out.remove())); 5075 assertEquals("hh:mm:ss BBB | 06:00:00", "06:00:00 in the morning", sdf.format(k060000, out.remove())); 5076 assertEquals("hh:mm:ss BBB | 12:00:00", "12:00:00 noon", sdf.format(k120000, out.remove())); 5077 assertEquals("hh:mm:ss BBB | 18:00:00", "06:00:00 in the evening", sdf.format(k180000, out.remove())); 5078 5079 sdf.applyPattern(UnicodeString("hh:mm BBB")); 5080 5081 // assertEquals("hh:mm BBB | 00:00:00", "12:00 midnight", sdf.format(k000000, out.remove())); 5082 assertEquals("hh:mm BBB | 00:00:00", "12:00 at night", sdf.format(k000000, out.remove())); 5083 // assertEquals("hh:mm BBB | 00:00:30", "12:00 midnight", sdf.format(k000030, out.remove())); 5084 assertEquals("hh:mm BBB | 00:00:00", "12:00 at night", sdf.format(k000000, out.remove())); 5085 assertEquals("hh:mm BBB | 00:30:00", "12:30 at night", sdf.format(k003000, out.remove())); 5086 5087 sdf.applyPattern(UnicodeString("hh BBB")); 5088 5089 // assertEquals("hh BBB | 00:00:00", "12 midnight", sdf.format(k000000, out.remove())); 5090 assertEquals("hh BBB | 00:00:30", "12 at night", sdf.format(k000030, out.remove())); 5091 // assertEquals("hh BBB | 00:00:30", "12 midnight", sdf.format(k000030, out.remove())); 5092 assertEquals("hh BBB | 00:00:30", "12 at night", sdf.format(k000030, out.remove())); 5093 // assertEquals("hh BBB | 00:30:00", "12 midnight", sdf.format(k003000, out.remove())); 5094 assertEquals("hh BBB | 00:30:00", "12 at night", sdf.format(k003000, out.remove())); 5095 5096 // Wide. 5097 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5098 5099 // assertEquals("hh:mm:ss BBBB | 00:00:00", "12:00:00 midnight", sdf.format(k000000, out.remove())); 5100 assertEquals("hh:mm:ss BBBB | 00:00:00", "12:00:00 at night", sdf.format(k000000, out.remove())); 5101 assertEquals("hh:mm:ss BBBB | 00:00:30", "12:00:30 at night", sdf.format(k000030, out.remove())); 5102 assertEquals("hh:mm:ss BBBB | 00:30:00", "12:30:00 at night", sdf.format(k003000, out.remove())); 5103 assertEquals("hh:mm:ss BBBB | 06:00:00", "06:00:00 in the morning", sdf.format(k060000, out.remove())); 5104 assertEquals("hh:mm:ss BBBB | 12:00:00", "12:00:00 noon", sdf.format(k120000, out.remove())); 5105 assertEquals("hh:mm:ss BBBB | 18:00:00", "06:00:00 in the evening", sdf.format(k180000, out.remove())); 5106 5107 sdf.applyPattern(UnicodeString("hh:mm BBBB")); 5108 5109 // assertEquals("hh:mm BBBB | 00:00:00", "12:00 midnight", sdf.format(k000000, out.remove())); 5110 assertEquals("hh:mm BBBB | 00:00:00", "12:00 at night", sdf.format(k000000, out.remove())); 5111 // assertEquals("hh:mm BBBB | 00:00:30", "12:00 midnight", sdf.format(k000030, out.remove())); 5112 assertEquals("hh:mm BBBB | 00:00:30", "12:00 at night", sdf.format(k000030, out.remove())); 5113 assertEquals("hh:mm BBBB | 00:30:00", "12:30 at night", sdf.format(k003000, out.remove())); 5114 5115 sdf.applyPattern(UnicodeString("hh BBBB")); 5116 5117 // assertEquals("hh BBBB | 00:00:00", "12 midnight", sdf.format(k000000, out.remove())); 5118 assertEquals("hh BBBB | 00:00:00", "12 at night", sdf.format(k000000, out.remove())); 5119 // assertEquals("hh BBBB | 00:00:30", "12 midnight", sdf.format(k000030, out.remove())); 5120 assertEquals("hh BBBB | 00:00:00", "12 at night", sdf.format(k000000, out.remove())); 5121 // assertEquals("hh BBBB | 00:80:00", "12 midnight", sdf.format(k003000, out.remove())); 5122 assertEquals("hh BBBB | 00:00:00", "12 at night", sdf.format(k000000, out.remove())); 5123 5124 // Narrow. 5125 sdf.applyPattern(UnicodeString("hh:mm:ss BBBBB")); 5126 5127 // assertEquals("hh:mm:ss BBBBB | 00:00:00", "12:00:00 mi", sdf.format(k000000, out.remove())); 5128 assertEquals("hh:mm:ss BBBBB | 00:00:00", "12:00:00 at night", sdf.format(k000000, out.remove())); 5129 assertEquals("hh:mm:ss BBBBB | 00:00:30", "12:00:30 at night", sdf.format(k000030, out.remove())); 5130 assertEquals("hh:mm:ss BBBBB | 00:30:00", "12:30:00 at night", sdf.format(k003000, out.remove())); 5131 assertEquals("hh:mm:ss BBBBB | 06:00:00", "06:00:00 in the morning", sdf.format(k060000, out.remove())); 5132 assertEquals("hh:mm:ss BBBBB | 12:00:00", "12:00:00 n", sdf.format(k120000, out.remove())); 5133 assertEquals("hh:mm:ss BBBBB | 18:00:00", "06:00:00 in the evening", sdf.format(k180000, out.remove())); 5134 5135 sdf.applyPattern(UnicodeString("hh:mm BBBBB")); 5136 5137 // assertEquals("hh:mm BBBBB | 00:00:00", "12:00 mi", sdf.format(k000000, out.remove())); 5138 assertEquals("hh:mm BBBBB | 00:00:00", "12:00 at night", sdf.format(k000000, out.remove())); 5139 // assertEquals("hh:mm BBBBB | 00:00:30", "12:00 mi", sdf.format(k000030, out.remove())); 5140 assertEquals("hh:mm BBBBB | 00:00:30", "12:00 at night", sdf.format(k000030, out.remove())); 5141 assertEquals("hh:mm BBBBB | 00:30:00", "12:30 at night", sdf.format(k003000, out.remove())); 5142 5143 sdf.applyPattern(UnicodeString("hh BBBBB")); 5144 5145 // assertEquals("hh BBBBB | 00:00:00", "12 mi", sdf.format(k000000, out.remove())); 5146 assertEquals("hh BBBBB | 00:00:00", "12 at night", sdf.format(k000000, out.remove())); 5147 // assertEquals("hh BBBBB | 00:00:30", "12 mi", sdf.format(k000030, out.remove())); 5148 assertEquals("hh BBBBB | 00:00:30", "12 at night", sdf.format(k000030, out.remove())); 5149 // assertEquals("hh BBBBB | 00:30:00", "12 mi", sdf.format(k003000, out.remove())); 5150 assertEquals("hh BBBBB | 00:30:00", "12 at night", sdf.format(k003000, out.remove())); 5151 } 5152 5153 void DateFormatTest::TestDayPeriodWithLocales() { 5154 // Some times on 2015-11-13 (UTC+0). 5155 UDate k000000 = 1447372800000.0; 5156 UDate k010000 = 1447376400000.0; 5157 UDate k120000 = 1447416000000.0; 5158 UDate k220000 = 1447452000000.0; 5159 5160 UErrorCode errorCode = U_ZERO_ERROR; 5161 const TimeZone *tz = TimeZone::getGMT(); 5162 UnicodeString out; 5163 5164 // Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day. 5165 // For ICU 57 output of "midnight" and its localized equivalentns is temporarily suppressed. 5166 5167 // Locale de has a word for midnight, but not noon. 5168 SimpleDateFormat sdf(UnicodeString(), Locale::getGermany(), errorCode); 5169 if (U_FAILURE(errorCode)) { 5170 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 5171 return; 5172 } 5173 sdf.setTimeZone(*tz); 5174 5175 sdf.applyPattern(UnicodeString("hh:mm:ss bbbb")); 5176 5177 // assertEquals("hh:mm:ss bbbb | 00:00:00 | de", "12:00:00 Mitternacht", 5178 // sdf.format(k000000, out.remove())); 5179 assertEquals("hh:mm:ss bbbb | 00:00:00 | de", "12:00:00 vorm.", 5180 sdf.format(k000000, out.remove())); 5181 assertEquals("hh:mm:ss bbbb | 12:00:00 | de", "12:00:00 nachm.", 5182 sdf.format(k120000, out.remove())); 5183 5184 // Locale ee has a rule that wraps around midnight (21h - 4h). 5185 sdf = SimpleDateFormat(UnicodeString(), Locale("ee"), errorCode); 5186 sdf.setTimeZone(*tz); 5187 5188 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5189 5190 assertEquals("hh:mm:ss BBBB | 22:00:00 | ee", UnicodeString("10:00:00 z\\u00E3").unescape(), 5191 sdf.format(k220000, out.remove())); 5192 assertEquals("hh:mm:ss BBBB | 00:00:00 | ee", UnicodeString("12:00:00 z\\u00E3").unescape(), 5193 sdf.format(k000000, out.remove())); 5194 assertEquals("hh:mm:ss BBBB | 01:00:00 | ee", UnicodeString("01:00:00 z\\u00E3").unescape(), 5195 sdf.format(k010000, out.remove())); 5196 5197 // Locale root has rules for AM/PM only. 5198 sdf = SimpleDateFormat(UnicodeString(), Locale("root"), errorCode); 5199 sdf.setTimeZone(*tz); 5200 5201 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5202 5203 assertEquals("hh:mm:ss BBBB | 00:00:00 | root", "12:00:00 AM", 5204 sdf.format(k000000, out.remove())); 5205 assertEquals("hh:mm:ss BBBB | 12:00:00 | root", "12:00:00 PM", 5206 sdf.format(k120000, out.remove())); 5207 5208 // Empty string should behave exactly as root. 5209 sdf = SimpleDateFormat(UnicodeString(), Locale(""), errorCode); 5210 sdf.setTimeZone(*tz); 5211 5212 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5213 5214 assertEquals("hh:mm:ss BBBB | 00:00:00 | \"\" (root)", "12:00:00 AM", 5215 sdf.format(k000000, out.remove())); 5216 assertEquals("hh:mm:ss BBBB | 12:00:00 | \"\" (root)", "12:00:00 PM", 5217 sdf.format(k120000, out.remove())); 5218 5219 // Locale en_US should fall back to en. 5220 sdf = SimpleDateFormat(UnicodeString(), Locale("en_US"), errorCode); 5221 sdf.setTimeZone(*tz); 5222 5223 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5224 5225 // assertEquals("hh:mm:ss BBBB | 00:00:00 | en_US", "12:00:00 midnight", 5226 // sdf.format(k000000, out.remove())); 5227 assertEquals("hh:mm:ss BBBB | 00:00:00 | en_US", "12:00:00 at night", 5228 sdf.format(k000000, out.remove())); 5229 assertEquals("hh:mm:ss BBBB | 01:00:00 | en_US", "01:00:00 at night", 5230 sdf.format(k010000, out.remove())); 5231 assertEquals("hh:mm:ss BBBB | 12:00:00 | en_US", "12:00:00 noon", 5232 sdf.format(k120000, out.remove())); 5233 5234 // Locale es_CO should not fall back to es and should have a 5235 // different string for 1 in the morning. 5236 // (es_CO: "de la manana" (first n has a tilde) vs. es: "de la madrugada") 5237 sdf = SimpleDateFormat(UnicodeString(), Locale("es_CO"), errorCode); 5238 sdf.setTimeZone(*tz); 5239 5240 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5241 assertEquals("hh:mm:ss BBBB | 01:00:00 | es_CO", UnicodeString("01:00:00 de la ma\\u00F1ana").unescape(), 5242 sdf.format(k010000, out.remove())); 5243 5244 sdf = SimpleDateFormat(UnicodeString(), Locale("es"), errorCode); 5245 sdf.setTimeZone(*tz); 5246 5247 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5248 assertEquals("hh:mm:ss BBBB | 01:00:00 | es", "01:00:00 de la madrugada", 5249 sdf.format(k010000, out.remove())); 5250 } 5251 5252 void DateFormatTest::TestMinuteSecondFieldsInOddPlaces() { 5253 // Some times on 2015-11-13 (UTC+0). 5254 UDate k000000 = 1447372800000.0; 5255 UDate k000030 = 1447372830000.0; 5256 UDate k003000 = 1447374600000.0; 5257 UDate k060030 = 1447394430000.0; 5258 UDate k063000 = 1447396200000.0; 5259 5260 UErrorCode errorCode = U_ZERO_ERROR; 5261 const TimeZone *tz = TimeZone::getGMT(); 5262 UnicodeString out; 5263 5264 // Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day. 5265 // For ICU 57 output of "midnight" is temporarily suppressed. 5266 5267 // Seconds field is not present. 5268 5269 // Apply pattern through constructor to make sure parsePattern() is called during initialization. 5270 SimpleDateFormat sdf(UnicodeString("hh:mm 'ss' bbbb"), errorCode); 5271 if (U_FAILURE(errorCode)) { 5272 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 5273 return; 5274 } 5275 sdf.setTimeZone(*tz); 5276 5277 // assertEquals("hh:mm 'ss' bbbb | 00:00:30", "12:00 ss midnight", 5278 // sdf.format(k000030, out.remove())); 5279 assertEquals("hh:mm 'ss' bbbb | 00:00:30", "12:00 ss AM", 5280 sdf.format(k000030, out.remove())); 5281 assertEquals("hh:mm 'ss' bbbb | 06:00:30", "06:00 ss AM", 5282 sdf.format(k060030, out.remove())); 5283 5284 sdf.applyPattern(UnicodeString("hh:mm 'ss' BBBB")); 5285 5286 // assertEquals("hh:mm 'ss' BBBB | 00:00:30", "12:00 ss midnight", 5287 // sdf.format(k000030, out.remove())); 5288 assertEquals("hh:mm 'ss' BBBB | 00:00:30", "12:00 ss at night", 5289 sdf.format(k000030, out.remove())); 5290 assertEquals("hh:mm 'ss' BBBB | 06:00:30", "06:00 ss in the morning", 5291 sdf.format(k060030, out.remove())); 5292 5293 // Minutes field is not present. 5294 sdf.applyPattern(UnicodeString("hh 'mm ss' bbbb")); 5295 5296 // assertEquals("hh 'mm ss' bbbb | 00:30:00", "12 mm ss midnight", 5297 // sdf.format(k003000, out.remove())); 5298 assertEquals("hh 'mm ss' bbbb | 00:30:00", "12 mm ss AM", 5299 sdf.format(k003000, out.remove())); 5300 assertEquals("hh 'mm ss' bbbb | 06:30:00", "06 mm ss AM", 5301 sdf.format(k063000, out.remove())); 5302 5303 sdf.applyPattern(UnicodeString("hh 'mm ss' BBBB")); 5304 5305 // assertEquals("hh 'mm ss' BBBB | 00:30:00", "12 mm ss midnight", 5306 // sdf.format(k003000, out.remove())); 5307 assertEquals("hh 'mm ss' BBBB | 00:30:00", "12 mm ss at night", 5308 sdf.format(k003000, out.remove())); 5309 assertEquals("hh 'mm ss' BBBB | 06:30:00", "06 mm ss in the morning", 5310 sdf.format(k063000, out.remove())); 5311 5312 // Minutes and seconds fields appear after day periods. 5313 sdf.applyPattern(UnicodeString("bbbb hh:mm:ss")); 5314 5315 // assertEquals("bbbb hh:mm:ss | 00:00:00", "midnight 12:00:00", 5316 // sdf.format(k000000, out.remove())); 5317 assertEquals("bbbb hh:mm:ss | 00:00:00", "AM 12:00:00", 5318 sdf.format(k000000, out.remove())); 5319 assertEquals("bbbb hh:mm:ss | 00:00:30", "AM 12:00:30", 5320 sdf.format(k000030, out.remove())); 5321 assertEquals("bbbb hh:mm:ss | 00:30:00", "AM 12:30:00", 5322 sdf.format(k003000, out.remove())); 5323 5324 sdf.applyPattern(UnicodeString("BBBB hh:mm:ss")); 5325 5326 // assertEquals("BBBB hh:mm:ss | 00:00:00", "midnight 12:00:00", 5327 // sdf.format(k000000, out.remove())); 5328 assertEquals("BBBB hh:mm:ss | 00:00:00", "at night 12:00:00", 5329 sdf.format(k000000, out.remove())); 5330 assertEquals("BBBB hh:mm:ss | 00:00:30", "at night 12:00:30", 5331 sdf.format(k000030, out.remove())); 5332 assertEquals("BBBB hh:mm:ss | 00:30:00", "at night 12:30:00", 5333 sdf.format(k003000, out.remove())); 5334 5335 // Confirm applyPattern() reparses the pattern string. 5336 sdf.applyPattern(UnicodeString("BBBB hh")); 5337 // assertEquals("BBBB hh | 00:00:30", "midnight 12", 5338 // sdf.format(k000030, out.remove())); 5339 assertEquals("BBBB hh | 00:00:30", "at night 12", 5340 sdf.format(k000030, out.remove())); 5341 5342 sdf.applyPattern(UnicodeString("BBBB hh:mm:'ss'")); 5343 // assertEquals("BBBB hh:mm:'ss' | 00:00:30", "midnight 12:00:ss", 5344 // sdf.format(k000030, out.remove())); 5345 assertEquals("BBBB hh | 00:00:30", "at night 12:00:ss", 5346 sdf.format(k000030, out.remove())); 5347 5348 sdf.applyPattern(UnicodeString("BBBB hh:mm:ss")); 5349 assertEquals("BBBB hh:mm:ss | 00:00:30", "at night 12:00:30", 5350 sdf.format(k000030, out.remove())); 5351 } 5352 5353 void DateFormatTest::TestDayPeriodParsing() { 5354 // Some times on 2015-11-13 (UTC+0). 5355 UDate k000000 = 1447372800000.0; 5356 UDate k003700 = 1447375020000.0; 5357 UDate k010000 = 1447376400000.0; 5358 UDate k013000 = 1447378200000.0; 5359 UDate k030000 = 1447383600000.0; 5360 UDate k090000 = 1447405200000.0; 5361 UDate k120000 = 1447416000000.0; 5362 UDate k130000 = 1447419600000.0; 5363 UDate k133700 = 1447421820000.0; 5364 UDate k150000 = 1447426800000.0; 5365 UDate k190000 = 1447441200000.0; 5366 UDate k193000 = 1447443000000.0; 5367 UDate k200000 = 1447444800000.0; 5368 UDate k210000 = 1447448400000.0; 5369 5370 UErrorCode errorCode = U_ZERO_ERROR; 5371 SimpleDateFormat sdf(UnicodeString(), errorCode); 5372 if (U_FAILURE(errorCode)) { 5373 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 5374 return; 5375 } 5376 const TimeZone *tz = TimeZone::getGMT(); 5377 sdf.setTimeZone(*tz); 5378 UnicodeString out; 5379 5380 // 'B' -- flexible day periods 5381 // A day period on its own parses to the center of that period. 5382 sdf.applyPattern(UnicodeString("yyyy-MM-dd B")); 5383 assertEquals("yyyy-MM-dd B | 2015-11-13 midnight", 5384 k000000, sdf.parse(UnicodeString("2015-11-13 midnight"), errorCode)); 5385 assertEquals("yyyy-MM-dd B | 2015-11-13 noon", 5386 k120000, sdf.parse(UnicodeString("2015-11-13 noon"), errorCode)); 5387 assertEquals("yyyy-MM-dd B | 2015-11-13 in the afternoon", 5388 k150000, sdf.parse(UnicodeString("2015-11-13 in the afternoon"), errorCode)); 5389 assertEquals("yyyy-MM-dd B | 2015-11-13 in the evening", 5390 k193000, sdf.parse(UnicodeString("2015-11-13 in the evening"), errorCode)); 5391 assertEquals("yyyy-MM-dd B | 2015-11-13 at night", 5392 k013000, sdf.parse(UnicodeString("2015-11-13 at night"), errorCode)); 5393 5394 // If time and day period are consistent with each other then time is parsed accordingly. 5395 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm B")); 5396 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 12:00 midnight", 5397 k000000, sdf.parse(UnicodeString("2015-11-13 12:00 midnight"), errorCode)); 5398 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 12:00 noon", 5399 k120000, sdf.parse(UnicodeString("2015-11-13 12:00 noon"), errorCode)); 5400 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 01:00 at night", 5401 k010000, sdf.parse(UnicodeString("2015-11-13 01:00 at night"), errorCode)); 5402 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 01:00 in the afternoon", 5403 k130000, sdf.parse(UnicodeString("2015-11-13 01:00 in the afternoon"), errorCode)); 5404 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 09:00 in the morning", 5405 k090000, sdf.parse(UnicodeString("2015-11-13 09:00 in the morning"), errorCode)); 5406 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 09:00 at night", 5407 k210000, sdf.parse(UnicodeString("2015-11-13 09:00 at night"), errorCode)); 5408 5409 // If the hour is 13 thru 23 then day period has no effect on time (since time is assumed 5410 // to be in 24-hour format). 5411 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm B")); 5412 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 midnight", 5413 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 midnight"), errorCode)); 5414 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 noon", 5415 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 noon"), errorCode)); 5416 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 at night", 5417 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 at night"), errorCode)); 5418 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 in the afternoon", 5419 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 in the afternoon"), errorCode)); 5420 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 in the morning", 5421 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 in the morning"), errorCode)); 5422 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 at night", 5423 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 at night"), errorCode)); 5424 5425 // Hour 0 is synonymous with hour 12 when parsed with 'h'. 5426 // This unfortunately means we have to tolerate "0 noon" as it's synonymous with "12 noon". 5427 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm B")); 5428 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 00:00 midnight", 5429 k000000, sdf.parse(UnicodeString("2015-11-13 00:00 midnight"), errorCode)); 5430 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 00:00 noon", 5431 k120000, sdf.parse(UnicodeString("2015-11-13 00:00 noon"), errorCode)); 5432 5433 // But when parsed with 'H', 0 indicates a 24-hour time, therefore we disregard the day period. 5434 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm B")); 5435 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 midnight", 5436 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 midnight"), errorCode)); 5437 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 noon", 5438 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 noon"), errorCode)); 5439 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 at night", 5440 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 at night"), errorCode)); 5441 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 in the afternoon", 5442 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 in the afternoon"), errorCode)); 5443 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 in the morning", 5444 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 in the morning"), errorCode)); 5445 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 at night", 5446 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 at night"), errorCode)); 5447 5448 // Even when parsed with 'H', hours 1 thru 12 are considered 12-hour time and takes 5449 // day period into account in parsing. 5450 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm B")); 5451 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 12:00 midnight", 5452 k000000, sdf.parse(UnicodeString("2015-11-13 12:00 midnight"), errorCode)); 5453 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 12:00 noon", 5454 k120000, sdf.parse(UnicodeString("2015-11-13 12:00 noon"), errorCode)); 5455 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 01:00 at night", 5456 k010000, sdf.parse(UnicodeString("2015-11-13 01:00 at night"), errorCode)); 5457 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 01:00 in the afternoon", 5458 k130000, sdf.parse(UnicodeString("2015-11-13 01:00 in the afternoon"), errorCode)); 5459 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 09:00 in the morning", 5460 k090000, sdf.parse(UnicodeString("2015-11-13 09:00 in the morning"), errorCode)); 5461 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 09:00 at night", 5462 k210000, sdf.parse(UnicodeString("2015-11-13 09:00 at night"), errorCode)); 5463 5464 // If a 12-hour time and the day period don't agree with each other, time is parsed as close 5465 // to the given day period as possible. 5466 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm B")); 5467 5468 // AFTERNOON1 is [12, 18), but "7 in the afternoon" parses to 19:00. 5469 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 07:00 in the afternoon", 5470 k190000, sdf.parse(UnicodeString("2015-11-13 07:00 in the afternoon"), errorCode)); 5471 // NIGHT1 is [21, 6), but "8 at night" parses to 20:00. 5472 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 08:00 at night", 5473 k200000, sdf.parse(UnicodeString("2015-11-13 08:00 at night"), errorCode)); 5474 5475 // 'b' -- fixed day periods (AM, PM, midnight, noon) 5476 // On their own, "midnight" parses to 00:00 and "noon" parses to 12:00. 5477 // AM and PM are handled by the 'a' parser (which doesn't handle this case well). 5478 sdf.applyPattern(UnicodeString("yyyy-MM-dd b")); 5479 assertEquals("yyyy-MM-dd b | 2015-11-13 midnight", 5480 k000000, sdf.parse(UnicodeString("2015-11-13 midnight"), errorCode)); 5481 assertEquals("yyyy-MM-dd b | 2015-11-13 noon", 5482 k120000, sdf.parse(UnicodeString("2015-11-13 noon"), errorCode)); 5483 5484 // For 12-hour times, AM and PM should be parsed as if with pattern character 'a'. 5485 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm b")); 5486 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 01:00 AM", 5487 k010000, sdf.parse(UnicodeString("2015-11-13 01:00 AM"), errorCode)); 5488 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 01:00 PM", 5489 k130000, sdf.parse(UnicodeString("2015-11-13 01:00 PM"), errorCode)); 5490 5491 // 12 midnight parses to 00:00, and 12 noon parses to 12:00. 5492 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 12:00 midnight", 5493 k000000, sdf.parse(UnicodeString("2015-11-13 12:00 midnight"), errorCode)); 5494 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 12:00 noon", 5495 k120000, sdf.parse(UnicodeString("2015-11-13 12:00 noon"), errorCode)); 5496 5497 // Hours 13-23 indicate 24-hour time so we disregard "midnight" or "noon". 5498 // Again, AM and PM are handled by the 'a' parser which doesn't handle this case well. 5499 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm b")); 5500 assertEquals("yyyy-MM-dd HH:mm b | 2015-11-13 13:37 midnight", 5501 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 midnight"), errorCode)); 5502 assertEquals("yyyy-MM-dd HH:mm b | 2015-11-13 13:37 noon", 5503 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 noon"), errorCode)); 5504 5505 // Hour 0 is synonymous with hour 12 when parsed with 'h'. 5506 // Again, this means we have to tolerate "0 noon" as it's synonymous with "12 noon". 5507 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm b")); 5508 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 00:00 midnight", 5509 k000000, sdf.parse(UnicodeString("2015-11-13 00:00 midnight"), errorCode)); 5510 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 00:00 noon", 5511 k120000, sdf.parse(UnicodeString("2015-11-13 00:00 noon"), errorCode)); 5512 5513 // With 'H' though 0 indicates a 24-hour time, therefore we disregard the day period. 5514 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm b")); 5515 assertEquals("yyyy-MM-dd HH:mm b | 2015-11-13 00:37 midnight", 5516 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 midnight"), errorCode)); 5517 assertEquals("yyyy-MM-dd HH:mm b | 2015-11-13 00:37 noon", 5518 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 noon"), errorCode)); 5519 5520 // If "midnight" or "noon" is parsed with a 12-hour time other than 12:00, choose 5521 // the version that's closer to the period given. 5522 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm b")); 5523 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 03:00 midnight", 5524 k030000, sdf.parse(UnicodeString("2015-11-13 03:00 midnight"), errorCode)); 5525 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 03:00 noon", 5526 k150000, sdf.parse(UnicodeString("2015-11-13 03:00 noon"), errorCode)); 5527 } 5528 5529 #endif /* #if !UCONFIG_NO_FORMATTING */ 5530 5531 //eof 5532
