1 // 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_USES_ONLY_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 TESTCASE_AUTO(TestParseRegression13744); 125 126 TESTCASE_AUTO_END; 127 } 128 129 void DateFormatTest::TestPatterns() { 130 static const struct { 131 const char *actualPattern; 132 const char *expectedPattern; 133 const char *localeID; 134 const char *expectedLocalPattern; 135 } EXPECTED[] = { 136 {UDAT_YEAR, "y","en","y"}, 137 138 {UDAT_QUARTER, "QQQQ", "en", "QQQQ"}, 139 {UDAT_ABBR_QUARTER, "QQQ", "en", "QQQ"}, 140 {UDAT_YEAR_QUARTER, "yQQQQ", "en", "QQQQ y"}, 141 {UDAT_YEAR_ABBR_QUARTER, "yQQQ", "en", "QQQ y"}, 142 143 {UDAT_NUM_MONTH, "M", "en", "L"}, 144 {UDAT_ABBR_MONTH, "MMM", "en", "LLL"}, 145 {UDAT_MONTH, "MMMM", "en", "LLLL"}, 146 {UDAT_YEAR_NUM_MONTH, "yM","en","M/y"}, 147 {UDAT_YEAR_ABBR_MONTH, "yMMM","en","MMM y"}, 148 {UDAT_YEAR_MONTH, "yMMMM","en","MMMM y"}, 149 150 {UDAT_DAY, "d","en","d"}, 151 {UDAT_YEAR_NUM_MONTH_DAY, "yMd", "en", "M/d/y"}, 152 {UDAT_YEAR_ABBR_MONTH_DAY, "yMMMd", "en", "MMM d, y"}, 153 {UDAT_YEAR_MONTH_DAY, "yMMMMd", "en", "MMMM d, y"}, 154 {UDAT_YEAR_NUM_MONTH_WEEKDAY_DAY, "yMEd", "en", "EEE, M/d/y"}, 155 {UDAT_YEAR_ABBR_MONTH_WEEKDAY_DAY, "yMMMEd", "en", "EEE, MMM d, y"}, 156 {UDAT_YEAR_MONTH_WEEKDAY_DAY, "yMMMMEEEEd", "en", "EEEE, MMMM d, y"}, 157 158 {UDAT_NUM_MONTH_DAY, "Md","en","M/d"}, 159 {UDAT_ABBR_MONTH_DAY, "MMMd","en","MMM d"}, 160 {UDAT_MONTH_DAY, "MMMMd","en","MMMM d"}, 161 {UDAT_NUM_MONTH_WEEKDAY_DAY, "MEd","en","EEE, M/d"}, 162 {UDAT_ABBR_MONTH_WEEKDAY_DAY, "MMMEd","en","EEE, MMM d"}, 163 {UDAT_MONTH_WEEKDAY_DAY, "MMMMEEEEd","en","EEEE, MMMM d"}, 164 165 {UDAT_HOUR, "j", "en", "h a"}, // (fixed expected result per ticket 6872<-6626) 166 {UDAT_HOUR24, "H", "en", "HH"}, // (fixed expected result per ticket 6872<-6626 167 168 {UDAT_MINUTE, "m", "en", "m"}, 169 {UDAT_HOUR_MINUTE, "jm","en","h:mm a"}, // (fixed expected result per ticket 6872<-7180) 170 {UDAT_HOUR24_MINUTE, "Hm", "en", "HH:mm"}, // (fixed expected result per ticket 6872<-6626) 171 172 {UDAT_SECOND, "s", "en", "s"}, 173 {UDAT_HOUR_MINUTE_SECOND, "jms","en","h:mm:ss a"}, // (fixed expected result per ticket 6872<-7180) 174 {UDAT_HOUR24_MINUTE_SECOND, "Hms","en","HH:mm:ss"}, // (fixed expected result per ticket 6872<-6626) 175 {UDAT_MINUTE_SECOND, "ms", "en", "mm:ss"}, // (fixed expected result per ticket 6872<-6626) 176 177 {UDAT_LOCATION_TZ, "VVVV", "en", "VVVV"}, 178 {UDAT_GENERIC_TZ, "vvvv", "en", "vvvv"}, 179 {UDAT_ABBR_GENERIC_TZ, "v", "en", "v"}, 180 {UDAT_SPECIFIC_TZ, "zzzz", "en", "zzzz"}, 181 {UDAT_ABBR_SPECIFIC_TZ, "z", "en", "z"}, 182 {UDAT_ABBR_UTC_TZ, "ZZZZ", "en", "ZZZZ"}, 183 184 {UDAT_YEAR_NUM_MONTH_DAY UDAT_ABBR_UTC_TZ, "yMdZZZZ", "en", "M/d/y, ZZZZ"}, 185 {UDAT_MONTH_DAY UDAT_LOCATION_TZ, "MMMMdVVVV", "en", "MMMM d, VVVV"} 186 }; 187 188 IcuTestErrorCode errorCode(*this, "TestPatterns()"); 189 for (int32_t i = 0; i < UPRV_LENGTHOF(EXPECTED); i++) { 190 // Verify that patterns have the correct values 191 UnicodeString actualPattern(EXPECTED[i].actualPattern, -1, US_INV); 192 UnicodeString expectedPattern(EXPECTED[i].expectedPattern, -1, US_INV); 193 Locale locale(EXPECTED[i].localeID); 194 if (actualPattern != expectedPattern) { 195 errln("FAILURE! Expected pattern: " + expectedPattern + 196 " but was: " + actualPattern); 197 } 198 199 // Verify that DataFormat instances produced contain the correct 200 // localized patterns 201 // TODO: use DateFormat::getInstanceForSkeleton(), ticket #9029 202 // Java test code: 203 // DateFormat date1 = DateFormat.getPatternInstance(actualPattern, 204 // locale); 205 // DateFormat date2 = DateFormat.getPatternInstance(Calendar.getInstance(locale), 206 // actualPattern, locale); 207 LocalPointer<DateTimePatternGenerator> generator( 208 DateTimePatternGenerator::createInstance(locale, errorCode)); 209 if(errorCode.errDataIfFailureAndReset("DateTimePatternGenerator::createInstance() failed for locale ID \"%s\"", EXPECTED[i].localeID)) { 210 continue; 211 } 212 UnicodeString pattern = generator->getBestPattern(actualPattern, errorCode); 213 SimpleDateFormat date1(pattern, locale, errorCode); 214 SimpleDateFormat date2(pattern, locale, errorCode); 215 date2.adoptCalendar(Calendar::createInstance(locale, errorCode)); 216 if(errorCode.errIfFailureAndReset("DateFormat::getInstanceForSkeleton() failed")) { 217 errln(" for actualPattern \"%s\" & locale ID \"%s\"", 218 EXPECTED[i].actualPattern, EXPECTED[i].localeID); 219 continue; 220 } 221 222 UnicodeString expectedLocalPattern(EXPECTED[i].expectedLocalPattern, -1, US_INV); 223 UnicodeString actualLocalPattern1; 224 UnicodeString actualLocalPattern2; 225 date1.toLocalizedPattern(actualLocalPattern1, errorCode); 226 date2.toLocalizedPattern(actualLocalPattern2, errorCode); 227 if (actualLocalPattern1 != expectedLocalPattern) { 228 errln("FAILURE! Expected local pattern: " + expectedLocalPattern 229 + " but was: " + actualLocalPattern1); 230 } 231 if (actualLocalPattern2 != expectedLocalPattern) { 232 errln("FAILURE! Expected local pattern: " + expectedLocalPattern 233 + " but was: " + actualLocalPattern2); 234 } 235 } 236 } 237 238 // Test written by Wally Wedel and emailed to me. 239 void DateFormatTest::TestWallyWedel() 240 { 241 UErrorCode status = U_ZERO_ERROR; 242 /* 243 * Instantiate a TimeZone so we can get the ids. 244 */ 245 TimeZone *tz = new SimpleTimeZone(7,""); 246 /* 247 * Computational variables. 248 */ 249 int32_t offset, hours, minutes, seconds; 250 /* 251 * Instantiate a SimpleDateFormat set up to produce a full time 252 zone name. 253 */ 254 SimpleDateFormat *sdf = new SimpleDateFormat((UnicodeString)"zzzz", status); 255 /* 256 * A String array for the time zone ids. 257 */ 258 int32_t ids_length; 259 StringEnumeration* ids = TimeZone::createEnumeration(); 260 if (ids == NULL) { 261 dataerrln("Unable to create TimeZone enumeration."); 262 if (sdf != NULL) { 263 delete sdf; 264 } 265 return; 266 } 267 ids_length = ids->count(status); 268 /* 269 * How many ids do we have? 270 */ 271 logln("Time Zone IDs size: %d", ids_length); 272 /* 273 * Column headings (sort of) 274 */ 275 logln("Ordinal ID offset(h:m) name"); 276 /* 277 * Loop through the tzs. 278 */ 279 UDate today = Calendar::getNow(); 280 Calendar *cal = Calendar::createInstance(status); 281 for (int32_t i = 0; i < ids_length; i++) { 282 // logln(i + " " + ids[i]); 283 const UnicodeString* id = ids->snext(status); 284 TimeZone *ttz = TimeZone::createTimeZone(*id); 285 // offset = ttz.getRawOffset(); 286 cal->setTimeZone(*ttz); 287 cal->setTime(today, status); 288 offset = cal->get(UCAL_ZONE_OFFSET, status) + cal->get(UCAL_DST_OFFSET, status); 289 // logln(i + " " + ids[i] + " offset " + offset); 290 const char* sign = "+"; 291 if (offset < 0) { 292 sign = "-"; 293 offset = -offset; 294 } 295 hours = offset/3600000; 296 minutes = (offset%3600000)/60000; 297 seconds = (offset%60000)/1000; 298 UnicodeString dstOffset = (UnicodeString)"" + sign + (hours < 10 ? "0" : "") + 299 (int32_t)hours + ":" + (minutes < 10 ? "0" : "") + (int32_t)minutes; 300 if (seconds != 0) { 301 dstOffset = dstOffset + ":" + (seconds < 10 ? "0" : "") + seconds; 302 } 303 /* 304 * Instantiate a date so we can display the time zone name. 305 */ 306 sdf->setTimeZone(*ttz); 307 /* 308 * Format the output. 309 */ 310 UnicodeString fmtOffset; 311 FieldPosition pos(FieldPosition::DONT_CARE); 312 sdf->format(today,fmtOffset, pos); 313 // UnicodeString fmtOffset = tzS.toString(); 314 UnicodeString *fmtDstOffset = 0; 315 if (fmtOffset.startsWith("GMT") && fmtOffset.length() != 3) 316 { 317 //fmtDstOffset = fmtOffset->substring(3); 318 fmtDstOffset = new UnicodeString(); 319 fmtOffset.extract(3, fmtOffset.length(), *fmtDstOffset); 320 } 321 /* 322 * Show our result. 323 */ 324 UBool ok = fmtDstOffset == 0 || *fmtDstOffset == dstOffset; 325 if (ok) 326 { 327 logln(UnicodeString() + i + " " + *id + " " + dstOffset + 328 " " + fmtOffset + 329 (fmtDstOffset != 0 ? " ok" : " ?")); 330 } 331 else 332 { 333 errln(UnicodeString() + i + " " + *id + " " + dstOffset + 334 " " + fmtOffset + " *** FAIL ***"); 335 } 336 delete ttz; 337 delete fmtDstOffset; 338 } 339 delete cal; 340 // delete ids; // TODO: BAD API 341 delete ids; 342 delete sdf; 343 delete tz; 344 } 345 346 // ------------------------------------- 347 348 /** 349 * Test operator== 350 */ 351 void 352 DateFormatTest::TestEquals() 353 { 354 DateFormat* fmtA = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::FULL); 355 DateFormat* fmtB = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::FULL); 356 if ( fmtA == NULL || fmtB == NULL){ 357 dataerrln("Error calling DateFormat::createDateTimeInstance"); 358 delete fmtA; 359 delete fmtB; 360 return; 361 } 362 363 if (!(*fmtA == *fmtB)) errln((UnicodeString)"FAIL"); 364 delete fmtA; 365 delete fmtB; 366 367 TimeZone* test = TimeZone::createTimeZone("PDT"); 368 delete test; 369 } 370 371 // ------------------------------------- 372 373 /** 374 * Test the parsing of 2-digit years. 375 */ 376 void 377 DateFormatTest::TestTwoDigitYearDSTParse(void) 378 { 379 UErrorCode status = U_ZERO_ERROR; 380 SimpleDateFormat* fullFmt = new SimpleDateFormat((UnicodeString)"EEE MMM dd HH:mm:ss.SSS zzz yyyy G", status); 381 SimpleDateFormat *fmt = new SimpleDateFormat((UnicodeString)"dd-MMM-yy h:mm:ss 'o''clock' a z", Locale::getEnglish(), status); 382 //DateFormat* fmt = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::FULL, Locale::ENGLISH); 383 UnicodeString* s = new UnicodeString("03-Apr-04 2:20:47 o'clock AM PST", ""); 384 TimeZone* defaultTZ = TimeZone::createDefault(); 385 TimeZone* PST = TimeZone::createTimeZone("PST"); 386 int32_t defaultOffset = defaultTZ->getRawOffset(); 387 int32_t PSTOffset = PST->getRawOffset(); 388 int32_t hour = 2 + (defaultOffset - PSTOffset) / (60*60*1000); 389 // hour is the expected hour of day, in units of seconds 390 hour = ((hour < 0) ? hour + 24 : hour) * 60*60; 391 392 UnicodeString str; 393 394 if(U_FAILURE(status)) { 395 dataerrln("Could not set up test. exitting - %s", u_errorName(status)); 396 return; 397 } 398 399 UDate d = fmt->parse(*s, status); 400 logln(*s + " P> " + ((DateFormat*)fullFmt)->format(d, str)); 401 int32_t y, m, day, hr, min, sec; 402 dateToFields(d, y, m, day, hr, min, sec); 403 hour += defaultTZ->inDaylightTime(d, status) ? 1 : 0; 404 hr = hr*60*60; 405 if (hr != hour) 406 errln((UnicodeString)"FAIL: Should parse to hour " + hour + " but got " + hr); 407 408 if (U_FAILURE(status)) 409 errln((UnicodeString)"FAIL: " + (int32_t)status); 410 411 delete s; 412 delete fmt; 413 delete fullFmt; 414 delete PST; 415 delete defaultTZ; 416 } 417 418 // ------------------------------------- 419 420 UChar toHexString(int32_t i) { return (UChar)(i + (i < 10 ? 0x30 : (0x41 - 10))); } 421 422 UnicodeString& 423 DateFormatTest::escape(UnicodeString& s) 424 { 425 UnicodeString buf; 426 for (int32_t i=0; i<s.length(); ++i) 427 { 428 UChar c = s[(int32_t)i]; 429 if (c <= (UChar)0x7F) buf += c; 430 else { 431 buf += (UChar)0x5c; buf += (UChar)0x55; 432 buf += toHexString((c & 0xF000) >> 12); 433 buf += toHexString((c & 0x0F00) >> 8); 434 buf += toHexString((c & 0x00F0) >> 4); 435 buf += toHexString(c & 0x000F); 436 } 437 } 438 return (s = buf); 439 } 440 441 // ------------------------------------- 442 443 /** 444 * This MUST be kept in sync with DateFormatSymbols.gPatternChars. 445 */ 446 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 447 static const char* PATTERN_CHARS = "GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB:"; 448 #else 449 static const char* PATTERN_CHARS = "GyMdkHmsSEDFwWahKzYeugAZvcLQqVUOXxrbB"; 450 #endif 451 452 /** 453 * A list of the names of all the fields in DateFormat. 454 * This MUST be kept in sync with DateFormat. 455 */ 456 static const char* DATEFORMAT_FIELD_NAMES[] = { 457 "ERA_FIELD", 458 "YEAR_FIELD", 459 "MONTH_FIELD", 460 "DATE_FIELD", 461 "HOUR_OF_DAY1_FIELD", 462 "HOUR_OF_DAY0_FIELD", 463 "MINUTE_FIELD", 464 "SECOND_FIELD", 465 "MILLISECOND_FIELD", 466 "DAY_OF_WEEK_FIELD", 467 "DAY_OF_YEAR_FIELD", 468 "DAY_OF_WEEK_IN_MONTH_FIELD", 469 "WEEK_OF_YEAR_FIELD", 470 "WEEK_OF_MONTH_FIELD", 471 "AM_PM_FIELD", 472 "HOUR1_FIELD", 473 "HOUR0_FIELD", 474 "TIMEZONE_FIELD", 475 "YEAR_WOY_FIELD", 476 "DOW_LOCAL_FIELD", 477 "EXTENDED_YEAR_FIELD", 478 "JULIAN_DAY_FIELD", 479 "MILLISECONDS_IN_DAY_FIELD", 480 "TIMEZONE_RFC_FIELD", 481 "GENERIC_TIMEZONE_FIELD", 482 "STAND_ALONE_DAY_FIELD", 483 "STAND_ALONE_MONTH_FIELD", 484 "QUARTER_FIELD", 485 "STAND_ALONE_QUARTER_FIELD", 486 "TIMEZONE_SPECIAL_FIELD", 487 "YEAR_NAME_FIELD", 488 "TIMEZONE_LOCALIZED_GMT_OFFSET_FIELD", 489 "TIMEZONE_ISO_FIELD", 490 "TIMEZONE_ISO_LOCAL_FIELD", 491 "RELATED_YEAR_FIELD", 492 "AM_PM_MIDNIGHT_NOON_FIELD", 493 "FLEXIBLE_DAY_PERIOD_FIELD", 494 "UDAT_TIME_SEPARATOR_FIELD", 495 }; 496 497 static const int32_t DATEFORMAT_FIELD_NAMES_LENGTH = 498 UPRV_LENGTHOF(DATEFORMAT_FIELD_NAMES); 499 500 /** 501 * Verify that returned field position indices are correct. 502 */ 503 void DateFormatTest::TestFieldPosition() { 504 UErrorCode ec = U_ZERO_ERROR; 505 int32_t i, j, exp; 506 UnicodeString buf; 507 508 // Verify data 509 DateFormatSymbols rootSyms(Locale(""), ec); 510 if (U_FAILURE(ec)) { 511 dataerrln("Unable to create DateFormatSymbols - %s", u_errorName(ec)); 512 return; 513 } 514 515 // local pattern chars data is not longer loaded 516 // from icu locale bundle 517 assertEquals("patternChars", PATTERN_CHARS, rootSyms.getLocalPatternChars(buf)); 518 assertEquals("patternChars", PATTERN_CHARS, DateFormatSymbols::getPatternUChars()); 519 assertTrue("DATEFORMAT_FIELD_NAMES", DATEFORMAT_FIELD_NAMES_LENGTH == UDAT_FIELD_COUNT); 520 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 521 assertTrue("Data", UDAT_FIELD_COUNT == uprv_strlen(PATTERN_CHARS)); 522 #else 523 assertTrue("Data", UDAT_FIELD_COUNT == uprv_strlen(PATTERN_CHARS) + 1); // +1 for missing TIME_SEPARATOR pattern char 524 #endif 525 526 // Create test formatters 527 const int32_t COUNT = 4; 528 DateFormat* dateFormats[COUNT]; 529 dateFormats[0] = DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale::getUS()); 530 dateFormats[1] = DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale::getFrance()); 531 // Make the pattern "G y M d..." 532 buf.remove().append(PATTERN_CHARS); 533 for (j=buf.length()-1; j>=0; --j) buf.insert(j, (UChar)32/*' '*/); 534 dateFormats[2] = new SimpleDateFormat(buf, Locale::getUS(), ec); 535 // Make the pattern "GGGG yyyy MMMM dddd..." 536 for (j=buf.length()-1; j>=0; j-=2) { 537 for (i=0; i<3; ++i) { 538 buf.insert(j, buf.charAt(j)); 539 } 540 } 541 dateFormats[3] = new SimpleDateFormat(buf, Locale::getUS(), ec); 542 if(U_FAILURE(ec)){ 543 errln(UnicodeString("Could not create SimpleDateFormat object for locale en_US. Error: " )+ UnicodeString(u_errorName(ec))); 544 return; 545 } 546 UDate aug13 = 871508052513.0; 547 548 // Expected output field values for above DateFormats on aug13 549 // Fields are given in order of DateFormat field number 550 const char* EXPECTED[] = { 551 "", "1997", "August", "13", "", "", "34", "12", "", "Wednesday", 552 "", "", "", "", "PM", "2", "", "Pacific Daylight Time", "", "", 553 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 554 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 555 ":", 556 #else 557 "", 558 #endif 559 560 "", "1997", "ao\\u00FBt", "13", "", "14", "34", "12", "", "mercredi", 561 "", "", "", "", "", "", "", "heure d\\u2019\\u00E9t\\u00E9 du Pacifique", "", "", 562 "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", 563 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 564 ":", 565 #else 566 "", 567 #endif 568 569 "AD", "1997", "8", "13", "14", "14", "34", "12", "5", "Wed", 570 "225", "2", "33", "3", "PM", "2", "2", "PDT", "1997", "4", 571 "1997", "2450674", "52452513", "-0700", "PT", "4", "8", "3", "3", "uslax", 572 "1997", "GMT-7", "-07", "-07", "1997", "PM", "in the afternoon", 573 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 574 ":", 575 #else 576 "", 577 #endif 578 579 "Anno Domini", "1997", "August", "0013", "0014", "0014", "0034", "0012", "5130", "Wednesday", 580 "0225", "0002", "0033", "0003", "PM", "0002", "0002", "Pacific Daylight Time", "1997", "Wednesday", 581 "1997", "2450674", "52452513", "GMT-07:00", "Pacific Time", "Wednesday", "August", "3rd quarter", "3rd quarter", "Los Angeles Time", 582 "1997", "GMT-07:00", "-0700", "-0700", "1997", "PM", "in the afternoon", 583 #if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR 584 ":", 585 #else 586 "", 587 #endif 588 }; 589 590 const int32_t EXPECTED_LENGTH = UPRV_LENGTHOF(EXPECTED); 591 592 assertTrue("data size", EXPECTED_LENGTH == COUNT * UDAT_FIELD_COUNT); 593 594 TimeZone* PT = TimeZone::createTimeZone("America/Los_Angeles"); 595 for (j = 0, exp = 0; j < COUNT; ++j) { 596 // String str; 597 DateFormat* df = dateFormats[j]; 598 df->setTimeZone(*PT); 599 SimpleDateFormat* sdtfmt = dynamic_cast<SimpleDateFormat*>(df); 600 if (sdtfmt != NULL) { 601 logln(" Pattern = " + sdtfmt->toPattern(buf.remove())); 602 } else { 603 logln(" Pattern = ? (not a SimpleDateFormat)"); 604 } 605 logln((UnicodeString)" Result = " + df->format(aug13, buf.remove())); 606 607 int32_t expBase = exp; // save for later 608 for (i = 0; i < UDAT_FIELD_COUNT; ++i, ++exp) { 609 FieldPosition pos(i); 610 buf.remove(); 611 df->format(aug13, buf, pos); 612 UnicodeString field; 613 buf.extractBetween(pos.getBeginIndex(), pos.getEndIndex(), field); 614 assertEquals((UnicodeString)"field #" + i + " " + DATEFORMAT_FIELD_NAMES[i], 615 ctou(EXPECTED[exp]), field); 616 } 617 618 // test FieldPositionIterator API 619 logln("FieldPositionIterator"); 620 { 621 UErrorCode status = U_ZERO_ERROR; 622 FieldPositionIterator posIter; 623 FieldPosition fp; 624 625 buf.remove(); 626 df->format(aug13, buf, &posIter, status); 627 while (posIter.next(fp)) { 628 int32_t i = fp.getField(); 629 UnicodeString field; 630 buf.extractBetween(fp.getBeginIndex(), fp.getEndIndex(), field); 631 assertEquals((UnicodeString)"field #" + i + " " + DATEFORMAT_FIELD_NAMES[i], 632 ctou(EXPECTED[expBase + i]), field); 633 } 634 635 } 636 } 637 638 639 // test null posIter 640 buf.remove(); 641 UErrorCode status = U_ZERO_ERROR; 642 dateFormats[0]->format(aug13, buf, NULL, status); 643 // if we didn't crash, we succeeded. 644 645 for (i=0; i<COUNT; ++i) { 646 delete dateFormats[i]; 647 } 648 delete PT; 649 } 650 651 // ------------------------------------- 652 653 /** 654 * General parse/format tests. Add test cases as needed. 655 */ 656 void DateFormatTest::TestGeneral() { 657 const char* DATA[] = { 658 "yyyy MM dd HH:mm:ss.SSS", 659 660 // Milliseconds are left-justified, since they format as fractions of a second 661 "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", 662 "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", 663 "y/M/d H:mm:ss.SSS", "F", "2004 03 10 16:36:31.567", "2004/3/10 16:36:31.567", 664 "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", 665 }; 666 expect(DATA, UPRV_LENGTHOF(DATA), Locale("en", "", "")); 667 } 668 669 // ------------------------------------- 670 671 /** 672 * Verify that strings which contain incomplete specifications are parsed 673 * correctly. In some instances, this means not being parsed at all, and 674 * returning an appropriate error. 675 */ 676 void 677 DateFormatTest::TestPartialParse994() 678 { 679 UErrorCode status = U_ZERO_ERROR; 680 SimpleDateFormat* f = new SimpleDateFormat(status); 681 if (U_FAILURE(status)) { 682 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 683 delete f; 684 return; 685 } 686 UDate null = 0; 687 tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/17 10:11:42", date(97, 1 - 1, 17, 10, 11, 42)); 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 10", null); 690 tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/17 ", null); 691 tryPat994(f, "yy/MM/dd HH:mm:ss", "97/01/17", null); 692 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 693 delete f; 694 } 695 696 // ------------------------------------- 697 698 void 699 DateFormatTest::tryPat994(SimpleDateFormat* format, const char* pat, const char* str, UDate expected) 700 { 701 UErrorCode status = U_ZERO_ERROR; 702 UDate null = 0; 703 logln(UnicodeString("Pattern \"") + pat + "\" String \"" + str + "\""); 704 //try { 705 format->applyPattern(pat); 706 UDate date = format->parse(str, status); 707 if (U_FAILURE(status) || date == null) 708 { 709 logln((UnicodeString)"ParseException: " + (int32_t)status); 710 if (expected != null) errln((UnicodeString)"FAIL: Expected " + dateToString(expected)); 711 } 712 else 713 { 714 UnicodeString f; 715 ((DateFormat*)format)->format(date, f); 716 logln(UnicodeString(" parse(") + str + ") -> " + dateToString(date)); 717 logln((UnicodeString)" format -> " + f); 718 if (expected == null || 719 !(date == expected)) errln((UnicodeString)"FAIL: Expected null");//" + expected); 720 if (!(f == str)) errln(UnicodeString("FAIL: Expected ") + str); 721 } 722 //} 723 //catch(ParseException e) { 724 // logln((UnicodeString)"ParseException: " + e.getMessage()); 725 // if (expected != null) errln((UnicodeString)"FAIL: Expected " + dateToString(expected)); 726 //} 727 //catch(Exception e) { 728 // errln((UnicodeString)"*** Exception:"); 729 // e.printStackTrace(); 730 //} 731 } 732 733 // ------------------------------------- 734 735 /** 736 * Verify the behavior of patterns in which digits for different fields run together 737 * without intervening separators. 738 */ 739 void 740 DateFormatTest::TestRunTogetherPattern985() 741 { 742 UErrorCode status = U_ZERO_ERROR; 743 UnicodeString format("yyyyMMddHHmmssSSS"); 744 UnicodeString now, then; 745 //UBool flag; 746 SimpleDateFormat *formatter = new SimpleDateFormat(format, status); 747 if (U_FAILURE(status)) { 748 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 749 delete formatter; 750 return; 751 } 752 UDate date1 = Calendar::getNow(); 753 ((DateFormat*)formatter)->format(date1, now); 754 logln(now); 755 ParsePosition pos(0); 756 UDate date2 = formatter->parse(now, pos); 757 if (date2 == 0) then = UnicodeString("Parse stopped at ") + pos.getIndex(); 758 else ((DateFormat*)formatter)->format(date2, then); 759 logln(then); 760 if (!(date2 == date1)) errln((UnicodeString)"FAIL"); 761 delete formatter; 762 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 763 } 764 765 // ------------------------------------- 766 767 /** 768 * Verify the behavior of patterns in which digits for different fields run together 769 * without intervening separators. 770 */ 771 void 772 DateFormatTest::TestRunTogetherPattern917() 773 { 774 UErrorCode status = U_ZERO_ERROR; 775 SimpleDateFormat* fmt; 776 UnicodeString myDate; 777 fmt = new SimpleDateFormat((UnicodeString)"yyyy/MM/dd", status); 778 if (U_FAILURE(status)) { 779 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 780 delete fmt; 781 return; 782 } 783 myDate = "1997/02/03"; 784 testIt917(fmt, myDate, date(97, 2 - 1, 3)); 785 delete fmt; 786 fmt = new SimpleDateFormat((UnicodeString)"yyyyMMdd", status); 787 myDate = "19970304"; 788 testIt917(fmt, myDate, date(97, 3 - 1, 4)); 789 delete fmt; 790 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 791 } 792 793 // ------------------------------------- 794 795 void 796 DateFormatTest::testIt917(SimpleDateFormat* fmt, UnicodeString& str, UDate expected) 797 { 798 UErrorCode status = U_ZERO_ERROR; 799 UnicodeString pattern; 800 logln((UnicodeString)"pattern=" + fmt->toPattern(pattern) + " string=" + str); 801 Formattable o; 802 //try { 803 ((Format*)fmt)->parseObject(str, o, status); 804 //} 805 if (U_FAILURE(status)) return; 806 //catch(ParseException e) { 807 // e.printStackTrace(); 808 // return; 809 //} 810 logln((UnicodeString)"Parsed object: " + dateToString(o.getDate())); 811 if (!(o.getDate() == expected)) errln((UnicodeString)"FAIL: Expected " + dateToString(expected)); 812 UnicodeString formatted; ((Format*)fmt)->format(o, formatted, status); 813 logln((UnicodeString)"Formatted string: " + formatted); 814 if (!(formatted == str)) errln((UnicodeString)"FAIL: Expected " + str); 815 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 816 } 817 818 // ------------------------------------- 819 820 /** 821 * Verify the handling of Czech June and July, which have the unique attribute that 822 * one is a proper prefix substring of the other. 823 */ 824 void 825 DateFormatTest::TestCzechMonths459() 826 { 827 UErrorCode status = U_ZERO_ERROR; 828 DateFormat* fmt = DateFormat::createDateInstance(DateFormat::FULL, Locale("cs", "", "")); 829 if (fmt == NULL){ 830 dataerrln("Error calling DateFormat::createDateInstance()"); 831 return; 832 } 833 834 UnicodeString pattern; 835 logln((UnicodeString)"Pattern " + ((SimpleDateFormat*) fmt)->toPattern(pattern)); 836 UDate june = date(97, UCAL_JUNE, 15); 837 UDate july = date(97, UCAL_JULY, 15); 838 UnicodeString juneStr; fmt->format(june, juneStr); 839 UnicodeString julyStr; fmt->format(july, julyStr); 840 //try { 841 logln((UnicodeString)"format(June 15 1997) = " + juneStr); 842 UDate d = fmt->parse(juneStr, status); 843 UnicodeString s; fmt->format(d, s); 844 int32_t month,yr,day,hr,min,sec; dateToFields(d,yr,month,day,hr,min,sec); 845 logln((UnicodeString)" -> parse -> " + s + " (month = " + month + ")"); 846 if (month != UCAL_JUNE) errln((UnicodeString)"FAIL: Month should be June"); 847 logln((UnicodeString)"format(July 15 1997) = " + julyStr); 848 d = fmt->parse(julyStr, status); 849 fmt->format(d, s); 850 dateToFields(d,yr,month,day,hr,min,sec); 851 logln((UnicodeString)" -> parse -> " + s + " (month = " + month + ")"); 852 if (month != UCAL_JULY) errln((UnicodeString)"FAIL: Month should be July"); 853 //} 854 //catch(ParseException e) { 855 if (U_FAILURE(status)) 856 errln((UnicodeString)"Exception: " + (int32_t)status); 857 //} 858 delete fmt; 859 } 860 861 // ------------------------------------- 862 863 /** 864 * Test the handling of 'D' in patterns. 865 */ 866 void 867 DateFormatTest::TestLetterDPattern212() 868 { 869 UErrorCode status = U_ZERO_ERROR; 870 UnicodeString dateString("1995-040.05:01:29"); 871 UnicodeString bigD("yyyy-DDD.hh:mm:ss"); 872 UnicodeString littleD("yyyy-ddd.hh:mm:ss"); 873 UDate expLittleD = date(95, 0, 1, 5, 1, 29); 874 UDate expBigD = expLittleD + 39 * 24 * 3600000.0; 875 expLittleD = expBigD; // Expect the same, with default lenient parsing 876 logln((UnicodeString)"dateString= " + dateString); 877 SimpleDateFormat *formatter = new SimpleDateFormat(bigD, status); 878 if (U_FAILURE(status)) { 879 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 880 delete formatter; 881 return; 882 } 883 ParsePosition pos(0); 884 UDate myDate = formatter->parse(dateString, pos); 885 logln((UnicodeString)"Using " + bigD + " -> " + myDate); 886 if (myDate != expBigD) errln((UnicodeString)"FAIL: bigD - Expected " + dateToString(expBigD)); 887 delete formatter; 888 formatter = new SimpleDateFormat(littleD, status); 889 ASSERT_OK(status); 890 pos = ParsePosition(0); 891 myDate = formatter->parse(dateString, pos); 892 logln((UnicodeString)"Using " + littleD + " -> " + dateToString(myDate)); 893 if (myDate != expLittleD) errln((UnicodeString)"FAIL: littleD - Expected " + dateToString(expLittleD)); 894 delete formatter; 895 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 896 } 897 898 // ------------------------------------- 899 900 /** 901 * Test the day of year pattern. 902 */ 903 void 904 DateFormatTest::TestDayOfYearPattern195() 905 { 906 UErrorCode status = U_ZERO_ERROR; 907 UDate today = Calendar::getNow(); 908 int32_t year,month,day,hour,min,sec; dateToFields(today,year,month,day,hour,min,sec); 909 UDate expected = date(year, month, day); 910 logln((UnicodeString)"Test Date: " + dateToString(today)); 911 SimpleDateFormat* sdf = (SimpleDateFormat*)DateFormat::createDateInstance(); 912 if (sdf == NULL){ 913 dataerrln("Error calling DateFormat::createDateInstance()"); 914 return; 915 } 916 tryPattern(*sdf, today, 0, expected); 917 tryPattern(*sdf, today, "G yyyy DDD", expected); 918 delete sdf; 919 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 920 } 921 922 // ------------------------------------- 923 924 void 925 DateFormatTest::tryPattern(SimpleDateFormat& sdf, UDate d, const char* pattern, UDate expected) 926 { 927 UErrorCode status = U_ZERO_ERROR; 928 if (pattern != 0) sdf.applyPattern(pattern); 929 UnicodeString thePat; 930 logln((UnicodeString)"pattern: " + sdf.toPattern(thePat)); 931 UnicodeString formatResult; (*(DateFormat*)&sdf).format(d, formatResult); 932 logln((UnicodeString)" format -> " + formatResult); 933 // try { 934 UDate d2 = sdf.parse(formatResult, status); 935 logln((UnicodeString)" parse(" + formatResult + ") -> " + dateToString(d2)); 936 if (d2 != expected) errln((UnicodeString)"FAIL: Expected " + dateToString(expected)); 937 UnicodeString format2; (*(DateFormat*)&sdf).format(d2, format2); 938 logln((UnicodeString)" format -> " + format2); 939 if (!(formatResult == format2)) errln((UnicodeString)"FAIL: Round trip drift"); 940 //} 941 //catch(Exception e) { 942 if (U_FAILURE(status)) 943 errln((UnicodeString)"Error: " + (int32_t)status); 944 //} 945 } 946 947 // ------------------------------------- 948 949 /** 950 * Test the handling of single quotes in patterns. 951 */ 952 void 953 DateFormatTest::TestQuotePattern161() 954 { 955 UErrorCode status = U_ZERO_ERROR; 956 SimpleDateFormat* formatter = new SimpleDateFormat((UnicodeString)"MM/dd/yyyy 'at' hh:mm:ss a zzz", status); 957 if (U_FAILURE(status)) { 958 dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status)); 959 delete formatter; 960 return; 961 } 962 UDate currentTime_1 = date(97, UCAL_AUGUST, 13, 10, 42, 28); 963 UnicodeString dateString; ((DateFormat*)formatter)->format(currentTime_1, dateString); 964 UnicodeString exp("08/13/1997 at 10:42:28 AM "); 965 logln((UnicodeString)"format(" + dateToString(currentTime_1) + ") = " + dateString); 966 if (0 != dateString.compareBetween(0, exp.length(), exp, 0, exp.length())) errln((UnicodeString)"FAIL: Expected " + exp); 967 delete formatter; 968 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 969 } 970 971 // ------------------------------------- 972 973 /** 974 * Verify the correct behavior when handling invalid input strings. 975 */ 976 void 977 DateFormatTest::TestBadInput135() 978 { 979 UErrorCode status = U_ZERO_ERROR; 980 DateFormat::EStyle looks[] = { 981 DateFormat::SHORT, DateFormat::MEDIUM, DateFormat::LONG, DateFormat::FULL 982 }; 983 int32_t looks_length = UPRV_LENGTHOF(looks); 984 const char* strings[] = { 985 "Mar 15", "Mar 15 1997", "asdf", "3/1/97 1:23:", "3/1/00 1:23:45 AM" 986 }; 987 int32_t strings_length = UPRV_LENGTHOF(strings); 988 DateFormat *full = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::LONG); 989 if(full==NULL) { 990 dataerrln("could not create date time instance"); 991 return; 992 } 993 UnicodeString expected("March 1, 2000 at 1:23:45 AM "); 994 for (int32_t i = 0; i < strings_length;++i) { 995 const char* text = strings[i]; 996 for (int32_t j = 0; j < looks_length;++j) { 997 DateFormat::EStyle dateLook = looks[j]; 998 for (int32_t k = 0; k < looks_length;++k) { 999 DateFormat::EStyle timeLook = looks[k]; 1000 DateFormat *df = DateFormat::createDateTimeInstance(dateLook, timeLook); 1001 if (df == NULL){ 1002 dataerrln("Error calling DateFormat::createDateTimeInstance()"); 1003 continue; 1004 } 1005 UnicodeString prefix = UnicodeString(text) + ", " + dateLook + "/" + timeLook + ": "; 1006 //try { 1007 UDate when = df->parse(text, status); 1008 if (when == 0 && U_SUCCESS(status)) { 1009 errln(prefix + "SHOULD NOT HAPPEN: parse returned 0."); 1010 continue; 1011 } 1012 if (U_SUCCESS(status)) 1013 { 1014 UnicodeString format; 1015 UnicodeString pattern; 1016 SimpleDateFormat* sdtfmt = dynamic_cast<SimpleDateFormat*>(df); 1017 if (sdtfmt != NULL) { 1018 sdtfmt->toPattern(pattern); 1019 } 1020 full->format(when, format); 1021 logln(prefix + "OK: " + format); 1022 if (0!=format.compareBetween(0, expected.length(), expected, 0, expected.length())) 1023 errln((UnicodeString)"FAIL: Parse \"" + text + "\", pattern \"" + pattern + "\", expected " + expected + " got " + format); 1024 } 1025 //} 1026 //catch(ParseException e) { 1027 else 1028 status = U_ZERO_ERROR; 1029 //} 1030 //catch(StringIndexOutOfBoundsException e) { 1031 // errln(prefix + "SHOULD NOT HAPPEN: " + (int)status); 1032 //} 1033 delete df; 1034 } 1035 } 1036 } 1037 delete full; 1038 if (U_FAILURE(status)) 1039 errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 1040 } 1041 1042 static const char* const parseFormats[] = { 1043 "MMMM d, yyyy", 1044 "MMMM d yyyy", 1045 "M/d/yy", 1046 "d MMMM, yyyy", 1047 "d MMMM yyyy", 1048 "d MMMM", 1049 "MMMM d", 1050 "yyyy", 1051 "h:mm a MMMM d, yyyy" 1052 }; 1053 1054 #if 0 1055 // strict inputStrings 1056 static const char* const inputStrings[] = { 1057 "bogus string", 0, 0, 0, 0, 0, 0, 0, 0, 0, 1058 "April 1, 1997", "April 1, 1997", 0, 0, 0, 0, 0, "April 1", 0, 0, 1059 "Jan 1, 1970", "January 1, 1970", 0, 0, 0, 0, 0, "January 1", 0, 0, 1060 "Jan 1 2037", 0, "January 1 2037", 0, 0, 0, 0, "January 1", 0, 0, 1061 "1/1/70", 0, 0, "1/1/70", 0, 0, 0, 0, "0001", 0, 1062 "5 May 1997", 0, 0, 0, 0, "5 May 1997", "5 May", 0, "0005", 0, 1063 "16 May", 0, 0, 0, 0, 0, "16 May", 0, "0016", 0, 1064 "April 30", 0, 0, 0, 0, 0, 0, "April 30", 0, 0, 1065 "1998", 0, 0, 0, 0, 0, 0, 0, "1998", 0, 1066 "1", 0, 0, 0, 0, 0, 0, 0, "0001", 0, 1067 "3:00 pm Jan 1, 1997", 0, 0, 0, 0, 0, 0, 0, "0003", "3:00 PM January 1, 1997", 1068 }; 1069 #else 1070 // lenient inputStrings 1071 static const char* const inputStrings[] = { 1072 "bogus string", 0, 0, 0, 0, 0, 0, 0, 0, 0, 1073 "April 1, 1997", "April 1, 1997", "April 1 1997", "4/1/97", 0, 0, 0, "April 1", 0, 0, 1074 "Jan 1, 1970", "January 1, 1970", "January 1 1970", "1/1/70", 0, 0, 0, "January 1", 0, 0, 1075 "Jan 1 2037", "January 1, 2037", "January 1 2037", "1/1/37", 0, 0, 0, "January 1", 0, 0, 1076 "1/1/70", "January 1, 0070", "January 1 0070", "1/1/70", "1 January, 0070", "1 January 0070", "1 January", "January 1", "0001", 0, 1077 "5 May 1997", 0, 0, 0, "5 May, 1997", "5 May 1997", "5 May", 0, "0005", 0, 1078 "16 May", 0, 0, 0, 0, 0, "16 May", 0, "0016", 0, 1079 "April 30", 0, 0, 0, 0, 0, 0, "April 30", 0, 0, 1080 "1998", 0, 0, 0, 0, 0, 0, 0, "1998", 0, 1081 "1", 0, 0, 0, 0, 0, 0, 0, "0001", 0, 1082 "3:00 pm Jan 1, 1997", 0, 0, 0, 0, 0, 0, 0, "0003", "3:00 PM January 1, 1997", 1083 }; 1084 #endif 1085 1086 // ------------------------------------- 1087 1088 /** 1089 * Verify the correct behavior when parsing an array of inputs against an 1090 * array of patterns, with known results. The results are encoded after 1091 * the input strings in each row. 1092 */ 1093 void 1094 DateFormatTest::TestBadInput135a() 1095 { 1096 UErrorCode status = U_ZERO_ERROR; 1097 SimpleDateFormat* dateParse = new SimpleDateFormat(status); 1098 if(U_FAILURE(status)) { 1099 dataerrln("Failed creating SimpleDateFormat with %s. Quitting test", u_errorName(status)); 1100 delete dateParse; 1101 return; 1102 } 1103 const char* s; 1104 UDate date; 1105 const uint32_t PF_LENGTH = UPRV_LENGTHOF(parseFormats); 1106 const uint32_t INPUT_LENGTH = UPRV_LENGTHOF(inputStrings); 1107 1108 dateParse->applyPattern("d MMMM, yyyy"); 1109 dateParse->adoptTimeZone(TimeZone::createDefault()); 1110 s = "not parseable"; 1111 UnicodeString thePat; 1112 logln(UnicodeString("Trying to parse \"") + s + "\" with " + dateParse->toPattern(thePat)); 1113 //try { 1114 date = dateParse->parse(s, status); 1115 if (U_SUCCESS(status)) 1116 errln((UnicodeString)"FAIL: Expected exception during parse"); 1117 //} 1118 //catch(Exception ex) { 1119 else 1120 logln((UnicodeString)"Exception during parse: " + (int32_t)status); 1121 status = U_ZERO_ERROR; 1122 //} 1123 for (uint32_t i = 0; i < INPUT_LENGTH; i += (PF_LENGTH + 1)) { 1124 ParsePosition parsePosition(0); 1125 UnicodeString s( inputStrings[i]); 1126 for (uint32_t index = 0; index < PF_LENGTH;++index) { 1127 const char* expected = inputStrings[i + 1 + index]; 1128 dateParse->applyPattern(parseFormats[index]); 1129 dateParse->adoptTimeZone(TimeZone::createDefault()); 1130 //try { 1131 parsePosition.setIndex(0); 1132 date = dateParse->parse(s, parsePosition); 1133 if (parsePosition.getIndex() != 0) { 1134 UnicodeString s1, s2; 1135 s.extract(0, parsePosition.getIndex(), s1); 1136 s.extract(parsePosition.getIndex(), s.length(), s2); 1137 if (date == 0) { 1138 errln((UnicodeString)"ERROR: null result fmt=\"" + 1139 parseFormats[index] + 1140 "\" pos=" + parsePosition.getIndex() + " " + 1141 s1 + "|" + s2); 1142 } 1143 else { 1144 UnicodeString result; 1145 ((DateFormat*)dateParse)->format(date, result); 1146 logln((UnicodeString)"Parsed \"" + s + "\" using \"" + dateParse->toPattern(thePat) + "\" to: " + result); 1147 if (expected == 0) 1148 errln((UnicodeString)"FAIL: Expected parse failure, got " + result); 1149 else if (!(result == expected)) 1150 errln(UnicodeString("FAIL: Parse \"") + s + UnicodeString("\", expected ") + expected + UnicodeString(", got ") + result); 1151 } 1152 } 1153 else if (expected != 0) { 1154 errln(UnicodeString("FAIL: Expected ") + expected + " from \"" + 1155 s + "\" with \"" + dateParse->toPattern(thePat) + "\""); 1156 } 1157 //} 1158 //catch(Exception ex) { 1159 if (U_FAILURE(status)) 1160 errln((UnicodeString)"An exception was thrown during parse: " + (int32_t)status); 1161 //} 1162 } 1163 } 1164 delete dateParse; 1165 if (U_FAILURE(status)) 1166 errln((UnicodeString)"FAIL: UErrorCode received during test: " + (int32_t)status); 1167 } 1168 1169 // ------------------------------------- 1170 1171 /** 1172 * Test the parsing of two-digit years. 1173 */ 1174 void 1175 DateFormatTest::TestTwoDigitYear() 1176 { 1177 UErrorCode ec = U_ZERO_ERROR; 1178 SimpleDateFormat fmt("dd/MM/yy", Locale::getUK(), ec); 1179 if (U_FAILURE(ec)) { 1180 dataerrln("FAIL: SimpleDateFormat constructor - %s", u_errorName(ec)); 1181 return; 1182 } 1183 parse2DigitYear(fmt, "5/6/30", date(130, UCAL_JUNE, 5)); 1184 parse2DigitYear(fmt, "4/6/50", date(50, UCAL_JUNE, 4)); 1185 } 1186 1187 // ------------------------------------- 1188 1189 void 1190 DateFormatTest::parse2DigitYear(DateFormat& fmt, const char* str, UDate expected) 1191 { 1192 UErrorCode status = U_ZERO_ERROR; 1193 //try { 1194 UDate d = fmt.parse(str, status); 1195 UnicodeString thePat; 1196 logln(UnicodeString("Parsing \"") + str + "\" with " + ((SimpleDateFormat*)&fmt)->toPattern(thePat) + 1197 " => " + dateToString(d)); 1198 if (d != expected) errln((UnicodeString)"FAIL: Expected " + expected); 1199 //} 1200 //catch(ParseException e) { 1201 if (U_FAILURE(status)) 1202 errln((UnicodeString)"FAIL: Got exception"); 1203 //} 1204 } 1205 1206 // ------------------------------------- 1207 1208 /** 1209 * Test the formatting of time zones. 1210 */ 1211 void 1212 DateFormatTest::TestDateFormatZone061() 1213 { 1214 UErrorCode status = U_ZERO_ERROR; 1215 UDate date; 1216 DateFormat *formatter; 1217 date= 859248000000.0; 1218 logln((UnicodeString)"Date 1997/3/25 00:00 GMT: " + date); 1219 formatter = new SimpleDateFormat((UnicodeString)"dd-MMM-yyyyy HH:mm", Locale::getUK(), status); 1220 if(U_FAILURE(status)) { 1221 dataerrln("Failed creating SimpleDateFormat with %s. Quitting test", u_errorName(status)); 1222 delete formatter; 1223 return; 1224 } 1225 formatter->adoptTimeZone(TimeZone::createTimeZone("GMT")); 1226 UnicodeString temp; formatter->format(date, temp); 1227 logln((UnicodeString)"Formatted in GMT to: " + temp); 1228 //try { 1229 UDate tempDate = formatter->parse(temp, status); 1230 logln((UnicodeString)"Parsed to: " + dateToString(tempDate)); 1231 if (tempDate != date) errln((UnicodeString)"FAIL: Expected " + dateToString(date)); 1232 //} 1233 //catch(Throwable t) { 1234 if (U_FAILURE(status)) 1235 errln((UnicodeString)"Date Formatter throws: " + (int32_t)status); 1236 //} 1237 delete formatter; 1238 } 1239 1240 // ------------------------------------- 1241 1242 /** 1243 * Test the formatting of time zones. 1244 */ 1245 void 1246 DateFormatTest::TestDateFormatZone146() 1247 { 1248 TimeZone *saveDefault = TimeZone::createDefault(); 1249 1250 //try { 1251 TimeZone *thedefault = TimeZone::createTimeZone("GMT"); 1252 TimeZone::setDefault(*thedefault); 1253 // java.util.Locale.setDefault(new java.util.Locale("ar", "", "")); 1254 1255 // check to be sure... its GMT all right 1256 TimeZone *testdefault = TimeZone::createDefault(); 1257 UnicodeString testtimezone; 1258 testdefault->getID(testtimezone); 1259 if (testtimezone == "GMT") 1260 logln("Test timezone = " + testtimezone); 1261 else 1262 dataerrln("Test timezone should be GMT, not " + testtimezone); 1263 1264 UErrorCode status = U_ZERO_ERROR; 1265 // now try to use the default GMT time zone 1266 GregorianCalendar *greenwichcalendar = 1267 new GregorianCalendar(1997, 3, 4, 23, 0, status); 1268 if (U_FAILURE(status)) { 1269 dataerrln("Fail new GregorianCalendar: %s", u_errorName(status)); 1270 } else { 1271 //*****************************greenwichcalendar.setTimeZone(TimeZone.getDefault()); 1272 //greenwichcalendar.set(1997, 3, 4, 23, 0); 1273 // try anything to set hour to 23:00 !!! 1274 greenwichcalendar->set(UCAL_HOUR_OF_DAY, 23); 1275 // get time 1276 UDate greenwichdate = greenwichcalendar->getTime(status); 1277 // format every way 1278 UnicodeString DATA [] = { 1279 UnicodeString("simple format: "), UnicodeString("04/04/97 23:00 GMT"), 1280 UnicodeString("MM/dd/yy HH:mm z"), 1281 UnicodeString("full format: "), UnicodeString("Friday, April 4, 1997 11:00:00 o'clock PM GMT"), 1282 UnicodeString("EEEE, MMMM d, yyyy h:mm:ss 'o''clock' a z"), 1283 UnicodeString("long format: "), UnicodeString("April 4, 1997 11:00:00 PM GMT"), 1284 UnicodeString("MMMM d, yyyy h:mm:ss a z"), 1285 UnicodeString("default format: "), UnicodeString("04-Apr-97 11:00:00 PM"), 1286 UnicodeString("dd-MMM-yy h:mm:ss a"), 1287 UnicodeString("short format: "), UnicodeString("4/4/97 11:00 PM"), 1288 UnicodeString("M/d/yy h:mm a") 1289 }; 1290 int32_t DATA_length = UPRV_LENGTHOF(DATA); 1291 1292 for (int32_t i=0; i<DATA_length; i+=3) { 1293 DateFormat *fmt = new SimpleDateFormat(DATA[i+2], Locale::getEnglish(), status); 1294 if (U_FAILURE(status)) { 1295 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 1296 break; 1297 } 1298 fmt->setCalendar(*greenwichcalendar); 1299 UnicodeString result; 1300 result = fmt->format(greenwichdate, result); 1301 logln(DATA[i] + result); 1302 if (result != DATA[i+1]) 1303 errln("FAIL: Expected " + DATA[i+1] + ", got " + result); 1304 delete fmt; 1305 } 1306 } 1307 //} 1308 //finally { 1309 TimeZone::adoptDefault(saveDefault); 1310 //} 1311 delete testdefault; 1312 delete greenwichcalendar; 1313 delete thedefault; 1314 1315 1316 } 1317 1318 // ------------------------------------- 1319 1320 /** 1321 * Test the formatting of dates in different locales. 1322 */ 1323 void 1324 DateFormatTest::TestLocaleDateFormat() // Bug 495 1325 { 1326 UDate testDate = date(97, UCAL_SEPTEMBER, 15); 1327 DateFormat *dfFrench = DateFormat::createDateTimeInstance(DateFormat::FULL, 1328 DateFormat::FULL, Locale::getFrench()); 1329 DateFormat *dfUS = DateFormat::createDateTimeInstance(DateFormat::FULL, 1330 DateFormat::FULL, Locale::getUS()); 1331 UnicodeString expectedFRENCH ( "lundi 15 septembre 1997 \\u00E0 00:00:00 heure d\\u2019\\u00E9t\\u00E9 du Pacifique", -1, US_INV ); 1332 expectedFRENCH = expectedFRENCH.unescape(); 1333 UnicodeString expectedUS ( "Monday, September 15, 1997 at 12:00:00 AM Pacific Daylight Time" ); 1334 logln((UnicodeString)"Date set to : " + dateToString(testDate)); 1335 UnicodeString out; 1336 if (dfUS == NULL || dfFrench == NULL){ 1337 dataerrln("Error calling DateFormat::createDateTimeInstance)"); 1338 delete dfUS; 1339 delete dfFrench; 1340 return; 1341 } 1342 1343 dfFrench->format(testDate, out); 1344 logln((UnicodeString)"Date Formated with French Locale " + out); 1345 if (!(out == expectedFRENCH)) 1346 errln((UnicodeString)"FAIL: Expected " + expectedFRENCH); 1347 out.truncate(0); 1348 dfUS->format(testDate, out); 1349 logln((UnicodeString)"Date Formated with US Locale " + out); 1350 if (!(out == expectedUS)) 1351 errln((UnicodeString)"FAIL: Expected " + expectedUS); 1352 delete dfUS; 1353 delete dfFrench; 1354 } 1355 1356 void 1357 DateFormatTest::TestFormattingLocaleTimeSeparator() 1358 { 1359 // This test not as useful as it once was, since timeSeparator 1360 // in the Arabic locale is changed back to ":" in CLDR 28. 1361 const UDate testDate = 874266720000.; // Sun Sep 14 21:52:00 CET 1997 1362 logln((UnicodeString)"Date set to : " + dateToString(testDate)); 1363 1364 const LocalPointer<const TimeZone> tz(TimeZone::createTimeZone("CET")); 1365 1366 const LocalPointer<DateFormat> dfArab(DateFormat::createTimeInstance( 1367 DateFormat::SHORT, Locale("ar", "EG"))); 1368 1369 const LocalPointer<DateFormat> dfLatn(DateFormat::createTimeInstance( 1370 DateFormat::SHORT, Locale("ar", "EG", NULL, "numbers=latn"))); 1371 1372 if (dfLatn.isNull() || dfArab.isNull()) { 1373 dataerrln("Error calling DateFormat::createTimeInstance()"); 1374 return; 1375 } 1376 1377 dfArab->setTimeZone(*tz); 1378 dfLatn->setTimeZone(*tz); 1379 1380 const UnicodeString expectedArab = UnicodeString( 1381 "\\u0669:\\u0665\\u0662 \\u0645", -1, US_INV).unescape(); 1382 1383 const UnicodeString expectedLatn = UnicodeString( 1384 "9:52 \\u0645", -1, US_INV).unescape(); 1385 1386 UnicodeString actualArab; 1387 UnicodeString actualLatn; 1388 1389 dfArab->format(testDate, actualArab); 1390 dfLatn->format(testDate, actualLatn); 1391 1392 assertEquals("Arab", expectedArab, actualArab); 1393 assertEquals("Latn", expectedLatn, actualLatn); 1394 } 1395 1396 /** 1397 * Test DateFormat(Calendar) API 1398 */ 1399 void DateFormatTest::TestDateFormatCalendar() { 1400 DateFormat *date=0, *time=0, *full=0; 1401 Calendar *cal=0; 1402 UnicodeString str; 1403 ParsePosition pos; 1404 UDate when; 1405 UErrorCode ec = U_ZERO_ERROR; 1406 1407 /* Create a formatter for date fields. */ 1408 date = DateFormat::createDateInstance(DateFormat::kShort, Locale::getUS()); 1409 if (date == NULL) { 1410 dataerrln("FAIL: createDateInstance failed"); 1411 goto FAIL; 1412 } 1413 1414 /* Create a formatter for time fields. */ 1415 time = DateFormat::createTimeInstance(DateFormat::kShort, Locale::getUS()); 1416 if (time == NULL) { 1417 errln("FAIL: createTimeInstance failed"); 1418 goto FAIL; 1419 } 1420 1421 /* Create a full format for output */ 1422 full = DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, 1423 Locale::getUS()); 1424 if (full == NULL) { 1425 errln("FAIL: createInstance failed"); 1426 goto FAIL; 1427 } 1428 1429 /* Create a calendar */ 1430 cal = Calendar::createInstance(Locale::getUS(), ec); 1431 if (cal == NULL || U_FAILURE(ec)) { 1432 errln((UnicodeString)"FAIL: Calendar::createInstance failed with " + 1433 u_errorName(ec)); 1434 goto FAIL; 1435 } 1436 1437 /* Parse the date */ 1438 cal->clear(); 1439 str = UnicodeString("4/5/2001", ""); 1440 pos.setIndex(0); 1441 date->parse(str, *cal, pos); 1442 if (pos.getIndex() != str.length()) { 1443 errln((UnicodeString)"FAIL: DateFormat::parse(4/5/2001) failed at " + 1444 pos.getIndex()); 1445 goto FAIL; 1446 } 1447 1448 /* Parse the time */ 1449 str = UnicodeString("5:45 PM", ""); 1450 pos.setIndex(0); 1451 time->parse(str, *cal, pos); 1452 if (pos.getIndex() != str.length()) { 1453 errln((UnicodeString)"FAIL: DateFormat::parse(17:45) failed at " + 1454 pos.getIndex()); 1455 goto FAIL; 1456 } 1457 1458 /* Check result */ 1459 when = cal->getTime(ec); 1460 if (U_FAILURE(ec)) { 1461 errln((UnicodeString)"FAIL: cal->getTime() failed with " + u_errorName(ec)); 1462 goto FAIL; 1463 } 1464 str.truncate(0); 1465 full->format(when, str); 1466 // Thursday, April 5, 2001 5:45:00 PM PDT 986517900000 1467 if (when == 986517900000.0) { 1468 logln("Ok: Parsed result: " + str); 1469 } else { 1470 errln("FAIL: Parsed result: " + str + ", exp 4/5/2001 5:45 PM"); 1471 } 1472 1473 FAIL: 1474 delete date; 1475 delete time; 1476 delete full; 1477 delete cal; 1478 } 1479 1480 /** 1481 * Test DateFormat's parsing of space characters. See jitterbug 1916. 1482 */ 1483 void DateFormatTest::TestSpaceParsing() { 1484 const char* DATA[] = { 1485 "yyyy MM dd HH:mm:ss", 1486 1487 // pattern, input, expected parse or NULL if expect parse failure 1488 "MMMM d yy", " 04 05 06", "2006 04 05 00:00:00", 1489 NULL, "04 05 06", "2006 04 05 00:00:00", 1490 1491 "MM d yy", " 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, "04 / 05 / 06", "2006 04 05 00:00:00", 1497 NULL, "Apr / 05/ 06", "2006 04 05 00:00:00", 1498 NULL, "Apr-05-06", "2006 04 05 00:00:00", 1499 NULL, "Apr 05, 2006", "2006 04 05 00:00:00", 1500 1501 "MMMM d yy", " Apr 05 06", "2006 04 05 00:00:00", 1502 NULL, "Apr 05 06", "2006 04 05 00:00:00", 1503 NULL, "Apr05 06", "2006 04 05 00:00:00", 1504 1505 "hh:mm:ss a", "12:34:56 PM", "1970 01 01 12:34:56", 1506 NULL, "12:34:56PM", "1970 01 01 12:34:56", 1507 NULL, "12.34.56PM", "1970 01 01 12:34:56", 1508 NULL, "12 : 34 : 56 PM", "1970 01 01 12:34:56", 1509 1510 "MM d yy 'at' hh:mm:ss a", "04/05/06 12:34:56 PM", "2006 04 05 12:34:56", 1511 1512 "MMMM dd yyyy hh:mm a", "September 27, 1964 21:56 PM", "1964 09 28 09:56:00", 1513 NULL, "November 4, 2008 0:13 AM", "2008 11 04 00:13:00", 1514 1515 "HH'h'mm'min'ss's'", "12h34min56s", "1970 01 01 12:34:56", 1516 NULL, "12h34mi56s", "1970 01 01 12:34:56", 1517 NULL, "12h34m56s", "1970 01 01 12:34:56", 1518 NULL, "12:34:56", "1970 01 01 12:34:56" 1519 }; 1520 const int32_t DATA_len = UPRV_LENGTHOF(DATA); 1521 1522 expectParse(DATA, DATA_len, Locale("en")); 1523 } 1524 1525 /** 1526 * Test handling of "HHmmss" pattern. 1527 */ 1528 void DateFormatTest::TestExactCountFormat() { 1529 const char* DATA[] = { 1530 "yyyy MM dd HH:mm:ss", 1531 1532 // pattern, input, expected parse or NULL if expect parse failure 1533 "HHmmss", "123456", "1970 01 01 12:34:56", 1534 NULL, "12345", "1970 01 01 01:23:45", 1535 NULL, "1234", NULL, 1536 NULL, "00-05", NULL, 1537 NULL, "12-34", NULL, 1538 NULL, "00+05", NULL, 1539 "ahhmm", "PM730", "1970 01 01 19:30:00", 1540 }; 1541 const int32_t DATA_len = UPRV_LENGTHOF(DATA); 1542 1543 expectParse(DATA, DATA_len, Locale("en")); 1544 } 1545 1546 /** 1547 * Test handling of white space. 1548 */ 1549 void DateFormatTest::TestWhiteSpaceParsing() { 1550 const char* DATA[] = { 1551 "yyyy MM dd", 1552 1553 // pattern, input, expected parse or null if expect parse failure 1554 1555 // Pattern space run should parse input text space run 1556 "MM d yy", " 04 01 03", "2003 04 01", 1557 NULL, " 04 01 03 ", "2003 04 01", 1558 }; 1559 const int32_t DATA_len = UPRV_LENGTHOF(DATA); 1560 1561 expectParse(DATA, DATA_len, Locale("en")); 1562 } 1563 1564 1565 void DateFormatTest::TestInvalidPattern() { 1566 UErrorCode ec = U_ZERO_ERROR; 1567 SimpleDateFormat f(UnicodeString("Yesterday"), ec); 1568 if (U_FAILURE(ec)) { 1569 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(ec)); 1570 return; 1571 } 1572 UnicodeString out; 1573 FieldPosition pos; 1574 f.format((UDate)0, out, pos); 1575 logln(out); 1576 // The bug is that the call to format() will crash. By not 1577 // crashing, the test passes. 1578 } 1579 1580 void DateFormatTest::TestGreekMay() { 1581 UErrorCode ec = U_ZERO_ERROR; 1582 UDate date = -9896080848000.0; 1583 SimpleDateFormat fmt("EEEE, dd MMMM yyyy h:mm:ss a", Locale("el", "", ""), ec); 1584 if (U_FAILURE(ec)) { 1585 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(ec)); 1586 return; 1587 } 1588 UnicodeString str; 1589 fmt.format(date, str); 1590 ParsePosition pos(0); 1591 UDate d2 = fmt.parse(str, pos); 1592 if (date != d2) { 1593 errln("FAIL: unable to parse strings where case-folding changes length"); 1594 } 1595 } 1596 1597 void DateFormatTest::TestStandAloneMonths() 1598 { 1599 const char *EN_DATA[] = { 1600 "yyyy MM dd HH:mm:ss", 1601 1602 "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", 1603 "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", 1604 "yyyy LLLL dd H:mm:ss", "F", "2004 03 10 16:36:31", "2004 March 10 16:36:31", 1605 "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", 1606 1607 "LLLL", "fp", "1970 01 01 0:00:00", "January", "1970 01 01 0:00:00", 1608 "LLLL", "fp", "1970 02 01 0:00:00", "February", "1970 02 01 0:00:00", 1609 "LLLL", "fp", "1970 03 01 0:00:00", "March", "1970 03 01 0:00:00", 1610 "LLLL", "fp", "1970 04 01 0:00:00", "April", "1970 04 01 0:00:00", 1611 "LLLL", "fp", "1970 05 01 0:00:00", "May", "1970 05 01 0:00:00", 1612 "LLLL", "fp", "1970 06 01 0:00:00", "June", "1970 06 01 0:00:00", 1613 "LLLL", "fp", "1970 07 01 0:00:00", "July", "1970 07 01 0:00:00", 1614 "LLLL", "fp", "1970 08 01 0:00:00", "August", "1970 08 01 0:00:00", 1615 "LLLL", "fp", "1970 09 01 0:00:00", "September", "1970 09 01 0:00:00", 1616 "LLLL", "fp", "1970 10 01 0:00:00", "October", "1970 10 01 0:00:00", 1617 "LLLL", "fp", "1970 11 01 0:00:00", "November", "1970 11 01 0:00:00", 1618 "LLLL", "fp", "1970 12 01 0:00:00", "December", "1970 12 01 0:00:00", 1619 1620 "LLL", "fp", "1970 01 01 0:00:00", "Jan", "1970 01 01 0:00:00", 1621 "LLL", "fp", "1970 02 01 0:00:00", "Feb", "1970 02 01 0:00:00", 1622 "LLL", "fp", "1970 03 01 0:00:00", "Mar", "1970 03 01 0:00:00", 1623 "LLL", "fp", "1970 04 01 0:00:00", "Apr", "1970 04 01 0:00:00", 1624 "LLL", "fp", "1970 05 01 0:00:00", "May", "1970 05 01 0:00:00", 1625 "LLL", "fp", "1970 06 01 0:00:00", "Jun", "1970 06 01 0:00:00", 1626 "LLL", "fp", "1970 07 01 0:00:00", "Jul", "1970 07 01 0:00:00", 1627 "LLL", "fp", "1970 08 01 0:00:00", "Aug", "1970 08 01 0:00:00", 1628 "LLL", "fp", "1970 09 01 0:00:00", "Sep", "1970 09 01 0:00:00", 1629 "LLL", "fp", "1970 10 01 0:00:00", "Oct", "1970 10 01 0:00:00", 1630 "LLL", "fp", "1970 11 01 0:00:00", "Nov", "1970 11 01 0:00:00", 1631 "LLL", "fp", "1970 12 01 0:00:00", "Dec", "1970 12 01 0:00:00", 1632 }; 1633 1634 const char *CS_DATA[] = { 1635 "yyyy MM dd HH:mm:ss", 1636 1637 "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", 1638 "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", 1639 "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", 1640 "yyyy LLLL dd H:mm:ss", "F", "2004 04 10 16:36:31", "2004 duben 10 16:36:31", 1641 "yyyy MMMM dd H:mm:ss", "F", "2004 04 10 16:36:31", "2004 dubna 10 16:36:31", 1642 "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", 1643 "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", 1644 1645 "LLLL", "fp", "1970 01 01 0:00:00", "leden", "1970 01 01 0:00:00", 1646 "LLLL", "fp", "1970 02 01 0:00:00", "\\u00FAnor", "1970 02 01 0:00:00", 1647 "LLLL", "fp", "1970 03 01 0:00:00", "b\\u0159ezen", "1970 03 01 0:00:00", 1648 "LLLL", "fp", "1970 04 01 0:00:00", "duben", "1970 04 01 0:00:00", 1649 "LLLL", "fp", "1970 05 01 0:00:00", "kv\\u011Bten", "1970 05 01 0:00:00", 1650 "LLLL", "fp", "1970 06 01 0:00:00", "\\u010Derven", "1970 06 01 0:00:00", 1651 "LLLL", "fp", "1970 07 01 0:00:00", "\\u010Dervenec", "1970 07 01 0:00:00", 1652 "LLLL", "fp", "1970 08 01 0:00:00", "srpen", "1970 08 01 0:00:00", 1653 "LLLL", "fp", "1970 09 01 0:00:00", "z\\u00E1\\u0159\\u00ED", "1970 09 01 0:00:00", 1654 "LLLL", "fp", "1970 10 01 0:00:00", "\\u0159\\u00EDjen", "1970 10 01 0:00:00", 1655 "LLLL", "fp", "1970 11 01 0:00:00", "listopad", "1970 11 01 0:00:00", 1656 "LLLL", "fp", "1970 12 01 0:00:00", "prosinec", "1970 12 01 0:00:00", 1657 1658 "LLL", "fp", "1970 01 01 0:00:00", "led", "1970 01 01 0:00:00", 1659 "LLL", "fp", "1970 02 01 0:00:00", "\\u00FAno", "1970 02 01 0:00:00", 1660 "LLL", "fp", "1970 03 01 0:00:00", "b\\u0159e", "1970 03 01 0:00:00", 1661 "LLL", "fp", "1970 04 01 0:00:00", "dub", "1970 04 01 0:00:00", 1662 "LLL", "fp", "1970 05 01 0:00:00", "kv\\u011B", "1970 05 01 0:00:00", 1663 "LLL", "fp", "1970 06 01 0:00:00", "\\u010Dvn", "1970 06 01 0:00:00", 1664 "LLL", "fp", "1970 07 01 0:00:00", "\\u010Dvc", "1970 07 01 0:00:00", 1665 "LLL", "fp", "1970 08 01 0:00:00", "srp", "1970 08 01 0:00:00", 1666 "LLL", "fp", "1970 09 01 0:00:00", "z\\u00E1\\u0159", "1970 09 01 0:00:00", 1667 "LLL", "fp", "1970 10 01 0:00:00", "\\u0159\\u00EDj", "1970 10 01 0:00:00", 1668 "LLL", "fp", "1970 11 01 0:00:00", "lis", "1970 11 01 0:00:00", 1669 "LLL", "fp", "1970 12 01 0:00:00", "pro", "1970 12 01 0:00:00", 1670 }; 1671 1672 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1673 expect(CS_DATA, UPRV_LENGTHOF(CS_DATA), Locale("cs", "", "")); 1674 } 1675 1676 void DateFormatTest::TestStandAloneDays() 1677 { 1678 const char *EN_DATA[] = { 1679 "yyyy MM dd HH:mm:ss", 1680 1681 "cccc", "fp", "1970 01 04 0:00:00", "Sunday", "1970 01 04 0:00:00", 1682 "cccc", "fp", "1970 01 05 0:00:00", "Monday", "1970 01 05 0:00:00", 1683 "cccc", "fp", "1970 01 06 0:00:00", "Tuesday", "1970 01 06 0:00:00", 1684 "cccc", "fp", "1970 01 07 0:00:00", "Wednesday", "1970 01 07 0:00:00", 1685 "cccc", "fp", "1970 01 01 0:00:00", "Thursday", "1970 01 01 0:00:00", 1686 "cccc", "fp", "1970 01 02 0:00:00", "Friday", "1970 01 02 0:00:00", 1687 "cccc", "fp", "1970 01 03 0:00:00", "Saturday", "1970 01 03 0:00:00", 1688 1689 "ccc", "fp", "1970 01 04 0:00:00", "Sun", "1970 01 04 0:00:00", 1690 "ccc", "fp", "1970 01 05 0:00:00", "Mon", "1970 01 05 0:00:00", 1691 "ccc", "fp", "1970 01 06 0:00:00", "Tue", "1970 01 06 0:00:00", 1692 "ccc", "fp", "1970 01 07 0:00:00", "Wed", "1970 01 07 0:00:00", 1693 "ccc", "fp", "1970 01 01 0:00:00", "Thu", "1970 01 01 0:00:00", 1694 "ccc", "fp", "1970 01 02 0:00:00", "Fri", "1970 01 02 0:00:00", 1695 "ccc", "fp", "1970 01 03 0:00:00", "Sat", "1970 01 03 0:00:00", 1696 }; 1697 1698 const char *CS_DATA[] = { 1699 "yyyy MM dd HH:mm:ss", 1700 1701 "cccc", "fp", "1970 01 04 0:00:00", "ned\\u011Ble", "1970 01 04 0:00:00", 1702 "cccc", "fp", "1970 01 05 0:00:00", "pond\\u011Bl\\u00ED", "1970 01 05 0:00:00", 1703 "cccc", "fp", "1970 01 06 0:00:00", "\\u00FAter\\u00FD", "1970 01 06 0:00:00", 1704 "cccc", "fp", "1970 01 07 0:00:00", "st\\u0159eda", "1970 01 07 0:00:00", 1705 "cccc", "fp", "1970 01 01 0:00:00", "\\u010Dtvrtek", "1970 01 01 0:00:00", 1706 "cccc", "fp", "1970 01 02 0:00:00", "p\\u00E1tek", "1970 01 02 0:00:00", 1707 "cccc", "fp", "1970 01 03 0:00:00", "sobota", "1970 01 03 0:00:00", 1708 1709 "ccc", "fp", "1970 01 04 0:00:00", "ne", "1970 01 04 0:00:00", 1710 "ccc", "fp", "1970 01 05 0:00:00", "po", "1970 01 05 0:00:00", 1711 "ccc", "fp", "1970 01 06 0:00:00", "\\u00FAt", "1970 01 06 0:00:00", 1712 "ccc", "fp", "1970 01 07 0:00:00", "st", "1970 01 07 0:00:00", 1713 "ccc", "fp", "1970 01 01 0:00:00", "\\u010Dt", "1970 01 01 0:00:00", 1714 "ccc", "fp", "1970 01 02 0:00:00", "p\\u00E1", "1970 01 02 0:00:00", 1715 "ccc", "fp", "1970 01 03 0:00:00", "so", "1970 01 03 0:00:00", 1716 }; 1717 1718 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1719 expect(CS_DATA, UPRV_LENGTHOF(CS_DATA), Locale("cs", "", "")); 1720 } 1721 1722 void DateFormatTest::TestShortDays() 1723 { 1724 const char *EN_DATA[] = { 1725 "yyyy MM dd HH:mm:ss", 1726 1727 "EEEEEE, MMM d y", "fp", "2013 01 13 0:00:00", "Su, Jan 13 2013", "2013 01 13 0:00:00", 1728 "EEEEEE, MMM d y", "fp", "2013 01 16 0:00:00", "We, Jan 16 2013", "2013 01 16 0:00:00", 1729 "EEEEEE d", "fp", "1970 01 17 0:00:00", "Sa 17", "1970 01 17 0:00:00", 1730 "cccccc d", "fp", "1970 01 17 0:00:00", "Sa 17", "1970 01 17 0:00:00", 1731 "cccccc", "fp", "1970 01 03 0:00:00", "Sa", "1970 01 03 0:00:00", 1732 }; 1733 const char *SV_DATA[] = { 1734 "yyyy MM dd HH:mm:ss", 1735 1736 "EEEEEE d MMM y", "fp", "2013 01 13 0:00:00", "s\\u00F6 13 jan. 2013", "2013 01 13 0:00:00", 1737 "EEEEEE d MMM y", "fp", "2013 01 16 0:00:00", "on 16 jan. 2013", "2013 01 16 0:00:00", 1738 "EEEEEE d", "fp", "1970 01 17 0:00:00", "l\\u00F6 17", "1970 01 17 0:00:00", 1739 "cccccc d", "fp", "1970 01 17 0:00:00", "l\\u00F6 17", "1970 01 17 0:00:00", 1740 "cccccc", "fp", "1970 01 03 0:00:00", "l\\u00F6", "1970 01 03 0:00:00", 1741 }; 1742 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1743 expect(SV_DATA, UPRV_LENGTHOF(SV_DATA), Locale("sv", "", "")); 1744 } 1745 1746 void DateFormatTest::TestNarrowNames() 1747 { 1748 const char *EN_DATA[] = { 1749 "yyyy MM dd HH:mm:ss", 1750 1751 "yyyy MMMMM dd H:mm:ss", "2004 03 10 16:36:31", "2004 M 10 16:36:31", 1752 "yyyy LLLLL dd H:mm:ss", "2004 03 10 16:36:31", "2004 M 10 16:36:31", 1753 1754 "MMMMM", "1970 01 01 0:00:00", "J", 1755 "MMMMM", "1970 02 01 0:00:00", "F", 1756 "MMMMM", "1970 03 01 0:00:00", "M", 1757 "MMMMM", "1970 04 01 0:00:00", "A", 1758 "MMMMM", "1970 05 01 0:00:00", "M", 1759 "MMMMM", "1970 06 01 0:00:00", "J", 1760 "MMMMM", "1970 07 01 0:00:00", "J", 1761 "MMMMM", "1970 08 01 0:00:00", "A", 1762 "MMMMM", "1970 09 01 0:00:00", "S", 1763 "MMMMM", "1970 10 01 0:00:00", "O", 1764 "MMMMM", "1970 11 01 0:00:00", "N", 1765 "MMMMM", "1970 12 01 0:00:00", "D", 1766 1767 "LLLLL", "1970 01 01 0:00:00", "J", 1768 "LLLLL", "1970 02 01 0:00:00", "F", 1769 "LLLLL", "1970 03 01 0:00:00", "M", 1770 "LLLLL", "1970 04 01 0:00:00", "A", 1771 "LLLLL", "1970 05 01 0:00:00", "M", 1772 "LLLLL", "1970 06 01 0:00:00", "J", 1773 "LLLLL", "1970 07 01 0:00:00", "J", 1774 "LLLLL", "1970 08 01 0:00:00", "A", 1775 "LLLLL", "1970 09 01 0:00:00", "S", 1776 "LLLLL", "1970 10 01 0:00:00", "O", 1777 "LLLLL", "1970 11 01 0:00:00", "N", 1778 "LLLLL", "1970 12 01 0:00:00", "D", 1779 1780 "EEEEE", "1970 01 04 0:00:00", "S", 1781 "EEEEE", "1970 01 05 0:00:00", "M", 1782 "EEEEE", "1970 01 06 0:00:00", "T", 1783 "EEEEE", "1970 01 07 0:00:00", "W", 1784 "EEEEE", "1970 01 01 0:00:00", "T", 1785 "EEEEE", "1970 01 02 0:00:00", "F", 1786 "EEEEE", "1970 01 03 0:00:00", "S", 1787 1788 "ccccc", "1970 01 04 0:00:00", "S", 1789 "ccccc", "1970 01 05 0:00:00", "M", 1790 "ccccc", "1970 01 06 0:00:00", "T", 1791 "ccccc", "1970 01 07 0:00:00", "W", 1792 "ccccc", "1970 01 01 0:00:00", "T", 1793 "ccccc", "1970 01 02 0:00:00", "F", 1794 "ccccc", "1970 01 03 0:00:00", "S", 1795 1796 "h:mm a", "2015 01 01 10:00:00", "10:00 AM", 1797 "h:mm a", "2015 01 01 22:00:00", "10:00 PM", 1798 "h:mm aaaaa", "2015 01 01 10:00:00", "10:00 a", 1799 "h:mm aaaaa", "2015 01 01 22:00:00", "10:00 p", 1800 }; 1801 1802 const char *CS_DATA[] = { 1803 "yyyy MM dd HH:mm:ss", 1804 1805 "yyyy LLLLL dd H:mm:ss", "2004 04 10 16:36:31", "2004 4 10 16:36:31", 1806 "yyyy MMMMM dd H:mm:ss", "2004 04 10 16:36:31", "2004 4 10 16:36:31", 1807 1808 "MMMMM", "1970 01 01 0:00:00", "1", 1809 "MMMMM", "1970 02 01 0:00:00", "2", 1810 "MMMMM", "1970 03 01 0:00:00", "3", 1811 "MMMMM", "1970 04 01 0:00:00", "4", 1812 "MMMMM", "1970 05 01 0:00:00", "5", 1813 "MMMMM", "1970 06 01 0:00:00", "6", 1814 "MMMMM", "1970 07 01 0:00:00", "7", 1815 "MMMMM", "1970 08 01 0:00:00", "8", 1816 "MMMMM", "1970 09 01 0:00:00", "9", 1817 "MMMMM", "1970 10 01 0:00:00", "10", 1818 "MMMMM", "1970 11 01 0:00:00", "11", 1819 "MMMMM", "1970 12 01 0:00:00", "12", 1820 1821 "LLLLL", "1970 01 01 0:00:00", "1", 1822 "LLLLL", "1970 02 01 0:00:00", "2", 1823 "LLLLL", "1970 03 01 0:00:00", "3", 1824 "LLLLL", "1970 04 01 0:00:00", "4", 1825 "LLLLL", "1970 05 01 0:00:00", "5", 1826 "LLLLL", "1970 06 01 0:00:00", "6", 1827 "LLLLL", "1970 07 01 0:00:00", "7", 1828 "LLLLL", "1970 08 01 0:00:00", "8", 1829 "LLLLL", "1970 09 01 0:00:00", "9", 1830 "LLLLL", "1970 10 01 0:00:00", "10", 1831 "LLLLL", "1970 11 01 0:00:00", "11", 1832 "LLLLL", "1970 12 01 0:00:00", "12", 1833 1834 "EEEEE", "1970 01 04 0:00:00", "N", 1835 "EEEEE", "1970 01 05 0:00:00", "P", 1836 "EEEEE", "1970 01 06 0:00:00", "\\u00DA", 1837 "EEEEE", "1970 01 07 0:00:00", "S", 1838 "EEEEE", "1970 01 01 0:00:00", "\\u010C", 1839 "EEEEE", "1970 01 02 0:00:00", "P", 1840 "EEEEE", "1970 01 03 0:00:00", "S", 1841 1842 "ccccc", "1970 01 04 0:00:00", "N", 1843 "ccccc", "1970 01 05 0:00:00", "P", 1844 "ccccc", "1970 01 06 0:00:00", "\\u00DA", 1845 "ccccc", "1970 01 07 0:00:00", "S", 1846 "ccccc", "1970 01 01 0:00:00", "\\u010C", 1847 "ccccc", "1970 01 02 0:00:00", "P", 1848 "ccccc", "1970 01 03 0:00:00", "S", 1849 1850 "h:mm a", "2015 01 01 10:00:00", "10:00 dop.", 1851 "h:mm a", "2015 01 01 22:00:00", "10:00 odp.", 1852 "h:mm aaaaa", "2015 01 01 10:00:00", "10:00 dop.", 1853 "h:mm aaaaa", "2015 01 01 22:00:00", "10:00 odp.", 1854 }; 1855 1856 const char *CA_DATA[] = { 1857 "yyyy MM dd HH:mm:ss", 1858 1859 "h:mm a", "2015 01 01 10:00:00", "10:00 a. m.", 1860 "h:mm a", "2015 01 01 22:00:00", "10:00 p. m.", 1861 "h:mm aaaaa", "2015 01 01 10:00:00", "10:00 a. m.", 1862 "h:mm aaaaa", "2015 01 01 22:00:00", "10:00 p. m.", 1863 }; 1864 1865 expectFormat(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1866 expectFormat(CS_DATA, UPRV_LENGTHOF(CS_DATA), Locale("cs", "", "")); 1867 expectFormat(CA_DATA, UPRV_LENGTHOF(CA_DATA), Locale("ca", "", "")); 1868 } 1869 1870 void DateFormatTest::TestEras() 1871 { 1872 const char *EN_DATA[] = { 1873 "yyyy MM dd", 1874 1875 "MMMM dd yyyy G", "fp", "1951 07 17", "July 17 1951 AD", "1951 07 17", 1876 "MMMM dd yyyy GG", "fp", "1951 07 17", "July 17 1951 AD", "1951 07 17", 1877 "MMMM dd yyyy GGG", "fp", "1951 07 17", "July 17 1951 AD", "1951 07 17", 1878 "MMMM dd yyyy GGGG", "fp", "1951 07 17", "July 17 1951 Anno Domini", "1951 07 17", 1879 1880 "MMMM dd yyyy G", "fp", "-438 07 17", "July 17 0439 BC", "-438 07 17", 1881 "MMMM dd yyyy GG", "fp", "-438 07 17", "July 17 0439 BC", "-438 07 17", 1882 "MMMM dd yyyy GGG", "fp", "-438 07 17", "July 17 0439 BC", "-438 07 17", 1883 "MMMM dd yyyy GGGG", "fp", "-438 07 17", "July 17 0439 Before Christ", "-438 07 17", 1884 }; 1885 1886 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1887 } 1888 1889 void DateFormatTest::TestQuarters() 1890 { 1891 const char *EN_DATA[] = { 1892 "yyyy MM dd", 1893 1894 "Q", "fp", "1970 01 01", "1", "1970 01 01", 1895 "QQ", "fp", "1970 04 01", "02", "1970 04 01", 1896 "QQQ", "fp", "1970 07 01", "Q3", "1970 07 01", 1897 "QQQQ", "fp", "1970 10 01", "4th quarter", "1970 10 01", 1898 1899 "q", "fp", "1970 01 01", "1", "1970 01 01", 1900 "qq", "fp", "1970 04 01", "02", "1970 04 01", 1901 "qqq", "fp", "1970 07 01", "Q3", "1970 07 01", 1902 "qqqq", "fp", "1970 10 01", "4th quarter", "1970 10 01", 1903 1904 "Qyy", "fp", "2015 04 01", "215", "2015 04 01", 1905 "QQyy", "fp", "2015 07 01", "0315", "2015 07 01", 1906 }; 1907 1908 expect(EN_DATA, UPRV_LENGTHOF(EN_DATA), Locale("en", "", "")); 1909 } 1910 1911 /** 1912 * Test parsing. Input is an array that starts with the following 1913 * header: 1914 * 1915 * [0] = pattern string to parse [i+2] with 1916 * 1917 * followed by test cases, each of which is 3 array elements: 1918 * 1919 * [i] = pattern, or NULL to reuse prior pattern 1920 * [i+1] = input string 1921 * [i+2] = expected parse result (parsed with pattern [0]) 1922 * 1923 * If expect parse failure, then [i+2] should be NULL. 1924 */ 1925 void DateFormatTest::expectParse(const char** data, int32_t data_length, 1926 const Locale& loc) { 1927 const UDate FAIL = (UDate) -1; 1928 const UnicodeString FAIL_STR("parse failure"); 1929 int32_t i = 0; 1930 1931 UErrorCode ec = U_ZERO_ERROR; 1932 SimpleDateFormat fmt("", loc, ec); 1933 SimpleDateFormat ref(data[i++], loc, ec); 1934 SimpleDateFormat gotfmt("G yyyy MM dd HH:mm:ss z", loc, ec); 1935 if (U_FAILURE(ec)) { 1936 dataerrln("FAIL: SimpleDateFormat constructor - %s", u_errorName(ec)); 1937 return; 1938 } 1939 1940 const char* currentPat = NULL; 1941 while (i<data_length) { 1942 const char* pattern = data[i++]; 1943 const char* input = data[i++]; 1944 const char* expected = data[i++]; 1945 1946 ec = U_ZERO_ERROR; 1947 if (pattern != NULL) { 1948 fmt.applyPattern(pattern); 1949 currentPat = pattern; 1950 } 1951 UDate got = fmt.parse(input, ec); 1952 UnicodeString gotstr(FAIL_STR); 1953 if (U_FAILURE(ec)) { 1954 got = FAIL; 1955 } else { 1956 gotstr.remove(); 1957 gotfmt.format(got, gotstr); 1958 } 1959 1960 UErrorCode ec2 = U_ZERO_ERROR; 1961 UDate exp = FAIL; 1962 UnicodeString expstr(FAIL_STR); 1963 if (expected != NULL) { 1964 expstr = expected; 1965 exp = ref.parse(expstr, ec2); 1966 if (U_FAILURE(ec2)) { 1967 // This only happens if expected is in wrong format -- 1968 // should never happen once test is debugged. 1969 errln("FAIL: Internal test error"); 1970 return; 1971 } 1972 } 1973 1974 if (got == exp) { 1975 logln((UnicodeString)"Ok: " + input + " x " + 1976 currentPat + " => " + gotstr); 1977 } else { 1978 errln((UnicodeString)"FAIL: " + input + " x " + 1979 currentPat + " => " + gotstr + ", expected " + 1980 expstr); 1981 } 1982 } 1983 } 1984 1985 /** 1986 * Test formatting and parsing. Input is an array that starts 1987 * with the following header: 1988 * 1989 * [0] = pattern string to parse [i+2] with 1990 * 1991 * followed by test cases, each of which is 3 array elements: 1992 * 1993 * [i] = pattern, or null to reuse prior pattern 1994 * [i+1] = control string, either "fp", "pf", or "F". 1995 * [i+2..] = data strings 1996 * 1997 * The number of data strings depends on the control string. 1998 * Examples: 1999 * 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", 2000 * 'f': Format date [i+2] (as parsed using pattern [0]) and expect string [i+3]. 2001 * 'p': Parse string [i+3] and expect date [i+4]. 2002 * 2003 * 2. "y/M/d H:mm:ss.SSS", "F", "2004 03 10 16:36:31.567", "2004/3/10 16:36:31.567" 2004 * 'F': Format date [i+2] and expect string [i+3], 2005 * then parse string [i+3] and expect date [i+2]. 2006 * 2007 * 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", 2008 * 'p': Parse string [i+2] and expect date [i+3]. 2009 * 'f': Format date [i+3] and expect string [i+4]. 2010 */ 2011 void DateFormatTest::expect(const char** data, int32_t data_length, 2012 const Locale& loc) { 2013 int32_t i = 0; 2014 UErrorCode ec = U_ZERO_ERROR; 2015 UnicodeString str, str2; 2016 SimpleDateFormat fmt("", loc, ec); 2017 SimpleDateFormat ref(data[i++], loc, ec); 2018 SimpleDateFormat univ("EE G yyyy MM dd HH:mm:ss.SSS z", loc, ec); 2019 if (U_FAILURE(ec)) { 2020 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(ec)); 2021 return; 2022 } 2023 2024 UnicodeString currentPat; 2025 while (i<data_length) { 2026 const char* pattern = data[i++]; 2027 if (pattern != NULL) { 2028 fmt.applyPattern(pattern); 2029 currentPat = pattern; 2030 } 2031 2032 const char* control = data[i++]; 2033 2034 if (uprv_strcmp(control, "fp") == 0) { 2035 // 'f' 2036 const char* datestr = data[i++]; 2037 const char* string = data[i++]; 2038 UDate date = ref.parse(ctou(datestr), ec); 2039 if (!assertSuccess("parse", ec)) return; 2040 assertEquals((UnicodeString)"\"" + currentPat + "\".format(" + datestr + ")", 2041 ctou(string), 2042 fmt.format(date, str.remove())); 2043 // 'p' 2044 datestr = data[i++]; 2045 date = ref.parse(ctou(datestr), ec); 2046 if (!assertSuccess("parse", ec)) return; 2047 UDate parsedate = fmt.parse(ctou(string), ec); 2048 if (assertSuccess((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", ec)) { 2049 assertEquals((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", 2050 univ.format(date, str.remove()), 2051 univ.format(parsedate, str2.remove())); 2052 } 2053 } 2054 2055 else if (uprv_strcmp(control, "pf") == 0) { 2056 // 'p' 2057 const char* string = data[i++]; 2058 const char* datestr = data[i++]; 2059 UDate date = ref.parse(ctou(datestr), ec); 2060 if (!assertSuccess("parse", ec)) return; 2061 UDate parsedate = fmt.parse(ctou(string), ec); 2062 if (assertSuccess((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", ec)) { 2063 assertEquals((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", 2064 univ.format(date, str.remove()), 2065 univ.format(parsedate, str2.remove())); 2066 } 2067 // 'f' 2068 string = data[i++]; 2069 assertEquals((UnicodeString)"\"" + currentPat + "\".format(" + datestr + ")", 2070 ctou(string), 2071 fmt.format(date, str.remove())); 2072 } 2073 2074 else if (uprv_strcmp(control, "F") == 0) { 2075 const char* datestr = data[i++]; 2076 const char* string = data[i++]; 2077 UDate date = ref.parse(ctou(datestr), ec); 2078 if (!assertSuccess("parse", ec)) return; 2079 assertEquals((UnicodeString)"\"" + currentPat + "\".format(" + datestr + ")", 2080 ctou(string), 2081 fmt.format(date, str.remove())); 2082 2083 UDate parsedate = fmt.parse(string, ec); 2084 if (assertSuccess((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", ec)) { 2085 assertEquals((UnicodeString)"\"" + currentPat + "\".parse(" + string + ")", 2086 univ.format(date, str.remove()), 2087 univ.format(parsedate, str2.remove())); 2088 } 2089 } 2090 2091 else { 2092 errln((UnicodeString)"FAIL: Invalid control string " + control); 2093 return; 2094 } 2095 } 2096 } 2097 2098 /** 2099 * Test formatting. Input is an array that starts 2100 * with the following header: 2101 * 2102 * [0] = pattern string to parse [i+2] with 2103 * 2104 * followed by test cases, each of which is 3 array elements: 2105 * 2106 * [i] = pattern, or null to reuse prior pattern 2107 * [i+1] = data string a 2108 * [i+2] = data string b 2109 * 2110 * Examples: 2111 * Format date [i+1] and expect string [i+2]. 2112 * 2113 * "y/M/d H:mm:ss.SSSS", "2004/3/10 16:36:31.5679", "2004 03 10 16:36:31.567" 2114 */ 2115 void DateFormatTest::expectFormat(const char** data, int32_t data_length, 2116 const Locale& loc) { 2117 int32_t i = 0; 2118 UErrorCode ec = U_ZERO_ERROR; 2119 UnicodeString str, str2; 2120 SimpleDateFormat fmt("", loc, ec); 2121 SimpleDateFormat ref(data[i++], loc, ec); 2122 SimpleDateFormat univ("EE G yyyy MM dd HH:mm:ss.SSS z", loc, ec); 2123 if (U_FAILURE(ec)) { 2124 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(ec)); 2125 return; 2126 } 2127 2128 UnicodeString currentPat; 2129 2130 while (i<data_length) { 2131 const char* pattern = data[i++]; 2132 if (pattern != NULL) { 2133 fmt.applyPattern(pattern); 2134 currentPat = pattern; 2135 } 2136 2137 const char* datestr = data[i++]; 2138 const char* string = data[i++]; 2139 UDate date = ref.parse(ctou(datestr), ec); 2140 if (!assertSuccess("parse", ec)) return; 2141 assertEquals((UnicodeString)"\"" + currentPat + "\".format(" + datestr + ")", 2142 ctou(string), 2143 fmt.format(date, str.remove())); 2144 } 2145 } 2146 2147 void DateFormatTest::TestGenericTime() { 2148 const Locale en("en"); 2149 // Note: We no longer parse strings in different styles. 2150 /* 2151 const char* ZDATA[] = { 2152 "yyyy MM dd HH:mm zzz", 2153 // round trip 2154 "y/M/d H:mm zzzz", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Standard Time", 2155 "y/M/d H:mm zzz", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 PST", 2156 "y/M/d H:mm vvvv", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Time", 2157 "y/M/d H:mm v", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 PT", 2158 // non-generic timezone string influences dst offset even if wrong for date/time 2159 "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", 2160 "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", 2161 "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", 2162 "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", 2163 // generic timezone generates dst offset appropriate for local time 2164 "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", 2165 "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", 2166 "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", 2167 "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", 2168 // daylight savings time transition edge cases. 2169 // time to parse does not really exist, PT interpreted as earlier time 2170 "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", 2171 "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", 2172 "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", 2173 "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", 2174 "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", 2175 "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", 2176 "y/M/d H:mm", "pf", "2005/4/3 2:30", "2005 04 03 03:30 PDT", "2005/4/3 3:30", 2177 // time to parse is ambiguous, PT interpreted as later time 2178 "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", 2179 "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", 2180 "y/M/d H:mm", "pf", "2005/10/30 1:30 PT", "2005 10 30 01:30 PST", "2005/10/30 1:30", 2181 2182 "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", 2183 "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", 2184 "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", 2185 "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", 2186 "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", 2187 "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", 2188 "y/M/d H:mm", "pf", "2004/10/31 1:30", "2004 10 31 01:30 PST", "2004/10/31 1:30", 2189 }; 2190 */ 2191 const char* ZDATA[] = { 2192 "yyyy MM dd HH:mm zzz", 2193 // round trip 2194 "y/M/d H:mm zzzz", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Standard Time", 2195 "y/M/d H:mm zzz", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 PST", 2196 "y/M/d H:mm vvvv", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 Pacific Time", 2197 "y/M/d H:mm v", "F", "2004 01 01 01:00 PST", "2004/1/1 1:00 PT", 2198 // non-generic timezone string influences dst offset even if wrong for date/time 2199 "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", 2200 "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", 2201 // generic timezone generates dst offset appropriate for local time 2202 "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", 2203 "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", 2204 "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", 2205 "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", 2206 // daylight savings time transition edge cases. 2207 // time to parse does not really exist, PT interpreted as earlier time 2208 "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", 2209 "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", 2210 "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", 2211 "y/M/d H:mm", "pf", "2005/4/3 2:30", "2005 04 03 03:30 PDT", "2005/4/3 3:30", 2212 // time to parse is ambiguous, PT interpreted as later time 2213 "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", 2214 "y/M/d H:mm", "pf", "2005/10/30 1:30 PT", "2005 10 30 01:30 PST", "2005/10/30 1:30", 2215 2216 "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", 2217 "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", 2218 "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", 2219 "y/M/d H:mm", "pf", "2004/10/31 1:30", "2004 10 31 01:30 PST", "2004/10/31 1:30", 2220 }; 2221 2222 const int32_t ZDATA_length = UPRV_LENGTHOF(ZDATA); 2223 expect(ZDATA, ZDATA_length, en); 2224 2225 UErrorCode status = U_ZERO_ERROR; 2226 2227 logln("cross format/parse tests"); // Note: We no longer support cross format/parse 2228 UnicodeString basepat("yy/MM/dd H:mm "); 2229 SimpleDateFormat formats[] = { 2230 SimpleDateFormat(basepat + "vvv", en, status), 2231 SimpleDateFormat(basepat + "vvvv", en, status), 2232 SimpleDateFormat(basepat + "zzz", en, status), 2233 SimpleDateFormat(basepat + "zzzz", en, status) 2234 }; 2235 if (U_FAILURE(status)) { 2236 dataerrln("Fail construct SimpleDateFormat: %s", u_errorName(status)); 2237 return; 2238 } 2239 const int32_t formats_length = UPRV_LENGTHOF(formats); 2240 2241 UnicodeString test; 2242 SimpleDateFormat univ("yyyy MM dd HH:mm zzz", en, status); 2243 ASSERT_OK(status); 2244 const UnicodeString times[] = { 2245 "2004 01 02 03:04 PST", 2246 "2004 07 08 09:10 PDT" 2247 }; 2248 int32_t times_length = UPRV_LENGTHOF(times); 2249 for (int i = 0; i < times_length; ++i) { 2250 UDate d = univ.parse(times[i], status); 2251 logln(UnicodeString("\ntime: ") + d); 2252 for (int j = 0; j < formats_length; ++j) { 2253 test.remove(); 2254 formats[j].format(d, test); 2255 logln("\ntest: '" + test + "'"); 2256 for (int k = 0; k < formats_length; ++k) { 2257 UDate t = formats[k].parse(test, status); 2258 if (U_SUCCESS(status)) { 2259 if (d != t) { 2260 errln((UnicodeString)"FAIL: format " + k + 2261 " incorrectly parsed output of format " + j + 2262 " (" + test + "), returned " + 2263 dateToString(t) + " instead of " + dateToString(d)); 2264 } else { 2265 logln((UnicodeString)"OK: format " + k + " parsed ok"); 2266 } 2267 } else if (status == U_PARSE_ERROR) { 2268 errln((UnicodeString)"FAIL: format " + k + 2269 " could not parse output of format " + j + 2270 " (" + test + ")"); 2271 } 2272 } 2273 } 2274 } 2275 } 2276 2277 void DateFormatTest::TestGenericTimeZoneOrder() { 2278 // generic times should parse the same no matter what the placement of the time zone string 2279 2280 // Note: We no longer support cross style format/parse 2281 2282 //const char* XDATA[] = { 2283 // "yyyy MM dd HH:mm zzz", 2284 // // standard time, explicit daylight/standard 2285 // "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", 2286 // "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", 2287 // "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", 2288 2289 // // standard time, generic 2290 // "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", 2291 // "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", 2292 // "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", 2293 2294 // // dahylight time, explicit daylight/standard 2295 // "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", 2296 // "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", 2297 // "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", 2298 2299 // // daylight time, generic 2300 // "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", 2301 // "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", 2302 // "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", 2303 //}; 2304 const char* XDATA[] = { 2305 "yyyy MM dd HH:mm zzz", 2306 // standard time, explicit daylight/standard 2307 "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", 2308 "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", 2309 "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", 2310 2311 // standard time, generic 2312 "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", 2313 "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", 2314 "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", 2315 2316 // dahylight time, explicit daylight/standard 2317 "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", 2318 "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", 2319 "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", 2320 2321 // daylight time, generic 2322 "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", 2323 "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", 2324 "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", 2325 }; 2326 const int32_t XDATA_length = UPRV_LENGTHOF(XDATA); 2327 Locale en("en"); 2328 expect(XDATA, XDATA_length, en); 2329 } 2330 2331 void DateFormatTest::TestZTimeZoneParsing(void) { 2332 UErrorCode status = U_ZERO_ERROR; 2333 const Locale en("en"); 2334 UnicodeString test; 2335 //SimpleDateFormat univ("yyyy-MM-dd'T'HH:mm Z", en, status); 2336 SimpleDateFormat univ("HH:mm Z", en, status); 2337 if (failure(status, "construct SimpleDateFormat", TRUE)) return; 2338 const TimeZone *t = TimeZone::getGMT(); 2339 univ.setTimeZone(*t); 2340 2341 univ.setLenient(false); 2342 ParsePosition pp(0); 2343 struct { 2344 UnicodeString input; 2345 UnicodeString expected_result; 2346 } tests[] = { 2347 { "11:00 -0200", "13:00 +0000" }, 2348 { "11:00 +0200", "09:00 +0000" }, 2349 { "11:00 +0400", "07:00 +0000" }, 2350 { "11:00 +0530", "05:30 +0000" } 2351 }; 2352 2353 UnicodeString result; 2354 int32_t tests_length = UPRV_LENGTHOF(tests); 2355 for (int i = 0; i < tests_length; ++i) { 2356 pp.setIndex(0); 2357 UDate d = univ.parse(tests[i].input, pp); 2358 if(pp.getIndex() != tests[i].input.length()){ 2359 errln("Test %i: setZoneString() did not succeed. Consumed: %i instead of %i", 2360 i, pp.getIndex(), tests[i].input.length()); 2361 return; 2362 } 2363 result.remove(); 2364 univ.format(d, result); 2365 if(result != tests[i].expected_result) { 2366 errln("Expected " + tests[i].expected_result 2367 + " got " + result); 2368 return; 2369 } 2370 logln("SUCCESS: Parsed " + tests[i].input 2371 + " got " + result 2372 + " expected " + tests[i].expected_result); 2373 } 2374 } 2375 2376 void DateFormatTest::TestHost(void) 2377 { 2378 #if U_PLATFORM_USES_ONLY_WIN32_API 2379 Win32DateTimeTest::testLocales(this); 2380 #endif 2381 } 2382 2383 // Relative Date Tests 2384 2385 void DateFormatTest::TestRelative(int daysdelta, 2386 const Locale& loc, 2387 const char *expectChars) { 2388 char banner[25]; 2389 sprintf(banner, "%d", daysdelta); 2390 UnicodeString bannerStr(banner, ""); 2391 2392 UErrorCode status = U_ZERO_ERROR; 2393 2394 FieldPosition pos(FieldPosition::DONT_CARE); 2395 UnicodeString test; 2396 Locale en("en"); 2397 DateFormat *fullrelative = DateFormat::createDateInstance(DateFormat::kFullRelative, loc); 2398 2399 if (fullrelative == NULL) { 2400 dataerrln("DateFormat::createDateInstance(DateFormat::kFullRelative, %s) returned NULL", loc.getName()); 2401 return; 2402 } 2403 2404 DateFormat *full = DateFormat::createDateInstance(DateFormat::kFull , loc); 2405 2406 if (full == NULL) { 2407 errln("DateFormat::createDateInstance(DateFormat::kFull, %s) returned NULL", loc.getName()); 2408 return; 2409 } 2410 2411 DateFormat *en_full = DateFormat::createDateInstance(DateFormat::kFull, en); 2412 2413 if (en_full == NULL) { 2414 errln("DateFormat::createDateInstance(DateFormat::kFull, en) returned NULL"); 2415 return; 2416 } 2417 2418 DateFormat *en_fulltime = DateFormat::createDateTimeInstance(DateFormat::kFull,DateFormat::kFull,en); 2419 2420 if (en_fulltime == NULL) { 2421 errln("DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, en) returned NULL"); 2422 return; 2423 } 2424 2425 UnicodeString result; 2426 UnicodeString normalResult; 2427 UnicodeString expect; 2428 UnicodeString parseResult; 2429 2430 Calendar *c = Calendar::createInstance(status); 2431 2432 // Today = Today 2433 c->setTime(Calendar::getNow(), status); 2434 if(daysdelta != 0) { 2435 c->add(Calendar::DATE,daysdelta,status); 2436 } 2437 ASSERT_OK(status); 2438 2439 // calculate the expected string 2440 if(expectChars != NULL) { 2441 expect = expectChars; 2442 } else { 2443 full->format(*c, expect, pos); // expected = normal full 2444 } 2445 2446 fullrelative ->format(*c, result, pos); 2447 en_full ->format(*c, normalResult, pos); 2448 2449 if(result != expect) { 2450 errln("FAIL: Relative Format ["+bannerStr+"] of "+normalResult+" failed, expected "+expect+" but got " + result); 2451 } else { 2452 logln("PASS: Relative Format ["+bannerStr+"] of "+normalResult+" got " + result); 2453 } 2454 2455 2456 //verify 2457 UDate d = fullrelative->parse(result, status); 2458 ASSERT_OK(status); 2459 2460 UnicodeString parseFormat; // parse rel->format full 2461 en_full->format(d, parseFormat, status); 2462 2463 UnicodeString origFormat; 2464 en_full->format(*c, origFormat, pos); 2465 2466 if(parseFormat!=origFormat) { 2467 errln("FAIL: Relative Parse ["+bannerStr+"] of "+result+" failed, expected "+parseFormat+" but got "+origFormat); 2468 } else { 2469 logln("PASS: Relative Parse ["+bannerStr+"] of "+result+" passed, got "+parseFormat); 2470 } 2471 2472 delete full; 2473 delete fullrelative; 2474 delete en_fulltime; 2475 delete en_full; 2476 delete c; 2477 } 2478 2479 2480 void DateFormatTest::TestRelative(void) 2481 { 2482 Locale en("en"); 2483 TestRelative( 0, en, "today"); 2484 TestRelative(-1, en, "yesterday"); 2485 TestRelative( 1, en, "tomorrow"); 2486 TestRelative( 2, en, NULL); 2487 TestRelative( -2, en, NULL); 2488 TestRelative( 3, en, NULL); 2489 TestRelative( -3, en, NULL); 2490 TestRelative( 300, en, NULL); 2491 TestRelative( -300, en, NULL); 2492 } 2493 2494 void DateFormatTest::TestRelativeClone(void) 2495 { 2496 /* 2497 Verify that a cloned formatter gives the same results 2498 and is useable after the original has been deleted. 2499 */ 2500 UErrorCode status = U_ZERO_ERROR; 2501 Locale loc("en"); 2502 UDate now = Calendar::getNow(); 2503 DateFormat *full = DateFormat::createDateInstance(DateFormat::kFullRelative, loc); 2504 if (full == NULL) { 2505 dataerrln("FAIL: Can't create Relative date instance"); 2506 return; 2507 } 2508 UnicodeString result1; 2509 full->format(now, result1, status); 2510 Format *fullClone = full->clone(); 2511 delete full; 2512 full = NULL; 2513 2514 UnicodeString result2; 2515 fullClone->format(now, result2, status); 2516 ASSERT_OK(status); 2517 if (result1 != result2) { 2518 errln("FAIL: Clone returned different result from non-clone."); 2519 } 2520 delete fullClone; 2521 } 2522 2523 void DateFormatTest::TestHostClone(void) 2524 { 2525 /* 2526 Verify that a cloned formatter gives the same results 2527 and is useable after the original has been deleted. 2528 */ 2529 // This is mainly important on Windows. 2530 UErrorCode status = U_ZERO_ERROR; 2531 Locale loc("en_US@compat=host"); 2532 UDate now = Calendar::getNow(); 2533 DateFormat *full = DateFormat::createDateInstance(DateFormat::kFull, loc); 2534 if (full == NULL) { 2535 dataerrln("FAIL: Can't create host date instance"); 2536 return; 2537 } 2538 UnicodeString result1; 2539 full->format(now, result1, status); 2540 Format *fullClone = full->clone(); 2541 delete full; 2542 full = NULL; 2543 2544 UnicodeString result2; 2545 fullClone->format(now, result2, status); 2546 ASSERT_OK(status); 2547 if (result1 != result2) { 2548 errln("FAIL: Clone returned different result from non-clone."); 2549 } 2550 delete fullClone; 2551 } 2552 2553 void DateFormatTest::TestHebrewClone(void) 2554 { 2555 /* 2556 Verify that a cloned formatter gives the same results 2557 and is useable after the original has been deleted. 2558 */ 2559 UErrorCode status = U_ZERO_ERROR; 2560 Locale loc("he@calendar=hebrew"); 2561 UDate now = Calendar::getNow(); 2562 LocalPointer<DateFormat> fmt( 2563 DateFormat::createDateInstance(DateFormat::kLong, loc)); 2564 if (fmt.isNull()) { 2565 dataerrln("FAIL: Can't create Hebrew date instance"); 2566 return; 2567 } 2568 UnicodeString result1; 2569 fmt->format(now, result1, status); 2570 LocalPointer<Format> fmtClone(fmt->clone()); 2571 2572 // free fmt to be sure that fmtClone is independent of fmt. 2573 fmt.adoptInstead(NULL); 2574 2575 UnicodeString result2; 2576 fmtClone->format(now, result2, status); 2577 ASSERT_OK(status); 2578 if (result1 != result2) { 2579 errln("FAIL: Clone returned different result from non-clone."); 2580 } 2581 } 2582 2583 static UBool getActualAndValidLocales( 2584 const Format &fmt, Locale &valid, Locale &actual) { 2585 const SimpleDateFormat* dat = dynamic_cast<const SimpleDateFormat*>(&fmt); 2586 if (dat == NULL) { 2587 return FALSE; 2588 } 2589 const DateFormatSymbols *sym = dat->getDateFormatSymbols(); 2590 if (sym == NULL) { 2591 return FALSE; 2592 } 2593 UErrorCode status = U_ZERO_ERROR; 2594 valid = sym->getLocale(ULOC_VALID_LOCALE, status); 2595 actual = sym->getLocale(ULOC_ACTUAL_LOCALE, status); 2596 return U_SUCCESS(status); 2597 } 2598 2599 void DateFormatTest::TestDateFormatSymbolsClone(void) 2600 { 2601 /* 2602 Verify that a cloned formatter gives the same results 2603 and is useable after the original has been deleted. 2604 */ 2605 Locale loc("de_CH_LUCERNE"); 2606 LocalPointer<DateFormat> fmt( 2607 DateFormat::createDateInstance(DateFormat::kDefault, loc)); 2608 if (fmt.isNull()) { 2609 dataerrln("FAIL: DateFormat::createDateInstance failed for %s", loc.getName()); 2610 return; 2611 } 2612 Locale valid1; 2613 Locale actual1; 2614 if (!getActualAndValidLocales(*fmt, valid1, actual1)) { 2615 dataerrln("FAIL: Could not fetch valid + actual locales"); 2616 return; 2617 } 2618 LocalPointer<Format> fmtClone(fmt->clone()); 2619 2620 // Free fmt to be sure that fmtClone is really independent of fmt. 2621 fmt.adoptInstead(NULL); 2622 Locale valid2; 2623 Locale actual2; 2624 if (!getActualAndValidLocales(*fmtClone, valid2, actual2)) { 2625 errln("FAIL: Could not fetch valid + actual locales"); 2626 return; 2627 } 2628 if (valid1 != valid2 || actual1 != actual2) { 2629 errln("Date format symbol locales of clone don't match original"); 2630 } 2631 } 2632 2633 void DateFormatTest::TestTimeZoneDisplayName() 2634 { 2635 // This test data was ported from ICU4J. Don't know why the 6th column in there because it's not being 2636 // used currently. 2637 const char *fallbackTests[][6] = { 2638 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 2639 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 2640 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZZ", "-08:00", "-8:00" }, 2641 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "PST", "America/Los_Angeles" }, 2642 { "en", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "Pacific Standard Time", "America/Los_Angeles" }, 2643 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2644 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2645 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "PDT", "America/Los_Angeles" }, 2646 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "Pacific Daylight Time", "America/Los_Angeles" }, 2647 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "PT", "America/Los_Angeles" }, 2648 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "Pacific Time", "America/Los_Angeles" }, 2649 { "en", "America/Los_Angeles", "2004-07-15T00:00:00Z", "VVVV", "Los Angeles Time", "America/Los_Angeles" }, 2650 { "en_GB", "America/Los_Angeles", "2004-01-15T12:00:00Z", "z", "GMT-8", "America/Los_Angeles" }, 2651 { "en", "America/Phoenix", "2004-01-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2652 { "en", "America/Phoenix", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2653 { "en", "America/Phoenix", "2004-01-15T00:00:00Z", "z", "MST", "America/Phoenix" }, 2654 { "en", "America/Phoenix", "2004-01-15T00:00:00Z", "zzzz", "Mountain Standard Time", "America/Phoenix" }, 2655 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2656 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2657 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "z", "MST", "America/Phoenix" }, 2658 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "zzzz", "Mountain Standard Time", "America/Phoenix" }, 2659 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "v", "MST", "America/Phoenix" }, 2660 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "vvvv", "Mountain Standard Time", "America/Phoenix" }, 2661 { "en", "America/Phoenix", "2004-07-15T00:00:00Z", "VVVV", "Phoenix Time", "America/Phoenix" }, 2662 2663 { "en", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2664 { "en", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2665 { "en", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2666 { "en", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "Argentina Standard Time", "-3:00" }, 2667 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2668 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2669 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2670 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "Argentina Standard Time", "-3:00" }, 2671 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires Time", "America/Buenos_Aires" }, 2672 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Argentina Standard Time", "America/Buenos_Aires" }, 2673 { "en", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "VVVV", "Buenos Aires Time", "America/Buenos_Aires" }, 2674 2675 { "en", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2676 { "en", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2677 { "en", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2678 { "en", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "Argentina Standard Time", "-3:00" }, 2679 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2680 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2681 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2682 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "Argentina Standard Time", "-3:00" }, 2683 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires Time", "America/Buenos_Aires" }, 2684 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Argentina Standard Time", "America/Buenos_Aires" }, 2685 { "en", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "VVVV", "Buenos Aires Time", "America/Buenos_Aires" }, 2686 2687 { "en", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 2688 { "en", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 2689 { "en", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 2690 { "en", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "Cuba Standard Time", "-5:00" }, 2691 { "en", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 2692 { "en", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 2693 { "en", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 2694 { "en", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "Cuba Daylight Time", "-4:00" }, 2695 { "en", "America/Havana", "2004-07-15T00:00:00Z", "v", "Cuba Time", "America/Havana" }, 2696 { "en", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "Cuba Time", "America/Havana" }, 2697 { "en", "America/Havana", "2004-07-15T00:00:00Z", "VVVV", "Cuba Time", "America/Havana" }, 2698 2699 { "en", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2700 { "en", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2701 { "en", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2702 { "en", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "Australian Eastern Daylight Time", "+11:00" }, 2703 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2704 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2705 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2706 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "Australian Eastern Standard Time", "+10:00" }, 2707 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "Sydney Time", "Australia/Sydney" }, 2708 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "Eastern Australia Time", "Australia/Sydney" }, 2709 { "en", "Australia/ACT", "2004-07-15T00:00:00Z", "VVVV", "Sydney Time", "Australia/Sydney" }, 2710 2711 { "en", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2712 { "en", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2713 { "en", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2714 { "en", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "Australian Eastern Daylight Time", "+11:00" }, 2715 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2716 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2717 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2718 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "Australian Eastern Standard Time", "+10:00" }, 2719 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "Sydney Time", "Australia/Sydney" }, 2720 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "Eastern Australia Time", "Australia/Sydney" }, 2721 { "en", "Australia/Sydney", "2004-07-15T00:00:00Z", "VVVV", "Sydney Time", "Australia/Sydney" }, 2722 2723 { "en", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 2724 { "en", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 2725 { "en", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 2726 { "en", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "Greenwich Mean Time", "+0:00" }, 2727 { "en", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 2728 { "en", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 2729 { "en", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "Europe/London" }, 2730 { "en", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "British Summer Time", "Europe/London" }, 2731 // icu en.txt has exemplar city for this time zone 2732 { "en", "Europe/London", "2004-07-15T00:00:00Z", "v", "United Kingdom Time", "Europe/London" }, 2733 { "en", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "United Kingdom Time", "Europe/London" }, 2734 { "en", "Europe/London", "2004-07-15T00:00:00Z", "VVVV", "United Kingdom Time", "Europe/London" }, 2735 2736 { "en", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2737 { "en", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2738 { "en", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2739 { "en", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2740 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2741 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2742 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2743 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2744 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 2745 { "en", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 2746 2747 // JB#5150 2748 { "en", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2749 { "en", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2750 { "en", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 2751 { "en", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "India Standard Time", "+5:30" }, 2752 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2753 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2754 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 2755 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "India Standard Time", "+5:30" }, 2756 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "India Time", "Asia/Calcutta" }, 2757 { "en", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "India Standard Time", "Asia/Calcutta" }, 2758 2759 // Proper CLDR primary zone support #9733 2760 { "en", "America/Santiago", "2013-01-01T00:00:00Z", "VVVV", "Chile Time", "America/Santiago" }, 2761 { "en", "Pacific/Easter", "2013-01-01T00:00:00Z", "VVVV", "Easter Time", "Pacific/Easter" }, 2762 2763 // ========== 2764 2765 { "de", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 2766 { "de", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 2767 { "de", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "-8:00" }, 2768 { "de", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "Nordamerikanische Westk\\u00fcsten-Normalzeit", "-8:00" }, 2769 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2770 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2771 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "-7:00" }, 2772 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "Nordamerikanische Westk\\u00fcsten-Sommerzeit", "-7:00" }, 2773 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "Los Angeles Zeit", "America/Los_Angeles" }, 2774 { "de", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "Nordamerikanische Westk\\u00fcstenzeit", "America/Los_Angeles" }, 2775 2776 { "de", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2777 { "de", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2778 { "de", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2779 { "de", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "Argentinische Normalzeit", "-3:00" }, 2780 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2781 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2782 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2783 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "Argentinische Normalzeit", "-3:00" }, 2784 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires Zeit", "America/Buenos_Aires" }, 2785 { "de", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Argentinische Normalzeit", "America/Buenos_Aires" }, 2786 2787 { "de", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2788 { "de", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2789 { "de", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2790 { "de", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "Argentinische Normalzeit", "-3:00" }, 2791 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2792 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2793 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2794 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "Argentinische Normalzeit", "-3:00" }, 2795 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires Zeit", "America/Buenos_Aires" }, 2796 { "de", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Argentinische Normalzeit", "America/Buenos_Aires" }, 2797 2798 { "de", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 2799 { "de", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 2800 { "de", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 2801 { "de", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "Kubanische Normalzeit", "-5:00" }, 2802 { "de", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 2803 { "de", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 2804 { "de", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 2805 { "de", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "Kubanische Sommerzeit", "-4:00" }, 2806 { "de", "America/Havana", "2004-07-15T00:00:00Z", "v", "Kuba Zeit", "America/Havana" }, 2807 { "de", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "Kubanische Zeit", "America/Havana" }, 2808 // added to test proper fallback of country name 2809 { "de_CH", "America/Havana", "2004-07-15T00:00:00Z", "v", "Kuba Zeit", "America/Havana" }, 2810 { "de_CH", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "Kubanische Zeit", "America/Havana" }, 2811 2812 { "de", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2813 { "de", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2814 { "de", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2815 { "de", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "Ostaustralische Sommerzeit", "+11:00" }, 2816 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2817 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2818 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2819 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "Ostaustralische Normalzeit", "+10:00" }, 2820 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "Sydney Zeit", "Australia/Sydney" }, 2821 { "de", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "Ostaustralische Zeit", "Australia/Sydney" }, 2822 2823 { "de", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2824 { "de", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2825 { "de", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2826 { "de", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "Ostaustralische Sommerzeit", "+11:00" }, 2827 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2828 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2829 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2830 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "Ostaustralische Normalzeit", "+10:00" }, 2831 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "Sydney Zeit", "Australia/Sydney" }, 2832 { "de", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "Ostaustralische Zeit", "Australia/Sydney" }, 2833 2834 { "de", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 2835 { "de", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 2836 { "de", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 2837 { "de", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "Mittlere Greenwich-Zeit", "+0:00" }, 2838 { "de", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 2839 { "de", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 2840 { "de", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 2841 { "de", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "Britische Sommerzeit", "+1:00" }, 2842 { "de", "Europe/London", "2004-07-15T00:00:00Z", "v", "Vereinigtes K\\u00f6nigreich Zeit", "Europe/London" }, 2843 { "de", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "Vereinigtes K\\u00f6nigreich Zeit", "Europe/London" }, 2844 2845 { "de", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2846 { "de", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2847 { "de", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2848 { "de", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2849 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2850 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2851 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2852 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2853 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 2854 { "de", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 2855 2856 // JB#5150 2857 { "de", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2858 { "de", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2859 { "de", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 2860 { "de", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "Indische Zeit", "+5:30" }, 2861 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2862 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2863 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 2864 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "Indische Zeit", "+5:30" }, 2865 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "Indien Zeit", "Asia/Calcutta" }, 2866 { "de", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "Indische Zeit", "Asia/Calcutta" }, 2867 2868 // ========== 2869 2870 { "zh", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 2871 { "zh", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 2872 { "zh", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "America/Los_Angeles" }, 2873 { "zh", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "\\u5317\\u7f8e\\u592a\\u5e73\\u6d0b\\u6807\\u51c6\\u65f6\\u95f4", "America/Los_Angeles" }, 2874 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2875 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2876 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "America/Los_Angeles" }, 2877 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "\\u5317\\u7f8e\\u592a\\u5e73\\u6d0b\\u590f\\u4ee4\\u65f6\\u95f4", "America/Los_Angeles" }, 2878 // icu zh.txt has exemplar city for this time zone 2879 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "\\u6D1B\\u6749\\u77F6\\u65F6\\u95F4", "America/Los_Angeles" }, 2880 { "zh", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "\\u5317\\u7f8e\\u592a\\u5e73\\u6d0b\\u65f6\\u95f4", "America/Los_Angeles" }, 2881 2882 { "zh", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2883 { "zh", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2884 { "zh", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2885 { "zh", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "-3:00" }, 2886 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2887 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2888 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2889 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "-3:00" }, 2890 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u5E03\\u5B9C\\u8BFA\\u65AF\\u827E\\u5229\\u65AF\\u65F6\\u95F4", "America/Buenos_Aires" }, 2891 { "zh", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "America/Buenos_Aires" }, 2892 2893 { "zh", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2894 { "zh", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2895 { "zh", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2896 { "zh", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "-3:00" }, 2897 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2898 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2899 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2900 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "-3:00" }, 2901 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u5E03\\u5B9C\\u8BFA\\u65AF\\u827E\\u5229\\u65AF\\u65F6\\u95F4", "America/Buenos_Aires" }, 2902 { "zh", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u963f\\u6839\\u5ef7\\u6807\\u51c6\\u65f6\\u95f4", "America/Buenos_Aires" }, 2903 2904 { "zh", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 2905 { "zh", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 2906 { "zh", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 2907 { "zh", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "\\u53e4\\u5df4\\u6807\\u51c6\\u65f6\\u95f4", "-5:00" }, 2908 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 2909 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 2910 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 2911 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "\\u53e4\\u5df4\\u590f\\u4ee4\\u65f6\\u95f4", "-4:00" }, 2912 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "v", "\\u53e4\\u5df4\\u65f6\\u95f4", "America/Havana" }, 2913 { "zh", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "\\u53e4\\u5df4\\u65f6\\u95f4", "America/Havana" }, 2914 2915 { "zh", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2916 { "zh", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2917 { "zh", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2918 { "zh", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u590f\\u4ee4\\u65f6\\u95f4", "+11:00" }, 2919 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2920 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2921 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2922 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u6807\\u51c6\\u65f6\\u95f4", "+10:00" }, 2923 // icu zh.txt does not have info for this time zone 2924 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "\\u6089\\u5C3C\\u65F6\\u95F4", "Australia/Sydney" }, 2925 { "zh", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u65f6\\u95f4", "Australia/Sydney" }, 2926 2927 { "zh", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 2928 { "zh", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 2929 { "zh", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 2930 { "zh", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u590f\\u4ee4\\u65f6\\u95f4", "+11:00" }, 2931 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 2932 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 2933 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 2934 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u6807\\u51c6\\u65f6\\u95f4", "+10:00" }, 2935 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "\\u6089\\u5C3C\\u65F6\\u95F4", "Australia/Sydney" }, 2936 { "zh", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "\\u6fb3\\u5927\\u5229\\u4e9a\\u4e1c\\u90e8\\u65f6\\u95f4", "Australia/Sydney" }, 2937 2938 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 2939 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 2940 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 2941 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 2942 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 2943 { "zh", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "\\u683C\\u6797\\u5C3C\\u6CBB\\u6807\\u51C6\\u65F6\\u95F4", "+0:00" }, 2944 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 2945 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 2946 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 2947 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "\\u82f1\\u56fd\\u590f\\u4ee4\\u65f6\\u95f4", "+1:00" }, 2948 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "v", "\\u82f1\\u56fd\\u65f6\\u95f4", "Europe/London" }, 2949 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "\\u82f1\\u56fd\\u65f6\\u95f4", "Europe/London" }, 2950 { "zh", "Europe/London", "2004-07-15T00:00:00Z", "VVVV", "\\u82f1\\u56fd\\u65f6\\u95f4", "Europe/London" }, 2951 2952 { "zh", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2953 { "zh", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2954 { "zh", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2955 { "zh", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2956 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2957 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2958 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2959 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 2960 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 2961 { "zh", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 2962 2963 // JB#5150 2964 { "zh", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2965 { "zh", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2966 { "zh", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 2967 { "zh", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "\\u5370\\u5ea6\\u65f6\\u95f4", "+5:30" }, 2968 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 2969 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 2970 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 2971 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "\\u5370\\u5ea6\\u65f6\\u95f4", "+5:30" }, 2972 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "\\u5370\\u5ea6\\u65f6\\u95f4", "Asia/Calcutta" }, 2973 { "zh", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "\\u5370\\u5ea6\\u65f6\\u95f4", "Asia/Calcutta" }, 2974 2975 // ========== 2976 2977 { "hi", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 2978 { "hi", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 2979 { "hi", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "-8:00" }, 2980 { "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" }, 2981 { "hi", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 2982 { "hi", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 2983 { "hi", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "-7:00" }, 2984 { "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" }, 2985 { "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" }, 2986 { "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" }, 2987 2988 { "hi", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2989 { "hi", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2990 { "hi", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2991 { "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" }, 2992 { "hi", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 2993 { "hi", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 2994 { "hi", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 2995 { "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" }, 2996 { "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" }, 2997 { "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" }, 2998 2999 { "hi", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3000 { "hi", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3001 { "hi", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3002 { "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" }, 3003 { "hi", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3004 { "hi", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3005 { "hi", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3006 { "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" }, 3007 { "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" }, 3008 { "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" }, 3009 3010 { "hi", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 3011 { "hi", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 3012 { "hi", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 3013 { "hi", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "\\u0915\\u094d\\u092f\\u0942\\u092c\\u093e \\u092e\\u093e\\u0928\\u0915 \\u0938\\u092e\\u092f", "-5:00" }, 3014 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 3015 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 3016 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 3017 { "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" }, 3018 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "v", "\\u0915\\u094d\\u092f\\u0942\\u092c\\u093e \\u0938\\u092E\\u092F", "America/Havana" }, 3019 { "hi", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "\\u0915\\u094d\\u092f\\u0942\\u092c\\u093e \\u0938\\u092e\\u092f", "America/Havana" }, 3020 3021 { "hi", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3022 { "hi", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3023 { "hi", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3024 { "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" }, 3025 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3026 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3027 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3028 { "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" }, 3029 { "hi", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "\\u0938\\u093F\\u0921\\u0928\\u0940 \\u0938\\u092E\\u092F", "Australia/Sydney" }, 3030 { "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" }, 3031 3032 { "hi", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3033 { "hi", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3034 { "hi", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3035 { "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" }, 3036 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3037 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3038 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3039 { "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" }, 3040 { "hi", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "\\u0938\\u093F\\u0921\\u0928\\u0940 \\u0938\\u092E\\u092F", "Australia/Sydney" }, 3041 { "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" }, 3042 3043 { "hi", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 3044 { "hi", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 3045 { "hi", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 3046 { "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" }, 3047 { "hi", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 3048 { "hi", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 3049 { "hi", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 3050 { "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" }, 3051 { "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" }, 3052 { "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" }, 3053 3054 { "hi", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3055 { "hi", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3056 { "hi", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3057 { "hi", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3058 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3059 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3060 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3061 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3062 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 3063 { "hi", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 3064 3065 { "hi", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3066 { "hi", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3067 { "hi", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "IST", "+5:30" }, 3068 { "hi", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "\\u092D\\u093E\\u0930\\u0924\\u0940\\u092F \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "+5:30" }, 3069 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3070 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3071 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "IST", "+05:30" }, 3072 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "\\u092D\\u093E\\u0930\\u0924\\u0940\\u092F \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "+5:30" }, 3073 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "IST", "Asia/Calcutta" }, 3074 { "hi", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "\\u092D\\u093E\\u0930\\u0924\\u0940\\u092F \\u092E\\u093E\\u0928\\u0915 \\u0938\\u092E\\u092F", "Asia/Calcutta" }, 3075 3076 // ========== 3077 3078 { "bg", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 3079 { "bg", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-08:00", "-8:00" }, 3080 { "bg", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-8", "America/Los_Angeles" }, 3081 { "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" }, 3082 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 3083 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-07:00", "-7:00" }, 3084 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-7", "America/Los_Angeles" }, 3085 { "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" }, 3086 // icu bg.txt has exemplar city for this time zone 3087 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "\\u041B\\u043E\\u0441 \\u0410\\u043D\\u0434\\u0436\\u0435\\u043B\\u0438\\u0441", "America/Los_Angeles" }, 3088 { "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" }, 3089 { "bg", "America/Los_Angeles", "2004-07-15T00:00:00Z", "VVVV", "\\u041B\\u043E\\u0441 \\u0410\\u043D\\u0434\\u0436\\u0435\\u043B\\u0438\\u0441", "America/Los_Angeles" }, 3090 3091 { "bg", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3092 { "bg", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3093 { "bg", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3094 { "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" }, 3095 { "bg", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3096 { "bg", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3097 { "bg", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3098 { "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" }, 3099 { "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" }, 3100 { "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" }, 3101 3102 { "bg", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3103 { "bg", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3104 { "bg", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3105 { "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" }, 3106 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3107 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3108 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3109 { "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" }, 3110 // icu bg.txt does not have info for this time zone 3111 { "bg", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u0411\\u0443\\u0435\\u043D\\u043E\\u0441 \\u0410\\u0439\\u0440\\u0435\\u0441", "America/Buenos_Aires" }, 3112 { "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" }, 3113 3114 { "bg", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 3115 { "bg", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-05:00", "-5:00" }, 3116 { "bg", "America/Havana", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-5", "-5:00" }, 3117 { "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" }, 3118 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 3119 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-04:00", "-4:00" }, 3120 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-4", "-4:00" }, 3121 { "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" }, 3122 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "v", "\\u041a\\u0443\\u0431\\u0430", "America/Havana" }, 3123 { "bg", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "\\u041a\\u0443\\u0431\\u0438\\u043d\\u0441\\u043a\\u043e \\u0432\\u0440\\u0435\\u043C\\u0435", "America/Havana" }, 3124 3125 { "bg", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3126 { "bg", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+11:00", "+11:00" }, 3127 { "bg", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+11", "+11:00" }, 3128 { "bg", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "\\u0418\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E\\u0430\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u0439\\u0441\\u043A\\u043E \\u043B\\u044F\\u0442\\u043D\\u043E \\u0447\\u0430\\u0441\\u043E\\u0432\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "+11:00" }, 3129 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3130 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+10:00", "+10:00" }, 3131 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+10", "+10:00" }, 3132 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "\\u0418\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E\\u0430\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u0439\\u0441\\u043A\\u043E \\u0441\\u0442\\u0430\\u043D\\u0434\\u0430\\u0440\\u0442\\u043D\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "+10:00" }, 3133 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "\\u0421\\u0438\\u0434\\u043D\\u0438", "Australia/Sydney" }, 3134 { "bg", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "\\u0418\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E\\u0430\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u0439\\u0441\\u043A\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "Australia/Sydney" }, 3135 3136 { "bg", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3137 { "bg", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+11:00", "+11:00" }, 3138 { "bg", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+11", "+11:00" }, 3139 { "bg", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "\\u0418\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E\\u0430\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u0439\\u0441\\u043A\\u043E \\u043B\\u044F\\u0442\\u043D\\u043E \\u0447\\u0430\\u0441\\u043E\\u0432\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "+11:00" }, 3140 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3141 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+10:00", "+10:00" }, 3142 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+10", "+10:00" }, 3143 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "\\u0418\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E\\u0430\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u0439\\u0441\\u043A\\u043E \\u0441\\u0442\\u0430\\u043D\\u0434\\u0430\\u0440\\u0442\\u043D\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "+10:00" }, 3144 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "\\u0421\\u0438\\u0434\\u043D\\u0438", "Australia/Sydney" }, 3145 { "bg", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "\\u0418\\u0437\\u0442\\u043E\\u0447\\u043D\\u043E\\u0430\\u0432\\u0441\\u0442\\u0440\\u0430\\u043B\\u0438\\u0439\\u0441\\u043A\\u043E \\u0432\\u0440\\u0435\\u043C\\u0435", "Australia/Sydney" }, 3146 3147 { "bg", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 3148 { "bg", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447", "+0:00" }, 3149 { "bg", "Europe/London", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447", "+0:00" }, 3150 { "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" }, 3151 { "bg", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 3152 { "bg", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+01:00", "+1:00" }, 3153 { "bg", "Europe/London", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+1", "+1:00" }, 3154 { "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" }, 3155 { "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" }, 3156 { "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" }, 3157 3158 { "bg", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3159 { "bg", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3160 { "bg", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3161 { "bg", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3162 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3163 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3164 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3165 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3166 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-3", "-3:00" }, 3167 { "bg", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447-03:00", "-3:00" }, 3168 3169 // JB#5150 3170 { "bg", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3171 { "bg", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+05:30", "+5:30" }, 3172 { "bg", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+5:30", "+5:30" }, 3173 { "bg", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "\\u0418\\u043D\\u0434\\u0438\\u0439\\u0441\\u043A\\u043E \\u0432\\u0440\\u0435\\u043c\\u0435", "+5:30" }, 3174 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3175 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+05:30", "+5:30" }, 3176 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "\\u0413\\u0440\\u0438\\u043D\\u0443\\u0438\\u0447+5:30", "+05:30" }, 3177 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "\\u0418\\u043D\\u0434\\u0438\\u0439\\u0441\\u043A\\u043E \\u0432\\u0440\\u0435\\u043c\\u0435", "+5:30" }, 3178 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "\\u0418\\u043D\\u0434\\u0438\\u044F", "Asia/Calcutta" }, 3179 { "bg", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "\\u0418\\u043D\\u0434\\u0438\\u0439\\u0441\\u043A\\u043E \\u0432\\u0440\\u0435\\u043c\\u0435", "Asia/Calcutta" }, 3180 // ========== 3181 3182 { "ja", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 3183 { "ja", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 3184 { "ja", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "America/Los_Angeles" }, 3185 { "ja", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "\\u30a2\\u30e1\\u30ea\\u30ab\\u592a\\u5e73\\u6d0b\\u6a19\\u6e96\\u6642", "America/Los_Angeles" }, 3186 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-700" }, 3187 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 3188 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "America/Los_Angeles" }, 3189 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "\\u30a2\\u30e1\\u30ea\\u30ab\\u592a\\u5e73\\u6d0b\\u590f\\u6642\\u9593", "America/Los_Angeles" }, 3190 // icu ja.txt has exemplar city for this time zone 3191 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "\\u30ED\\u30B5\\u30F3\\u30BC\\u30EB\\u30B9\\u6642\\u9593", "America/Los_Angeles" }, 3192 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "\\u30A2\\u30E1\\u30EA\\u30AB\\u592A\\u5e73\\u6D0B\\u6642\\u9593", "America/Los_Angeles" }, 3193 { "ja", "America/Los_Angeles", "2004-07-15T00:00:00Z", "VVVV", "\\u30ED\\u30B5\\u30F3\\u30BC\\u30EB\\u30B9\\u6642\\u9593", "America/Los_Angeles" }, 3194 3195 { "ja", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3196 { "ja", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3197 { "ja", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3198 { "ja", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "-3:00" }, 3199 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3200 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3201 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3202 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "-3:00" }, 3203 // icu ja.txt does not have info for this time zone 3204 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u30D6\\u30A8\\u30CE\\u30B9\\u30A2\\u30A4\\u30EC\\u30B9\\u6642\\u9593", "America/Buenos_Aires" }, 3205 { "ja", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "America/Buenos_Aires" }, 3206 3207 { "ja", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3208 { "ja", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3209 { "ja", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3210 { "ja", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "-3:00" }, 3211 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3212 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3213 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3214 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "-3:00" }, 3215 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "\\u30D6\\u30A8\\u30CE\\u30B9\\u30A2\\u30A4\\u30EC\\u30B9\\u6642\\u9593", "America/Buenos_Aires" }, 3216 { "ja", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "\\u30A2\\u30EB\\u30BC\\u30F3\\u30C1\\u30F3\\u6A19\\u6E96\\u6642", "America/Buenos_Aires" }, 3217 3218 { "ja", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 3219 { "ja", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 3220 { "ja", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 3221 { "ja", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "\\u30AD\\u30E5\\u30FC\\u30D0\\u6A19\\u6E96\\u6642", "-5:00" }, 3222 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 3223 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 3224 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 3225 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "\\u30AD\\u30E5\\u30FC\\u30D0\\u590F\\u6642\\u9593", "-4:00" }, 3226 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "v", "\\u30ad\\u30e5\\u30fc\\u30d0\\u6642\\u9593", "America/Havana" }, 3227 { "ja", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "\\u30ad\\u30e5\\u30fc\\u30d0\\u6642\\u9593", "America/Havana" }, 3228 3229 { "ja", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3230 { "ja", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3231 { "ja", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3232 { "ja", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u590F\\u6642\\u9593", "+11:00" }, 3233 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3234 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3235 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3236 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u6A19\\u6E96\\u6642", "+10:00" }, 3237 // icu ja.txt does not have info for this time zone 3238 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "\\u30B7\\u30C9\\u30CB\\u30FC\\u6642\\u9593", "Australia/Sydney" }, 3239 { "ja", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u6642\\u9593", "Australia/Sydney" }, 3240 3241 { "ja", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3242 { "ja", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3243 { "ja", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3244 { "ja", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u590F\\u6642\\u9593", "+11:00" }, 3245 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3246 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3247 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3248 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u6A19\\u6E96\\u6642", "+10:00" }, 3249 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "\\u30B7\\u30C9\\u30CB\\u30FC\\u6642\\u9593", "Australia/Sydney" }, 3250 { "ja", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "\\u30AA\\u30FC\\u30B9\\u30C8\\u30E9\\u30EA\\u30A2\\u6771\\u90E8\\u6642\\u9593", "Australia/Sydney" }, 3251 3252 { "ja", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 3253 { "ja", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 3254 { "ja", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 3255 { "ja", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "\\u30B0\\u30EA\\u30CB\\u30C3\\u30B8\\u6A19\\u6E96\\u6642", "+0:00" }, 3256 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 3257 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 3258 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 3259 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "\\u82f1\\u56fd\\u590f\\u6642\\u9593", "+1:00" }, 3260 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "v", "\\u30a4\\u30ae\\u30ea\\u30b9\\u6642\\u9593", "Europe/London" }, 3261 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "\\u30a4\\u30ae\\u30ea\\u30b9\\u6642\\u9593", "Europe/London" }, 3262 { "ja", "Europe/London", "2004-07-15T00:00:00Z", "VVVV", "\\u30a4\\u30ae\\u30ea\\u30b9\\u6642\\u9593", "Europe/London" }, 3263 3264 { "ja", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3265 { "ja", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3266 { "ja", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3267 { "ja", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3268 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3269 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3270 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3271 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3272 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 3273 { "ja", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 3274 3275 // JB#5150 3276 { "ja", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3277 { "ja", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3278 { "ja", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 3279 { "ja", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "\\u30A4\\u30F3\\u30C9\\u6A19\\u6E96\\u6642", "+5:30" }, 3280 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3281 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3282 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 3283 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "\\u30A4\\u30F3\\u30C9\\u6A19\\u6E96\\u6642", "+5:30" }, 3284 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "\\u30A4\\u30F3\\u30C9\\u6642\\u9593", "Asia/Calcutta" }, 3285 { "ja", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "\\u30A4\\u30F3\\u30C9\\u6A19\\u6E96\\u6642", "Asia/Calcutta" }, 3286 3287 // ========== 3288 3289 { "ti", "America/Los_Angeles", "2004-01-15T00:00:00Z", "Z", "-0800", "-8:00" }, 3290 { "ti", "America/Los_Angeles", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-08:00", "-8:00" }, 3291 { "ti", "America/Los_Angeles", "2004-01-15T00:00:00Z", "z", "GMT-8", "-8:00" }, 3292 { "ti", "America/Los_Angeles", "2004-01-15T00:00:00Z", "zzzz", "GMT-08:00", "-8:00" }, 3293 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "Z", "-0700", "-7:00" }, 3294 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-07:00", "-7:00" }, 3295 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "z", "GMT-7", "-7:00" }, 3296 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "zzzz", "GMT-07:00", "-7:00" }, 3297 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "v", "Los Angeles", "America/Los_Angeles" }, 3298 { "ti", "America/Los_Angeles", "2004-07-15T00:00:00Z", "vvvv", "Los Angeles", "America/Los_Angeles" }, 3299 3300 { "ti", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3301 { "ti", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3302 { "ti", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3303 { "ti", "America/Argentina/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3304 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3305 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3306 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3307 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3308 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires", "America/Buenos_Aires" }, 3309 { "ti", "America/Argentina/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Buenos Aires", "America/Buenos_Aires" }, 3310 3311 { "ti", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3312 { "ti", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3313 { "ti", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3314 { "ti", "America/Buenos_Aires", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3315 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3316 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3317 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3318 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3319 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "v", "Buenos Aires", "America/Buenos_Aires" }, 3320 { "ti", "America/Buenos_Aires", "2004-07-15T00:00:00Z", "vvvv", "Buenos Aires", "America/Buenos_Aires" }, 3321 3322 { "ti", "America/Havana", "2004-01-15T00:00:00Z", "Z", "-0500", "-5:00" }, 3323 { "ti", "America/Havana", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-05:00", "-5:00" }, 3324 { "ti", "America/Havana", "2004-01-15T00:00:00Z", "z", "GMT-5", "-5:00" }, 3325 { "ti", "America/Havana", "2004-01-15T00:00:00Z", "zzzz", "GMT-05:00", "-5:00" }, 3326 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "Z", "-0400", "-4:00" }, 3327 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-04:00", "-4:00" }, 3328 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "z", "GMT-4", "-4:00" }, 3329 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "zzzz", "GMT-04:00", "-4:00" }, 3330 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "v", "\\u12A9\\u1263", "America/Havana" }, 3331 { "ti", "America/Havana", "2004-07-15T00:00:00Z", "vvvv", "\\u12A9\\u1263", "America/Havana" }, 3332 3333 { "ti", "Australia/ACT", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3334 { "ti", "Australia/ACT", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3335 { "ti", "Australia/ACT", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3336 { "ti", "Australia/ACT", "2004-01-15T00:00:00Z", "zzzz", "GMT+11:00", "+11:00" }, 3337 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3338 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3339 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3340 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "zzzz", "GMT+10:00", "+10:00" }, 3341 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "v", "Sydney", "Australia/Sydney" }, 3342 { "ti", "Australia/ACT", "2004-07-15T00:00:00Z", "vvvv", "Sydney", "Australia/Sydney" }, 3343 3344 { "ti", "Australia/Sydney", "2004-01-15T00:00:00Z", "Z", "+1100", "+11:00" }, 3345 { "ti", "Australia/Sydney", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+11:00", "+11:00" }, 3346 { "ti", "Australia/Sydney", "2004-01-15T00:00:00Z", "z", "GMT+11", "+11:00" }, 3347 { "ti", "Australia/Sydney", "2004-01-15T00:00:00Z", "zzzz", "GMT+11:00", "+11:00" }, 3348 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "Z", "+1000", "+10:00" }, 3349 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+10:00", "+10:00" }, 3350 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "z", "GMT+10", "+10:00" }, 3351 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "zzzz", "GMT+10:00", "+10:00" }, 3352 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "v", "Sydney", "Australia/Sydney" }, 3353 { "ti", "Australia/Sydney", "2004-07-15T00:00:00Z", "vvvv", "Sydney", "Australia/Sydney" }, 3354 3355 { "ti", "Europe/London", "2004-01-15T00:00:00Z", "Z", "+0000", "+0:00" }, 3356 { "ti", "Europe/London", "2004-01-15T00:00:00Z", "ZZZZ", "GMT", "+0:00" }, 3357 { "ti", "Europe/London", "2004-01-15T00:00:00Z", "z", "GMT", "+0:00" }, 3358 { "ti", "Europe/London", "2004-01-15T00:00:00Z", "zzzz", "GMT", "+0:00" }, 3359 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "Z", "+0100", "+1:00" }, 3360 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+01:00", "+1:00" }, 3361 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "z", "GMT+1", "+1:00" }, 3362 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "zzzz", "GMT+01:00", "+1:00" }, 3363 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "v", "\\u12A5\\u1295\\u130D\\u120A\\u12DD", "Europe/London" }, 3364 { "ti", "Europe/London", "2004-07-15T00:00:00Z", "vvvv", "\\u12A5\\u1295\\u130D\\u120A\\u12DD", "Europe/London" }, 3365 3366 { "ti", "Etc/GMT+3", "2004-01-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3367 { "ti", "Etc/GMT+3", "2004-01-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3368 { "ti", "Etc/GMT+3", "2004-01-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3369 { "ti", "Etc/GMT+3", "2004-01-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3370 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "Z", "-0300", "-3:00" }, 3371 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "ZZZZ", "GMT-03:00", "-3:00" }, 3372 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "z", "GMT-3", "-3:00" }, 3373 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "zzzz", "GMT-03:00", "-3:00" }, 3374 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "v", "GMT-3", "-3:00" }, 3375 { "ti", "Etc/GMT+3", "2004-07-15T00:00:00Z", "vvvv", "GMT-03:00", "-3:00" }, 3376 3377 // JB#5150 3378 { "ti", "Asia/Calcutta", "2004-01-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3379 { "ti", "Asia/Calcutta", "2004-01-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3380 { "ti", "Asia/Calcutta", "2004-01-15T00:00:00Z", "z", "GMT+5:30", "+5:30" }, 3381 { "ti", "Asia/Calcutta", "2004-01-15T00:00:00Z", "zzzz", "GMT+05:30", "+5:30" }, 3382 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "Z", "+0530", "+5:30" }, 3383 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "ZZZZ", "GMT+05:30", "+5:30" }, 3384 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "z", "GMT+5:30", "+05:30" }, 3385 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "zzzz", "GMT+05:30", "+5:30" }, 3386 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "v", "\\u1205\\u1295\\u12F2", "Alna/Calcutta" }, 3387 { "ti", "Asia/Calcutta", "2004-07-15T00:00:00Z", "vvvv", "\\u1205\\u1295\\u12F2", "Asia/Calcutta" }, 3388 3389 // Ticket#8589 Partial location name to use country name if the zone is the golden 3390 // zone for the time zone's country. 3391 { "en_MX", "America/Chicago", "1995-07-15T00:00:00Z", "vvvv", "Central Time (United States)", "America/Chicago"}, 3392 3393 // Tests proper handling of time zones that should have empty sets when inherited from the parent. 3394 // For example, en_GB understands CET as Central European Time, but en_HK, which inherits from en_GB 3395 // does not 3396 { "en_GB", "Europe/Paris", "2004-01-15T00:00:00Z", "zzzz", "Central European Standard Time", "+1:00"}, 3397 { "en_GB", "Europe/Paris", "2004-07-15T00:00:00Z", "zzzz", "Central European Summer Time", "+2:00"}, 3398 { "en_GB", "Europe/Paris", "2004-01-15T00:00:00Z", "z", "CET", "+1:00"}, 3399 { "en_GB", "Europe/Paris", "2004-07-15T00:00:00Z", "z", "CEST", "+2:00"}, 3400 { "en_HK", "Europe/Paris", "2004-01-15T00:00:00Z", "zzzz", "Central European Standard Time", "+1:00"}, 3401 { "en_HK", "Europe/Paris", "2004-07-15T00:00:00Z", "zzzz", "Central European Summer Time", "+2:00"}, 3402 { "en_HK", "Europe/Paris", "2004-01-15T00:00:00Z", "z", "GMT+1", "+1:00"}, 3403 { "en_HK", "Europe/Paris", "2004-07-15T00:00:00Z", "z", "GMT+2", "+2:00"}, 3404 3405 { NULL, NULL, NULL, NULL, NULL, NULL }, 3406 }; 3407 3408 UErrorCode status = U_ZERO_ERROR; 3409 Calendar *cal = GregorianCalendar::createInstance(status); 3410 if (failure(status, "GregorianCalendar::createInstance", TRUE)) return; 3411 SimpleDateFormat testfmt(UnicodeString("yyyy-MM-dd'T'HH:mm:ss'Z'"), status); 3412 if (failure(status, "SimpleDateFormat constructor", TRUE)) return; 3413 testfmt.setTimeZone(*TimeZone::getGMT()); 3414 3415 for (int i = 0; fallbackTests[i][0]; i++) { 3416 const char **testLine = fallbackTests[i]; 3417 UnicodeString info[5]; 3418 for ( int j = 0 ; j < 5 ; j++ ) { 3419 info[j] = UnicodeString(testLine[j], -1, US_INV); 3420 } 3421 info[4] = info[4].unescape(); 3422 logln("%s;%s;%s;%s", testLine[0], testLine[1], testLine[2], testLine[3]); 3423 3424 TimeZone *tz = TimeZone::createTimeZone(info[1]); 3425 3426 UDate d = testfmt.parse(testLine[2], status); 3427 cal->setTime(d, status); 3428 if (U_FAILURE(status)) { 3429 errln(UnicodeString("Failed to set date: ") + testLine[2]); 3430 } 3431 3432 SimpleDateFormat fmt(info[3], Locale(testLine[0]),status); 3433 ASSERT_OK(status); 3434 cal->adoptTimeZone(tz); 3435 UnicodeString result; 3436 FieldPosition pos(FieldPosition::DONT_CARE); 3437 fmt.format(*cal,result,pos); 3438 if (result != info[4]) { 3439 errln(info[0] + ";" + info[1] + ";" + info[2] + ";" + info[3] + " expected: '" + 3440 info[4] + "' but got: '" + result + "'"); 3441 } 3442 } 3443 delete cal; 3444 } 3445 3446 void DateFormatTest::TestRoundtripWithCalendar(void) { 3447 UErrorCode status = U_ZERO_ERROR; 3448 3449 TimeZone *tz = TimeZone::createTimeZone("Europe/Paris"); 3450 TimeZone *gmt = TimeZone::createTimeZone("Etc/GMT"); 3451 3452 Calendar *calendars[] = { 3453 Calendar::createInstance(*tz, Locale("und@calendar=gregorian"), status), 3454 Calendar::createInstance(*tz, Locale("und@calendar=buddhist"), status), 3455 // Calendar::createInstance(*tz, Locale("und@calendar=hebrew"), status), 3456 Calendar::createInstance(*tz, Locale("und@calendar=islamic"), status), 3457 Calendar::createInstance(*tz, Locale("und@calendar=japanese"), status), 3458 NULL 3459 }; 3460 if (U_FAILURE(status)) { 3461 dataerrln("Failed to initialize calendars: %s", u_errorName(status)); 3462 for (int i = 0; calendars[i] != NULL; i++) { 3463 delete calendars[i]; 3464 } 3465 return; 3466 } 3467 3468 //FIXME The formatters commented out below are currently failing because of 3469 // the calendar calculation problem reported by #6691 3470 3471 // The order of test formatters must match the order of calendars above. 3472 DateFormat *formatters[] = { 3473 DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("en_US")), //calendar=gregorian 3474 DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("th_TH")), //calendar=buddhist 3475 // DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("he_IL@calendar=hebrew")), 3476 DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("ar_EG@calendar=islamic")), 3477 // DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, Locale("ja_JP@calendar=japanese")), 3478 NULL 3479 }; 3480 3481 UDate d = Calendar::getNow(); 3482 UnicodeString buf; 3483 FieldPosition fpos; 3484 ParsePosition ppos; 3485 3486 for (int i = 0; formatters[i] != NULL; i++) { 3487 buf.remove(); 3488 fpos.setBeginIndex(0); 3489 fpos.setEndIndex(0); 3490 calendars[i]->setTime(d, status); 3491 3492 // Normal case output - the given calendar matches the calendar 3493 // used by the formatter 3494 formatters[i]->format(*calendars[i], buf, fpos); 3495 UnicodeString refStr(buf); 3496 3497 for (int j = 0; calendars[j] != NULL; j++) { 3498 if (j == i) { 3499 continue; 3500 } 3501 buf.remove(); 3502 fpos.setBeginIndex(0); 3503 fpos.setEndIndex(0); 3504 calendars[j]->setTime(d, status); 3505 3506 // Even the different calendar type is specified, 3507 // we should get the same result. 3508 formatters[i]->format(*calendars[j], buf, fpos); 3509 if (refStr != buf) { 3510 errln((UnicodeString)"FAIL: Different format result with a different calendar for the same time -" 3511 + "\n Reference calendar type=" + calendars[i]->getType() 3512 + "\n Another calendar type=" + calendars[j]->getType() 3513 + "\n Expected result=" + refStr 3514 + "\n Actual result=" + buf); 3515 } 3516 } 3517 3518 calendars[i]->setTimeZone(*gmt); 3519 calendars[i]->clear(); 3520 ppos.setErrorIndex(-1); 3521 ppos.setIndex(0); 3522 3523 // Normal case parse result - the given calendar matches the calendar 3524 // used by the formatter 3525 formatters[i]->parse(refStr, *calendars[i], ppos); 3526 3527 for (int j = 0; calendars[j] != NULL; j++) { 3528 if (j == i) { 3529 continue; 3530 } 3531 calendars[j]->setTimeZone(*gmt); 3532 calendars[j]->clear(); 3533 ppos.setErrorIndex(-1); 3534 ppos.setIndex(0); 3535 3536 // Even the different calendar type is specified, 3537 // we should get the same time and time zone. 3538 formatters[i]->parse(refStr, *calendars[j], ppos); 3539 if (calendars[i]->getTime(status) != calendars[j]->getTime(status) 3540 || calendars[i]->getTimeZone() != calendars[j]->getTimeZone()) { 3541 UnicodeString tzid; 3542 errln((UnicodeString)"FAIL: Different parse result with a different calendar for the same string -" 3543 + "\n Reference calendar type=" + calendars[i]->getType() 3544 + "\n Another calendar type=" + calendars[j]->getType() 3545 + "\n Date string=" + refStr 3546 + "\n Expected time=" + calendars[i]->getTime(status) 3547 + "\n Expected time zone=" + calendars[i]->getTimeZone().getID(tzid) 3548 + "\n Actual time=" + calendars[j]->getTime(status) 3549 + "\n Actual time zone=" + calendars[j]->getTimeZone().getID(tzid)); 3550 } 3551 } 3552 if (U_FAILURE(status)) { 3553 errln((UnicodeString)"FAIL: " + u_errorName(status)); 3554 break; 3555 } 3556 } 3557 3558 delete tz; 3559 delete gmt; 3560 for (int i = 0; calendars[i] != NULL; i++) { 3561 delete calendars[i]; 3562 } 3563 for (int i = 0; formatters[i] != NULL; i++) { 3564 delete formatters[i]; 3565 } 3566 } 3567 3568 /* 3569 void DateFormatTest::TestRelativeError(void) 3570 { 3571 UErrorCode status; 3572 Locale en("en"); 3573 3574 DateFormat *en_reltime_reldate = DateFormat::createDateTimeInstance(DateFormat::kFullRelative,DateFormat::kFullRelative,en); 3575 if(en_reltime_reldate == NULL) { 3576 logln("PASS: rel date/rel time failed"); 3577 } else { 3578 errln("FAIL: rel date/rel time created, should have failed."); 3579 delete en_reltime_reldate; 3580 } 3581 } 3582 3583 void DateFormatTest::TestRelativeOther(void) 3584 { 3585 logln("Nothing in this test. When we get more data from CLDR, put in some tests of -2, +2, etc. "); 3586 } 3587 */ 3588 3589 void DateFormatTest::Test6338(void) 3590 { 3591 UErrorCode status = U_ZERO_ERROR; 3592 3593 SimpleDateFormat *fmt1 = new SimpleDateFormat(UnicodeString("y-M-d"), Locale("ar"), status); 3594 if (failure(status, "new SimpleDateFormat", TRUE)) return; 3595 3596 UDate dt1 = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3597 UnicodeString str1; 3598 str1 = fmt1->format(dt1, str1); 3599 logln(str1); 3600 3601 UDate dt11 = fmt1->parse(str1, status); 3602 failure(status, "fmt->parse"); 3603 3604 UnicodeString str11; 3605 str11 = fmt1->format(dt11, str11); 3606 logln(str11); 3607 3608 if (str1 != str11) { 3609 errln((UnicodeString)"FAIL: Different dates str1:" + str1 3610 + " str2:" + str11); 3611 } 3612 delete fmt1; 3613 3614 ///////////////// 3615 3616 status = U_ZERO_ERROR; 3617 SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("y M d"), Locale("ar"), status); 3618 failure(status, "new SimpleDateFormat"); 3619 3620 UDate dt2 = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3621 UnicodeString str2; 3622 str2 = fmt2->format(dt2, str2); 3623 logln(str2); 3624 3625 UDate dt22 = fmt2->parse(str2, status); 3626 failure(status, "fmt->parse"); 3627 3628 UnicodeString str22; 3629 str22 = fmt2->format(dt22, str22); 3630 logln(str22); 3631 3632 if (str2 != str22) { 3633 errln((UnicodeString)"FAIL: Different dates str1:" + str2 3634 + " str2:" + str22); 3635 } 3636 delete fmt2; 3637 3638 ///////////////// 3639 3640 status = U_ZERO_ERROR; 3641 SimpleDateFormat *fmt3 = new SimpleDateFormat(UnicodeString("y-M-d"), Locale("en-us"), status); 3642 failure(status, "new SimpleDateFormat"); 3643 3644 UDate dt3 = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3645 UnicodeString str3; 3646 str3 = fmt3->format(dt3, str3); 3647 logln(str3); 3648 3649 UDate dt33 = fmt3->parse(str3, status); 3650 failure(status, "fmt->parse"); 3651 3652 UnicodeString str33; 3653 str33 = fmt3->format(dt33, str33); 3654 logln(str33); 3655 3656 if (str3 != str33) { 3657 errln((UnicodeString)"FAIL: Different dates str1:" + str3 3658 + " str2:" + str33); 3659 } 3660 delete fmt3; 3661 3662 ///////////////// 3663 3664 status = U_ZERO_ERROR; 3665 SimpleDateFormat *fmt4 = new SimpleDateFormat(UnicodeString("y M d"), Locale("en-us"), status); 3666 failure(status, "new SimpleDateFormat"); 3667 3668 UDate dt4 = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3669 UnicodeString str4; 3670 str4 = fmt4->format(dt4, str4); 3671 logln(str4); 3672 3673 UDate dt44 = fmt4->parse(str4, status); 3674 failure(status, "fmt->parse"); 3675 3676 UnicodeString str44; 3677 str44 = fmt4->format(dt44, str44); 3678 logln(str44); 3679 3680 if (str4 != str44) { 3681 errln((UnicodeString)"FAIL: Different dates str1:" + str4 3682 + " str2:" + str44); 3683 } 3684 delete fmt4; 3685 3686 } 3687 3688 void DateFormatTest::Test6726(void) 3689 { 3690 // status 3691 // UErrorCode status = U_ZERO_ERROR; 3692 3693 // fmtf, fmtl, fmtm, fmts; 3694 UnicodeString strf, strl, strm, strs; 3695 UDate dt = date(2008-1900, UCAL_JUNE, 10, 12, 00); 3696 3697 Locale loc("ja"); 3698 DateFormat* fmtf = DateFormat::createDateTimeInstance(DateFormat::FULL, DateFormat::FULL, loc); 3699 DateFormat* fmtl = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::FULL, loc); 3700 DateFormat* fmtm = DateFormat::createDateTimeInstance(DateFormat::MEDIUM, DateFormat::FULL, loc); 3701 DateFormat* fmts = DateFormat::createDateTimeInstance(DateFormat::SHORT, DateFormat::FULL, loc); 3702 if (fmtf == NULL || fmtl == NULL || fmtm == NULL || fmts == NULL) { 3703 dataerrln("Unable to create DateFormat. got NULL."); 3704 /* It may not be true that if one is NULL all is NULL. Just to be safe. */ 3705 delete fmtf; 3706 delete fmtl; 3707 delete fmtm; 3708 delete fmts; 3709 3710 return; 3711 } 3712 strf = fmtf->format(dt, strf); 3713 strl = fmtl->format(dt, strl); 3714 strm = fmtm->format(dt, strm); 3715 strs = fmts->format(dt, strs); 3716 3717 3718 logln("strm.charAt(10)=%04X wanted 0x20\n", strm.charAt(10)); 3719 if (strm.charAt(10) != UChar(0x0020)) { 3720 errln((UnicodeString)"FAIL: Improper formatted date: " + strm ); 3721 } 3722 logln("strs.charAt(10)=%04X wanted 0x20\n", strs.charAt(8)); 3723 if (strs.charAt(10) != UChar(0x0020)) { 3724 errln((UnicodeString)"FAIL: Improper formatted date: " + strs); 3725 } 3726 3727 delete fmtf; 3728 delete fmtl; 3729 delete fmtm; 3730 delete fmts; 3731 3732 return; 3733 } 3734 3735 /** 3736 * Test DateFormat's parsing of default GMT variants. See ticket#6135 3737 */ 3738 void DateFormatTest::TestGMTParsing() { 3739 const char* DATA[] = { 3740 "HH:mm:ss Z", 3741 3742 // pattern, input, expected output (in quotes) 3743 "HH:mm:ss Z", "10:20:30 GMT+03:00", "10:20:30 +0300", 3744 "HH:mm:ss Z", "10:20:30 UT-02:00", "10:20:30 -0200", 3745 "HH:mm:ss Z", "10:20:30 GMT", "10:20:30 +0000", 3746 "HH:mm:ss vvvv", "10:20:30 UT+10:00", "10:20:30 +1000", 3747 "HH:mm:ss zzzz", "10:20:30 UTC", "10:20:30 +0000", // standalone "UTC" 3748 "ZZZZ HH:mm:ss", "UT 10:20:30", "10:20:30 +0000", 3749 "z HH:mm:ss", "UT+0130 10:20:30", "10:20:30 +0130", 3750 "z HH:mm:ss", "UTC+0130 10:20:30", "10:20:30 +0130", 3751 // Note: GMT-1100 no longer works because of the introduction of the short 3752 // localized GMT support. Previous implementation support this level of 3753 // leniency (no separator char in localized GMT format), but the new 3754 // implementation handles GMT-11 as the legitimate short localized GMT format 3755 // and stop at there. Otherwise, roundtrip would be broken. 3756 //"HH mm Z ss", "10 20 GMT-1100 30", "10:20:30 -1100", 3757 "HH mm Z ss", "10 20 GMT-11 30", "10:20:30 -1100", 3758 "HH:mm:ssZZZZZ", "14:25:45Z", "14:25:45 +0000", 3759 "HH:mm:ssZZZZZ", "15:00:00-08:00", "15:00:00 -0800", 3760 }; 3761 const int32_t DATA_len = UPRV_LENGTHOF(DATA); 3762 expectParse(DATA, DATA_len, Locale("en")); 3763 } 3764 3765 // Test case for localized GMT format parsing 3766 // with no delimitters in offset format (Chinese locale) 3767 void DateFormatTest::Test6880() { 3768 UErrorCode status = U_ZERO_ERROR; 3769 UDate d1, d2, dp1, dp2, dexp1, dexp2; 3770 UnicodeString s1, s2; 3771 3772 TimeZone *tz = TimeZone::createTimeZone("Asia/Shanghai"); 3773 GregorianCalendar gcal(*tz, status); 3774 if (failure(status, "construct GregorianCalendar", TRUE)) return; 3775 3776 gcal.clear(); 3777 gcal.set(1900, UCAL_JULY, 1, 12, 00); // offset 8:05:43 3778 d1 = gcal.getTime(status); 3779 3780 gcal.clear(); 3781 gcal.set(1950, UCAL_JULY, 1, 12, 00); // offset 8:00 3782 d2 = gcal.getTime(status); 3783 3784 gcal.clear(); 3785 gcal.set(1970, UCAL_JANUARY, 1, 12, 00); 3786 dexp2 = gcal.getTime(status); 3787 dexp1 = dexp2 - (5*60 + 43)*1000; // subtract 5m43s 3788 3789 if (U_FAILURE(status)) { 3790 errln("FAIL: Gregorian calendar error"); 3791 } 3792 3793 DateFormat *fmt = DateFormat::createTimeInstance(DateFormat::kFull, Locale("zh")); 3794 if (fmt == NULL) { 3795 dataerrln("Unable to create DateFormat. Got NULL."); 3796 return; 3797 } 3798 fmt->adoptTimeZone(tz); 3799 3800 fmt->format(d1, s1); 3801 fmt->format(d2, s2); 3802 3803 dp1 = fmt->parse(s1, status); 3804 dp2 = fmt->parse(s2, status); 3805 3806 if (U_FAILURE(status)) { 3807 errln("FAIL: Parse failure"); 3808 } 3809 3810 if (dp1 != dexp1) { 3811 errln("FAIL: Failed to parse " + s1 + " parsed: " + dp1 + " expected: " + dexp1); 3812 } 3813 if (dp2 != dexp2) { 3814 errln("FAIL: Failed to parse " + s2 + " parsed: " + dp2 + " expected: " + dexp2); 3815 } 3816 3817 delete fmt; 3818 } 3819 3820 typedef struct { 3821 const char * localeStr; 3822 UBool lenient; 3823 UBool expectFail; 3824 UnicodeString datePattern; 3825 UnicodeString dateString; 3826 } NumAsStringItem; 3827 3828 void DateFormatTest::TestNumberAsStringParsing() 3829 { 3830 const NumAsStringItem items[] = { 3831 // loc lenient fail? datePattern dateString 3832 { "", FALSE, TRUE, UnicodeString("y MMMM d HH:mm:ss"), UnicodeString("2009 7 14 08:43:57") }, 3833 { "", TRUE, FALSE, UnicodeString("y MMMM d HH:mm:ss"), UnicodeString("2009 7 14 08:43:57") }, 3834 { "en", FALSE, FALSE, UnicodeString("MMM d, y"), UnicodeString("Jul 14, 2009") }, 3835 { "en", TRUE, FALSE, UnicodeString("MMM d, y"), UnicodeString("Jul 14, 2009") }, 3836 { "en", FALSE, TRUE, UnicodeString("MMM d, y"), UnicodeString("7 14, 2009") }, 3837 { "en", TRUE, FALSE, UnicodeString("MMM d, y"), UnicodeString("7 14, 2009") }, 3838 { "ja", FALSE, FALSE, UnicodeString("yyyy/MM/dd"), UnicodeString("2009/07/14") }, 3839 { "ja", TRUE, FALSE, UnicodeString("yyyy/MM/dd"), UnicodeString("2009/07/14") }, 3840 //{ "ja", FALSE, FALSE, UnicodeString("yyyy/MMMMM/d"), UnicodeString("2009/7/14") }, // #8860 covers test failure 3841 { "ja", TRUE, FALSE, UnicodeString("yyyy/MMMMM/d"), UnicodeString("2009/7/14") }, 3842 { "ja", FALSE, FALSE, CharsToUnicodeString("y\\u5E74M\\u6708d\\u65E5"), CharsToUnicodeString("2009\\u5E747\\u670814\\u65E5") }, 3843 { "ja", TRUE, FALSE, CharsToUnicodeString("y\\u5E74M\\u6708d\\u65E5"), CharsToUnicodeString("2009\\u5E747\\u670814\\u65E5") }, 3844 { "ja", FALSE, FALSE, CharsToUnicodeString("y\\u5E74MMMd\\u65E5"), CharsToUnicodeString("2009\\u5E747\\u670814\\u65E5") }, 3845 { "ja", TRUE, FALSE, CharsToUnicodeString("y\\u5E74MMMd\\u65E5"), CharsToUnicodeString("2009\\u5E747\\u670814\\u65E5") }, // #8820 fixes test failure 3846 { "ko", FALSE, FALSE, UnicodeString("yyyy. M. d."), UnicodeString("2009. 7. 14.") }, 3847 { "ko", TRUE, FALSE, UnicodeString("yyyy. M. d."), UnicodeString("2009. 7. 14.") }, 3848 { "ko", FALSE, FALSE, UnicodeString("yyyy. MMMMM d."), CharsToUnicodeString("2009. 7\\uC6D4 14.") }, 3849 { "ko", TRUE, FALSE, UnicodeString("yyyy. MMMMM d."), CharsToUnicodeString("2009. 7\\uC6D4 14.") }, // #8820 fixes test failure 3850 { "ko", FALSE, FALSE, CharsToUnicodeString("y\\uB144 M\\uC6D4 d\\uC77C"), CharsToUnicodeString("2009\\uB144 7\\uC6D4 14\\uC77C") }, 3851 { "ko", TRUE, FALSE, CharsToUnicodeString("y\\uB144 M\\uC6D4 d\\uC77C"), CharsToUnicodeString("2009\\uB144 7\\uC6D4 14\\uC77C") }, 3852 { "ko", FALSE, FALSE, CharsToUnicodeString("y\\uB144 MMM d\\uC77C"), CharsToUnicodeString("2009\\uB144 7\\uC6D4 14\\uC77C") }, 3853 { "ko", TRUE, FALSE, CharsToUnicodeString("y\\uB144 MMM d\\uC77C"), CharsToUnicodeString("2009\\uB144 7\\uC6D4 14\\uC77C") }, // #8820 fixes test failure 3854 { NULL, FALSE, FALSE, UnicodeString(""), UnicodeString("") } 3855 }; 3856 const NumAsStringItem * itemPtr; 3857 for (itemPtr = items; itemPtr->localeStr != NULL; itemPtr++ ) { 3858 Locale locale = Locale::createFromName(itemPtr->localeStr); 3859 UErrorCode status = U_ZERO_ERROR; 3860 SimpleDateFormat *formatter = new SimpleDateFormat(itemPtr->datePattern, locale, status); 3861 if (formatter == NULL || U_FAILURE(status)) { 3862 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 3863 return; 3864 } 3865 3866 formatter->setLenient(itemPtr->lenient); 3867 formatter->setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, itemPtr->lenient, status).setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, itemPtr->lenient, status); 3868 UDate date1 = formatter->parse(itemPtr->dateString, status); 3869 if (U_FAILURE(status)) { 3870 if (!itemPtr->expectFail) { 3871 errln("FAIL, err when expected success: Locale \"" + UnicodeString(itemPtr->localeStr) + "\", lenient " + itemPtr->lenient + 3872 ": using pattern \"" + itemPtr->datePattern + "\", could not parse \"" + itemPtr->dateString + "\"; err: " + u_errorName(status) ); 3873 } 3874 } else if (itemPtr->expectFail) { 3875 errln("FAIL, expected err but got none: Locale \"" + UnicodeString(itemPtr->localeStr) + "\", lenient " + itemPtr->lenient + 3876 ": using pattern \"" + itemPtr->datePattern + "\", did parse \"" + itemPtr->dateString + "\"." ); 3877 } else if (!itemPtr->lenient) { 3878 UnicodeString formatted; 3879 formatter->format(date1, formatted); 3880 if (formatted != itemPtr->dateString) { 3881 errln("FAIL, mismatch formatting parsed date: Locale \"" + UnicodeString(itemPtr->localeStr) + "\", lenient " + itemPtr->lenient + 3882 ": using pattern \"" + itemPtr->datePattern + "\", did parse \"" + itemPtr->dateString + "\", formatted result \"" + formatted + "\"."); 3883 } 3884 } 3885 3886 delete formatter; 3887 } 3888 } 3889 3890 void DateFormatTest::TestISOEra() { 3891 3892 const char* data[] = { 3893 // input, output 3894 "BC 4004-10-23T07:00:00Z", "BC 4004-10-23T07:00:00Z", 3895 "AD 4004-10-23T07:00:00Z", "AD 4004-10-23T07:00:00Z", 3896 "-4004-10-23T07:00:00Z" , "BC 4005-10-23T07:00:00Z", 3897 "4004-10-23T07:00:00Z" , "AD 4004-10-23T07:00:00Z", 3898 }; 3899 3900 int32_t numData = 8; 3901 3902 UErrorCode status = U_ZERO_ERROR; 3903 3904 // create formatter 3905 SimpleDateFormat *fmt1 = new SimpleDateFormat(UnicodeString("GGG yyyy-MM-dd'T'HH:mm:ss'Z"), status); 3906 failure(status, "new SimpleDateFormat", TRUE); 3907 if (status == U_MISSING_RESOURCE_ERROR) { 3908 if (fmt1 != NULL) { 3909 delete fmt1; 3910 } 3911 return; 3912 } 3913 for(int i=0; i < numData; i+=2) { 3914 // create input string 3915 UnicodeString in = data[i]; 3916 3917 // parse string to date 3918 UDate dt1 = fmt1->parse(in, status); 3919 failure(status, "fmt->parse", TRUE); 3920 3921 // format date back to string 3922 UnicodeString out; 3923 out = fmt1->format(dt1, out); 3924 logln(out); 3925 3926 // check that roundtrip worked as expected 3927 UnicodeString expected = data[i+1]; 3928 if (out != expected) { 3929 dataerrln((UnicodeString)"FAIL: " + in + " -> " + out + " expected -> " + expected); 3930 } 3931 } 3932 3933 delete fmt1; 3934 } 3935 void DateFormatTest::TestFormalChineseDate() { 3936 3937 UErrorCode status = U_ZERO_ERROR; 3938 UnicodeString pattern ("y\\u5e74M\\u6708d\\u65e5", -1, US_INV ); 3939 pattern = pattern.unescape(); 3940 UnicodeString override ("y=hanidec;M=hans;d=hans", -1, US_INV ); 3941 3942 // create formatter 3943 SimpleDateFormat *sdf = new SimpleDateFormat(pattern,override,Locale::getChina(),status); 3944 if (failure(status, "new SimpleDateFormat with override", TRUE)) { 3945 return; 3946 } 3947 3948 UDate thedate = date(2009-1900, UCAL_JULY, 28); 3949 FieldPosition pos(FieldPosition::DONT_CARE); 3950 UnicodeString result; 3951 sdf->format(thedate,result,pos); 3952 3953 UnicodeString expected = "\\u4e8c\\u3007\\u3007\\u4e5d\\u5e74\\u4e03\\u6708\\u4e8c\\u5341\\u516b\\u65e5"; 3954 expected = expected.unescape(); 3955 if (result != expected) { 3956 dataerrln((UnicodeString)"FAIL: -> " + result + " expected -> " + expected); 3957 } 3958 3959 UDate parsedate = sdf->parse(expected,status); 3960 if ( parsedate != thedate ) { 3961 UnicodeString pat1 ("yyyy-MM-dd'T'HH:mm:ss'Z'", -1, US_INV ); 3962 SimpleDateFormat *usf = new SimpleDateFormat(pat1,Locale::getEnglish(),status); 3963 UnicodeString parsedres,expres; 3964 usf->format(parsedate,parsedres,pos); 3965 usf->format(thedate,expres,pos); 3966 dataerrln((UnicodeString)"FAIL: parsed -> " + parsedres + " expected -> " + expres); 3967 delete usf; 3968 } 3969 delete sdf; 3970 } 3971 3972 // Test case for #8675 3973 // Incorrect parse offset with stand alone GMT string on 2nd or later iteration. 3974 void DateFormatTest::TestStandAloneGMTParse() { 3975 UErrorCode status = U_ZERO_ERROR; 3976 SimpleDateFormat *sdf = new SimpleDateFormat("ZZZZ", Locale(""), status); 3977 3978 if (U_SUCCESS(status)) { 3979 3980 UnicodeString inText("GMT$$$"); 3981 for (int32_t i = 0; i < 10; i++) { 3982 ParsePosition pos(0); 3983 sdf->parse(inText, pos); 3984 if (pos.getIndex() != 3) { 3985 errln((UnicodeString)"FAIL: Incorrect output parse position: actual=" + pos.getIndex() + " expected=3"); 3986 } 3987 } 3988 3989 delete sdf; 3990 } else { 3991 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 3992 } 3993 } 3994 3995 void DateFormatTest::TestParsePosition() { 3996 const char* TestData[][4] = { 3997 // {<pattern>, <lead>, <date string>, <trail>} 3998 {"yyyy-MM-dd HH:mm:ssZ", "", "2010-01-10 12:30:00+0500", ""}, 3999 {"yyyy-MM-dd HH:mm:ss ZZZZ", "", "2010-01-10 12:30:00 GMT+05:00", ""}, 4000 {"Z HH:mm:ss", "", "-0100 13:20:30", ""}, 4001 {"y-M-d Z", "", "2011-8-25 -0400", " Foo"}, 4002 {"y/M/d H:mm:ss z", "", "2011/7/1 12:34:00 PDT", ""}, 4003 {"y/M/d H:mm:ss z", "+123", "2011/7/1 12:34:00 PDT", " PST"}, 4004 {"vvvv a h:mm:ss", "", "Pacific Time AM 10:21:45", ""}, 4005 {"HH:mm v M/d", "111", "14:15 PT 8/10", " 12345"}, 4006 {"'time zone:' VVVV 'date:' yyyy-MM-dd", "xxxx", "time zone: Los Angeles Time date: 2010-02-25", "xxxx"}, 4007 {"yG", "", "2012AD", ""}, 4008 {"yG", "", "2012", "x"}, 4009 {0, 0, 0, 0}, 4010 }; 4011 4012 for (int32_t i = 0; TestData[i][0]; i++) { 4013 UErrorCode status = U_ZERO_ERROR; 4014 SimpleDateFormat *sdf = new SimpleDateFormat(UnicodeString(TestData[i][0]), status); 4015 if (failure(status, "new SimpleDateFormat", TRUE)) return; 4016 4017 int32_t startPos, resPos; 4018 4019 // lead text 4020 UnicodeString input(TestData[i][1]); 4021 startPos = input.length(); 4022 4023 // date string 4024 input += TestData[i][2]; 4025 resPos = input.length(); 4026 4027 // trail text 4028 input += TestData[i][3]; 4029 4030 ParsePosition pos(startPos); 4031 //UDate d = sdf->parse(input, pos); 4032 (void)sdf->parse(input, pos); 4033 4034 if (pos.getIndex() != resPos) { 4035 errln(UnicodeString("FAIL: Parsing [") + input + "] with pattern [" + TestData[i][0] + "] returns position - " 4036 + pos.getIndex() + ", expected - " + resPos); 4037 } 4038 4039 delete sdf; 4040 } 4041 } 4042 4043 4044 typedef struct { 4045 int32_t era; 4046 int32_t year; 4047 int32_t month; // 1-based 4048 int32_t isLeapMonth; 4049 int32_t day; 4050 } ChineseCalTestDate; 4051 4052 #define NUM_TEST_DATES 3 4053 4054 typedef struct { 4055 const char * locale; 4056 int32_t style; // <0 => custom 4057 UnicodeString dateString[NUM_TEST_DATES]; 4058 } MonthPatternItem; 4059 4060 void DateFormatTest::TestMonthPatterns() 4061 { 4062 const ChineseCalTestDate dates[NUM_TEST_DATES] = { 4063 // era yr mo lp da 4064 { 78, 29, 4, 0, 2 }, // (in chinese era 78) gregorian 2012-4-22 4065 { 78, 29, 4, 1, 2 }, // (in chinese era 78) gregorian 2012-5-22 4066 { 78, 29, 5, 0, 2 }, // (in chinese era 78) gregorian 2012-6-20 4067 }; 4068 4069 const MonthPatternItem items[] = { 4070 // locale date style; expected formats for the 3 dates above 4071 { "root@calendar=chinese", DateFormat::kLong, { UnicodeString("2012(ren-chen) M04 2"), UnicodeString("2012(ren-chen) M04bis 2"), UnicodeString("2012(ren-chen) M05 2") } }, 4072 { "root@calendar=chinese", DateFormat::kShort, { UnicodeString("2012-04-02"), UnicodeString("2012-04bis-02"), UnicodeString("2012-05-02") } }, 4073 { "root@calendar=chinese", -1, { UnicodeString("29-4-2"), UnicodeString("29-4bis-2"), UnicodeString("29-5-2") } }, 4074 { "root@calendar=chinese", -2, { UnicodeString("78x29-4-2"), UnicodeString("78x29-4bis-2"), UnicodeString("78x29-5-2") } }, 4075 { "root@calendar=chinese", -3, { UnicodeString("ren-chen-4-2"), UnicodeString("ren-chen-4bis-2"), UnicodeString("ren-chen-5-2") } }, 4076 { "root@calendar=chinese", -4, { UnicodeString("ren-chen M04 2"), UnicodeString("ren-chen M04bis 2"), UnicodeString("ren-chen M05 2") } }, 4077 { "en@calendar=gregorian", -3, { UnicodeString("2012-4-22"), UnicodeString("2012-5-22"), UnicodeString("2012-6-20") } }, 4078 { "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)") } }, 4079 { "en@calendar=chinese", DateFormat::kShort, { UnicodeString("4/2/2012"), UnicodeString("4bis/2/2012"), UnicodeString("5/2/2012") } }, 4080 { "zh@calendar=chinese", DateFormat::kLong, { CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u56DB\\u6708\\u521D\\u4E8C"), 4081 CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u95F0\\u56DB\\u6708\\u521D\\u4E8C"), 4082 CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u4E94\\u6708\\u521D\\u4E8C") } }, 4083 { "zh@calendar=chinese", DateFormat::kShort, { CharsToUnicodeString("2012/4/2"), 4084 CharsToUnicodeString("2012/\\u95F04/2"), 4085 CharsToUnicodeString("2012/5/2") } }, 4086 { "zh@calendar=chinese", -3, { CharsToUnicodeString("\\u58EC\\u8FB0-4-2"), 4087 CharsToUnicodeString("\\u58EC\\u8FB0-\\u95F04-2"), 4088 CharsToUnicodeString("\\u58EC\\u8FB0-5-2") } }, 4089 { "zh@calendar=chinese", -4, { CharsToUnicodeString("\\u58EC\\u8FB0 \\u56DB\\u6708 2"), 4090 CharsToUnicodeString("\\u58EC\\u8FB0 \\u95F0\\u56DB\\u6708 2"), 4091 CharsToUnicodeString("\\u58EC\\u8FB0 \\u4E94\\u6708 2") } }, 4092 { "zh_Hant@calendar=chinese", DateFormat::kLong, { CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u56DB\\u6708\\u521D\\u4E8C"), 4093 CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u958F\\u56DB\\u6708\\u521D\\u4E8C"), 4094 CharsToUnicodeString("2012\\u58EC\\u8FB0\\u5E74\\u4E94\\u6708\\u521D\\u4E8C") } }, 4095 { "zh_Hant@calendar=chinese", DateFormat::kShort, { CharsToUnicodeString("2012/4/2"), 4096 CharsToUnicodeString("2012/\\u958F4/2"), 4097 CharsToUnicodeString("2012/5/2") } }, 4098 { "fr@calendar=chinese", DateFormat::kLong, { CharsToUnicodeString("2 s\\u00ECyu\\u00E8 ren-chen"), 4099 CharsToUnicodeString("2 s\\u00ECyu\\u00E8bis ren-chen"), 4100 CharsToUnicodeString("2 w\\u01D4yu\\u00E8 ren-chen") } }, 4101 { "fr@calendar=chinese", DateFormat::kShort, { UnicodeString("2/4/29"), UnicodeString("2/4bis/29"), UnicodeString("2/5/29") } }, 4102 { "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)") } }, 4103 { "en@calendar=dangi", DateFormat::kShort, { UnicodeString("3bis/2/2012"), UnicodeString("4/2/2012"), UnicodeString("5/1/2012") } }, 4104 { "en@calendar=dangi", -2, { UnicodeString("78x29-3bis-2"), UnicodeString("78x29-4-2"), UnicodeString("78x29-5-1") } }, 4105 { "ko@calendar=dangi", DateFormat::kLong, { CharsToUnicodeString("\\uC784\\uC9C4\\uB144 \\uC7243\\uC6D4 2\\uC77C"), 4106 CharsToUnicodeString("\\uC784\\uC9C4\\uB144 4\\uC6D4 2\\uC77C"), 4107 CharsToUnicodeString("\\uC784\\uC9C4\\uB144 5\\uC6D4 1\\uC77C") } }, 4108 { "ko@calendar=dangi", DateFormat::kShort, { CharsToUnicodeString("29. \\uC7243. 2."), 4109 CharsToUnicodeString("29. 4. 2."), 4110 CharsToUnicodeString("29. 5. 1.") } }, 4111 // terminator 4112 { NULL, 0, { UnicodeString(""), UnicodeString(""), UnicodeString("") } } 4113 }; 4114 4115 //. style: -1 -2 -3 -4 4116 const UnicodeString customPatterns[] = { "y-Ml-d", "G'x'y-Ml-d", "U-M-d", "U MMM d" }; // like old root pattern, using 'l' 4117 4118 UErrorCode status = U_ZERO_ERROR; 4119 Locale rootChineseCalLocale = Locale::createFromName("root@calendar=chinese"); 4120 Calendar * rootChineseCalendar = Calendar::createInstance(rootChineseCalLocale, status); 4121 if (U_SUCCESS(status)) { 4122 const MonthPatternItem * itemPtr; 4123 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) { 4124 Locale locale = Locale::createFromName(itemPtr->locale); 4125 DateFormat * dmft = (itemPtr->style >= 0)? 4126 DateFormat::createDateInstance((DateFormat::EStyle)itemPtr->style, locale): 4127 new SimpleDateFormat(customPatterns[-itemPtr->style - 1], locale, status); 4128 if ( dmft != NULL ) { 4129 if (U_SUCCESS(status)) { 4130 const ChineseCalTestDate * datePtr = dates; 4131 int32_t idate; 4132 for (idate = 0; idate < NUM_TEST_DATES; idate++, datePtr++) { 4133 rootChineseCalendar->clear(); 4134 rootChineseCalendar->set(UCAL_ERA, datePtr->era); 4135 rootChineseCalendar->set(datePtr->year, datePtr->month-1, datePtr->day); 4136 rootChineseCalendar->set(UCAL_IS_LEAP_MONTH, datePtr->isLeapMonth); 4137 UnicodeString result; 4138 FieldPosition fpos(FieldPosition::DONT_CARE); 4139 dmft->format(*rootChineseCalendar, result, fpos); 4140 if ( result.compare(itemPtr->dateString[idate]) != 0 ) { 4141 errln( UnicodeString("FAIL: Chinese calendar format for locale ") + UnicodeString(itemPtr->locale) + ", style " + itemPtr->style + 4142 ", expected \"" + itemPtr->dateString[idate] + "\", got \"" + result + "\""); 4143 } else { 4144 // formatted OK, try parse 4145 ParsePosition ppos(0); 4146 // ensure we are really parsing the fields we should be 4147 rootChineseCalendar->set(UCAL_YEAR, 1); 4148 rootChineseCalendar->set(UCAL_MONTH, 0); 4149 rootChineseCalendar->set(UCAL_IS_LEAP_MONTH, 0); 4150 rootChineseCalendar->set(UCAL_DATE, 1); 4151 // 4152 dmft->parse(result, *rootChineseCalendar, ppos); 4153 int32_t year = rootChineseCalendar->get(UCAL_YEAR, status); 4154 int32_t month = rootChineseCalendar->get(UCAL_MONTH, status) + 1; 4155 int32_t isLeapMonth = rootChineseCalendar->get(UCAL_IS_LEAP_MONTH, status); 4156 int32_t day = rootChineseCalendar->get(UCAL_DATE, status); 4157 if ( ppos.getIndex() < result.length() || year != datePtr->year || month != datePtr->month || isLeapMonth != datePtr->isLeapMonth || day != datePtr->day ) { 4158 errln( UnicodeString("FAIL: Chinese calendar parse for locale ") + UnicodeString(itemPtr->locale) + ", style " + itemPtr->style + 4159 ", string \"" + result + "\", expected " + datePtr->year +"-"+datePtr->month+"("+datePtr->isLeapMonth+")-"+datePtr->day + ", got pos " + 4160 ppos.getIndex() + " " + year +"-"+month+"("+isLeapMonth+")-"+day); 4161 } 4162 } 4163 } 4164 } else { 4165 dataerrln("Error creating SimpleDateFormat for Chinese calendar- %s", u_errorName(status)); 4166 } 4167 delete dmft; 4168 } else { 4169 dataerrln("FAIL: Unable to create DateFormat for Chinese calendar- %s", u_errorName(status)); 4170 } 4171 } 4172 delete rootChineseCalendar; 4173 } else { 4174 errln(UnicodeString("FAIL: Unable to create Calendar for root@calendar=chinese")); 4175 } 4176 } 4177 4178 typedef struct { 4179 const char * locale; 4180 UnicodeString pattern; 4181 UDisplayContext capitalizationContext; 4182 UnicodeString expectedFormat; 4183 } TestContextItem; 4184 4185 void DateFormatTest::TestContext() 4186 { 4187 const UDate july022008 = 1215000001979.0; 4188 const TestContextItem items[] = { 4189 //locale pattern capitalizationContext expected formatted date 4190 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_NONE, UnicodeString("juillet 2008") }, 4191 #if !UCONFIG_NO_BREAK_ITERATION 4192 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, UnicodeString("juillet 2008") }, 4193 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, UnicodeString("Juillet 2008") }, 4194 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, UnicodeString("juillet 2008") }, 4195 { "fr", UnicodeString("MMMM y"), UDISPCTX_CAPITALIZATION_FOR_STANDALONE, UnicodeString("Juillet 2008") }, 4196 #endif 4197 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_NONE, CharsToUnicodeString("\\u010Dervenec 2008") }, 4198 #if !UCONFIG_NO_BREAK_ITERATION 4199 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, CharsToUnicodeString("\\u010Dervenec 2008") }, 4200 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, CharsToUnicodeString("\\u010Cervenec 2008") }, 4201 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, CharsToUnicodeString("\\u010Cervenec 2008") }, 4202 { "cs", UnicodeString("LLLL y"), UDISPCTX_CAPITALIZATION_FOR_STANDALONE, CharsToUnicodeString("\\u010Dervenec 2008") }, 4203 #endif 4204 // terminator 4205 { NULL, UnicodeString(""), (UDisplayContext)0, UnicodeString("") } 4206 }; 4207 UErrorCode status = U_ZERO_ERROR; 4208 Calendar* cal = Calendar::createInstance(status); 4209 if (U_FAILURE(status)) { 4210 dataerrln(UnicodeString("FAIL: Unable to create Calendar for default timezone and locale.")); 4211 } else { 4212 cal->setTime(july022008, status); 4213 const TestContextItem * itemPtr; 4214 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) { 4215 Locale locale = Locale::createFromName(itemPtr->locale); 4216 status = U_ZERO_ERROR; 4217 SimpleDateFormat * sdmft = new SimpleDateFormat(itemPtr->pattern, locale, status); 4218 if (U_FAILURE(status)) { 4219 dataerrln(UnicodeString("FAIL: Unable to create SimpleDateFormat for specified pattern with locale ") + UnicodeString(itemPtr->locale)); 4220 } else { 4221 sdmft->setContext(itemPtr->capitalizationContext, status); 4222 UnicodeString result; 4223 FieldPosition pos(FieldPosition::DONT_CARE); 4224 sdmft->format(*cal, result, pos); 4225 if (result.compare(itemPtr->expectedFormat) != 0) { 4226 errln(UnicodeString("FAIL: format for locale ") + UnicodeString(itemPtr->locale) + 4227 ", status " + (int)status + 4228 ", capitalizationContext " + (int)itemPtr->capitalizationContext + 4229 ", expected " + itemPtr->expectedFormat + ", got " + result); 4230 } 4231 } 4232 if (sdmft) { 4233 delete sdmft; 4234 } 4235 } 4236 } 4237 if (cal) { 4238 delete cal; 4239 } 4240 } 4241 4242 // test item for a particular locale + calendar and date format 4243 typedef struct { 4244 int32_t era; 4245 int32_t year; 4246 int32_t month; 4247 int32_t day; 4248 int32_t hour; 4249 int32_t minute; 4250 UnicodeString formattedDate; 4251 } CalAndFmtTestItem; 4252 4253 // test item giving locale + calendar, date format, and CalAndFmtTestItems 4254 typedef struct { 4255 const char * locale; // with calendar 4256 DateFormat::EStyle style; 4257 UnicodeString pattern; // ignored unless style == DateFormat::kNone 4258 const CalAndFmtTestItem *caftItems; 4259 } TestNonGregoItem; 4260 4261 void DateFormatTest::TestNonGregoFmtParse() 4262 { 4263 // test items for he@calendar=hebrew, long date format 4264 const CalAndFmtTestItem cafti_he_hebrew_long[] = { 4265 { 0, 4999, 12, 29, 12, 0, CharsToUnicodeString("\\u05DB\\u05F4\\u05D8 \\u05D1\\u05D0\\u05DC\\u05D5\\u05DC \\u05D3\\u05F3\\u05EA\\u05EA\\u05E7\\u05E6\\u05F4\\u05D8") }, 4266 { 0, 5100, 0, 1, 12, 0, CharsToUnicodeString("\\u05D0\\u05F3 \\u05D1\\u05EA\\u05E9\\u05E8\\u05D9 \\u05E7\\u05F3") }, 4267 { 0, 5774, 5, 1, 12, 0, CharsToUnicodeString("\\u05D0\\u05F3 \\u05D1\\u05D0\\u05D3\\u05E8 \\u05D0\\u05F3 \\u05EA\\u05E9\\u05E2\\u05F4\\u05D3") }, 4268 { 0, 5999, 12, 29, 12, 0, CharsToUnicodeString("\\u05DB\\u05F4\\u05D8 \\u05D1\\u05D0\\u05DC\\u05D5\\u05DC \\u05EA\\u05EA\\u05E7\\u05E6\\u05F4\\u05D8") }, 4269 { 0, 6100, 0, 1, 12, 0, CharsToUnicodeString("\\u05D0\\u05F3 \\u05D1\\u05EA\\u05E9\\u05E8\\u05D9 \\u05D5\\u05F3\\u05E7\\u05F3") }, 4270 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4271 }; 4272 const CalAndFmtTestItem cafti_zh_chinese_custU[] = { 4273 { 78, 31, 0, 1, 12, 0, CharsToUnicodeString("2014\\u7532\\u5348\\u5E74\\u6B63\\u67081") }, 4274 { 77, 31, 0, 1, 12, 0, CharsToUnicodeString("1954\\u7532\\u5348\\u5E74\\u6B63\\u67081") }, 4275 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4276 }; 4277 const CalAndFmtTestItem cafti_zh_chinese_custNoU[] = { 4278 { 78, 31, 0, 1, 12, 0, CharsToUnicodeString("2014\\u5E74\\u6B63\\u67081") }, 4279 { 77, 31, 0, 1, 12, 0, CharsToUnicodeString("1954\\u5E74\\u6B63\\u67081") }, 4280 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4281 }; 4282 const CalAndFmtTestItem cafti_ja_japanese_custGy[] = { 4283 {235, 26, 2, 5, 12, 0, CharsToUnicodeString("2014(\\u5E73\\u621026)\\u5E743\\u67085\\u65E5") }, 4284 {234, 60, 2, 5, 12, 0, CharsToUnicodeString("1985(\\u662D\\u548C60)\\u5E743\\u67085\\u65E5") }, 4285 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4286 }; 4287 const CalAndFmtTestItem cafti_ja_japanese_custNoGy[] = { 4288 {235, 26, 2, 5, 12, 0, CharsToUnicodeString("2014\\u5E743\\u67085\\u65E5") }, 4289 {234, 60, 2, 5, 12, 0, CharsToUnicodeString("1985\\u5E743\\u67085\\u65E5") }, 4290 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4291 }; 4292 const CalAndFmtTestItem cafti_en_islamic_cust[] = { 4293 { 0, 1384, 0, 1, 12, 0, UnicodeString("1 Muh. 1384 AH, 1964") }, 4294 { 0, 1436, 0, 1, 12, 0, UnicodeString("1 Muh. 1436 AH, 2014") }, 4295 { 0, 1487, 0, 1, 12, 0, UnicodeString("1 Muh. 1487 AH, 2064") }, 4296 { 0, 0, 0, 0, 0, 0, UnicodeString("") } // terminator 4297 }; 4298 // overal test items 4299 const TestNonGregoItem items[] = { 4300 { "he@calendar=hebrew", DateFormat::kLong, UnicodeString(""), cafti_he_hebrew_long }, 4301 { "zh@calendar=chinese", DateFormat::kNone, CharsToUnicodeString("rU\\u5E74MMMd"), cafti_zh_chinese_custU }, 4302 { "zh@calendar=chinese", DateFormat::kNone, CharsToUnicodeString("r\\u5E74MMMd"), cafti_zh_chinese_custNoU }, 4303 { "ja@calendar=japanese", DateFormat::kNone, CharsToUnicodeString("r(Gy)\\u5E74M\\u6708d\\u65E5"), cafti_ja_japanese_custGy }, 4304 { "ja@calendar=japanese", DateFormat::kNone, CharsToUnicodeString("r\\u5E74M\\u6708d\\u65E5"), cafti_ja_japanese_custNoGy }, 4305 { "en@calendar=islamic", DateFormat::kNone, UnicodeString("d MMM y G, r"), cafti_en_islamic_cust }, 4306 { NULL, DateFormat::kNone, UnicodeString(""), NULL } // terminator 4307 }; 4308 const TestNonGregoItem * itemPtr; 4309 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++) { 4310 Locale locale = Locale::createFromName(itemPtr->locale); 4311 DateFormat * dfmt = NULL; 4312 UErrorCode status = U_ZERO_ERROR; 4313 if (itemPtr->style != DateFormat::kNone) { 4314 dfmt = DateFormat::createDateInstance(itemPtr->style, locale); 4315 } else { 4316 dfmt = new SimpleDateFormat(itemPtr->pattern, locale, status); 4317 } 4318 if (U_FAILURE(status)) { 4319 dataerrln("new SimpleDateFormat fails for locale %s", itemPtr->locale); 4320 } else if (dfmt == NULL) { 4321 dataerrln("DateFormat::createDateInstance fails for locale %s", itemPtr->locale); 4322 } else { 4323 Calendar * cal = (dfmt->getCalendar())->clone(); 4324 if (cal == NULL) { 4325 dataerrln("(DateFormat::getCalendar)->clone() fails for locale %s", itemPtr->locale); 4326 } else { 4327 const CalAndFmtTestItem * caftItemPtr; 4328 for (caftItemPtr = itemPtr->caftItems; caftItemPtr->year != 0; caftItemPtr++) { 4329 cal->clear(); 4330 cal->set(UCAL_ERA, caftItemPtr->era); 4331 cal->set(UCAL_YEAR, caftItemPtr->year); 4332 cal->set(UCAL_MONTH, caftItemPtr->month); 4333 cal->set(UCAL_DATE, caftItemPtr->day); 4334 cal->set(UCAL_HOUR_OF_DAY, caftItemPtr->hour); 4335 cal->set(UCAL_MINUTE, caftItemPtr->minute); 4336 UnicodeString result; 4337 FieldPosition fpos(FieldPosition::DONT_CARE); 4338 dfmt->format(*cal, result, fpos); 4339 if ( result.compare(caftItemPtr->formattedDate) != 0 ) { 4340 errln( UnicodeString("FAIL: date format for locale ") + UnicodeString(itemPtr->locale) + ", style " + itemPtr->style + 4341 ", expected \"" + caftItemPtr->formattedDate + "\", got \"" + result + "\""); 4342 } else { 4343 // formatted OK, try parse 4344 ParsePosition ppos(0); 4345 dfmt->parse(result, *cal, ppos); 4346 status = U_ZERO_ERROR; 4347 int32_t era = cal->get(UCAL_ERA, status); 4348 int32_t year = cal->get(UCAL_YEAR, status); 4349 int32_t month = cal->get(UCAL_MONTH, status); 4350 int32_t day = cal->get(UCAL_DATE, status); 4351 if ( U_FAILURE(status) || ppos.getIndex() < result.length() || era != caftItemPtr->era || 4352 year != caftItemPtr->year || month != caftItemPtr->month || day != caftItemPtr->day ) { 4353 errln( UnicodeString("FAIL: date parse for locale ") + UnicodeString(itemPtr->locale) + 4354 ", style " + itemPtr->style + ", string \"" + result + "\", expected " + 4355 caftItemPtr->era +":"+caftItemPtr->year +"-"+caftItemPtr->month+"-"+caftItemPtr->day + ", got pos " + 4356 ppos.getIndex() + " " + year +"-"+month+"-"+day + " status " + UnicodeString(u_errorName(status)) ); 4357 } 4358 } 4359 } 4360 delete cal; 4361 } 4362 delete dfmt; 4363 } 4364 } 4365 } 4366 4367 typedef struct { 4368 const char* localeID; 4369 DateFormat::EStyle style; 4370 UnicodeString expectPattern; 4371 UnicodeString expectFormat; 4372 } TestFmtWithNumSysItem; 4373 enum { kBBufMax = 128 }; 4374 void DateFormatTest::TestFormatsWithNumberSystems() 4375 { 4376 LocalPointer<TimeZone> zone(TimeZone::createTimeZone(UnicodeString("UTC"))); 4377 const UDate date = 1451556000000.0; // for UTC: grego 31-Dec-2015 10 AM, hebrew 19 tevet 5776, chinese yi-wei 11mo 21day 4378 const TestFmtWithNumSysItem items[] = { 4379 { "haw@calendar=gregorian", DateFormat::kShort, UnicodeString("d/M/yy"), UnicodeString("31/xii/15") }, 4380 { "he@calendar=hebrew", DateFormat::kLong, CharsToUnicodeString("d \\u05D1MMMM y"), CharsToUnicodeString("\\u05D9\\u05F4\\u05D8 \\u05D1\\u05D8\\u05D1\\u05EA \\u05EA\\u05E9\\u05E2\\u05F4\\u05D5") }, 4381 { "zh@calendar=chinese", DateFormat::kLong, CharsToUnicodeString("rU\\u5E74MMMd"), CharsToUnicodeString("2015\\u4E59\\u672A\\u5E74\\u5341\\u4E00\\u6708\\u5EFF\\u4E00") }, 4382 { "zh_Hant@calendar=chinese", DateFormat::kLong, CharsToUnicodeString("rU\\u5E74MMMd"), CharsToUnicodeString("2015\\u4E59\\u672A\\u5E74\\u51AC\\u6708\\u5EFF\\u4E00") }, 4383 { "ja@calendar=chinese", DateFormat::kLong, CharsToUnicodeString("U\\u5E74MMMd\\u65E5"), CharsToUnicodeString("\\u4E59\\u672A\\u5E74\\u5341\\u4E00\\u6708\\u4E8C\\u4E00\\u65E5") }, 4384 { NULL, DateFormat::kNone, UnicodeString(""), UnicodeString("") }, 4385 }; 4386 const TestFmtWithNumSysItem * itemPtr; 4387 for (itemPtr = items; itemPtr->localeID != NULL; itemPtr++) { 4388 char bExpected[kBBufMax]; 4389 char bResult[kBBufMax]; 4390 UErrorCode status = U_ZERO_ERROR; 4391 Locale locale = Locale::createFromName(itemPtr->localeID); 4392 LocalPointer<Calendar> cal(Calendar::createInstance(zone.orphan(), locale, status)); 4393 if (U_FAILURE(status)) { 4394 dataerrln("Calendar::createInstance fails for locale %s, status %s", itemPtr->localeID, u_errorName(status)); 4395 continue; 4396 } 4397 cal->setTime(date, status); 4398 if (U_FAILURE(status)) { 4399 dataerrln("Calendar::setTime fails for locale %s, date %.1f, status %s", itemPtr->localeID, date, u_errorName(status)); 4400 continue; 4401 } 4402 LocalPointer<SimpleDateFormat> sdfmt(static_cast<SimpleDateFormat *>(DateFormat::createDateInstance(itemPtr->style, locale))); 4403 if (sdfmt.isNull()) { 4404 dataerrln("DateFormat::createDateInstance fails for locale %s", itemPtr->localeID); 4405 continue; 4406 } 4407 UnicodeString getFormat; 4408 sdfmt->format(*(cal.getAlias()), getFormat, NULL, status); 4409 if (U_FAILURE(status)) { 4410 errln("DateFormat::format fails for locale %s, status %s", itemPtr->localeID, u_errorName(status)); 4411 continue; 4412 } 4413 if (getFormat.compare(itemPtr->expectFormat) != 0) { 4414 itemPtr->expectFormat.extract(0, itemPtr->expectFormat.length(), bExpected, kBBufMax); 4415 getFormat.extract(0, getFormat.length(), bResult, kBBufMax); 4416 errln("DateFormat::format for locale %s, expected \"%s\", got \"%s\"", itemPtr->localeID, bExpected, bResult); 4417 } 4418 UnicodeString getPattern; 4419 sdfmt->toPattern(getPattern); 4420 if (getPattern.compare(itemPtr->expectPattern) != 0) { 4421 itemPtr->expectPattern.extract(0, itemPtr->expectPattern.length(), bExpected, kBBufMax); 4422 getPattern.extract(0, getPattern.length(), bResult, kBBufMax); 4423 errln("DateFormat::toPattern() for locale %s, expected \"%s\", got \"%s\"", itemPtr->localeID, bExpected, bResult); 4424 } 4425 } 4426 } 4427 4428 static const UDate TEST_DATE = 1326585600000.; // 2012-jan-15 4429 4430 void DateFormatTest::TestDotAndAtLeniency() { 4431 // Test for date/time parsing regression with CLDR 22.1/ICU 50 pattern strings. 4432 // For details see http://bugs.icu-project.org/trac/ticket/9789 4433 static const char *locales[] = { "en", "fr" }; 4434 for (int32_t i = 0; i < UPRV_LENGTHOF(locales); ++i) { 4435 Locale locale(locales[i]); 4436 4437 for (DateFormat::EStyle dateStyle = DateFormat::FULL; dateStyle <= DateFormat::SHORT; 4438 dateStyle = static_cast<DateFormat::EStyle>(dateStyle + 1)) { 4439 LocalPointer<DateFormat> dateFormat(DateFormat::createDateInstance(dateStyle, locale)); 4440 4441 for (DateFormat::EStyle timeStyle = DateFormat::FULL; timeStyle <= DateFormat::SHORT; 4442 timeStyle = static_cast<DateFormat::EStyle>(timeStyle + 1)) { 4443 LocalPointer<DateFormat> format(DateFormat::createDateTimeInstance(dateStyle, timeStyle, locale)); 4444 LocalPointer<DateFormat> timeFormat(DateFormat::createTimeInstance(timeStyle, locale)); 4445 UnicodeString formattedString; 4446 if (format.isNull()) { 4447 dataerrln("Unable to create DateFormat"); 4448 continue; 4449 } 4450 format->format(TEST_DATE, formattedString); 4451 4452 if (!showParse(*format, formattedString)) { 4453 errln(UnicodeString(" with date-time: dateStyle=") + dateStyle + " timeStyle=" + timeStyle); 4454 } 4455 4456 UnicodeString ds, ts; 4457 formattedString = dateFormat->format(TEST_DATE, ds) + " " + timeFormat->format(TEST_DATE, ts); 4458 if (!showParse(*format, formattedString)) { 4459 errln(UnicodeString(" with date sp sp time: dateStyle=") + dateStyle + " timeStyle=" + timeStyle); 4460 } 4461 if (formattedString.indexOf("n ") >= 0) { // will add "." after the end of text ending in 'n', like Jan. 4462 UnicodeString plusDot(formattedString); 4463 plusDot.findAndReplace("n ", "n. ").append("."); 4464 if (!showParse(*format, plusDot)) { 4465 errln(UnicodeString(" with date plus-dot time: dateStyle=") + dateStyle + " timeStyle=" + timeStyle); 4466 } 4467 } 4468 if (formattedString.indexOf(". ") >= 0) { // will subtract "." at the end of strings. 4469 UnicodeString minusDot(formattedString); 4470 minusDot.findAndReplace(". ", " "); 4471 if (!showParse(*format, minusDot)) { 4472 errln(UnicodeString(" with date minus-dot time: dateStyle=") + dateStyle + " timeStyle=" + timeStyle); 4473 } 4474 } 4475 } 4476 } 4477 } 4478 } 4479 4480 UBool DateFormatTest::showParse(DateFormat &format, const UnicodeString &formattedString) { 4481 ParsePosition parsePosition; 4482 UDate parsed = format.parse(formattedString, parsePosition); 4483 UBool ok = TEST_DATE == parsed && parsePosition.getIndex() == formattedString.length(); 4484 UnicodeString pattern; 4485 static_cast<SimpleDateFormat &>(format).toPattern(pattern); 4486 if (ok) { 4487 logln(pattern + " parsed: " + formattedString); 4488 } else { 4489 errln(pattern + " fails to parse: " + formattedString); 4490 } 4491 return ok; 4492 } 4493 4494 4495 typedef struct { 4496 const char * locale; 4497 UBool leniency; 4498 UnicodeString parseString; 4499 UnicodeString pattern; 4500 UnicodeString expectedResult; // empty string indicates expected error 4501 } TestDateFormatLeniencyItem; 4502 4503 void DateFormatTest::TestDateFormatLeniency() { 4504 // For details see http://bugs.icu-project.org/trac/ticket/10261 4505 4506 const UDate july022008 = 1215000001979.0; 4507 const TestDateFormatLeniencyItem items[] = { 4508 //locale leniency parse String pattern expected result 4509 { "en", true, UnicodeString("2008-07 02"), UnicodeString("yyyy-LLLL dd"), UnicodeString("2008-July 02") }, 4510 { "en", false, UnicodeString("2008-07 02"), UnicodeString("yyyy-LLLL dd"), UnicodeString("") }, 4511 { "en", true, UnicodeString("2008-Jan 02"), UnicodeString("yyyy-LLL. dd"), UnicodeString("2008-Jan. 02") }, 4512 { "en", false, UnicodeString("2008-Jan 02"), UnicodeString("yyyy-LLL. dd"), UnicodeString("") }, 4513 { "en", true, UnicodeString("2008-Jan--02"), UnicodeString("yyyy-MMM' -- 'dd"), UnicodeString("2008-Jan -- 02") }, 4514 { "en", false, UnicodeString("2008-Jan--02"), UnicodeString("yyyy-MMM' -- 'dd"), UnicodeString("") }, 4515 // terminator 4516 { NULL, true, UnicodeString(""), UnicodeString(""), UnicodeString("") } 4517 }; 4518 UErrorCode status = U_ZERO_ERROR; 4519 LocalPointer<Calendar> cal(Calendar::createInstance(status)); 4520 if (U_FAILURE(status)) { 4521 dataerrln(UnicodeString("FAIL: Unable to create Calendar for default timezone and locale.")); 4522 return; 4523 } 4524 cal->setTime(july022008, status); 4525 const TestDateFormatLeniencyItem * itemPtr; 4526 LocalPointer<SimpleDateFormat> sdmft; 4527 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) { 4528 4529 Locale locale = Locale::createFromName(itemPtr->locale); 4530 status = U_ZERO_ERROR; 4531 ParsePosition pos(0); 4532 sdmft.adoptInsteadAndCheckErrorCode(new SimpleDateFormat(itemPtr->pattern, locale, status), status); 4533 if (U_FAILURE(status)) { 4534 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 4535 continue; 4536 } 4537 sdmft->setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, itemPtr->leniency, status). 4538 setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, itemPtr->leniency, status). 4539 setBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, itemPtr->leniency, status); 4540 UDate d = sdmft->parse(itemPtr->parseString, pos); 4541 4542 if(itemPtr->expectedResult.length() == 0) { 4543 if(pos.getErrorIndex() != -1) { 4544 continue; 4545 } else { 4546 errln("error: unexpected parse success - " + itemPtr->parseString + 4547 " - pattern " + itemPtr->pattern + 4548 " - error index " + pos.getErrorIndex() + 4549 " - leniency " + itemPtr->leniency); 4550 continue; 4551 } 4552 } 4553 if(pos.getErrorIndex() != -1) { 4554 errln("error: parse error for string - " + itemPtr->parseString + 4555 " - pattern " + itemPtr->pattern + 4556 " - idx " + pos.getIndex() + 4557 " - error index "+pos.getErrorIndex() + 4558 " - leniency " + itemPtr->leniency); 4559 continue; 4560 } 4561 4562 UnicodeString formatResult(""); 4563 sdmft->format(d, formatResult); 4564 if(formatResult.compare(itemPtr->expectedResult) != 0) { 4565 errln("error: unexpected format result. pattern["+itemPtr->pattern+"] expected[" + itemPtr->expectedResult + "] but result was[" + formatResult + "]"); 4566 continue; 4567 } else { 4568 logln("formatted results match! - " + formatResult); 4569 } 4570 4571 } 4572 } 4573 4574 4575 typedef struct { 4576 UBool leniency; 4577 UnicodeString parseString; 4578 UnicodeString pattern; 4579 UnicodeString expectedResult; // empty string indicates expected error 4580 } TestMultiPatternMatchItem; 4581 4582 void DateFormatTest::TestParseMultiPatternMatch() { 4583 // For details see http://bugs.icu-project.org/trac/ticket/10336 4584 const TestMultiPatternMatchItem items[] = { 4585 // leniency parse String pattern expected result 4586 {true, UnicodeString("2013-Sep 13"), UnicodeString("yyyy-MMM dd"), UnicodeString("2013-Sep 13")}, 4587 {true, UnicodeString("2013-September 14"), UnicodeString("yyyy-MMM dd"), UnicodeString("2013-Sep 14")}, 4588 {false, UnicodeString("2013-September 15"), UnicodeString("yyyy-MMM dd"), UnicodeString("")}, 4589 {false, UnicodeString("2013-September 16"), UnicodeString("yyyy-MMMM dd"), UnicodeString("2013-September 16")}, 4590 {true, UnicodeString("2013-Sep 17"), UnicodeString("yyyy-LLL dd"), UnicodeString("2013-Sep 17")}, 4591 {true, UnicodeString("2013-September 18"), UnicodeString("yyyy-LLL dd"), UnicodeString("2013-Sep 18")}, 4592 {false, UnicodeString("2013-September 19"), UnicodeString("yyyy-LLL dd"), UnicodeString("")}, 4593 {false, UnicodeString("2013-September 20"), UnicodeString("yyyy-LLLL dd"), UnicodeString("2013-September 20")}, 4594 {true, UnicodeString("2013 Sat Sep 21"), UnicodeString("yyyy EEE MMM dd"), UnicodeString("2013 Sat Sep 21")}, 4595 {true, UnicodeString("2013 Sunday Sep 22"), UnicodeString("yyyy EEE MMM dd"), UnicodeString("2013 Sun Sep 22")}, 4596 {false, UnicodeString("2013 Monday Sep 23"), UnicodeString("yyyy EEE MMM dd"), UnicodeString("")}, 4597 {false, UnicodeString("2013 Tuesday Sep 24"), UnicodeString("yyyy EEEE MMM dd"), UnicodeString("2013 Tuesday Sep 24")}, 4598 {true, UnicodeString("2013 Wed Sep 25"), UnicodeString("yyyy eee MMM dd"), UnicodeString("2013 Wed Sep 25")}, 4599 {true, UnicodeString("2013 Thu Sep 26"), UnicodeString("yyyy eee MMM dd"), UnicodeString("2013 Thu Sep 26")}, 4600 {false, UnicodeString("2013 Friday Sep 27"), UnicodeString("yyyy eee MMM dd"), UnicodeString("")}, 4601 {false, UnicodeString("2013 Saturday Sep 28"), UnicodeString("yyyy eeee MMM dd"), UnicodeString("2013 Saturday Sep 28")}, 4602 {true, UnicodeString("2013 Sun Sep 29"), UnicodeString("yyyy ccc MMM dd"), UnicodeString("2013 Sun Sep 29")}, 4603 {true, UnicodeString("2013 Monday Sep 30"), UnicodeString("yyyy ccc MMM dd"), UnicodeString("2013 Mon Sep 30")}, 4604 {false, UnicodeString("2013 Sunday Oct 13"), UnicodeString("yyyy ccc MMM dd"), UnicodeString("")}, 4605 {false, UnicodeString("2013 Monday Oct 14"), UnicodeString("yyyy cccc MMM dd"), UnicodeString("2013 Monday Oct 14")}, 4606 {true, UnicodeString("2013 Oct 15 Q4"), UnicodeString("yyyy MMM dd QQQ"), UnicodeString("2013 Oct 15 Q4")}, 4607 {true, UnicodeString("2013 Oct 16 4th quarter"), UnicodeString("yyyy MMM dd QQQ"), UnicodeString("2013 Oct 16 Q4")}, 4608 {false, UnicodeString("2013 Oct 17 4th quarter"), UnicodeString("yyyy MMM dd QQQ"), UnicodeString("")}, 4609 {false, UnicodeString("2013 Oct 18 Q4"), UnicodeString("yyyy MMM dd QQQ"), UnicodeString("2013 Oct 18 Q4")}, 4610 {true, UnicodeString("2013 Oct 19 Q4"), UnicodeString("yyyy MMM dd qqqq"), UnicodeString("2013 Oct 19 4th quarter")}, 4611 {true, UnicodeString("2013 Oct 20 4th quarter"), UnicodeString("yyyy MMM dd qqqq"), UnicodeString("2013 Oct 20 4th quarter")}, 4612 {false, UnicodeString("2013 Oct 21 Q4"), UnicodeString("yyyy MMM dd qqqq"), UnicodeString("")}, 4613 {false, UnicodeString("2013 Oct 22 4th quarter"), UnicodeString("yyyy MMM dd qqqq"), UnicodeString("2013 Oct 22 4th quarter")}, 4614 {false, UnicodeString("--end--"), UnicodeString(""), UnicodeString("")}, 4615 }; 4616 4617 UErrorCode status = U_ZERO_ERROR; 4618 LocalPointer<Calendar> cal(Calendar::createInstance(status)); 4619 if (U_FAILURE(status)) { 4620 dataerrln(UnicodeString("FAIL: Unable to create Calendar for default timezone and locale.")); 4621 return; 4622 } 4623 const TestMultiPatternMatchItem * itemPtr; 4624 DateFormat* sdmft = DateFormat::createDateInstance(); 4625 if (sdmft == NULL) { 4626 dataerrln(UnicodeString("FAIL: Unable to create DateFormat")); 4627 return; 4628 } 4629 for (itemPtr = items; itemPtr->parseString != "--end--"; itemPtr++ ) { 4630 status = U_ZERO_ERROR; 4631 ParsePosition pos(0); 4632 ((SimpleDateFormat*) sdmft)->applyPattern(itemPtr->pattern); 4633 if (U_FAILURE(status)) { 4634 dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); 4635 continue; 4636 } 4637 sdmft->setBooleanAttribute(UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH, itemPtr->leniency, status); 4638 UDate d = sdmft->parse(itemPtr->parseString, pos); 4639 4640 if(itemPtr->expectedResult.length() == 0) { 4641 if(pos.getErrorIndex() != -1) { 4642 continue; 4643 } else { 4644 errln("error: unexpected parse success - " + itemPtr->parseString + 4645 " - error index " + pos.getErrorIndex() + 4646 " - leniency " + itemPtr->leniency); 4647 continue; 4648 } 4649 } 4650 if(pos.getErrorIndex() != -1) { 4651 errln("error: parse error for string - " +itemPtr->parseString + " -- idx["+pos.getIndex()+"] errIdx["+pos.getErrorIndex()+"]"); 4652 continue; 4653 } 4654 4655 UnicodeString formatResult(""); 4656 sdmft->format(d, formatResult); 4657 if(formatResult.compare(itemPtr->expectedResult) != 0) { 4658 errln("error: unexpected format result. expected[" + itemPtr->expectedResult + "] but result was[" + formatResult + "]"); 4659 } else { 4660 logln("formatted results match! - " + formatResult); 4661 } 4662 } 4663 delete sdmft; 4664 } 4665 4666 void DateFormatTest::TestParseLeniencyAPIs() { 4667 UErrorCode status = U_ZERO_ERROR; 4668 LocalPointer<DateFormat> dateFormat(DateFormat::createDateInstance()); 4669 DateFormat *fmt = dateFormat.getAlias(); 4670 if (fmt == NULL) { 4671 dataerrln("Failed calling dateFormat.getAlias()"); 4672 return; 4673 } 4674 4675 assertTrue("isLenient default", fmt->isLenient()); 4676 assertTrue("isCalendarLenient default", fmt->isCalendarLenient()); 4677 assertTrue("ALLOW_WHITESPACE default", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4678 assertTrue("ALLOW_NUMERIC default", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4679 assertTrue("PARTIAL_MATCH default", fmt->getBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, status)); 4680 assertTrue("MULTIPLE_PATTERNS default", fmt->getBooleanAttribute(UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH, status)); 4681 4682 // Set calendar to strict 4683 fmt->setCalendarLenient(FALSE); 4684 4685 assertFalse("isLeninent after setCalendarLenient(FALSE)", fmt->isLenient()); 4686 assertFalse("isCalendarLenient after setCalendarLenient(FALSE)", fmt->isCalendarLenient()); 4687 assertTrue("ALLOW_WHITESPACE after setCalendarLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4688 assertTrue("ALLOW_NUMERIC after setCalendarLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4689 4690 // Set to strict 4691 fmt->setLenient(FALSE); 4692 4693 assertFalse("isLeninent after setLenient(FALSE)", fmt->isLenient()); 4694 assertFalse("isCalendarLenient after setLenient(FALSE)", fmt->isCalendarLenient()); 4695 assertFalse("ALLOW_WHITESPACE after setLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4696 assertFalse("ALLOW_NUMERIC after setLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4697 // These two boolean attributes are NOT affected according to the API specification 4698 assertTrue("PARTIAL_MATCH after setLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, status)); 4699 assertTrue("MULTIPLE_PATTERNS after setLenient(FALSE)", fmt->getBooleanAttribute(UDAT_PARSE_MULTIPLE_PATTERNS_FOR_MATCH, status)); 4700 4701 // Allow white space leniency 4702 fmt->setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, TRUE, status); 4703 4704 assertFalse("isLeninent after ALLOW_WHITESPACE/TRUE", fmt->isLenient()); 4705 assertFalse("isCalendarLenient after ALLOW_WHITESPACE/TRUE", fmt->isCalendarLenient()); 4706 assertTrue("ALLOW_WHITESPACE after ALLOW_WHITESPACE/TRUE", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4707 assertFalse("ALLOW_NUMERIC after ALLOW_WHITESPACE/TRUE", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4708 4709 // Set to lenient 4710 fmt->setLenient(TRUE); 4711 4712 assertTrue("isLenient after setLenient(TRUE)", fmt->isLenient()); 4713 assertTrue("isCalendarLenient after setLenient(TRUE)", fmt->isCalendarLenient()); 4714 assertTrue("ALLOW_WHITESPACE after setLenient(TRUE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, status)); 4715 assertTrue("ALLOW_NUMERIC after setLenient(TRUE)", fmt->getBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, status)); 4716 } 4717 4718 void DateFormatTest::TestNumberFormatOverride() { 4719 UErrorCode status = U_ZERO_ERROR; 4720 UnicodeString fields = (UnicodeString) "M"; 4721 4722 LocalPointer<SimpleDateFormat> fmt; 4723 fmt.adoptInsteadAndCheckErrorCode(new SimpleDateFormat((UnicodeString)"MM d", status), status); 4724 if (!assertSuccess("SimpleDateFormat with pattern MM d", status)) { 4725 return; 4726 } 4727 4728 4729 for(int i=0; i<3; i++){ 4730 NumberFormat* check_nf = NumberFormat::createInstance(Locale("en_US"), status); 4731 assertSuccess("NumberFormat en_US", status); 4732 fmt->adoptNumberFormat(fields, check_nf, status); 4733 assertSuccess("adoptNumberFormat check_nf", status); 4734 4735 const NumberFormat* get_nf = fmt->getNumberFormatForField((UChar)0x004D /*'M'*/); 4736 if (get_nf != check_nf) errln("FAIL: getter and setter do not work"); 4737 } 4738 NumberFormat* check_nf = NumberFormat::createInstance(Locale("en_US"), status); 4739 assertSuccess("NumberFormat en_US", status); 4740 fmt->adoptNumberFormat(check_nf); // make sure using the same NF will not crash 4741 4742 const char * DATA [][2] = { 4743 { "", "\\u521D\\u516D \\u5341\\u4E94"}, 4744 { "M", "\\u521D\\u516D 15"}, 4745 { "Mo", "\\u521D\\u516D 15"}, 4746 { "Md", "\\u521D\\u516D \\u5341\\u4E94"}, 4747 { "MdMMd", "\\u521D\\u516D \\u5341\\u4E94"}, 4748 { "mixed", "\\u521D\\u516D \\u5341\\u4E94"} 4749 }; 4750 4751 UDate test_date = date(97, 6 - 1, 15); 4752 4753 for(int i=0; i < UPRV_LENGTHOF(DATA); i++){ 4754 fields = DATA[i][0]; 4755 4756 LocalPointer<SimpleDateFormat> fmt; 4757 fmt.adoptInsteadAndCheckErrorCode(new SimpleDateFormat((UnicodeString)"MM d", status), status); 4758 assertSuccess("SimpleDateFormat with pattern MM d", status); 4759 NumberFormat* overrideNF = NumberFormat::createInstance(Locale::createFromName("zh@numbers=hanidays"),status); 4760 assertSuccess("NumberFormat zh@numbers=hanidays", status); 4761 4762 if (fields == (UnicodeString) "") { // use the one w/o fields 4763 fmt->adoptNumberFormat(overrideNF); 4764 } else if (fields == (UnicodeString) "mixed") { // set 1 field at first but then full override, both(M & d) should be override 4765 NumberFormat* singleOverrideNF = NumberFormat::createInstance(Locale::createFromName("en@numbers=hebr"),status); 4766 assertSuccess("NumberFormat en@numbers=hebr", status); 4767 4768 fields = (UnicodeString) "M"; 4769 fmt->adoptNumberFormat(fields, singleOverrideNF, status); 4770 assertSuccess("adoptNumberFormat singleOverrideNF", status); 4771 4772 fmt->adoptNumberFormat(overrideNF); 4773 } else if (fields == (UnicodeString) "Mo"){ // o is invlid field 4774 fmt->adoptNumberFormat(fields, overrideNF, status); 4775 if(status == U_INVALID_FORMAT_ERROR) { 4776 status = U_ZERO_ERROR; 4777 continue; 4778 } 4779 } else { 4780 fmt->adoptNumberFormat(fields, overrideNF, status); 4781 assertSuccess("adoptNumberFormat overrideNF", status); 4782 } 4783 4784 UnicodeString result; 4785 FieldPosition pos(FieldPosition::DONT_CARE); 4786 fmt->format(test_date,result, pos); 4787 4788 UnicodeString expected = ((UnicodeString)DATA[i][1]).unescape();; 4789 4790 if (result != expected) 4791 errln("FAIL: Expected " + expected + " get: " + result); 4792 } 4793 } 4794 4795 void DateFormatTest::TestCreateInstanceForSkeleton() { 4796 UErrorCode status = U_ZERO_ERROR; 4797 LocalPointer<DateFormat> fmt(DateFormat::createInstanceForSkeleton( 4798 "yMMMMd", "en", status)); 4799 if (!assertSuccess("Create with pattern yMMMMd", status)) { 4800 return; 4801 } 4802 UnicodeString result; 4803 FieldPosition pos(FieldPosition::DONT_CARE); 4804 fmt->format(date(98, 5-1, 25), result, pos); 4805 assertEquals("format yMMMMd", "May 25, 1998", result); 4806 fmt.adoptInstead(DateFormat::createInstanceForSkeleton( 4807 "yMd", "en", status)); 4808 if (!assertSuccess("Create with pattern yMd", status)) { 4809 return; 4810 } 4811 result.remove(); 4812 fmt->format(date(98, 5-1, 25), result, pos); 4813 assertEquals("format yMd", "5/25/1998", result); 4814 } 4815 4816 void DateFormatTest::TestCreateInstanceForSkeletonDefault() { 4817 UErrorCode status = U_ZERO_ERROR; 4818 Locale savedLocale; 4819 Locale::setDefault(Locale::getUS(), status); 4820 LocalPointer<DateFormat> fmt(DateFormat::createInstanceForSkeleton( 4821 "yMMMd", status)); 4822 Locale::setDefault(savedLocale, status); 4823 if (!assertSuccess("Create with pattern yMMMd", status)) { 4824 return; 4825 } 4826 UnicodeString result; 4827 FieldPosition pos(FieldPosition::DONT_CARE); 4828 fmt->format(date(98, 5-1, 25), result, pos); 4829 assertEquals("format yMMMd", "May 25, 1998", result); 4830 } 4831 4832 void DateFormatTest::TestCreateInstanceForSkeletonWithCalendar() { 4833 UErrorCode status = U_ZERO_ERROR; 4834 LocalPointer<DateFormat> fmt( 4835 DateFormat::createInstanceForSkeleton( 4836 Calendar::createInstance( 4837 TimeZone::createTimeZone("GMT-3:00"), 4838 status), 4839 "yMdHm", "en", status)); 4840 if (!assertSuccess("Create with pattern yMMMMd", status)) { 4841 return; 4842 } 4843 UnicodeString result; 4844 FieldPosition pos(FieldPosition::DONT_CARE); 4845 4846 LocalPointer<Calendar> cal(Calendar::createInstance( 4847 TimeZone::createTimeZone("GMT-7:00"), 4848 status)); 4849 if (!assertSuccess("Creating GMT-7 time zone failed", status)) { 4850 return; 4851 } 4852 cal->clear(); 4853 cal->set(1998, 5-1, 25, 0, 0, 0); 4854 4855 // date format time zone should be 4 hours ahead. 4856 fmt->format(cal->getTime(status), result, pos); 4857 assertEquals("format yMdHm", "5/25/1998, 04:00", result); 4858 assertSuccess("", status); 4859 } 4860 4861 void DateFormatTest::TestDFSCreateForLocaleNonGregorianLocale() { 4862 UErrorCode status = U_ZERO_ERROR; 4863 Locale fa("fa"); 4864 LocalPointer<DateFormatSymbols> sym( 4865 DateFormatSymbols::createForLocale(fa, status)); 4866 if (!assertSuccess("", status)) { 4867 return; 4868 } 4869 4870 // Android: All locales default to Gregorian calendar: 4871 int32_t count; 4872 const UnicodeString *months = sym->getShortMonths(count); 4873 4874 // First persian month. 4875 UnicodeString expected("\\u0698\\u0627\\u0646\\u0648\\u06CC\\u0647\\u0654"); // Android-changed 4876 assertEquals("", expected.unescape(), months[0]); 4877 } 4878 4879 void DateFormatTest::TestDFSCreateForLocaleWithCalendarInLocale() { 4880 UErrorCode status = U_ZERO_ERROR; 4881 Locale en_heb("en@calendar=hebrew"); 4882 LocalPointer<DateFormatSymbols> sym( 4883 DateFormatSymbols::createForLocale(en_heb, status)); 4884 if (!assertSuccess("", status)) { 4885 return; 4886 } 4887 4888 // We should get the months of the hebrew calendar, not the gregorian 4889 // calendar. 4890 int32_t count; 4891 const UnicodeString *months = sym->getShortMonths(count); 4892 4893 // First hebrew month. 4894 UnicodeString expected("Tishri"); 4895 assertEquals("", expected, months[0]); 4896 } 4897 4898 void DateFormatTest::TestChangeCalendar() { 4899 UErrorCode status = U_ZERO_ERROR; 4900 Locale en("en"); 4901 Locale en_heb("en@calendar=hebrew"); 4902 LocalPointer<DateFormat> fmt( 4903 DateFormat::createInstanceForSkeleton("yMMMd", en, status)); 4904 if (!assertSuccess("", status)) { 4905 return; 4906 } 4907 fmt->adoptCalendar(Calendar::createInstance(en_heb, status)); 4908 if (!assertSuccess("", status)) { 4909 return; 4910 } 4911 UnicodeString result; 4912 FieldPosition pos(FieldPosition::DONT_CARE); 4913 fmt->format(date(98, 5-1, 25), result, pos); 4914 assertEquals("format yMMMd", "Iyar 29, 5758", result); 4915 } 4916 4917 void DateFormatTest::TestPatternFromSkeleton() { 4918 static const struct { 4919 const Locale& locale; 4920 const char* const skeleton; 4921 const char* const pattern; 4922 } TESTDATA[] = { 4923 // Ticket #11985 4924 {Locale::getEnglish(), "jjmm", "h:mm a"}, 4925 {Locale::getEnglish(), "JJmm", "hh:mm"}, 4926 {Locale::getGerman(), "jjmm", "HH:mm"}, 4927 {Locale::getGerman(), "JJmm", "HH:mm"} 4928 }; 4929 4930 for (size_t i = 0; i < UPRV_LENGTHOF(TESTDATA); i++) { 4931 UErrorCode status = U_ZERO_ERROR; 4932 LocalPointer<DateFormat> fmt( 4933 DateFormat::createInstanceForSkeleton( 4934 TESTDATA[i].skeleton, TESTDATA[i].locale, status)); 4935 if (!assertSuccess("createInstanceForSkeleton", status)) { 4936 return; 4937 } 4938 UnicodeString pattern; 4939 static_cast<const SimpleDateFormat*>(fmt.getAlias())->toPattern(pattern); 4940 assertEquals("Format pattern", TESTDATA[i].pattern, pattern); 4941 } 4942 } 4943 4944 void DateFormatTest::TestAmPmMidnightNoon() { 4945 // Some times on 2015-11-13 (UTC+0). 4946 UDate k000000 = 1447372800000.0; 4947 UDate k000030 = 1447372830000.0; 4948 UDate k003000 = 1447374600000.0; 4949 UDate k060000 = 1447394400000.0; 4950 UDate k120000 = 1447416000000.0; 4951 UDate k180000 = 1447437600000.0; 4952 4953 UErrorCode errorCode = U_ZERO_ERROR; 4954 SimpleDateFormat sdf(UnicodeString(), errorCode); 4955 if (U_FAILURE(errorCode)) { 4956 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 4957 return; 4958 } 4959 const TimeZone *tz = TimeZone::getGMT(); 4960 sdf.setTimeZone(*tz); 4961 UnicodeString out; 4962 4963 // Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day. 4964 // For ICU 57 output of "midnight" is temporarily suppressed. 4965 4966 // Short. 4967 sdf.applyPattern(UnicodeString("hh:mm:ss bbb")); 4968 4969 // assertEquals("hh:mm:ss bbb | 00:00:00", "12:00:00 midnight", sdf.format(k000000, out.remove())); 4970 assertEquals("hh:mm:ss bbb | 00:00:00", "12:00:00 AM", sdf.format(k000000, out.remove())); 4971 assertEquals("hh:mm:ss bbb | 00:00:30", "12:00:30 AM", sdf.format(k000030, out.remove())); 4972 assertEquals("hh:mm:ss bbb | 00:30:00", "12:30:00 AM", sdf.format(k003000, out.remove())); 4973 assertEquals("hh:mm:ss bbb | 06:00:00", "06:00:00 AM", sdf.format(k060000, out.remove())); 4974 assertEquals("hh:mm:ss bbb | 12:00:00", "12:00:00 noon", sdf.format(k120000, out.remove())); 4975 assertEquals("hh:mm:ss bbb | 18:00:00", "06:00:00 PM", sdf.format(k180000, out.remove())); 4976 4977 sdf.applyPattern(UnicodeString("hh:mm bbb")); 4978 4979 // assertEquals("hh:mm bbb | 00:00:00", "12:00 midnight", sdf.format(k000000, out.remove())); 4980 assertEquals("hh:mm bbb | 00:00:00", "12:00 AM", sdf.format(k000000, out.remove())); 4981 // assertEquals("hh:mm bbb | 00:00:30", "12:00 midnight", sdf.format(k000030, out.remove())); 4982 assertEquals("hh:mm bbb | 00:00:30", "12:00 AM", sdf.format(k000030, out.remove())); 4983 assertEquals("hh:mm bbb | 00:30:00", "12:30 AM", sdf.format(k003000, out.remove())); 4984 4985 sdf.applyPattern(UnicodeString("hh bbb")); 4986 4987 // assertEquals("hh bbb | 00:00:00", "12 midnight", sdf.format(k000000, out.remove())); 4988 assertEquals("hh bbb | 00:00:00", "12 AM", sdf.format(k000000, out.remove())); 4989 // assertEquals("hh bbb | 00:00:30", "12 midnight", sdf.format(k000030, out.remove())); 4990 assertEquals("hh bbb | 00:00:30", "12 AM", sdf.format(k000030, out.remove())); 4991 // assertEquals("hh bbb | 00:30:00", "12 midnight", sdf.format(k003000, out.remove())); 4992 assertEquals("hh bbb | 00:30:00", "12 AM", sdf.format(k003000, out.remove())); 4993 4994 // Wide. 4995 sdf.applyPattern(UnicodeString("hh:mm:ss bbbb")); 4996 4997 // assertEquals("hh:mm:ss bbbb | 00:00:00", "12:00:00 midnight", sdf.format(k000000, out.remove())); 4998 assertEquals("hh:mm:ss bbbb | 00:00:00", "12:00:00 AM", sdf.format(k000000, out.remove())); 4999 assertEquals("hh:mm:ss bbbb | 00:00:30", "12:00:30 AM", sdf.format(k000030, out.remove())); 5000 assertEquals("hh:mm:ss bbbb | 00:30:00", "12:30:00 AM", sdf.format(k003000, out.remove())); 5001 assertEquals("hh:mm:ss bbbb | 06:00:00", "06:00:00 AM", sdf.format(k060000, out.remove())); 5002 assertEquals("hh:mm:ss bbbb | 12:00:00", "12:00:00 noon", sdf.format(k120000, out.remove())); 5003 assertEquals("hh:mm:ss bbbb | 18:00:00", "06:00:00 PM", sdf.format(k180000, out.remove())); 5004 5005 sdf.applyPattern(UnicodeString("hh:mm bbbb")); 5006 5007 // assertEquals("hh:mm bbbb | 00:00:00", "12:00 midnight", sdf.format(k000000, out.remove())); 5008 assertEquals("hh:mm bbbb | 00:00:00", "12:00 AM", sdf.format(k000000, out.remove())); 5009 // assertEquals("hh:mm bbbb | 00:00:30", "12:00 midnight", sdf.format(k000030, out.remove())); 5010 assertEquals("hh:mm bbbb | 00:00:30", "12:00 AM", sdf.format(k000030, out.remove())); 5011 assertEquals("hh:mm bbbb | 00:30:00", "12:30 AM", sdf.format(k003000, out.remove())); 5012 5013 sdf.applyPattern(UnicodeString("hh bbbb")); 5014 5015 // assertEquals("hh bbbb | 00:00:00", "12 midnight", sdf.format(k000000, out.remove())); 5016 assertEquals("hh bbbb | 00:00:00", "12 AM", sdf.format(k000000, out.remove())); 5017 // assertEquals("hh bbbb | 00:00:30", "12 midnight", sdf.format(k000030, out.remove())); 5018 assertEquals("hh bbbb | 00:00:30", "12 AM", sdf.format(k000030, out.remove())); 5019 // assertEquals("hh bbbb | 00:30:00", "12 midnight", sdf.format(k003000, out.remove())); 5020 assertEquals("hh bbbb | 00:30:00", "12 AM", sdf.format(k003000, out.remove())); 5021 5022 // Narrow. 5023 sdf.applyPattern(UnicodeString("hh:mm:ss bbbbb")); 5024 5025 // assertEquals("hh:mm:ss bbbbb | 00:00:00", "12:00:00 mi", sdf.format(k000000, out.remove())); 5026 assertEquals("hh:mm:ss bbbbb | 00:00:00", "12:00:00 a", sdf.format(k000000, out.remove())); 5027 assertEquals("hh:mm:ss bbbbb | 00:00:30", "12:00:30 a", sdf.format(k000030, out.remove())); 5028 assertEquals("hh:mm:ss bbbbb | 00:30:00", "12:30:00 a", sdf.format(k003000, out.remove())); 5029 assertEquals("hh:mm:ss bbbbb | 06:00:00", "06:00:00 a", sdf.format(k060000, out.remove())); 5030 assertEquals("hh:mm:ss bbbbb | 12:00:00", "12:00:00 n", sdf.format(k120000, out.remove())); 5031 assertEquals("hh:mm:ss bbbbb | 18:00:00", "06:00:00 p", sdf.format(k180000, out.remove())); 5032 5033 sdf.applyPattern(UnicodeString("hh:mm bbbbb")); 5034 5035 // assertEquals("hh:mm bbbbb | 00:00:00", "12:00 mi", sdf.format(k000000, out.remove())); 5036 assertEquals("hh:mm bbbbb | 00:00:00", "12:00 a", sdf.format(k000000, out.remove())); 5037 // assertEquals("hh:mm bbbbb | 00:00:30", "12:00 mi", sdf.format(k000030, out.remove())); 5038 assertEquals("hh:mm bbbbb | 00:00:30", "12:00 a", sdf.format(k000030, out.remove())); 5039 assertEquals("hh:mm bbbbb | 00:30:00", "12:30 a", sdf.format(k003000, out.remove())); 5040 5041 sdf.applyPattern(UnicodeString("hh bbbbb")); 5042 5043 // assertEquals("hh bbbbb | 00:00:00", "12 mi", sdf.format(k000000, out.remove())); 5044 assertEquals("hh bbbbb | 00:00:00", "12 a", sdf.format(k000000, out.remove())); 5045 // assertEquals("hh bbbbb | 00:00:30", "12 mi", sdf.format(k000030, out.remove())); 5046 assertEquals("hh bbbbb | 00:00:30", "12 a", sdf.format(k000030, out.remove())); 5047 // assertEquals("hh bbbbb | 00:30:00", "12 mi", sdf.format(k003000, out.remove())); 5048 assertEquals("hh bbbbb | 00:30:00", "12 a", sdf.format(k003000, out.remove())); 5049 } 5050 5051 void DateFormatTest::TestFlexibleDayPeriod() { 5052 // Some times on 2015-11-13 (UTC+0). 5053 UDate k000000 = 1447372800000.0; 5054 UDate k000030 = 1447372830000.0; 5055 UDate k003000 = 1447374600000.0; 5056 UDate k060000 = 1447394400000.0; 5057 UDate k120000 = 1447416000000.0; 5058 UDate k180000 = 1447437600000.0; 5059 5060 UErrorCode errorCode = U_ZERO_ERROR; 5061 SimpleDateFormat sdf(UnicodeString(), errorCode); 5062 if (U_FAILURE(errorCode)) { 5063 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 5064 return; 5065 } 5066 const TimeZone *tz = TimeZone::getGMT(); 5067 sdf.setTimeZone(*tz); 5068 UnicodeString out; 5069 5070 // Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day. 5071 // For ICU 57 output of "midnight" is temporarily suppressed. 5072 5073 // Short. 5074 sdf.applyPattern(UnicodeString("hh:mm:ss BBB")); 5075 5076 // assertEquals("hh:mm:ss BBB | 00:00:00", "12:00:00 midnight", sdf.format(k000000, out.remove())); 5077 assertEquals("hh:mm:ss BBB | 00:00:00", "12:00:00 at night", sdf.format(k000000, out.remove())); 5078 assertEquals("hh:mm:ss BBB | 00:00:30", "12:00:30 at night", sdf.format(k000030, out.remove())); 5079 assertEquals("hh:mm:ss BBB | 00:30:00", "12:30:00 at night", sdf.format(k003000, out.remove())); 5080 assertEquals("hh:mm:ss BBB | 06:00:00", "06:00:00 in the morning", sdf.format(k060000, out.remove())); 5081 assertEquals("hh:mm:ss BBB | 12:00:00", "12:00:00 noon", sdf.format(k120000, out.remove())); 5082 assertEquals("hh:mm:ss BBB | 18:00:00", "06:00:00 in the evening", sdf.format(k180000, out.remove())); 5083 5084 sdf.applyPattern(UnicodeString("hh:mm BBB")); 5085 5086 // assertEquals("hh:mm BBB | 00:00:00", "12:00 midnight", sdf.format(k000000, out.remove())); 5087 assertEquals("hh:mm BBB | 00:00:00", "12:00 at night", sdf.format(k000000, out.remove())); 5088 // assertEquals("hh:mm BBB | 00:00:30", "12:00 midnight", sdf.format(k000030, out.remove())); 5089 assertEquals("hh:mm BBB | 00:00:00", "12:00 at night", sdf.format(k000000, out.remove())); 5090 assertEquals("hh:mm BBB | 00:30:00", "12:30 at night", sdf.format(k003000, out.remove())); 5091 5092 sdf.applyPattern(UnicodeString("hh BBB")); 5093 5094 // assertEquals("hh BBB | 00:00:00", "12 midnight", sdf.format(k000000, out.remove())); 5095 assertEquals("hh BBB | 00:00:30", "12 at night", sdf.format(k000030, out.remove())); 5096 // assertEquals("hh BBB | 00:00:30", "12 midnight", sdf.format(k000030, out.remove())); 5097 assertEquals("hh BBB | 00:00:30", "12 at night", sdf.format(k000030, out.remove())); 5098 // assertEquals("hh BBB | 00:30:00", "12 midnight", sdf.format(k003000, out.remove())); 5099 assertEquals("hh BBB | 00:30:00", "12 at night", sdf.format(k003000, out.remove())); 5100 5101 // Wide. 5102 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5103 5104 // assertEquals("hh:mm:ss BBBB | 00:00:00", "12:00:00 midnight", sdf.format(k000000, out.remove())); 5105 assertEquals("hh:mm:ss BBBB | 00:00:00", "12:00:00 at night", sdf.format(k000000, out.remove())); 5106 assertEquals("hh:mm:ss BBBB | 00:00:30", "12:00:30 at night", sdf.format(k000030, out.remove())); 5107 assertEquals("hh:mm:ss BBBB | 00:30:00", "12:30:00 at night", sdf.format(k003000, out.remove())); 5108 assertEquals("hh:mm:ss BBBB | 06:00:00", "06:00:00 in the morning", sdf.format(k060000, out.remove())); 5109 assertEquals("hh:mm:ss BBBB | 12:00:00", "12:00:00 noon", sdf.format(k120000, out.remove())); 5110 assertEquals("hh:mm:ss BBBB | 18:00:00", "06:00:00 in the evening", sdf.format(k180000, out.remove())); 5111 5112 sdf.applyPattern(UnicodeString("hh:mm BBBB")); 5113 5114 // assertEquals("hh:mm BBBB | 00:00:00", "12:00 midnight", sdf.format(k000000, out.remove())); 5115 assertEquals("hh:mm BBBB | 00:00:00", "12:00 at night", sdf.format(k000000, out.remove())); 5116 // assertEquals("hh:mm BBBB | 00:00:30", "12:00 midnight", sdf.format(k000030, out.remove())); 5117 assertEquals("hh:mm BBBB | 00:00:30", "12:00 at night", sdf.format(k000030, out.remove())); 5118 assertEquals("hh:mm BBBB | 00:30:00", "12:30 at night", sdf.format(k003000, out.remove())); 5119 5120 sdf.applyPattern(UnicodeString("hh BBBB")); 5121 5122 // assertEquals("hh BBBB | 00:00:00", "12 midnight", sdf.format(k000000, out.remove())); 5123 assertEquals("hh BBBB | 00:00:00", "12 at night", sdf.format(k000000, out.remove())); 5124 // assertEquals("hh BBBB | 00:00:30", "12 midnight", sdf.format(k000030, out.remove())); 5125 assertEquals("hh BBBB | 00:00:00", "12 at night", sdf.format(k000000, out.remove())); 5126 // assertEquals("hh BBBB | 00:80:00", "12 midnight", sdf.format(k003000, out.remove())); 5127 assertEquals("hh BBBB | 00:00:00", "12 at night", sdf.format(k000000, out.remove())); 5128 5129 // Narrow. 5130 sdf.applyPattern(UnicodeString("hh:mm:ss BBBBB")); 5131 5132 // assertEquals("hh:mm:ss BBBBB | 00:00:00", "12:00:00 mi", sdf.format(k000000, out.remove())); 5133 assertEquals("hh:mm:ss BBBBB | 00:00:00", "12:00:00 at night", sdf.format(k000000, out.remove())); 5134 assertEquals("hh:mm:ss BBBBB | 00:00:30", "12:00:30 at night", sdf.format(k000030, out.remove())); 5135 assertEquals("hh:mm:ss BBBBB | 00:30:00", "12:30:00 at night", sdf.format(k003000, out.remove())); 5136 assertEquals("hh:mm:ss BBBBB | 06:00:00", "06:00:00 in the morning", sdf.format(k060000, out.remove())); 5137 assertEquals("hh:mm:ss BBBBB | 12:00:00", "12:00:00 n", sdf.format(k120000, out.remove())); 5138 assertEquals("hh:mm:ss BBBBB | 18:00:00", "06:00:00 in the evening", sdf.format(k180000, out.remove())); 5139 5140 sdf.applyPattern(UnicodeString("hh:mm BBBBB")); 5141 5142 // assertEquals("hh:mm BBBBB | 00:00:00", "12:00 mi", sdf.format(k000000, out.remove())); 5143 assertEquals("hh:mm BBBBB | 00:00:00", "12:00 at night", sdf.format(k000000, out.remove())); 5144 // assertEquals("hh:mm BBBBB | 00:00:30", "12:00 mi", sdf.format(k000030, out.remove())); 5145 assertEquals("hh:mm BBBBB | 00:00:30", "12:00 at night", sdf.format(k000030, out.remove())); 5146 assertEquals("hh:mm BBBBB | 00:30:00", "12:30 at night", sdf.format(k003000, out.remove())); 5147 5148 sdf.applyPattern(UnicodeString("hh BBBBB")); 5149 5150 // assertEquals("hh BBBBB | 00:00:00", "12 mi", sdf.format(k000000, out.remove())); 5151 assertEquals("hh BBBBB | 00:00:00", "12 at night", sdf.format(k000000, out.remove())); 5152 // assertEquals("hh BBBBB | 00:00:30", "12 mi", sdf.format(k000030, out.remove())); 5153 assertEquals("hh BBBBB | 00:00:30", "12 at night", sdf.format(k000030, out.remove())); 5154 // assertEquals("hh BBBBB | 00:30:00", "12 mi", sdf.format(k003000, out.remove())); 5155 assertEquals("hh BBBBB | 00:30:00", "12 at night", sdf.format(k003000, out.remove())); 5156 } 5157 5158 void DateFormatTest::TestDayPeriodWithLocales() { 5159 // Some times on 2015-11-13 (UTC+0). 5160 UDate k000000 = 1447372800000.0; 5161 UDate k010000 = 1447376400000.0; 5162 UDate k120000 = 1447416000000.0; 5163 UDate k220000 = 1447452000000.0; 5164 5165 UErrorCode errorCode = U_ZERO_ERROR; 5166 const TimeZone *tz = TimeZone::getGMT(); 5167 UnicodeString out; 5168 5169 // Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day. 5170 // For ICU 57 output of "midnight" and its localized equivalentns is temporarily suppressed. 5171 5172 // Locale de has a word for midnight, but not noon. 5173 SimpleDateFormat sdf(UnicodeString(), Locale::getGermany(), errorCode); 5174 if (U_FAILURE(errorCode)) { 5175 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 5176 return; 5177 } 5178 sdf.setTimeZone(*tz); 5179 5180 sdf.applyPattern(UnicodeString("hh:mm:ss bbbb")); 5181 5182 // assertEquals("hh:mm:ss bbbb | 00:00:00 | de", "12:00:00 Mitternacht", 5183 // sdf.format(k000000, out.remove())); 5184 assertEquals("hh:mm:ss bbbb | 00:00:00 | de", "12:00:00 AM", 5185 sdf.format(k000000, out.remove())); 5186 assertEquals("hh:mm:ss bbbb | 12:00:00 | de", "12:00:00 PM", 5187 sdf.format(k120000, out.remove())); 5188 5189 // Locale ee has a rule that wraps around midnight (21h - 4h). 5190 sdf = SimpleDateFormat(UnicodeString(), Locale("ee"), errorCode); 5191 sdf.setTimeZone(*tz); 5192 5193 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5194 5195 assertEquals("hh:mm:ss BBBB | 22:00:00 | ee", UnicodeString("10:00:00 z\\u00E3").unescape(), 5196 sdf.format(k220000, out.remove())); 5197 assertEquals("hh:mm:ss BBBB | 00:00:00 | ee", UnicodeString("12:00:00 z\\u00E3").unescape(), 5198 sdf.format(k000000, out.remove())); 5199 assertEquals("hh:mm:ss BBBB | 01:00:00 | ee", UnicodeString("01:00:00 z\\u00E3").unescape(), 5200 sdf.format(k010000, out.remove())); 5201 5202 // Locale root has rules for AM/PM only. 5203 sdf = SimpleDateFormat(UnicodeString(), Locale("root"), errorCode); 5204 sdf.setTimeZone(*tz); 5205 5206 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5207 5208 assertEquals("hh:mm:ss BBBB | 00:00:00 | root", "12:00:00 AM", 5209 sdf.format(k000000, out.remove())); 5210 assertEquals("hh:mm:ss BBBB | 12:00:00 | root", "12:00:00 PM", 5211 sdf.format(k120000, out.remove())); 5212 5213 // Empty string should behave exactly as root. 5214 sdf = SimpleDateFormat(UnicodeString(), Locale(""), errorCode); 5215 sdf.setTimeZone(*tz); 5216 5217 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5218 5219 assertEquals("hh:mm:ss BBBB | 00:00:00 | \"\" (root)", "12:00:00 AM", 5220 sdf.format(k000000, out.remove())); 5221 assertEquals("hh:mm:ss BBBB | 12:00:00 | \"\" (root)", "12:00:00 PM", 5222 sdf.format(k120000, out.remove())); 5223 5224 // Locale en_US should fall back to en. 5225 sdf = SimpleDateFormat(UnicodeString(), Locale("en_US"), errorCode); 5226 sdf.setTimeZone(*tz); 5227 5228 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5229 5230 // assertEquals("hh:mm:ss BBBB | 00:00:00 | en_US", "12:00:00 midnight", 5231 // sdf.format(k000000, out.remove())); 5232 assertEquals("hh:mm:ss BBBB | 00:00:00 | en_US", "12:00:00 at night", 5233 sdf.format(k000000, out.remove())); 5234 assertEquals("hh:mm:ss BBBB | 01:00:00 | en_US", "01:00:00 at night", 5235 sdf.format(k010000, out.remove())); 5236 assertEquals("hh:mm:ss BBBB | 12:00:00 | en_US", "12:00:00 noon", 5237 sdf.format(k120000, out.remove())); 5238 5239 // Locale es_CO should not fall back to es and should have a 5240 // different string for 1 in the morning. 5241 // (es_CO: "de la manana" (first n has a tilde) vs. es: "de la madrugada") 5242 sdf = SimpleDateFormat(UnicodeString(), Locale("es_CO"), errorCode); 5243 sdf.setTimeZone(*tz); 5244 5245 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5246 assertEquals("hh:mm:ss BBBB | 01:00:00 | es_CO", UnicodeString("01:00:00 de la ma\\u00F1ana").unescape(), 5247 sdf.format(k010000, out.remove())); 5248 5249 sdf = SimpleDateFormat(UnicodeString(), Locale("es"), errorCode); 5250 sdf.setTimeZone(*tz); 5251 5252 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5253 assertEquals("hh:mm:ss BBBB | 01:00:00 | es", "01:00:00 de la madrugada", 5254 sdf.format(k010000, out.remove())); 5255 5256 // #13215: for locales with keywords, check hang in DayPeriodRules""getInstance(const Locale, ...), 5257 // which is called in SimpleDateFormat::format for patterns that include 'B'. 5258 sdf = SimpleDateFormat(UnicodeString(), Locale("en@calendar=buddhist"), errorCode); 5259 sdf.setTimeZone(*tz); 5260 5261 sdf.applyPattern(UnicodeString("hh:mm:ss BBBB")); 5262 assertEquals("hh:mm:ss BBBB | 01:00:00 | en@calendar=buddhist", "01:00:00 at night", 5263 sdf.format(k010000, out.remove())); 5264 } 5265 5266 void DateFormatTest::TestMinuteSecondFieldsInOddPlaces() { 5267 // Some times on 2015-11-13 (UTC+0). 5268 UDate k000000 = 1447372800000.0; 5269 UDate k000030 = 1447372830000.0; 5270 UDate k003000 = 1447374600000.0; 5271 UDate k060030 = 1447394430000.0; 5272 UDate k063000 = 1447396200000.0; 5273 5274 UErrorCode errorCode = U_ZERO_ERROR; 5275 const TimeZone *tz = TimeZone::getGMT(); 5276 UnicodeString out; 5277 5278 // Note: "midnight" can be ambiguous as to whether it refers to beginning of day or end of day. 5279 // For ICU 57 output of "midnight" is temporarily suppressed. 5280 5281 // Seconds field is not present. 5282 5283 // Apply pattern through constructor to make sure parsePattern() is called during initialization. 5284 SimpleDateFormat sdf(UnicodeString("hh:mm 'ss' bbbb"), errorCode); 5285 if (U_FAILURE(errorCode)) { 5286 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 5287 return; 5288 } 5289 sdf.setTimeZone(*tz); 5290 5291 // assertEquals("hh:mm 'ss' bbbb | 00:00:30", "12:00 ss midnight", 5292 // sdf.format(k000030, out.remove())); 5293 assertEquals("hh:mm 'ss' bbbb | 00:00:30", "12:00 ss AM", 5294 sdf.format(k000030, out.remove())); 5295 assertEquals("hh:mm 'ss' bbbb | 06:00:30", "06:00 ss AM", 5296 sdf.format(k060030, out.remove())); 5297 5298 sdf.applyPattern(UnicodeString("hh:mm 'ss' BBBB")); 5299 5300 // assertEquals("hh:mm 'ss' BBBB | 00:00:30", "12:00 ss midnight", 5301 // sdf.format(k000030, out.remove())); 5302 assertEquals("hh:mm 'ss' BBBB | 00:00:30", "12:00 ss at night", 5303 sdf.format(k000030, out.remove())); 5304 assertEquals("hh:mm 'ss' BBBB | 06:00:30", "06:00 ss in the morning", 5305 sdf.format(k060030, out.remove())); 5306 5307 // Minutes field is not present. 5308 sdf.applyPattern(UnicodeString("hh 'mm ss' bbbb")); 5309 5310 // assertEquals("hh 'mm ss' bbbb | 00:30:00", "12 mm ss midnight", 5311 // sdf.format(k003000, out.remove())); 5312 assertEquals("hh 'mm ss' bbbb | 00:30:00", "12 mm ss AM", 5313 sdf.format(k003000, out.remove())); 5314 assertEquals("hh 'mm ss' bbbb | 06:30:00", "06 mm ss AM", 5315 sdf.format(k063000, out.remove())); 5316 5317 sdf.applyPattern(UnicodeString("hh 'mm ss' BBBB")); 5318 5319 // assertEquals("hh 'mm ss' BBBB | 00:30:00", "12 mm ss midnight", 5320 // sdf.format(k003000, out.remove())); 5321 assertEquals("hh 'mm ss' BBBB | 00:30:00", "12 mm ss at night", 5322 sdf.format(k003000, out.remove())); 5323 assertEquals("hh 'mm ss' BBBB | 06:30:00", "06 mm ss in the morning", 5324 sdf.format(k063000, out.remove())); 5325 5326 // Minutes and seconds fields appear after day periods. 5327 sdf.applyPattern(UnicodeString("bbbb hh:mm:ss")); 5328 5329 // assertEquals("bbbb hh:mm:ss | 00:00:00", "midnight 12:00:00", 5330 // sdf.format(k000000, out.remove())); 5331 assertEquals("bbbb hh:mm:ss | 00:00:00", "AM 12:00:00", 5332 sdf.format(k000000, out.remove())); 5333 assertEquals("bbbb hh:mm:ss | 00:00:30", "AM 12:00:30", 5334 sdf.format(k000030, out.remove())); 5335 assertEquals("bbbb hh:mm:ss | 00:30:00", "AM 12:30:00", 5336 sdf.format(k003000, out.remove())); 5337 5338 sdf.applyPattern(UnicodeString("BBBB hh:mm:ss")); 5339 5340 // assertEquals("BBBB hh:mm:ss | 00:00:00", "midnight 12:00:00", 5341 // sdf.format(k000000, out.remove())); 5342 assertEquals("BBBB hh:mm:ss | 00:00:00", "at night 12:00:00", 5343 sdf.format(k000000, out.remove())); 5344 assertEquals("BBBB hh:mm:ss | 00:00:30", "at night 12:00:30", 5345 sdf.format(k000030, out.remove())); 5346 assertEquals("BBBB hh:mm:ss | 00:30:00", "at night 12:30:00", 5347 sdf.format(k003000, out.remove())); 5348 5349 // Confirm applyPattern() reparses the pattern string. 5350 sdf.applyPattern(UnicodeString("BBBB hh")); 5351 // assertEquals("BBBB hh | 00:00:30", "midnight 12", 5352 // sdf.format(k000030, out.remove())); 5353 assertEquals("BBBB hh | 00:00:30", "at night 12", 5354 sdf.format(k000030, out.remove())); 5355 5356 sdf.applyPattern(UnicodeString("BBBB hh:mm:'ss'")); 5357 // assertEquals("BBBB hh:mm:'ss' | 00:00:30", "midnight 12:00:ss", 5358 // sdf.format(k000030, out.remove())); 5359 assertEquals("BBBB hh | 00:00:30", "at night 12:00:ss", 5360 sdf.format(k000030, out.remove())); 5361 5362 sdf.applyPattern(UnicodeString("BBBB hh:mm:ss")); 5363 assertEquals("BBBB hh:mm:ss | 00:00:30", "at night 12:00:30", 5364 sdf.format(k000030, out.remove())); 5365 } 5366 5367 void DateFormatTest::TestDayPeriodParsing() { 5368 // Some times on 2015-11-13 (UTC+0). 5369 UDate k000000 = 1447372800000.0; 5370 UDate k003700 = 1447375020000.0; 5371 UDate k010000 = 1447376400000.0; 5372 UDate k013000 = 1447378200000.0; 5373 UDate k030000 = 1447383600000.0; 5374 UDate k090000 = 1447405200000.0; 5375 UDate k120000 = 1447416000000.0; 5376 UDate k130000 = 1447419600000.0; 5377 UDate k133700 = 1447421820000.0; 5378 UDate k150000 = 1447426800000.0; 5379 UDate k190000 = 1447441200000.0; 5380 UDate k193000 = 1447443000000.0; 5381 UDate k200000 = 1447444800000.0; 5382 UDate k210000 = 1447448400000.0; 5383 5384 UErrorCode errorCode = U_ZERO_ERROR; 5385 SimpleDateFormat sdf(UnicodeString(), errorCode); 5386 if (U_FAILURE(errorCode)) { 5387 dataerrln("Error creating SimpleDateFormat - %s", u_errorName(errorCode)); 5388 return; 5389 } 5390 const TimeZone *tz = TimeZone::getGMT(); 5391 sdf.setTimeZone(*tz); 5392 UnicodeString out; 5393 5394 // 'B' -- flexible day periods 5395 // A day period on its own parses to the center of that period. 5396 sdf.applyPattern(UnicodeString("yyyy-MM-dd B")); 5397 assertEquals("yyyy-MM-dd B | 2015-11-13 midnight", 5398 k000000, sdf.parse(UnicodeString("2015-11-13 midnight"), errorCode)); 5399 assertEquals("yyyy-MM-dd B | 2015-11-13 noon", 5400 k120000, sdf.parse(UnicodeString("2015-11-13 noon"), errorCode)); 5401 assertEquals("yyyy-MM-dd B | 2015-11-13 in the afternoon", 5402 k150000, sdf.parse(UnicodeString("2015-11-13 in the afternoon"), errorCode)); 5403 assertEquals("yyyy-MM-dd B | 2015-11-13 in the evening", 5404 k193000, sdf.parse(UnicodeString("2015-11-13 in the evening"), errorCode)); 5405 assertEquals("yyyy-MM-dd B | 2015-11-13 at night", 5406 k013000, sdf.parse(UnicodeString("2015-11-13 at night"), errorCode)); 5407 5408 // If time and day period are consistent with each other then time is parsed accordingly. 5409 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm B")); 5410 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 12:00 midnight", 5411 k000000, sdf.parse(UnicodeString("2015-11-13 12:00 midnight"), errorCode)); 5412 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 12:00 noon", 5413 k120000, sdf.parse(UnicodeString("2015-11-13 12:00 noon"), errorCode)); 5414 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 01:00 at night", 5415 k010000, sdf.parse(UnicodeString("2015-11-13 01:00 at night"), errorCode)); 5416 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 01:00 in the afternoon", 5417 k130000, sdf.parse(UnicodeString("2015-11-13 01:00 in the afternoon"), errorCode)); 5418 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 09:00 in the morning", 5419 k090000, sdf.parse(UnicodeString("2015-11-13 09:00 in the morning"), errorCode)); 5420 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 09:00 at night", 5421 k210000, sdf.parse(UnicodeString("2015-11-13 09:00 at night"), errorCode)); 5422 5423 // If the hour is 13 thru 23 then day period has no effect on time (since time is assumed 5424 // to be in 24-hour format). 5425 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm B")); 5426 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 midnight", 5427 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 midnight"), errorCode)); 5428 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 noon", 5429 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 noon"), errorCode)); 5430 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 at night", 5431 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 at night"), errorCode)); 5432 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 in the afternoon", 5433 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 in the afternoon"), errorCode)); 5434 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 in the morning", 5435 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 in the morning"), errorCode)); 5436 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 13:37 at night", 5437 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 at night"), errorCode)); 5438 5439 // Hour 0 is synonymous with hour 12 when parsed with 'h'. 5440 // This unfortunately means we have to tolerate "0 noon" as it's synonymous with "12 noon". 5441 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm B")); 5442 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 00:00 midnight", 5443 k000000, sdf.parse(UnicodeString("2015-11-13 00:00 midnight"), errorCode)); 5444 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 00:00 noon", 5445 k120000, sdf.parse(UnicodeString("2015-11-13 00:00 noon"), errorCode)); 5446 5447 // But when parsed with 'H', 0 indicates a 24-hour time, therefore we disregard the day period. 5448 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm B")); 5449 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 midnight", 5450 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 midnight"), errorCode)); 5451 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 noon", 5452 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 noon"), errorCode)); 5453 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 at night", 5454 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 at night"), errorCode)); 5455 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 in the afternoon", 5456 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 in the afternoon"), errorCode)); 5457 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 in the morning", 5458 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 in the morning"), errorCode)); 5459 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 00:37 at night", 5460 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 at night"), errorCode)); 5461 5462 // Even when parsed with 'H', hours 1 thru 12 are considered 12-hour time and takes 5463 // day period into account in parsing. 5464 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm B")); 5465 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 12:00 midnight", 5466 k000000, sdf.parse(UnicodeString("2015-11-13 12:00 midnight"), errorCode)); 5467 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 12:00 noon", 5468 k120000, sdf.parse(UnicodeString("2015-11-13 12:00 noon"), errorCode)); 5469 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 01:00 at night", 5470 k010000, sdf.parse(UnicodeString("2015-11-13 01:00 at night"), errorCode)); 5471 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 01:00 in the afternoon", 5472 k130000, sdf.parse(UnicodeString("2015-11-13 01:00 in the afternoon"), errorCode)); 5473 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 09:00 in the morning", 5474 k090000, sdf.parse(UnicodeString("2015-11-13 09:00 in the morning"), errorCode)); 5475 assertEquals("yyyy-MM-dd HH:mm B | 2015-11-13 09:00 at night", 5476 k210000, sdf.parse(UnicodeString("2015-11-13 09:00 at night"), errorCode)); 5477 5478 // If a 12-hour time and the day period don't agree with each other, time is parsed as close 5479 // to the given day period as possible. 5480 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm B")); 5481 5482 // AFTERNOON1 is [12, 18), but "7 in the afternoon" parses to 19:00. 5483 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 07:00 in the afternoon", 5484 k190000, sdf.parse(UnicodeString("2015-11-13 07:00 in the afternoon"), errorCode)); 5485 // NIGHT1 is [21, 6), but "8 at night" parses to 20:00. 5486 assertEquals("yyyy-MM-dd hh:mm B | 2015-11-13 08:00 at night", 5487 k200000, sdf.parse(UnicodeString("2015-11-13 08:00 at night"), errorCode)); 5488 5489 // 'b' -- fixed day periods (AM, PM, midnight, noon) 5490 // On their own, "midnight" parses to 00:00 and "noon" parses to 12:00. 5491 // AM and PM are handled by the 'a' parser (which doesn't handle this case well). 5492 sdf.applyPattern(UnicodeString("yyyy-MM-dd b")); 5493 assertEquals("yyyy-MM-dd b | 2015-11-13 midnight", 5494 k000000, sdf.parse(UnicodeString("2015-11-13 midnight"), errorCode)); 5495 assertEquals("yyyy-MM-dd b | 2015-11-13 noon", 5496 k120000, sdf.parse(UnicodeString("2015-11-13 noon"), errorCode)); 5497 5498 // For 12-hour times, AM and PM should be parsed as if with pattern character 'a'. 5499 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm b")); 5500 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 01:00 AM", 5501 k010000, sdf.parse(UnicodeString("2015-11-13 01:00 AM"), errorCode)); 5502 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 01:00 PM", 5503 k130000, sdf.parse(UnicodeString("2015-11-13 01:00 PM"), errorCode)); 5504 5505 // 12 midnight parses to 00:00, and 12 noon parses to 12:00. 5506 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 12:00 midnight", 5507 k000000, sdf.parse(UnicodeString("2015-11-13 12:00 midnight"), errorCode)); 5508 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 12:00 noon", 5509 k120000, sdf.parse(UnicodeString("2015-11-13 12:00 noon"), errorCode)); 5510 5511 // Hours 13-23 indicate 24-hour time so we disregard "midnight" or "noon". 5512 // Again, AM and PM are handled by the 'a' parser which doesn't handle this case well. 5513 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm b")); 5514 assertEquals("yyyy-MM-dd HH:mm b | 2015-11-13 13:37 midnight", 5515 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 midnight"), errorCode)); 5516 assertEquals("yyyy-MM-dd HH:mm b | 2015-11-13 13:37 noon", 5517 k133700, sdf.parse(UnicodeString("2015-11-13 13:37 noon"), errorCode)); 5518 5519 // Hour 0 is synonymous with hour 12 when parsed with 'h'. 5520 // Again, this means we have to tolerate "0 noon" as it's synonymous with "12 noon". 5521 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm b")); 5522 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 00:00 midnight", 5523 k000000, sdf.parse(UnicodeString("2015-11-13 00:00 midnight"), errorCode)); 5524 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 00:00 noon", 5525 k120000, sdf.parse(UnicodeString("2015-11-13 00:00 noon"), errorCode)); 5526 5527 // With 'H' though 0 indicates a 24-hour time, therefore we disregard the day period. 5528 sdf.applyPattern(UnicodeString("yyyy-MM-dd HH:mm b")); 5529 assertEquals("yyyy-MM-dd HH:mm b | 2015-11-13 00:37 midnight", 5530 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 midnight"), errorCode)); 5531 assertEquals("yyyy-MM-dd HH:mm b | 2015-11-13 00:37 noon", 5532 k003700, sdf.parse(UnicodeString("2015-11-13 00:37 noon"), errorCode)); 5533 5534 // If "midnight" or "noon" is parsed with a 12-hour time other than 12:00, choose 5535 // the version that's closer to the period given. 5536 sdf.applyPattern(UnicodeString("yyyy-MM-dd hh:mm b")); 5537 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 03:00 midnight", 5538 k030000, sdf.parse(UnicodeString("2015-11-13 03:00 midnight"), errorCode)); 5539 assertEquals("yyyy-MM-dd hh:mm b | 2015-11-13 03:00 noon", 5540 k150000, sdf.parse(UnicodeString("2015-11-13 03:00 noon"), errorCode)); 5541 } 5542 5543 void DateFormatTest::TestParseRegression13744() { 5544 LocalPointer<DateFormat> dfmt(DateFormat::createDateTimeInstance( 5545 DateFormat::SHORT, DateFormat::SHORT, Locale("en", "US"))); 5546 if (dfmt.isNull()) { 5547 dataerrln("DateFormat::createDateTimeInstance() failed"); 5548 return; 5549 } 5550 ParsePosition pos(0); 5551 UnicodeString inDate("4/27/18"); 5552 dfmt->parse(inDate, pos); 5553 assertEquals("Error index", inDate.length(), pos.getErrorIndex()); 5554 } 5555 5556 #endif /* #if !UCONFIG_NO_FORMATTING */ 5557 5558 //eof 5559
