diff options
author | Peter Breitenlohner <peb@mppmu.mpg.de> | 2012-10-26 07:13:09 +0000 |
---|---|---|
committer | Peter Breitenlohner <peb@mppmu.mpg.de> | 2012-10-26 07:13:09 +0000 |
commit | 74cc05c672add53f566ac385f117008e8c4b3eda (patch) | |
tree | ce973a7d2e4814a20d52a55b1a2131d1515e9911 /Build/source/libs/icu/icu-50.1/test/intltest/tztest.cpp | |
parent | 6439fb8917718c4d620170e1459a1d9e7ab3c441 (diff) |
icu 50.1 (50_rc)
git-svn-id: svn://tug.org/texlive/trunk@28087 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/libs/icu/icu-50.1/test/intltest/tztest.cpp')
-rw-r--r-- | Build/source/libs/icu/icu-50.1/test/intltest/tztest.cpp | 2303 |
1 files changed, 2303 insertions, 0 deletions
diff --git a/Build/source/libs/icu/icu-50.1/test/intltest/tztest.cpp b/Build/source/libs/icu/icu-50.1/test/intltest/tztest.cpp new file mode 100644 index 00000000000..b2a76124172 --- /dev/null +++ b/Build/source/libs/icu/icu-50.1/test/intltest/tztest.cpp @@ -0,0 +1,2303 @@ +/*********************************************************************** + * COPYRIGHT: + * Copyright (c) 1997-2012, International Business Machines Corporation + * and others. All Rights Reserved. + ***********************************************************************/ + +#include "unicode/utypes.h" + +#if !UCONFIG_NO_FORMATTING + +#include "unicode/timezone.h" +#include "unicode/simpletz.h" +#include "unicode/calendar.h" +#include "unicode/gregocal.h" +#include "unicode/resbund.h" +#include "unicode/strenum.h" +#include "unicode/uversion.h" +#include "tztest.h" +#include "cmemory.h" +#include "putilimp.h" +#include "cstring.h" +#include "olsontz.h" + +#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0])) + +#define CASE(id,test) case id: \ + name = #test; \ + if (exec) { \ + logln(#test "---"); logln(""); \ + test(); \ + } \ + break + +// ***************************************************************************** +// class TimeZoneTest +// ***************************************************************************** + +// Some test case data is current date/tzdata version sensitive and producing errors +// when year/rule are changed. Although we want to keep our eyes on test failures +// caused by tzdata changes while development, keep maintaining test data in maintenance +// stream is a little bit hassle. ICU 49 or later versions are using minor version field +// to indicate a development build (0) or official release build (others). For development +// builds, a test failure triggers an error, while release builds only report them in +// verbose mode with logln. +static UBool isDevelopmentBuild = (U_ICU_VERSION_MINOR_NUM == 0); + +void TimeZoneTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) +{ + if (exec) { + logln("TestSuite TestTimeZone"); + } + TESTCASE_AUTO_BEGIN; + TESTCASE_AUTO(TestPRTOffset); + TESTCASE_AUTO(TestVariousAPI518); + TESTCASE_AUTO(TestGetAvailableIDs913); + TESTCASE_AUTO(TestGenericAPI); + TESTCASE_AUTO(TestRuleAPI); + TESTCASE_AUTO(TestShortZoneIDs); + TESTCASE_AUTO(TestCustomParse); + TESTCASE_AUTO(TestDisplayName); + TESTCASE_AUTO(TestDSTSavings); + TESTCASE_AUTO(TestAlternateRules); + TESTCASE_AUTO(TestCountries); + TESTCASE_AUTO(TestHistorical); + TESTCASE_AUTO(TestEquivalentIDs); + TESTCASE_AUTO(TestAliasedNames); + TESTCASE_AUTO(TestFractionalDST); + TESTCASE_AUTO(TestFebruary); + TESTCASE_AUTO(TestCanonicalID); + TESTCASE_AUTO(TestDisplayNamesMeta); + TESTCASE_AUTO(TestGetRegion); + TESTCASE_AUTO(TestGetAvailableIDsNew); + TESTCASE_AUTO(TestGetUnknown); + TESTCASE_AUTO_END; +} + +const int32_t TimeZoneTest::millisPerHour = 3600000; + +// --------------------------------------------------------------------------------- + +/** + * Generic API testing for API coverage. + */ +void +TimeZoneTest::TestGenericAPI() +{ + UnicodeString id("NewGMT"); + int32_t offset = 12345; + + SimpleTimeZone *zone = new SimpleTimeZone(offset, id); + if (zone->useDaylightTime()) errln("FAIL: useDaylightTime should return FALSE"); + + TimeZone* zoneclone = zone->clone(); + if (!(*zoneclone == *zone)) errln("FAIL: clone or operator== failed"); + zoneclone->setID("abc"); + if (!(*zoneclone != *zone)) errln("FAIL: clone or operator!= failed"); + delete zoneclone; + + zoneclone = zone->clone(); + if (!(*zoneclone == *zone)) errln("FAIL: clone or operator== failed"); + zoneclone->setRawOffset(45678); + if (!(*zoneclone != *zone)) errln("FAIL: clone or operator!= failed"); + + SimpleTimeZone copy(*zone); + if (!(copy == *zone)) errln("FAIL: copy constructor or operator== failed"); + copy = *(SimpleTimeZone*)zoneclone; + if (!(copy == *zoneclone)) errln("FAIL: assignment operator or operator== failed"); + + TimeZone* saveDefault = TimeZone::createDefault(); + logln((UnicodeString)"TimeZone::createDefault() => " + saveDefault->getID(id)); + TimeZone* pstZone = TimeZone::createTimeZone("America/Los_Angeles"); + + logln("call uprv_timezone() which uses the host"); + logln("to get the difference in seconds between coordinated universal"); + logln("time and local time. E.g., -28,800 for PST (GMT-8hrs)"); + + int32_t tzoffset = uprv_timezone(); + logln(UnicodeString("Value returned from uprv_timezone = ") + tzoffset); + // Invert sign because UNIX semantics are backwards + if (tzoffset < 0) + tzoffset = -tzoffset; + if ((*saveDefault == *pstZone) && (tzoffset != 28800)) { + errln("FAIL: t_timezone may be incorrect. It is not 28800"); + } + + if ((tzoffset % 900) != 0) { + /* + * Ticket#6364 and #7648 + * A few time zones are using GMT offests not a multiple of 15 minutes. + * Therefore, we should not interpret such case as an error. + * We downgrade this from errln to infoln. When we see this message, + * we should examine if it is ignorable or not. + */ + infoln("WARNING: t_timezone may be incorrect. It is not a multiple of 15min.", tzoffset); + } + + TimeZone::adoptDefault(zone); + TimeZone* defaultzone = TimeZone::createDefault(); + if (defaultzone == zone || + !(*defaultzone == *zone)) + errln("FAIL: createDefault failed"); + TimeZone::adoptDefault(saveDefault); + delete defaultzone; + delete zoneclone; + delete pstZone; + + UErrorCode status = U_ZERO_ERROR; + const char* tzver = TimeZone::getTZDataVersion(status); + if (U_FAILURE(status)) { + errcheckln(status, "FAIL: getTZDataVersion failed - %s", u_errorName(status)); + } else if (uprv_strlen(tzver) != 5 /* 4 digits + 1 letter */) { + errln((UnicodeString)"FAIL: getTZDataVersion returned " + tzver); + } else { + logln((UnicodeString)"tzdata version: " + tzver); + } +} + +// --------------------------------------------------------------------------------- + +/** + * Test the setStartRule/setEndRule API calls. + */ +void +TimeZoneTest::TestRuleAPI() +{ + UErrorCode status = U_ZERO_ERROR; + + UDate offset = 60*60*1000*1.75; // Pick a weird offset + SimpleTimeZone *zone = new SimpleTimeZone((int32_t)offset, "TestZone"); + if (zone->useDaylightTime()) errln("FAIL: useDaylightTime should return FALSE"); + + // Establish our expected transition times. Do this with a non-DST + // calendar with the (above) declared local offset. + GregorianCalendar *gc = new GregorianCalendar(*zone, status); + if (failure(status, "new GregorianCalendar", TRUE)) return; + gc->clear(); + gc->set(1990, UCAL_MARCH, 1); + UDate marchOneStd = gc->getTime(status); // Local Std time midnight + gc->clear(); + gc->set(1990, UCAL_JULY, 1); + UDate julyOneStd = gc->getTime(status); // Local Std time midnight + if (failure(status, "GregorianCalendar::getTime")) return; + + // Starting and ending hours, WALL TIME + int32_t startHour = (int32_t)(2.25 * 3600000); + int32_t endHour = (int32_t)(3.5 * 3600000); + + zone->setStartRule(UCAL_MARCH, 1, 0, startHour, status); + zone->setEndRule (UCAL_JULY, 1, 0, endHour, status); + + delete gc; + gc = new GregorianCalendar(*zone, status); + if (failure(status, "new GregorianCalendar")) return; + + UDate marchOne = marchOneStd + startHour; + UDate julyOne = julyOneStd + endHour - 3600000; // Adjust from wall to Std time + + UDate expMarchOne = 636251400000.0; + if (marchOne != expMarchOne) + { + errln((UnicodeString)"FAIL: Expected start computed as " + marchOne + + " = " + dateToString(marchOne)); + logln((UnicodeString)" Should be " + expMarchOne + + " = " + dateToString(expMarchOne)); + } + + UDate expJulyOne = 646793100000.0; + if (julyOne != expJulyOne) + { + errln((UnicodeString)"FAIL: Expected start computed as " + julyOne + + " = " + dateToString(julyOne)); + logln((UnicodeString)" Should be " + expJulyOne + + " = " + dateToString(expJulyOne)); + } + + testUsingBinarySearch(*zone, date(90, UCAL_JANUARY, 1), date(90, UCAL_JUNE, 15), marchOne); + testUsingBinarySearch(*zone, date(90, UCAL_JUNE, 1), date(90, UCAL_DECEMBER, 31), julyOne); + + if (zone->inDaylightTime(marchOne - 1000, status) || + !zone->inDaylightTime(marchOne, status)) + errln("FAIL: Start rule broken"); + if (!zone->inDaylightTime(julyOne - 1000, status) || + zone->inDaylightTime(julyOne, status)) + errln("FAIL: End rule broken"); + + zone->setStartYear(1991); + if (zone->inDaylightTime(marchOne, status) || + zone->inDaylightTime(julyOne - 1000, status)) + errln("FAIL: Start year broken"); + + failure(status, "TestRuleAPI"); + delete gc; + delete zone; +} + +void +TimeZoneTest::findTransition(const TimeZone& tz, + UDate min, UDate max) { + UErrorCode ec = U_ZERO_ERROR; + UnicodeString id,s; + UBool startsInDST = tz.inDaylightTime(min, ec); + if (failure(ec, "TimeZone::inDaylightTime")) return; + if (tz.inDaylightTime(max, ec) == startsInDST) { + logln("Error: " + tz.getID(id) + ".inDaylightTime(" + dateToString(min) + ") = " + (startsInDST?"TRUE":"FALSE") + + ", inDaylightTime(" + dateToString(max) + ") = " + (startsInDST?"TRUE":"FALSE")); + return; + } + if (failure(ec, "TimeZone::inDaylightTime")) return; + while ((max - min) > INTERVAL) { + UDate mid = (min + max) / 2; + if (tz.inDaylightTime(mid, ec) == startsInDST) { + min = mid; + } else { + max = mid; + } + if (failure(ec, "TimeZone::inDaylightTime")) return; + } + min = 1000.0 * uprv_floor(min/1000.0); + max = 1000.0 * uprv_floor(max/1000.0); + logln(tz.getID(id) + " Before: " + min/1000 + " = " + + dateToString(min,s,tz)); + logln(tz.getID(id) + " After: " + max/1000 + " = " + + dateToString(max,s,tz)); +} + +void +TimeZoneTest::testUsingBinarySearch(const TimeZone& tz, + UDate min, UDate max, + UDate expectedBoundary) +{ + UErrorCode status = U_ZERO_ERROR; + UBool startsInDST = tz.inDaylightTime(min, status); + if (failure(status, "TimeZone::inDaylightTime")) return; + if (tz.inDaylightTime(max, status) == startsInDST) { + logln("Error: inDaylightTime(" + dateToString(max) + ") != " + ((!startsInDST)?"TRUE":"FALSE")); + return; + } + if (failure(status, "TimeZone::inDaylightTime")) return; + while ((max - min) > INTERVAL) { + UDate mid = (min + max) / 2; + if (tz.inDaylightTime(mid, status) == startsInDST) { + min = mid; + } else { + max = mid; + } + if (failure(status, "TimeZone::inDaylightTime")) return; + } + logln(UnicodeString("Binary Search Before: ") + uprv_floor(0.5 + min) + " = " + dateToString(min)); + logln(UnicodeString("Binary Search After: ") + uprv_floor(0.5 + max) + " = " + dateToString(max)); + UDate mindelta = expectedBoundary - min; + UDate maxdelta = max - expectedBoundary; + if (mindelta >= 0 && + mindelta <= INTERVAL && + maxdelta >= 0 && + maxdelta <= INTERVAL) + logln(UnicodeString("PASS: Expected bdry: ") + expectedBoundary + " = " + dateToString(expectedBoundary)); + else + errln(UnicodeString("FAIL: Expected bdry: ") + expectedBoundary + " = " + dateToString(expectedBoundary)); +} + +const UDate TimeZoneTest::INTERVAL = 100; + +// --------------------------------------------------------------------------------- + +// ------------------------------------- + +/** + * Test the offset of the PRT timezone. + */ +void +TimeZoneTest::TestPRTOffset() +{ + TimeZone* tz = TimeZone::createTimeZone("PRT"); + if (tz == 0) { + errln("FAIL: TimeZone(PRT) is null"); + } + else { + int32_t expectedHour = -4; + double expectedOffset = (((double)expectedHour) * millisPerHour); + double foundOffset = tz->getRawOffset(); + int32_t foundHour = (int32_t)foundOffset / millisPerHour; + if (expectedOffset != foundOffset) { + dataerrln("FAIL: Offset for PRT should be %d, found %d", expectedHour, foundHour); + } else { + logln("PASS: Offset for PRT should be %d, found %d", expectedHour, foundHour); + } + } + delete tz; +} + +// ------------------------------------- + +/** + * Regress a specific bug with a sequence of API calls. + */ +void +TimeZoneTest::TestVariousAPI518() +{ + UErrorCode status = U_ZERO_ERROR; + TimeZone* time_zone = TimeZone::createTimeZone("PST"); + UDate d = date(97, UCAL_APRIL, 30); + UnicodeString str; + logln("The timezone is " + time_zone->getID(str)); + if (!time_zone->inDaylightTime(d, status)) dataerrln("FAIL: inDaylightTime returned FALSE"); + if (failure(status, "TimeZone::inDaylightTime", TRUE)) return; + if (!time_zone->useDaylightTime()) dataerrln("FAIL: useDaylightTime returned FALSE"); + if (time_zone->getRawOffset() != - 8 * millisPerHour) dataerrln("FAIL: getRawOffset returned wrong value"); + GregorianCalendar *gc = new GregorianCalendar(status); + if (U_FAILURE(status)) { errln("FAIL: Couldn't create GregorianCalendar"); return; } + gc->setTime(d, status); + if (U_FAILURE(status)) { errln("FAIL: GregorianCalendar::setTime failed"); return; } + if (time_zone->getOffset(gc->AD, gc->get(UCAL_YEAR, status), gc->get(UCAL_MONTH, status), + gc->get(UCAL_DATE, status), (uint8_t)gc->get(UCAL_DAY_OF_WEEK, status), 0, status) != - 7 * millisPerHour) + dataerrln("FAIL: getOffset returned wrong value"); + if (U_FAILURE(status)) { errln("FAIL: GregorianCalendar::set failed"); return; } + delete gc; + delete time_zone; +} + +// ------------------------------------- + +/** + * Test the call which retrieves the available IDs. + */ +void +TimeZoneTest::TestGetAvailableIDs913() +{ + UErrorCode ec = U_ZERO_ERROR; + int32_t i; + +#ifdef U_USE_TIMEZONE_OBSOLETE_2_8 + // Test legacy API -- remove these tests when the corresponding API goes away (duh) + int32_t numIDs = -1; + const UnicodeString** ids = TimeZone::createAvailableIDs(numIDs); + if (ids == 0 || numIDs < 1) { + errln("FAIL: createAvailableIDs()"); + } else { + UnicodeString buf("TimeZone::createAvailableIDs() = { "); + for(i=0; i<numIDs; ++i) { + if (i) buf.append(", "); + buf.append(*ids[i]); + } + buf.append(" } "); + logln(buf + numIDs); + // we own the array; the caller owns the contained strings (yuck) + uprv_free(ids); + } + + numIDs = -1; + ids = TimeZone::createAvailableIDs(-8*U_MILLIS_PER_HOUR, numIDs); + if (ids == 0 || numIDs < 1) { + errln("FAIL: createAvailableIDs(-8:00)"); + } else { + UnicodeString buf("TimeZone::createAvailableIDs(-8:00) = { "); + for(i=0; i<numIDs; ++i) { + if (i) buf.append(", "); + buf.append(*ids[i]); + } + buf.append(" } "); + logln(buf + numIDs); + // we own the array; the caller owns the contained strings (yuck) + uprv_free(ids); + } + numIDs = -1; + ids = TimeZone::createAvailableIDs("US", numIDs); + if (ids == 0 || numIDs < 1) { + errln("FAIL: createAvailableIDs(US) ids=%d, numIDs=%d", ids, numIDs); + } else { + UnicodeString buf("TimeZone::createAvailableIDs(US) = { "); + for(i=0; i<numIDs; ++i) { + if (i) buf.append(", "); + buf.append(*ids[i]); + } + buf.append(" } "); + logln(buf + numIDs); + // we own the array; the caller owns the contained strings (yuck) + uprv_free(ids); + } +#endif + + UnicodeString str; + UnicodeString *buf = new UnicodeString("TimeZone::createEnumeration() = { "); + int32_t s_length; + StringEnumeration* s = TimeZone::createEnumeration(); + if (s == NULL) { + dataerrln("Unable to create TimeZone enumeration"); + return; + } + s_length = s->count(ec); + for (i = 0; i < s_length;++i) { + if (i > 0) *buf += ", "; + if ((i & 1) == 0) { + *buf += *s->snext(ec); + } else { + *buf += UnicodeString(s->next(NULL, ec), ""); + } + + if((i % 5) == 4) { + // replace s with a clone of itself + StringEnumeration *s2 = s->clone(); + if(s2 == NULL || s_length != s2->count(ec)) { + errln("TimezoneEnumeration.clone() failed"); + } else { + delete s; + s = s2; + } + } + } + *buf += " };"; + logln(*buf); + + /* Confirm that the following zones can be retrieved: The first + * zone, the last zone, and one in-between. This tests the binary + * search through the system zone data. + */ + s->reset(ec); + int32_t middle = s_length/2; + for (i=0; i<s_length; ++i) { + const UnicodeString* id = s->snext(ec); + if (i==0 || i==middle || i==(s_length-1)) { + TimeZone *z = TimeZone::createTimeZone(*id); + if (z == 0) { + errln(UnicodeString("FAIL: createTimeZone(") + + *id + ") -> 0"); + } else if (z->getID(str) != *id) { + errln(UnicodeString("FAIL: createTimeZone(") + + *id + ") -> zone " + str); + } else { + logln(UnicodeString("OK: createTimeZone(") + + *id + ") succeeded"); + } + delete z; + } + } + delete s; + + buf->truncate(0); + *buf += "TimeZone::createEnumeration(GMT+01:00) = { "; + + s = TimeZone::createEnumeration(1 * U_MILLIS_PER_HOUR); + s_length = s->count(ec); + for (i = 0; i < s_length;++i) { + if (i > 0) *buf += ", "; + *buf += *s->snext(ec); + } + delete s; + *buf += " };"; + logln(*buf); + + + buf->truncate(0); + *buf += "TimeZone::createEnumeration(US) = { "; + + s = TimeZone::createEnumeration("US"); + s_length = s->count(ec); + for (i = 0; i < s_length;++i) { + if (i > 0) *buf += ", "; + *buf += *s->snext(ec); + } + *buf += " };"; + logln(*buf); + + TimeZone *tz = TimeZone::createTimeZone("PST"); + if (tz != 0) logln("getTimeZone(PST) = " + tz->getID(str)); + else errln("FAIL: getTimeZone(PST) = null"); + delete tz; + tz = TimeZone::createTimeZone("America/Los_Angeles"); + if (tz != 0) logln("getTimeZone(America/Los_Angeles) = " + tz->getID(str)); + else errln("FAIL: getTimeZone(PST) = null"); + delete tz; + + // @bug 4096694 + tz = TimeZone::createTimeZone("NON_EXISTENT"); + UnicodeString temp; + if (tz == 0) + errln("FAIL: getTimeZone(NON_EXISTENT) = null"); + else if (tz->getID(temp) != UCAL_UNKNOWN_ZONE_ID) + errln("FAIL: getTimeZone(NON_EXISTENT) = " + temp); + delete tz; + + delete buf; + delete s; +} + +void +TimeZoneTest::TestGetAvailableIDsNew() +{ + UErrorCode ec = U_ZERO_ERROR; + StringEnumeration *any, *canonical, *canonicalLoc; + StringEnumeration *any_US, *canonical_US, *canonicalLoc_US; + StringEnumeration *any_W5, *any_CA_W5; + StringEnumeration *any_US_E14; + int32_t rawOffset; + const UnicodeString *id1, *id2; + UnicodeString canonicalID; + UBool isSystemID; + char region[4]; + int32_t zoneCount; + + any = canonical = canonicalLoc = any_US = canonical_US = canonicalLoc_US = any_W5 = any_CA_W5 = any_US_E14 = NULL; + + any = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, NULL, NULL, ec); + if (U_FAILURE(ec)) { + dataerrln("Failed to create enumration for ANY"); + goto cleanup; + } + + canonical = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, ec); + if (U_FAILURE(ec)) { + errln("Failed to create enumration for CANONICAL"); + goto cleanup; + } + + canonicalLoc = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL_LOCATION, NULL, NULL, ec); + if (U_FAILURE(ec)) { + errln("Failed to create enumration for CANONICALLOC"); + goto cleanup; + } + + any_US = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, "US", NULL, ec); + if (U_FAILURE(ec)) { + errln("Failed to create enumration for ANY_US"); + goto cleanup; + } + + canonical_US = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, "US", NULL, ec); + if (U_FAILURE(ec)) { + errln("Failed to create enumration for CANONICAL_US"); + goto cleanup; + } + + canonicalLoc_US = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL_LOCATION, "US", NULL, ec); + if (U_FAILURE(ec)) { + errln("Failed to create enumration for CANONICALLOC_US"); + goto cleanup; + } + + rawOffset = (-5)*60*60*1000; + any_W5 = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, NULL, &rawOffset, ec); + if (U_FAILURE(ec)) { + errln("Failed to create enumration for ANY_W5"); + goto cleanup; + } + + any_CA_W5 = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, "CA", &rawOffset, ec); + if (U_FAILURE(ec)) { + errln("Failed to create enumration for ANY_CA_W5"); + goto cleanup; + } + + rawOffset = 14*60*60*1000; + any_US_E14 = TimeZone::createTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, "US", &rawOffset, ec); + if (U_FAILURE(ec)) { + errln("Failed to create enumration for ANY_US_E14"); + goto cleanup; + } + + checkContainsAll(any, "ANY", canonical, "CANONICAL"); + checkContainsAll(canonical, "CANONICAL", canonicalLoc, "CANONICALLOC"); + + checkContainsAll(any, "ANY", any_US, "ANY_US"); + checkContainsAll(canonical, "CANONICAL", canonical_US, "CANONICAL_US"); + checkContainsAll(canonicalLoc, "CANONICALLOC", canonicalLoc_US, "CANONICALLOC_US"); + + checkContainsAll(any_US, "ANY_US", canonical_US, "CANONICAL_US"); + checkContainsAll(canonical_US, "CANONICAL_US", canonicalLoc_US, "CANONICALLOC_US"); + + checkContainsAll(any, "ANY", any_W5, "ANY_W5"); + checkContainsAll(any_W5, "ANY_W5", any_CA_W5, "ANY_CA_W5"); + + // And ID in any set, but not in canonical set must not be a canonical ID + any->reset(ec); + while ((id1 = any->snext(ec)) != NULL) { + UBool found = FALSE; + canonical->reset(ec); + while ((id2 = canonical->snext(ec)) != NULL) { + if (*id1 == *id2) { + found = TRUE; + break; + } + } + if (U_FAILURE(ec)) { + break; + } + if (!found) { + TimeZone::getCanonicalID(*id1, canonicalID, isSystemID, ec); + if (U_FAILURE(ec)) { + break; + } + if (*id1 == canonicalID) { + errln((UnicodeString)"FAIL: canonicalID [" + *id1 + "] is not in CANONICAL"); + } + if (!isSystemID) { + errln((UnicodeString)"FAIL: ANY contains non-system ID: " + *id1); + } + } + } + if (U_FAILURE(ec)) { + errln("Error checking IDs in ANY, but not in CANONICAL"); + ec = U_ZERO_ERROR; + } + + // canonical set must contains only canonical IDs + canonical->reset(ec); + while ((id1 = canonical->snext(ec)) != NULL) { + TimeZone::getCanonicalID(*id1, canonicalID, isSystemID, ec); + if (U_FAILURE(ec)) { + break; + } + if (*id1 != canonicalID) { + errln((UnicodeString)"FAIL: CANONICAL contains non-canonical ID: " + *id1); + } + if (!isSystemID) { + errln((UnicodeString)"FAILE: CANONICAL contains non-system ID: " + *id1); + } + } + if (U_FAILURE(ec)) { + errln("Error checking IDs in CANONICAL"); + ec = U_ZERO_ERROR; + } + + // canonicalLoc set must contain only canonical location IDs + canonicalLoc->reset(ec); + while ((id1 = canonicalLoc->snext(ec)) != NULL) { + TimeZone::getRegion(*id1, region, sizeof(region), ec); + if (U_FAILURE(ec)) { + break; + } + if (uprv_strcmp(region, "001") == 0) { + errln((UnicodeString)"FAIL: CANONICALLOC contains non location zone: " + *id1); + } + } + if (U_FAILURE(ec)) { + errln("Error checking IDs in CANONICALLOC"); + ec = U_ZERO_ERROR; + } + + // any_US must contain only US zones + any_US->reset(ec); + while ((id1 = any_US->snext(ec)) != NULL) { + TimeZone::getRegion(*id1, region, sizeof(region), ec); + if (U_FAILURE(ec)) { + break; + } + if (uprv_strcmp(region, "US") != 0) { + errln((UnicodeString)"FAIL: ANY_US contains non-US zone ID: " + *id1); + } + } + if (U_FAILURE(ec)) { + errln("Error checking IDs in ANY_US"); + ec = U_ZERO_ERROR; + } + + // any_W5 must contain only GMT-05:00 zones + any_W5->reset(ec); + while ((id1 = any_W5->snext(ec)) != NULL) { + TimeZone *tz = TimeZone::createTimeZone(*id1); + if (tz->getRawOffset() != (-5)*60*60*1000) { + errln((UnicodeString)"FAIL: ANY_W5 contains a zone whose offset is not -05:00: " + *id1); + } + delete tz; + } + if (U_FAILURE(ec)) { + errln("Error checking IDs in ANY_W5"); + ec = U_ZERO_ERROR; + } + + // No US zone swith GMT+14:00 + zoneCount = any_US_E14->count(ec); + if (U_FAILURE(ec)) { + errln("Error checking IDs in ANY_US_E14"); + ec = U_ZERO_ERROR; + } else if (zoneCount != 0) { + errln("FAIL: ANY_US_E14 must be empty"); + } + +cleanup: + delete any; + delete canonical; + delete canonicalLoc; + delete any_US; + delete canonical_US; + delete canonicalLoc_US; + delete any_W5; + delete any_CA_W5; + delete any_US_E14; +} + +void +TimeZoneTest::checkContainsAll(StringEnumeration *s1, const char *name1, + StringEnumeration *s2, const char *name2) +{ + UErrorCode ec = U_ZERO_ERROR; + const UnicodeString *id1, *id2; + + s2->reset(ec); + + while ((id2 = s2->snext(ec)) != NULL) { + UBool found = FALSE; + s1->reset(ec); + while ((id1 = s1->snext(ec)) != NULL) { + if (*id1 == *id2) { + found = TRUE; + break; + } + } + if (!found) { + errln((UnicodeString)"FAIL: " + name1 + "does not contain " + + *id2 + " in " + name2); + } + } + + if (U_FAILURE(ec)) { + errln((UnicodeString)"Error checkContainsAll for " + name1 + " - " + name2); + } +} + +/** + * NOTE: As of ICU 2.8, this test confirms that the "tz.alias" + * file, used to build ICU alias zones, is working. It also + * looks at some genuine Olson compatibility IDs. [aliu] + * + * This test is problematic. It should really just confirm that + * the list of compatibility zone IDs exist and are somewhat + * meaningful (that is, they aren't all aliases of GMT). It goes a + * bit further -- it hard-codes expectations about zone behavior, + * when in fact zones are redefined quite frequently. ICU's build + * process means that it is easy to update ICU to contain the + * latest Olson zone data, but if a zone tested here changes, then + * this test will fail. I have updated the test for 1999j data, + * but further updates will probably be required. Note that some + * of the concerts listed below no longer apply -- in particular, + * we do NOT overwrite real UNIX zones with 3-letter IDs. There + * are two points of overlap as of 1999j: MET and EET. These are + * both real UNIX zones, so we just use the official + * definition. This test has been updated to reflect this. + * 12/3/99 aliu + * + * Added tests for additional zones and aliases from the icuzones file. + * Markus Scherer 2006-nov-06 + * + * [srl - from java - 7/5/1998] + * @bug 4130885 + * Certain short zone IDs, used since 1.1.x, are incorrect. + * + * The worst of these is: + * + * "CAT" (Central African Time) should be GMT+2:00, but instead returns a + * zone at GMT-1:00. The zone at GMT-1:00 should be called EGT, CVT, EGST, + * or AZOST, depending on which zone is meant, but in no case is it CAT. + * + * Other wrong zone IDs: + * + * ECT (European Central Time) GMT+1:00: ECT is Ecuador Time, + * GMT-5:00. European Central time is abbreviated CEST. + * + * SST (Solomon Island Time) GMT+11:00. SST is actually Samoa Standard Time, + * GMT-11:00. Solomon Island time is SBT. + * + * NST (New Zealand Time) GMT+12:00. NST is the abbreviation for + * Newfoundland Standard Time, GMT-3:30. New Zealanders use NZST. + * + * AST (Alaska Standard Time) GMT-9:00. [This has already been noted in + * another bug.] It should be "AKST". AST is Atlantic Standard Time, + * GMT-4:00. + * + * PNT (Phoenix Time) GMT-7:00. PNT usually means Pitcairn Time, + * GMT-8:30. There is no standard abbreviation for Phoenix time, as distinct + * from MST with daylight savings. + * + * In addition to these problems, a number of zones are FAKE. That is, they + * don't match what people use in the real world. + * + * FAKE zones: + * + * EET (should be EEST) + * ART (should be EEST) + * MET (should be IRST) + * NET (should be AMST) + * PLT (should be PKT) + * BST (should be BDT) + * VST (should be ICT) + * CTT (should be CST) + + * ACT (should be CST) + + * AET (should be EST) + + * MIT (should be WST) + + * IET (should be EST) + + * PRT (should be AST) + + * CNT (should be NST) + * AGT (should be ARST) + * BET (should be EST) + + * + * + A zone with the correct name already exists and means something + * else. E.g., EST usually indicates the US Eastern zone, so it cannot be + * used for Brazil (BET). + */ +void TimeZoneTest::TestShortZoneIDs() +{ + int32_t i; + // Create a small struct to hold the array + struct + { + const char *id; + int32_t offset; + UBool daylight; + } + kReferenceList [] = + { + {"HST", -600, FALSE}, // Olson northamerica -10:00 + {"AST", -540, TRUE}, // ICU Link - America/Anchorage + {"PST", -480, TRUE}, // ICU Link - America/Los_Angeles + {"PNT", -420, FALSE}, // ICU Link - America/Phoenix + {"MST", -420, FALSE}, // updated Aug 2003 aliu + {"CST", -360, TRUE}, // Olson northamerica -7:00 + {"IET", -300, TRUE}, // ICU Link - America/Indiana/Indianapolis + {"EST", -300, FALSE}, // Olson northamerica -5:00 + {"PRT", -240, FALSE}, // ICU Link - America/Puerto_Rico + {"CNT", -210, TRUE}, // ICU Link - America/St_Johns + {"AGT", -180, FALSE}, // ICU Link - America/Argentina/Buenos_Aires + {"BET", -180, TRUE}, // ICU Link - America/Sao_Paulo + {"GMT", 0, FALSE}, // Olson etcetera Link - Etc/GMT + {"UTC", 0, FALSE}, // Olson etcetera 0 + {"ECT", 60, TRUE}, // ICU Link - Europe/Paris + {"MET", 60, TRUE}, // Olson europe 1:00 C-Eur + {"CAT", 120, FALSE}, // ICU Link - Africa/Harare + {"ART", 120, FALSE}, // ICU Link - Africa/Cairo + {"EET", 120, TRUE}, // Olson europe 2:00 EU + {"EAT", 180, FALSE}, // ICU Link - Africa/Addis_Ababa + {"NET", 240, FALSE}, // ICU Link - Asia/Yerevan + {"PLT", 300, FALSE}, // ICU Link - Asia/Karachi + {"IST", 330, FALSE}, // ICU Link - Asia/Kolkata + {"BST", 360, FALSE}, // ICU Link - Asia/Dhaka + {"VST", 420, FALSE}, // ICU Link - Asia/Ho_Chi_Minh + {"CTT", 480, FALSE}, // ICU Link - Asia/Shanghai + {"JST", 540, FALSE}, // ICU Link - Asia/Tokyo + {"ACT", 570, FALSE}, // ICU Link - Australia/Darwin + {"AET", 600, TRUE}, // ICU Link - Australia/Sydney + {"SST", 660, FALSE}, // ICU Link - Pacific/Guadalcanal + {"NST", 720, TRUE}, // ICU Link - Pacific/Auckland + {"MIT", 780, TRUE}, // ICU Link - Pacific/Apia + + {"Etc/Unknown", 0, FALSE}, // CLDR + + {"SystemV/AST4ADT", -240, TRUE}, + {"SystemV/EST5EDT", -300, TRUE}, + {"SystemV/CST6CDT", -360, TRUE}, + {"SystemV/MST7MDT", -420, TRUE}, + {"SystemV/PST8PDT", -480, TRUE}, + {"SystemV/YST9YDT", -540, TRUE}, + {"SystemV/AST4", -240, FALSE}, + {"SystemV/EST5", -300, FALSE}, + {"SystemV/CST6", -360, FALSE}, + {"SystemV/MST7", -420, FALSE}, + {"SystemV/PST8", -480, FALSE}, + {"SystemV/YST9", -540, FALSE}, + {"SystemV/HST10", -600, FALSE}, + + {"",0,FALSE} + }; + + for(i=0;kReferenceList[i].id[0];i++) { + UnicodeString itsID(kReferenceList[i].id); + UBool ok = TRUE; + // Check existence. + TimeZone *tz = TimeZone::createTimeZone(itsID); + if (!tz || (kReferenceList[i].offset != 0 && *tz == *TimeZone::getGMT())) { + errln("FAIL: Time Zone " + itsID + " does not exist!"); + continue; + } + + // Check daylight usage. + UBool usesDaylight = tz->useDaylightTime(); + if (usesDaylight != kReferenceList[i].daylight) { + if (!isDevelopmentBuild) { + logln("Warning: Time Zone " + itsID + " use daylight is " + + (usesDaylight?"TRUE":"FALSE") + + " but it should be " + + ((kReferenceList[i].daylight)?"TRUE":"FALSE")); + } else { + dataerrln("FAIL: Time Zone " + itsID + " use daylight is " + + (usesDaylight?"TRUE":"FALSE") + + " but it should be " + + ((kReferenceList[i].daylight)?"TRUE":"FALSE")); + } + ok = FALSE; + } + + // Check offset + int32_t offsetInMinutes = tz->getRawOffset()/60000; + if (offsetInMinutes != kReferenceList[i].offset) { + if (!isDevelopmentBuild) { + logln("FAIL: Time Zone " + itsID + " raw offset is " + + offsetInMinutes + + " but it should be " + kReferenceList[i].offset); + } else { + dataerrln("FAIL: Time Zone " + itsID + " raw offset is " + + offsetInMinutes + + " but it should be " + kReferenceList[i].offset); + } + ok = FALSE; + } + + if (ok) { + logln("OK: " + itsID + + " useDaylightTime() & getRawOffset() as expected"); + } + delete tz; + } + + + // OK now test compat + logln("Testing for compatibility zones"); + + const char* compatibilityMap[] = { + // This list is copied from tz.alias. If tz.alias + // changes, this list must be updated. Current as of Mar 2007 + "ACT", "Australia/Darwin", + "AET", "Australia/Sydney", + "AGT", "America/Buenos_Aires", + "ART", "Africa/Cairo", + "AST", "America/Anchorage", + "BET", "America/Sao_Paulo", + "BST", "Asia/Dhaka", // # spelling changed in 2000h; was Asia/Dacca + "CAT", "Africa/Harare", + "CNT", "America/St_Johns", + "CST", "America/Chicago", + "CTT", "Asia/Shanghai", + "EAT", "Africa/Addis_Ababa", + "ECT", "Europe/Paris", + // EET Europe/Istanbul # EET is a standard UNIX zone + // "EST", "America/New_York", # Defined as -05:00 + // "HST", "Pacific/Honolulu", # Defined as -10:00 + "IET", "America/Indianapolis", + "IST", "Asia/Calcutta", + "JST", "Asia/Tokyo", + // MET Asia/Tehran # MET is a standard UNIX zone + "MIT", "Pacific/Apia", + // "MST", "America/Denver", # Defined as -07:00 + "NET", "Asia/Yerevan", + "NST", "Pacific/Auckland", + "PLT", "Asia/Karachi", + "PNT", "America/Phoenix", + "PRT", "America/Puerto_Rico", + "PST", "America/Los_Angeles", + "SST", "Pacific/Guadalcanal", + "UTC", "Etc/GMT", + "VST", "Asia/Saigon", + "","","" + }; + + for (i=0;*compatibilityMap[i];i+=2) { + UnicodeString itsID; + + const char *zone1 = compatibilityMap[i]; + const char *zone2 = compatibilityMap[i+1]; + + TimeZone *tz1 = TimeZone::createTimeZone(zone1); + TimeZone *tz2 = TimeZone::createTimeZone(zone2); + + if (!tz1) { + errln(UnicodeString("FAIL: Could not find short ID zone ") + zone1); + } + if (!tz2) { + errln(UnicodeString("FAIL: Could not find long ID zone ") + zone2); + } + + if (tz1 && tz2) { + // make NAME same so comparison will only look at the rest + tz2->setID(tz1->getID(itsID)); + + if (*tz1 != *tz2) { + errln("FAIL: " + UnicodeString(zone1) + + " != " + UnicodeString(zone2)); + } else { + logln("OK: " + UnicodeString(zone1) + + " == " + UnicodeString(zone2)); + } + } + + delete tz1; + delete tz2; + } +} + + +/** + * Utility function for TestCustomParse + */ +UnicodeString& TimeZoneTest::formatOffset(int32_t offset, UnicodeString &rv) { + rv.remove(); + UChar sign = 0x002B; + if (offset < 0) { + sign = 0x002D; + offset = -offset; + } + + int32_t s = offset % 60; + offset /= 60; + int32_t m = offset % 60; + int32_t h = offset / 60; + + rv += (UChar)(sign); + if (h >= 10) { + rv += (UChar)(0x0030 + (h/10)); + } else { + rv += (UChar)0x0030; + } + rv += (UChar)(0x0030 + (h%10)); + + rv += (UChar)0x003A; /* ':' */ + if (m >= 10) { + rv += (UChar)(0x0030 + (m/10)); + } else { + rv += (UChar)0x0030; + } + rv += (UChar)(0x0030 + (m%10)); + + if (s) { + rv += (UChar)0x003A; /* ':' */ + if (s >= 10) { + rv += (UChar)(0x0030 + (s/10)); + } else { + rv += (UChar)0x0030; + } + rv += (UChar)(0x0030 + (s%10)); + } + return rv; +} + +/** + * Utility function for TestCustomParse, generating time zone ID + * string for the give offset. + */ +UnicodeString& TimeZoneTest::formatTZID(int32_t offset, UnicodeString &rv) { + rv.remove(); + UChar sign = 0x002B; + if (offset < 0) { + sign = 0x002D; + offset = -offset; + } + + int32_t s = offset % 60; + offset /= 60; + int32_t m = offset % 60; + int32_t h = offset / 60; + + rv += "GMT"; + rv += (UChar)(sign); + if (h >= 10) { + rv += (UChar)(0x0030 + (h/10)); + } else { + rv += (UChar)0x0030; + } + rv += (UChar)(0x0030 + (h%10)); + rv += (UChar)0x003A; + if (m >= 10) { + rv += (UChar)(0x0030 + (m/10)); + } else { + rv += (UChar)0x0030; + } + rv += (UChar)(0x0030 + (m%10)); + + if (s) { + rv += (UChar)0x003A; + if (s >= 10) { + rv += (UChar)(0x0030 + (s/10)); + } else { + rv += (UChar)0x0030; + } + rv += (UChar)(0x0030 + (s%10)); + } + return rv; +} + +/** + * As part of the VM fix (see CCC approved RFE 4028006, bug + * 4044013), TimeZone.getTimeZone() has been modified to recognize + * generic IDs of the form GMT[+-]hh:mm, GMT[+-]hhmm, and + * GMT[+-]hh. Test this behavior here. + * + * @bug 4044013 + */ +void TimeZoneTest::TestCustomParse() +{ + int32_t i; + const int32_t kUnparseable = 604800; // the number of seconds in a week. More than any offset should be. + + struct + { + const char *customId; + int32_t expectedOffset; + } + kData[] = + { + // ID Expected offset in seconds + {"GMT", kUnparseable}, //Isn't custom. [returns normal GMT] + {"GMT-YOUR.AD.HERE", kUnparseable}, + {"GMT0", kUnparseable}, + {"GMT+0", (0)}, + {"GMT+1", (1*60*60)}, + {"GMT-0030", (-30*60)}, + {"GMT+15:99", kUnparseable}, + {"GMT+", kUnparseable}, + {"GMT-", kUnparseable}, + {"GMT+0:", kUnparseable}, + {"GMT-:", kUnparseable}, + {"GMT-YOUR.AD.HERE", kUnparseable}, + {"GMT+0010", (10*60)}, // Interpret this as 00:10 + {"GMT-10", (-10*60*60)}, + {"GMT+30", kUnparseable}, + {"GMT-3:30", (-(3*60+30)*60)}, + {"GMT-230", (-(2*60+30)*60)}, + {"GMT+05:13:05", ((5*60+13)*60+5)}, + {"GMT-71023", (-((7*60+10)*60+23))}, + {"GMT+01:23:45:67", kUnparseable}, + {"GMT+01:234", kUnparseable}, + {"GMT-2:31:123", kUnparseable}, + {"GMT+3:75", kUnparseable}, + {"GMT-01010101", kUnparseable}, + {0, 0} + }; + + for (i=0; kData[i].customId != 0; i++) { + UnicodeString id(kData[i].customId); + int32_t exp = kData[i].expectedOffset; + TimeZone *zone = TimeZone::createTimeZone(id); + UnicodeString itsID, temp; + + if (dynamic_cast<OlsonTimeZone *>(zone) != NULL) { + logln(id + " -> Olson time zone"); + } else { + zone->getID(itsID); + int32_t ioffset = zone->getRawOffset()/1000; + UnicodeString offset, expectedID; + formatOffset(ioffset, offset); + formatTZID(ioffset, expectedID); + logln(id + " -> " + itsID + " " + offset); + if (exp == kUnparseable && itsID != UCAL_UNKNOWN_ZONE_ID) { + errln("Expected parse failure for " + id + + ", got offset of " + offset + + ", id " + itsID); + } + // JDK 1.3 creates custom zones with the ID "Custom" + // JDK 1.4 creates custom zones with IDs of the form "GMT+02:00" + // ICU creates custom zones with IDs of the form "GMT+02:00" + else if (exp != kUnparseable && (ioffset != exp || itsID != expectedID)) { + dataerrln("Expected offset of " + formatOffset(exp, temp) + + ", id " + expectedID + + ", for " + id + + ", got offset of " + offset + + ", id " + itsID); + } + } + delete zone; + } +} + +void +TimeZoneTest::TestAliasedNames() +{ + struct { + const char *from; + const char *to; + } kData[] = { + /* Generated by org.unicode.cldr.tool.CountItems */ + + /* zoneID, canonical zoneID */ + {"Africa/Timbuktu", "Africa/Bamako"}, + {"America/Argentina/Buenos_Aires", "America/Buenos_Aires"}, + {"America/Argentina/Catamarca", "America/Catamarca"}, + {"America/Argentina/ComodRivadavia", "America/Catamarca"}, + {"America/Argentina/Cordoba", "America/Cordoba"}, + {"America/Argentina/Jujuy", "America/Jujuy"}, + {"America/Argentina/Mendoza", "America/Mendoza"}, + {"America/Atka", "America/Adak"}, + {"America/Ensenada", "America/Tijuana"}, + {"America/Fort_Wayne", "America/Indiana/Indianapolis"}, + {"America/Indianapolis", "America/Indiana/Indianapolis"}, + {"America/Knox_IN", "America/Indiana/Knox"}, + {"America/Louisville", "America/Kentucky/Louisville"}, + {"America/Porto_Acre", "America/Rio_Branco"}, + {"America/Rosario", "America/Cordoba"}, + {"America/Virgin", "America/St_Thomas"}, + {"Asia/Ashkhabad", "Asia/Ashgabat"}, + {"Asia/Chungking", "Asia/Chongqing"}, + {"Asia/Dacca", "Asia/Dhaka"}, + {"Asia/Istanbul", "Europe/Istanbul"}, + {"Asia/Macao", "Asia/Macau"}, + {"Asia/Tel_Aviv", "Asia/Jerusalem"}, + {"Asia/Thimbu", "Asia/Thimphu"}, + {"Asia/Ujung_Pandang", "Asia/Makassar"}, + {"Asia/Ulan_Bator", "Asia/Ulaanbaatar"}, + {"Australia/ACT", "Australia/Sydney"}, + {"Australia/Canberra", "Australia/Sydney"}, + {"Australia/LHI", "Australia/Lord_Howe"}, + {"Australia/NSW", "Australia/Sydney"}, + {"Australia/North", "Australia/Darwin"}, + {"Australia/Queensland", "Australia/Brisbane"}, + {"Australia/South", "Australia/Adelaide"}, + {"Australia/Tasmania", "Australia/Hobart"}, + {"Australia/Victoria", "Australia/Melbourne"}, + {"Australia/West", "Australia/Perth"}, + {"Australia/Yancowinna", "Australia/Broken_Hill"}, + {"Brazil/Acre", "America/Rio_Branco"}, + {"Brazil/DeNoronha", "America/Noronha"}, + {"Brazil/East", "America/Sao_Paulo"}, + {"Brazil/West", "America/Manaus"}, + {"Canada/Atlantic", "America/Halifax"}, + {"Canada/Central", "America/Winnipeg"}, + {"Canada/East-Saskatchewan", "America/Regina"}, + {"Canada/Eastern", "America/Toronto"}, + {"Canada/Mountain", "America/Edmonton"}, + {"Canada/Newfoundland", "America/St_Johns"}, + {"Canada/Pacific", "America/Vancouver"}, + {"Canada/Saskatchewan", "America/Regina"}, + {"Canada/Yukon", "America/Whitehorse"}, + {"Chile/Continental", "America/Santiago"}, + {"Chile/EasterIsland", "Pacific/Easter"}, + {"Cuba", "America/Havana"}, + {"Egypt", "Africa/Cairo"}, + {"Eire", "Europe/Dublin"}, + {"Etc/GMT+0", "Etc/GMT"}, + {"Etc/GMT-0", "Etc/GMT"}, + {"Etc/GMT0", "Etc/GMT"}, + {"Etc/Greenwich", "Etc/GMT"}, + {"Etc/UCT", "Etc/GMT"}, + {"Etc/UTC", "Etc/GMT"}, + {"Etc/Universal", "Etc/GMT"}, + {"Etc/Zulu", "Etc/GMT"}, + {"Europe/Belfast", "Europe/London"}, + {"Europe/Nicosia", "Asia/Nicosia"}, + {"Europe/Tiraspol", "Europe/Chisinau"}, + {"GB", "Europe/London"}, + {"GB-Eire", "Europe/London"}, + {"GMT", "Etc/GMT"}, + {"GMT+0", "Etc/GMT"}, + {"GMT-0", "Etc/GMT"}, + {"GMT0", "Etc/GMT"}, + {"Greenwich", "Etc/GMT"}, + {"Hongkong", "Asia/Hong_Kong"}, + {"Iceland", "Atlantic/Reykjavik"}, + {"Iran", "Asia/Tehran"}, + {"Israel", "Asia/Jerusalem"}, + {"Jamaica", "America/Jamaica"}, + {"Japan", "Asia/Tokyo"}, + {"Kwajalein", "Pacific/Kwajalein"}, + {"Libya", "Africa/Tripoli"}, + {"Mexico/BajaNorte", "America/Tijuana"}, + {"Mexico/BajaSur", "America/Mazatlan"}, + {"Mexico/General", "America/Mexico_City"}, + {"NZ", "Pacific/Auckland"}, + {"NZ-CHAT", "Pacific/Chatham"}, + {"Navajo", "America/Shiprock"}, + {"PRC", "Asia/Shanghai"}, + {"Pacific/Samoa", "Pacific/Pago_Pago"}, + {"Pacific/Yap", "Pacific/Truk"}, + {"Poland", "Europe/Warsaw"}, + {"Portugal", "Europe/Lisbon"}, + {"ROC", "Asia/Taipei"}, + {"ROK", "Asia/Seoul"}, + {"Singapore", "Asia/Singapore"}, + {"Turkey", "Europe/Istanbul"}, + {"UCT", "Etc/GMT"}, + {"US/Alaska", "America/Anchorage"}, + {"US/Aleutian", "America/Adak"}, + {"US/Arizona", "America/Phoenix"}, + {"US/Central", "America/Chicago"}, + {"US/East-Indiana", "America/Indiana/Indianapolis"}, + {"US/Eastern", "America/New_York"}, + {"US/Hawaii", "Pacific/Honolulu"}, + {"US/Indiana-Starke", "America/Indiana/Knox"}, + {"US/Michigan", "America/Detroit"}, + {"US/Mountain", "America/Denver"}, + {"US/Pacific", "America/Los_Angeles"}, + {"US/Pacific-New", "America/Los_Angeles"}, + {"US/Samoa", "Pacific/Pago_Pago"}, + {"UTC", "Etc/GMT"}, + {"Universal", "Etc/GMT"}, + {"W-SU", "Europe/Moscow"}, + {"Zulu", "Etc/GMT"}, + /* Total: 113 */ + + }; + + TimeZone::EDisplayType styles[] = { TimeZone::SHORT, TimeZone::LONG }; + UBool useDst[] = { FALSE, TRUE }; + int32_t noLoc = uloc_countAvailable(); + + int32_t i, j, k, loc; + UnicodeString fromName, toName; + TimeZone *from = NULL, *to = NULL; + for(i = 0; i < (int32_t)(sizeof(kData)/sizeof(kData[0])); i++) { + from = TimeZone::createTimeZone(kData[i].from); + to = TimeZone::createTimeZone(kData[i].to); + if(!from->hasSameRules(*to)) { + errln("different at %i\n", i); + } + if(!quick) { + for(loc = 0; loc < noLoc; loc++) { + const char* locale = uloc_getAvailable(loc); + for(j = 0; j < (int32_t)(sizeof(styles)/sizeof(styles[0])); j++) { + for(k = 0; k < (int32_t)(sizeof(useDst)/sizeof(useDst[0])); k++) { + fromName.remove(); + toName.remove(); + from->getDisplayName(useDst[k], styles[j],locale, fromName); + to->getDisplayName(useDst[k], styles[j], locale, toName); + if(fromName.compare(toName) != 0) { + errln("Fail: Expected "+toName+" but got " + prettify(fromName) + + " for locale: " + locale + " index: "+ loc + + " to id "+ kData[i].to + + " from id " + kData[i].from); + } + } + } + } + } else { + fromName.remove(); + toName.remove(); + from->getDisplayName(fromName); + to->getDisplayName(toName); + if(fromName.compare(toName) != 0) { + errln("Fail: Expected "+toName+" but got " + fromName); + } + } + delete from; + delete to; + } +} + +/** + * Test the basic functionality of the getDisplayName() API. + * + * @bug 4112869 + * @bug 4028006 + * + * See also API change request A41. + * + * 4/21/98 - make smarter, so the test works if the ext resources + * are present or not. + */ +void +TimeZoneTest::TestDisplayName() +{ + UErrorCode status = U_ZERO_ERROR; + int32_t i; + TimeZone *zone = TimeZone::createTimeZone("PST"); + UnicodeString name; + zone->getDisplayName(Locale::getEnglish(), name); + logln("PST->" + name); + if (name.compare("Pacific Standard Time") != 0) + dataerrln("Fail: Expected \"Pacific Standard Time\" but got " + name); + + //***************************************************************** + // THE FOLLOWING LINES MUST BE UPDATED IF THE LOCALE DATA CHANGES + // THE FOLLOWING LINES MUST BE UPDATED IF THE LOCALE DATA CHANGES + // THE FOLLOWING LINES MUST BE UPDATED IF THE LOCALE DATA CHANGES + //***************************************************************** + struct + { + UBool useDst; + TimeZone::EDisplayType style; + const char *expect; + } kData[] = { + {FALSE, TimeZone::SHORT, "PST"}, + {TRUE, TimeZone::SHORT, "PDT"}, + {FALSE, TimeZone::LONG, "Pacific Standard Time"}, + {TRUE, TimeZone::LONG, "Pacific Daylight Time"}, + + {FALSE, TimeZone::SHORT_GENERIC, "PT"}, + {TRUE, TimeZone::SHORT_GENERIC, "PT"}, + {FALSE, TimeZone::LONG_GENERIC, "Pacific Time"}, + {TRUE, TimeZone::LONG_GENERIC, "Pacific Time"}, + + {FALSE, TimeZone::SHORT_GMT, "-0800"}, + {TRUE, TimeZone::SHORT_GMT, "-0700"}, + {FALSE, TimeZone::LONG_GMT, "GMT-08:00"}, + {TRUE, TimeZone::LONG_GMT, "GMT-07:00"}, + + {FALSE, TimeZone::SHORT_COMMONLY_USED, "PST"}, + {TRUE, TimeZone::SHORT_COMMONLY_USED, "PDT"}, + {FALSE, TimeZone::GENERIC_LOCATION, "Los Angeles Time"}, + {TRUE, TimeZone::GENERIC_LOCATION, "Los Angeles Time"}, + + {FALSE, TimeZone::LONG, ""} + }; + + for (i=0; kData[i].expect[0] != '\0'; i++) + { + name.remove(); + name = zone->getDisplayName(kData[i].useDst, + kData[i].style, + Locale::getEnglish(), name); + if (name.compare(kData[i].expect) != 0) + dataerrln("Fail: Expected " + UnicodeString(kData[i].expect) + "; got " + name); + logln("PST [with options]->" + name); + } + for (i=0; kData[i].expect[0] != '\0'; i++) + { + name.remove(); + name = zone->getDisplayName(kData[i].useDst, + kData[i].style, name); + if (name.compare(kData[i].expect) != 0) + dataerrln("Fail: Expected " + UnicodeString(kData[i].expect) + "; got " + name); + logln("PST [with options]->" + name); + } + + + // Make sure that we don't display the DST name by constructing a fake + // PST zone that has DST all year long. + SimpleTimeZone *zone2 = new SimpleTimeZone(0, "PST"); + + zone2->setStartRule(UCAL_JANUARY, 1, 0, 0, status); + zone2->setEndRule(UCAL_DECEMBER, 31, 0, 0, status); + + UnicodeString inDaylight; + if (zone2->inDaylightTime(UDate(0), status)) { + inDaylight = UnicodeString("TRUE"); + } else { + inDaylight = UnicodeString("FALSE"); + } + logln(UnicodeString("Modified PST inDaylightTime->") + inDaylight ); + if(U_FAILURE(status)) + { + dataerrln("Some sort of error..." + UnicodeString(u_errorName(status))); // REVISIT + } + name.remove(); + name = zone2->getDisplayName(Locale::getEnglish(),name); + logln("Modified PST->" + name); + if (name.compare("Pacific Standard Time") != 0) + dataerrln("Fail: Expected \"Pacific Standard Time\""); + + // Make sure we get the default display format for Locales + // with no display name data. + Locale mt_MT("mt_MT"); + name.remove(); + name = zone->getDisplayName(mt_MT,name); + //***************************************************************** + // THE FOLLOWING LINE MUST BE UPDATED IF THE LOCALE DATA CHANGES + // THE FOLLOWING LINE MUST BE UPDATED IF THE LOCALE DATA CHANGES + // THE FOLLOWING LINE MUST BE UPDATED IF THE LOCALE DATA CHANGES + //***************************************************************** + logln("PST(mt_MT)->" + name); + + // *** REVISIT SRL how in the world do I check this? looks java specific. + // Now be smart -- check to see if zh resource is even present. + // If not, we expect the en fallback behavior. + ResourceBundle enRB(NULL, + Locale::getEnglish(), status); + if(U_FAILURE(status)) + dataerrln("Couldn't get ResourceBundle for en - %s", u_errorName(status)); + + ResourceBundle mtRB(NULL, + mt_MT, status); + //if(U_FAILURE(status)) + // errln("Couldn't get ResourceBundle for mt_MT"); + + UBool noZH = U_FAILURE(status); + + if (noZH) { + logln("Warning: Not testing the mt_MT behavior because resource is absent"); + if (name != "Pacific Standard Time") + dataerrln("Fail: Expected Pacific Standard Time"); + } + + + if (name.compare("GMT-08:00") && + name.compare("GMT-8:00") && + name.compare("GMT-0800") && + name.compare("GMT-800")) { + dataerrln(UnicodeString("Fail: Expected GMT-08:00 or something similar for PST in mt_MT but got ") + name ); + dataerrln("************************************************************"); + dataerrln("THE ABOVE FAILURE MAY JUST MEAN THE LOCALE DATA HAS CHANGED"); + dataerrln("************************************************************"); + } + + // Now try a non-existent zone + delete zone2; + zone2 = new SimpleTimeZone(90*60*1000, "xyzzy"); + name.remove(); + name = zone2->getDisplayName(Locale::getEnglish(),name); + logln("GMT+90min->" + name); + if (name.compare("GMT+01:30") && + name.compare("GMT+1:30") && + name.compare("GMT+0130") && + name.compare("GMT+130")) + dataerrln("Fail: Expected GMT+01:30 or something similar"); + name.truncate(0); + zone2->getDisplayName(name); + logln("GMT+90min->" + name); + if (name.compare("GMT+01:30") && + name.compare("GMT+1:30") && + name.compare("GMT+0130") && + name.compare("GMT+130")) + dataerrln("Fail: Expected GMT+01:30 or something similar"); + // clean up + delete zone; + delete zone2; +} + +/** + * @bug 4107276 + */ +void +TimeZoneTest::TestDSTSavings() +{ + UErrorCode status = U_ZERO_ERROR; + // It might be better to find a way to integrate this test into the main TimeZone + // tests above, but I don't have time to figure out how to do this (or if it's + // even really a good idea). Let's consider that a future. --rtg 1/27/98 + SimpleTimeZone *tz = new SimpleTimeZone(-5 * U_MILLIS_PER_HOUR, "dstSavingsTest", + UCAL_MARCH, 1, 0, 0, UCAL_SEPTEMBER, 1, 0, 0, + (int32_t)(0.5 * U_MILLIS_PER_HOUR), status); + if(U_FAILURE(status)) + errln("couldn't create TimeZone"); + + if (tz->getRawOffset() != -5 * U_MILLIS_PER_HOUR) + errln(UnicodeString("Got back a raw offset of ") + (tz->getRawOffset() / U_MILLIS_PER_HOUR) + + " hours instead of -5 hours."); + if (!tz->useDaylightTime()) + errln("Test time zone should use DST but claims it doesn't."); + if (tz->getDSTSavings() != 0.5 * U_MILLIS_PER_HOUR) + errln(UnicodeString("Set DST offset to 0.5 hour, but got back ") + (tz->getDSTSavings() / + U_MILLIS_PER_HOUR) + " hours instead."); + + int32_t offset = tz->getOffset(GregorianCalendar::AD, 1998, UCAL_JANUARY, 1, + UCAL_THURSDAY, 10 * U_MILLIS_PER_HOUR,status); + if (offset != -5 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10 AM, 1/1/98 should have been -5 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + offset = tz->getOffset(GregorianCalendar::AD, 1998, UCAL_JUNE, 1, UCAL_MONDAY, + 10 * U_MILLIS_PER_HOUR,status); + if (offset != -4.5 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10 AM, 6/1/98 should have been -4.5 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + tz->setDSTSavings(U_MILLIS_PER_HOUR, status); + offset = tz->getOffset(GregorianCalendar::AD, 1998, UCAL_JANUARY, 1, + UCAL_THURSDAY, 10 * U_MILLIS_PER_HOUR,status); + if (offset != -5 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10 AM, 1/1/98 should have been -5 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + offset = tz->getOffset(GregorianCalendar::AD, 1998, UCAL_JUNE, 1, UCAL_MONDAY, + 10 * U_MILLIS_PER_HOUR,status); + if (offset != -4 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10 AM, 6/1/98 (with a 1-hour DST offset) should have been -4 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + delete tz; +} + +/** + * @bug 4107570 + */ +void +TimeZoneTest::TestAlternateRules() +{ + // Like TestDSTSavings, this test should probably be integrated somehow with the main + // test at the top of this class, but I didn't have time to figure out how to do that. + // --rtg 1/28/98 + + SimpleTimeZone tz(-5 * U_MILLIS_PER_HOUR, "alternateRuleTest"); + + // test the day-of-month API + UErrorCode status = U_ZERO_ERROR; + tz.setStartRule(UCAL_MARCH, 10, 12 * U_MILLIS_PER_HOUR, status); + if(U_FAILURE(status)) + errln("tz.setStartRule failed"); + tz.setEndRule(UCAL_OCTOBER, 20, 12 * U_MILLIS_PER_HOUR, status); + if(U_FAILURE(status)) + errln("tz.setStartRule failed"); + + int32_t offset = tz.getOffset(GregorianCalendar::AD, 1998, UCAL_MARCH, 5, + UCAL_THURSDAY, 10 * U_MILLIS_PER_HOUR,status); + if (offset != -5 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10AM, 3/5/98 should have been -5 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + offset = tz.getOffset(GregorianCalendar::AD, 1998, UCAL_MARCH, 15, + UCAL_SUNDAY, 10 * millisPerHour,status); + if (offset != -4 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10AM, 3/15/98 should have been -4 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + offset = tz.getOffset(GregorianCalendar::AD, 1998, UCAL_OCTOBER, 15, + UCAL_THURSDAY, 10 * millisPerHour,status); + if (offset != -4 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10AM, 10/15/98 should have been -4 hours, but we got ") + (offset / U_MILLIS_PER_HOUR) + " hours."); + + offset = tz.getOffset(GregorianCalendar::AD, 1998, UCAL_OCTOBER, 25, + UCAL_SUNDAY, 10 * millisPerHour,status); + if (offset != -5 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10AM, 10/25/98 should have been -5 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + // test the day-of-week-after-day-in-month API + tz.setStartRule(UCAL_MARCH, 10, UCAL_FRIDAY, 12 * millisPerHour, TRUE, status); + if(U_FAILURE(status)) + errln("tz.setStartRule failed"); + tz.setEndRule(UCAL_OCTOBER, 20, UCAL_FRIDAY, 12 * millisPerHour, FALSE, status); + if(U_FAILURE(status)) + errln("tz.setStartRule failed"); + + offset = tz.getOffset(GregorianCalendar::AD, 1998, UCAL_MARCH, 11, + UCAL_WEDNESDAY, 10 * millisPerHour,status); + if (offset != -5 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10AM, 3/11/98 should have been -5 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + offset = tz.getOffset(GregorianCalendar::AD, 1998, UCAL_MARCH, 14, + UCAL_SATURDAY, 10 * millisPerHour,status); + if (offset != -4 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10AM, 3/14/98 should have been -4 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + offset = tz.getOffset(GregorianCalendar::AD, 1998, UCAL_OCTOBER, 15, + UCAL_THURSDAY, 10 * millisPerHour,status); + if (offset != -4 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10AM, 10/15/98 should have been -4 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); + + offset = tz.getOffset(GregorianCalendar::AD, 1998, UCAL_OCTOBER, 17, + UCAL_SATURDAY, 10 * millisPerHour,status); + if (offset != -5 * U_MILLIS_PER_HOUR) + errln(UnicodeString("The offset for 10AM, 10/17/98 should have been -5 hours, but we got ") + + (offset / U_MILLIS_PER_HOUR) + " hours."); +} + +void TimeZoneTest::TestFractionalDST() { + const char* tzName = "Australia/Lord_Howe"; // 30 min offset + TimeZone* tz_icu = TimeZone::createTimeZone(tzName); + int dst_icu = tz_icu->getDSTSavings(); + UnicodeString id; + int32_t expected = 1800000; + if (expected != dst_icu) { + dataerrln(UnicodeString("java reports dst savings of ") + expected + + " but icu reports " + dst_icu + + " for tz " + tz_icu->getID(id)); + } else { + logln(UnicodeString("both java and icu report dst savings of ") + expected + " for tz " + tz_icu->getID(id)); + } + delete tz_icu; +} + +/** + * Test country code support. Jitterbug 776. + */ +void TimeZoneTest::TestCountries() { + // Make sure America/Los_Angeles is in the "US" group, and + // Asia/Tokyo isn't. Vice versa for the "JP" group. + UErrorCode ec = U_ZERO_ERROR; + int32_t n; + StringEnumeration* s = TimeZone::createEnumeration("US"); + if (s == NULL) { + dataerrln("Unable to create TimeZone enumeration for US"); + return; + } + n = s->count(ec); + UBool la = FALSE, tokyo = FALSE; + UnicodeString laZone("America/Los_Angeles", ""); + UnicodeString tokyoZone("Asia/Tokyo", ""); + int32_t i; + + if (s == NULL || n <= 0) { + dataerrln("FAIL: TimeZone::createEnumeration() returned nothing"); + return; + } + for (i=0; i<n; ++i) { + const UnicodeString* id = s->snext(ec); + if (*id == (laZone)) { + la = TRUE; + } + if (*id == (tokyoZone)) { + tokyo = TRUE; + } + } + if (!la || tokyo) { + errln("FAIL: " + laZone + " in US = " + la); + errln("FAIL: " + tokyoZone + " in US = " + tokyo); + } + delete s; + + s = TimeZone::createEnumeration("JP"); + n = s->count(ec); + la = FALSE; tokyo = FALSE; + + for (i=0; i<n; ++i) { + const UnicodeString* id = s->snext(ec); + if (*id == (laZone)) { + la = TRUE; + } + if (*id == (tokyoZone)) { + tokyo = TRUE; + } + } + if (la || !tokyo) { + errln("FAIL: " + laZone + " in JP = " + la); + errln("FAIL: " + tokyoZone + " in JP = " + tokyo); + } + StringEnumeration* s1 = TimeZone::createEnumeration("US"); + StringEnumeration* s2 = TimeZone::createEnumeration("US"); + for(i=0;i<n;++i){ + const UnicodeString* id1 = s1->snext(ec); + if(id1==NULL || U_FAILURE(ec)){ + errln("Failed to fetch next from TimeZone enumeration. Length returned : %i Current Index: %i", n,i); + } + TimeZone* tz1 = TimeZone::createTimeZone(*id1); + for(int j=0; j<n;++j){ + const UnicodeString* id2 = s2->snext(ec); + if(id2==NULL || U_FAILURE(ec)){ + errln("Failed to fetch next from TimeZone enumeration. Length returned : %i Current Index: %i", n,i); + } + TimeZone* tz2 = TimeZone::createTimeZone(*id2); + if(tz1->hasSameRules(*tz2)){ + logln("ID1 : " + *id1+" == ID2 : " +*id2); + } + delete tz2; + } + delete tz1; + } + delete s1; + delete s2; + delete s; +} + +void TimeZoneTest::TestHistorical() { + const int32_t H = U_MILLIS_PER_HOUR; + struct { + const char* id; + int32_t time; // epoch seconds + int32_t offset; // total offset (millis) + } DATA[] = { + // Add transition points (before/after) as desired to test historical + // behavior. + {"America/Los_Angeles", 638963999, -8*H}, // Sun Apr 01 01:59:59 GMT-08:00 1990 + {"America/Los_Angeles", 638964000, -7*H}, // Sun Apr 01 03:00:00 GMT-07:00 1990 + {"America/Los_Angeles", 657104399, -7*H}, // Sun Oct 28 01:59:59 GMT-07:00 1990 + {"America/Los_Angeles", 657104400, -8*H}, // Sun Oct 28 01:00:00 GMT-08:00 1990 + {"America/Goose_Bay", -116445601, -4*H}, // Sun Apr 24 01:59:59 GMT-04:00 1966 + {"America/Goose_Bay", -116445600, -3*H}, // Sun Apr 24 03:00:00 GMT-03:00 1966 + {"America/Goose_Bay", -100119601, -3*H}, // Sun Oct 30 01:59:59 GMT-03:00 1966 + {"America/Goose_Bay", -100119600, -4*H}, // Sun Oct 30 01:00:00 GMT-04:00 1966 + {"America/Goose_Bay", -84391201, -4*H}, // Sun Apr 30 01:59:59 GMT-04:00 1967 + {"America/Goose_Bay", -84391200, -3*H}, // Sun Apr 30 03:00:00 GMT-03:00 1967 + {"America/Goose_Bay", -68670001, -3*H}, // Sun Oct 29 01:59:59 GMT-03:00 1967 + {"America/Goose_Bay", -68670000, -4*H}, // Sun Oct 29 01:00:00 GMT-04:00 1967 + {0, 0, 0} + }; + + for (int32_t i=0; DATA[i].id!=0; ++i) { + const char* id = DATA[i].id; + TimeZone *tz = TimeZone::createTimeZone(id); + UnicodeString s; + if (tz == 0) { + errln("FAIL: Cannot create %s", id); + } else if (tz->getID(s) != UnicodeString(id)) { + dataerrln((UnicodeString)"FAIL: createTimeZone(" + id + ") => " + s); + } else { + UErrorCode ec = U_ZERO_ERROR; + int32_t raw, dst; + UDate when = (double) DATA[i].time * U_MILLIS_PER_SECOND; + tz->getOffset(when, FALSE, raw, dst, ec); + if (U_FAILURE(ec)) { + errln("FAIL: getOffset"); + } else if ((raw+dst) != DATA[i].offset) { + errln((UnicodeString)"FAIL: " + DATA[i].id + ".getOffset(" + + //when + " = " + + dateToString(when) + ") => " + + raw + ", " + dst); + } else { + logln((UnicodeString)"Ok: " + DATA[i].id + ".getOffset(" + + //when + " = " + + dateToString(when) + ") => " + + raw + ", " + dst); + } + } + delete tz; + } +} + +void TimeZoneTest::TestEquivalentIDs() { + int32_t n = TimeZone::countEquivalentIDs("PST"); + if (n < 2) { + dataerrln((UnicodeString)"FAIL: countEquivalentIDs(PST) = " + n); + } else { + UBool sawLA = FALSE; + for (int32_t i=0; i<n; ++i) { + UnicodeString id = TimeZone::getEquivalentID("PST", i); + logln((UnicodeString)"" + i + " : " + id); + if (id == UnicodeString("America/Los_Angeles")) { + sawLA = TRUE; + } + } + if (!sawLA) { + errln("FAIL: America/Los_Angeles should be in the list"); + } + } +} + +// Test that a transition at the end of February is handled correctly. +void TimeZoneTest::TestFebruary() { + UErrorCode status = U_ZERO_ERROR; + + // Time zone with daylight savings time from the first Sunday in November + // to the last Sunday in February. + // Similar to the new rule for Brazil (Sao Paulo) in tzdata2006n. + // + // Note: In tzdata2007h, the rule had changed, so no actual zones uses + // lastSun in Feb anymore. + SimpleTimeZone tz1(-3 * U_MILLIS_PER_HOUR, // raw offset: 3h before (west of) GMT + UNICODE_STRING("nov-feb", 7), + UCAL_NOVEMBER, 1, UCAL_SUNDAY, // start: November, first, Sunday + 0, // midnight wall time + UCAL_FEBRUARY, -1, UCAL_SUNDAY, // end: February, last, Sunday + 0, // midnight wall time + status); + if (U_FAILURE(status)) { + errln("Unable to create the SimpleTimeZone(nov-feb): %s", u_errorName(status)); + return; + } + + // Now hardcode the same rules as for Brazil in tzdata 2006n, so that + // we cover the intended code even when in the future zoneinfo hardcodes + // these transition dates. + SimpleTimeZone tz2(-3 * U_MILLIS_PER_HOUR, // raw offset: 3h before (west of) GMT + UNICODE_STRING("nov-feb2", 8), + UCAL_NOVEMBER, 1, -UCAL_SUNDAY, // start: November, 1 or after, Sunday + 0, // midnight wall time + UCAL_FEBRUARY, -29, -UCAL_SUNDAY,// end: February, 29 or before, Sunday + 0, // midnight wall time + status); + if (U_FAILURE(status)) { + errln("Unable to create the SimpleTimeZone(nov-feb2): %s", u_errorName(status)); + return; + } + + // Gregorian calendar with the UTC time zone for getting sample test date/times. + GregorianCalendar gc(*TimeZone::getGMT(), status); + if (U_FAILURE(status)) { + dataerrln("Unable to create the UTC calendar: %s", u_errorName(status)); + return; + } + + struct { + // UTC time. + int32_t year, month, day, hour, minute, second; + // Expected time zone offset in hours after GMT (negative=before GMT). + int32_t offsetHours; + } data[] = { + { 2006, UCAL_NOVEMBER, 5, 02, 59, 59, -3 }, + { 2006, UCAL_NOVEMBER, 5, 03, 00, 00, -2 }, + { 2007, UCAL_FEBRUARY, 25, 01, 59, 59, -2 }, + { 2007, UCAL_FEBRUARY, 25, 02, 00, 00, -3 }, + + { 2007, UCAL_NOVEMBER, 4, 02, 59, 59, -3 }, + { 2007, UCAL_NOVEMBER, 4, 03, 00, 00, -2 }, + { 2008, UCAL_FEBRUARY, 24, 01, 59, 59, -2 }, + { 2008, UCAL_FEBRUARY, 24, 02, 00, 00, -3 }, + + { 2008, UCAL_NOVEMBER, 2, 02, 59, 59, -3 }, + { 2008, UCAL_NOVEMBER, 2, 03, 00, 00, -2 }, + { 2009, UCAL_FEBRUARY, 22, 01, 59, 59, -2 }, + { 2009, UCAL_FEBRUARY, 22, 02, 00, 00, -3 }, + + { 2009, UCAL_NOVEMBER, 1, 02, 59, 59, -3 }, + { 2009, UCAL_NOVEMBER, 1, 03, 00, 00, -2 }, + { 2010, UCAL_FEBRUARY, 28, 01, 59, 59, -2 }, + { 2010, UCAL_FEBRUARY, 28, 02, 00, 00, -3 } + }; + + TimeZone *timezones[] = { &tz1, &tz2 }; + + TimeZone *tz; + UDate dt; + int32_t t, i, raw, dst; + for (t = 0; t < LENGTHOF(timezones); ++t) { + tz = timezones[t]; + for (i = 0; i < LENGTHOF(data); ++i) { + gc.set(data[i].year, data[i].month, data[i].day, + data[i].hour, data[i].minute, data[i].second); + dt = gc.getTime(status); + if (U_FAILURE(status)) { + errln("test case %d.%d: bad date/time %04d-%02d-%02d %02d:%02d:%02d", + t, i, + data[i].year, data[i].month + 1, data[i].day, + data[i].hour, data[i].minute, data[i].second); + status = U_ZERO_ERROR; + continue; + } + tz->getOffset(dt, FALSE, raw, dst, status); + if (U_FAILURE(status)) { + errln("test case %d.%d: tz.getOffset(%04d-%02d-%02d %02d:%02d:%02d) fails: %s", + t, i, + data[i].year, data[i].month + 1, data[i].day, + data[i].hour, data[i].minute, data[i].second, + u_errorName(status)); + status = U_ZERO_ERROR; + } else if ((raw + dst) != data[i].offsetHours * U_MILLIS_PER_HOUR) { + errln("test case %d.%d: tz.getOffset(%04d-%02d-%02d %02d:%02d:%02d) returns %d+%d != %d", + t, i, + data[i].year, data[i].month + 1, data[i].day, + data[i].hour, data[i].minute, data[i].second, + raw, dst, data[i].offsetHours * U_MILLIS_PER_HOUR); + } + } + } +} +void TimeZoneTest::TestCanonicalID() { + + // Some canonical IDs in CLDR are defined as "Link" + // in Olson tzdata. + static const struct { + const char *alias; + const char *zone; + } excluded1[] = { + {"America/Shiprock", "America/Denver"}, // America/Shiprock is defined as a Link to America/Denver in tzdata + {"America/Marigot", "America/Guadeloupe"}, + {"America/St_Barthelemy", "America/Guadeloupe"}, + {"America/Lower_Princes", "America/Curacao"}, + {"America/Kralendijk", "America/Curacao"}, + {"Antarctica/South_Pole", "Antarctica/McMurdo"}, + {"Atlantic/Jan_Mayen", "Europe/Oslo"}, + {"Arctic/Longyearbyen", "Europe/Oslo"}, + {"Europe/Guernsey", "Europe/London"}, + {"Europe/Isle_of_Man", "Europe/London"}, + {"Europe/Jersey", "Europe/London"}, + {"Europe/Ljubljana", "Europe/Belgrade"}, + {"Europe/Podgorica", "Europe/Belgrade"}, + {"Europe/Sarajevo", "Europe/Belgrade"}, + {"Europe/Skopje", "Europe/Belgrade"}, + {"Europe/Zagreb", "Europe/Belgrade"}, + {"Europe/Bratislava", "Europe/Prague"}, + {"Europe/Mariehamn", "Europe/Helsinki"}, + {"Europe/San_Marino", "Europe/Rome"}, + {"Europe/Vatican", "Europe/Rome"}, + {0, 0} + }; + + // Following IDs are aliases of Etc/GMT in CLDR, + // but Olson tzdata has 3 independent definitions + // for Etc/GMT, Etc/UTC, Etc/UCT. + // Until we merge them into one equivalent group + // in zoneinfo.res, we exclude them in the test + // below. + static const char* excluded2[] = { + "Etc/UCT", "UCT", + "Etc/UTC", "UTC", + "Etc/Universal", "Universal", + "Etc/Zulu", "Zulu", 0 + }; + + // Walk through equivalency groups + UErrorCode ec = U_ZERO_ERROR; + int32_t s_length, i, j, k; + StringEnumeration* s = TimeZone::createEnumeration(); + if (s == NULL) { + dataerrln("Unable to create TimeZone enumeration"); + return; + } + UnicodeString canonicalID, tmpCanonical; + s_length = s->count(ec); + for (i = 0; i < s_length;++i) { + const UnicodeString *tzid = s->snext(ec); + int32_t nEquiv = TimeZone::countEquivalentIDs(*tzid); + if (nEquiv == 0) { + continue; + } + UBool bFoundCanonical = FALSE; + // Make sure getCanonicalID returns the exact same result + // for all entries within a same equivalency group with some + // exceptions listed in exluded1. + // Also, one of them must be canonical id. + for (j = 0; j < nEquiv; j++) { + UnicodeString tmp = TimeZone::getEquivalentID(*tzid, j); + TimeZone::getCanonicalID(tmp, tmpCanonical, ec); + if (U_FAILURE(ec)) { + errln((UnicodeString)"FAIL: getCanonicalID(" + tmp + ") failed."); + ec = U_ZERO_ERROR; + continue; + } + // Some exceptional cases + for (k = 0; excluded1[k].alias != 0; k++) { + if (tmpCanonical == excluded1[k].alias) { + tmpCanonical = excluded1[k].zone; + break; + } + } + if (j == 0) { + canonicalID = tmpCanonical; + } else if (canonicalID != tmpCanonical) { + errln("FAIL: getCanonicalID(" + tmp + ") returned " + tmpCanonical + " expected:" + canonicalID); + } + + if (canonicalID == tmp) { + bFoundCanonical = TRUE; + } + } + // At least one ID in an equvalency group must match the + // canonicalID + if (bFoundCanonical == FALSE) { + // test exclusion because of differences between Olson tzdata and CLDR + UBool isExcluded = FALSE; + for (k = 0; excluded2[k] != 0; k++) { + if (*tzid == UnicodeString(excluded2[k])) { + isExcluded = TRUE; + break; + } + } + if (isExcluded) { + continue; + } + errln((UnicodeString)"FAIL: No timezone ids match the canonical ID " + canonicalID); + } + } + delete s; + + // Testing some special cases + static const struct { + const char *id; + const char *expected; + UBool isSystem; + } data[] = { + {"GMT-03", "GMT-03:00", FALSE}, + {"GMT+4", "GMT+04:00", FALSE}, + {"GMT-055", "GMT-00:55", FALSE}, + {"GMT+430", "GMT+04:30", FALSE}, + {"GMT-12:15", "GMT-12:15", FALSE}, + {"GMT-091015", "GMT-09:10:15", FALSE}, + {"GMT+1:90", 0, FALSE}, + {"America/Argentina/Buenos_Aires", "America/Buenos_Aires", TRUE}, + {"Etc/Unknown", "Etc/Unknown", FALSE}, + {"bogus", 0, FALSE}, + {"", 0, FALSE}, + {"America/Marigot", "America/Marigot", TRUE}, // Olson link, but CLDR canonical (#8953) + {"Europe/Bratislava", "Europe/Bratislava", TRUE}, // Same as above + {0, 0, FALSE} + }; + + UBool isSystemID; + for (i = 0; data[i].id != 0; i++) { + TimeZone::getCanonicalID(UnicodeString(data[i].id), canonicalID, isSystemID, ec); + if (U_FAILURE(ec)) { + if (ec != U_ILLEGAL_ARGUMENT_ERROR || data[i].expected != 0) { + errln((UnicodeString)"FAIL: getCanonicalID(\"" + data[i].id + + "\") returned status U_ILLEGAL_ARGUMENT_ERROR"); + } + ec = U_ZERO_ERROR; + continue; + } + if (canonicalID != data[i].expected) { + dataerrln((UnicodeString)"FAIL: getCanonicalID(\"" + data[i].id + + "\") returned " + canonicalID + " - expected: " + data[i].expected); + } + if (isSystemID != data[i].isSystem) { + dataerrln((UnicodeString)"FAIL: getCanonicalID(\"" + data[i].id + + "\") set " + isSystemID + " to isSystemID"); + } + } +} + +// +// Test Display Names, choosing zones and lcoales where there are multiple +// meta-zones defined. +// +static struct { + const char *zoneName; + const char *localeName; + UBool summerTime; + TimeZone::EDisplayType style; + const char *expectedDisplayName; } + zoneDisplayTestData [] = { + // zone id locale summer format expected display name + {"Europe/London", "en", FALSE, TimeZone::SHORT, "GMT"}, + {"Europe/London", "en", FALSE, TimeZone::LONG, "Greenwich Mean Time"}, + {"Europe/London", "en", TRUE, TimeZone::SHORT, "GMT+01:00" /*"BST"*/}, + {"Europe/London", "en", TRUE, TimeZone::LONG, "British Summer Time"}, + + {"America/Anchorage", "en", FALSE, TimeZone::SHORT, "AKST"}, + {"America/Anchorage", "en", FALSE, TimeZone::LONG, "Alaska Standard Time"}, + {"America/Anchorage", "en", TRUE, TimeZone::SHORT, "AKDT"}, + {"America/Anchorage", "en", TRUE, TimeZone::LONG, "Alaska Daylight Time"}, + + // Southern Hemisphere, all data from meta:Australia_Western + {"Australia/Perth", "en", FALSE, TimeZone::SHORT, "GMT+08:00"/*"AWST"*/}, + {"Australia/Perth", "en", FALSE, TimeZone::LONG, "Australian Western Standard Time"}, + // Note: Perth does not observe DST currently. When display name is missing, + // the localized GMT format with the current offset is used even daylight name was + // requested. See #9350. + {"Australia/Perth", "en", TRUE, TimeZone::SHORT, "GMT+08:00"/*"AWDT"*/}, + {"Australia/Perth", "en", TRUE, TimeZone::LONG, "Australian Western Daylight Time"}, + + {"America/Sao_Paulo", "en", FALSE, TimeZone::SHORT, "GMT-03:00"/*"BRT"*/}, + {"America/Sao_Paulo", "en", FALSE, TimeZone::LONG, "Brasilia Standard Time"}, + {"America/Sao_Paulo", "en", TRUE, TimeZone::SHORT, "GMT-02:00"/*"BRST"*/}, + {"America/Sao_Paulo", "en", TRUE, TimeZone::LONG, "Brasilia Summer Time"}, + + // No Summer Time, but had it before 1983. + {"Pacific/Honolulu", "en", FALSE, TimeZone::SHORT, "HST"}, + {"Pacific/Honolulu", "en", FALSE, TimeZone::LONG, "Hawaii-Aleutian Standard Time"}, + {"Pacific/Honolulu", "en", TRUE, TimeZone::SHORT, "HDT"}, + {"Pacific/Honolulu", "en", TRUE, TimeZone::LONG, "Hawaii-Aleutian Daylight Time"}, + + // Northern, has Summer, not commonly used. + {"Europe/Helsinki", "en", FALSE, TimeZone::SHORT, "GMT+02:00"/*"EET"*/}, + {"Europe/Helsinki", "en", FALSE, TimeZone::LONG, "Eastern European Standard Time"}, + {"Europe/Helsinki", "en", TRUE, TimeZone::SHORT, "GMT+03:00"/*"EEST"*/}, + {"Europe/Helsinki", "en", TRUE, TimeZone::LONG, "Eastern European Summer Time"}, + + // Repeating the test data for DST. The test data below trigger the problem reported + // by Ticket#6644 + {"Europe/London", "en", TRUE, TimeZone::SHORT, "GMT+01:00" /*"BST"*/}, + {"Europe/London", "en", TRUE, TimeZone::LONG, "British Summer Time"}, + + {NULL, NULL, FALSE, TimeZone::SHORT, NULL} // NULL values terminate list + }; + +void TimeZoneTest::TestDisplayNamesMeta() { + UErrorCode status = U_ZERO_ERROR; + GregorianCalendar cal(*TimeZone::getGMT(), status); + if (failure(status, "GregorianCalendar", TRUE)) return; + + UBool sawAnError = FALSE; + for (int testNum = 0; zoneDisplayTestData[testNum].zoneName != NULL; testNum++) { + Locale locale = Locale::createFromName(zoneDisplayTestData[testNum].localeName); + TimeZone *zone = TimeZone::createTimeZone(zoneDisplayTestData[testNum].zoneName); + UnicodeString displayName; + zone->getDisplayName(zoneDisplayTestData[testNum].summerTime, + zoneDisplayTestData[testNum].style, + locale, + displayName); + if (displayName != zoneDisplayTestData[testNum].expectedDisplayName) { + char name[100]; + UErrorCode status = U_ZERO_ERROR; + displayName.extract(name, 100, NULL, status); + if (isDevelopmentBuild) { + sawAnError = TRUE; + dataerrln("Incorrect time zone display name. zone = \"%s\",\n" + " locale = \"%s\", style = %s, Summertime = %d\n" + " Expected \"%s\", " + " Got \"%s\"\n Error: %s", zoneDisplayTestData[testNum].zoneName, + zoneDisplayTestData[testNum].localeName, + zoneDisplayTestData[testNum].style==TimeZone::SHORT ? + "SHORT" : "LONG", + zoneDisplayTestData[testNum].summerTime, + zoneDisplayTestData[testNum].expectedDisplayName, + name, + u_errorName(status)); + } else { + logln("Incorrect time zone display name. zone = \"%s\",\n" + " locale = \"%s\", style = %s, Summertime = %d\n" + " Expected \"%s\", " + " Got \"%s\"\n", zoneDisplayTestData[testNum].zoneName, + zoneDisplayTestData[testNum].localeName, + zoneDisplayTestData[testNum].style==TimeZone::SHORT ? + "SHORT" : "LONG", + zoneDisplayTestData[testNum].summerTime, + zoneDisplayTestData[testNum].expectedDisplayName, + name); + } + } + delete zone; + } + if (sawAnError) { + dataerrln("***Note: Errors could be the result of changes to zoneStrings locale data"); + } +} + +void TimeZoneTest::TestGetRegion() +{ + static const struct { + const char *id; + const char *region; + } data[] = { + {"America/Los_Angeles", "US"}, + {"America/Indianapolis", "US"}, // CLDR canonical, Olson backward + {"America/Indiana/Indianapolis", "US"}, // CLDR alias + {"Mexico/General", "MX"}, // Link America/Mexico_City, Olson backward + {"Etc/UTC", "001"}, + {"EST5EDT", "001"}, + {"PST", "US"}, // Link America/Los_Angeles + {"Europe/Helsinki", "FI"}, + {"Europe/Mariehamn", "AX"}, // Link Europe/Helsinki, but in zone.tab + {"Asia/Riyadh", "SA"}, + {"Asia/Riyadh87", "001"}, // this should be "SA" actually, but not in zone.tab + {"Etc/Unknown", 0}, // CLDR canonical, but not a sysmte zone ID + {"bogus", 0}, // bogus + {"GMT+08:00", 0}, // a custom ID, not a system zone ID + {0, 0} + }; + + int32_t i; + char region[4]; + UErrorCode sts; + for (i = 0; data[i].id; i++) { + sts = U_ZERO_ERROR; + TimeZone::getRegion(data[i].id, region, sizeof(region), sts); + if (U_SUCCESS(sts)) { + if (data[i].region == 0) { + errln((UnicodeString)"Fail: getRegion(\"" + data[i].id + "\") returns " + + region + " [expected: U_ILLEGAL_ARGUMENT_ERROR]"); + } else if (uprv_strcmp(region, data[i].region) != 0) { + errln((UnicodeString)"Fail: getRegion(\"" + data[i].id + "\") returns " + + region + " [expected: " + data[i].region + "]"); + } + } else if (sts == U_ILLEGAL_ARGUMENT_ERROR) { + if (data[i].region != 0) { + dataerrln((UnicodeString)"Fail: getRegion(\"" + data[i].id + + "\") returns error status U_ILLEGAL_ARGUMENT_ERROR [expected: " + + data[i].region + "]"); + } + } else { + errln((UnicodeString)"Fail: getRegion(\"" + data[i].id + + "\") returns an unexpected error status"); + } + } + + // Extra test cases for short buffer + int32_t len; + char region2[2]; + sts = U_ZERO_ERROR; + + len = TimeZone::getRegion("America/New_York", region2, sizeof(region2), sts); + if (sts == U_ILLEGAL_ARGUMENT_ERROR) { + dataerrln("Error calling TimeZone::getRegion"); + } else { + if (sts != U_STRING_NOT_TERMINATED_WARNING) { + errln("Expected U_STRING_NOT_TERMINATED_WARNING"); + } + if (len != 2) { // length of "US" + errln("Incorrect result length"); + } + if (uprv_strncmp(region2, "US", 2) != 0) { + errln("Incorrect result"); + } + } + + char region1[1]; + sts = U_ZERO_ERROR; + + len = TimeZone::getRegion("America/Chicago", region1, sizeof(region1), sts); + if (sts == U_ILLEGAL_ARGUMENT_ERROR) { + dataerrln("Error calling TimeZone::getRegion"); + } else { + if (sts != U_BUFFER_OVERFLOW_ERROR) { + errln("Expected U_BUFFER_OVERFLOW_ERROR"); + } + if (len != 2) { // length of "US" + errln("Incorrect result length"); + } + } +} + +void TimeZoneTest::TestGetUnknown() { + const TimeZone &unknown = TimeZone::getUnknown(); + UnicodeString expectedID = UNICODE_STRING_SIMPLE("Etc/Unknown"); + UnicodeString id; + assertEquals("getUnknown() wrong ID", expectedID, unknown.getID(id)); + assertTrue("getUnknown() wrong offset", 0 == unknown.getRawOffset()); + assertFalse("getUnknown() uses DST", unknown.useDaylightTime()); +} + +#endif /* #if !UCONFIG_NO_FORMATTING */ |