Update ICU to 54.1 step 1

source/test/intltest/tztest.cpp

 /***********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2013, International Business Machines Corporation
+ * Copyright (c) 1997-2014, 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
@@ skipping 23 matching lines @@
     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(TestCanonicalIDAPI);
     TESTCASE_AUTO(TestCanonicalID);
     TESTCASE_AUTO(TestDisplayNamesMeta);
     TESTCASE_AUTO(TestGetRegion);
     TESTCASE_AUTO(TestGetAvailableIDsNew);
     TESTCASE_AUTO(TestGetUnknown);
     TESTCASE_AUTO(TestGetWindowsID);
     TESTCASE_AUTO(TestGetIDForWindowsID);
     TESTCASE_AUTO_END;
 }
 
@@ skipping 24 matching lines @@
     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");
+
+    TimeZone::adoptDefault(zone);
+    TimeZone* defaultzone = TimeZone::createDefault();
+    if (defaultzone == zone ||
+        !(*defaultzone == *zone))
+        errln("FAIL: createDefault failed");
+    TimeZone::adoptDefault(saveDefault);
+    delete defaultzone;
+    delete zoneclone;
 
     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);
     }
 }
@@ skipping 698 matching lines @@
         {"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
+        {"CAT", 120, FALSE},  // ICU Link - Africa/Maputo
+        {"ART", 120, TRUE},   // 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
@@ skipping 77 matching lines @@
     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",
+        "CAT", "Africa/Maputo",
         "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",
@@ skipping 932 matching lines @@
         { 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) {
+    for (t = 0; t < UPRV_LENGTHOF(timezones); ++t) {
         tz = timezones[t];
-        for (i = 0; i < LENGTHOF(data); ++i) {
+        for (i = 0; i < UPRV_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::TestCanonicalIDAPI() {
+    // Bogus input string.
+    UnicodeString bogus;
+    bogus.setToBogus();
+    UnicodeString canonicalID;
+    UErrorCode ec = U_ZERO_ERROR;
+    UnicodeString *pResult = &TimeZone::getCanonicalID(bogus, canonicalID, ec);
+    assertEquals("TimeZone::getCanonicalID(bogus) should fail", U_ILLEGAL_ARGUMENT_ERROR, ec);
+    assertTrue("TimeZone::getCanonicalID(bogus) should return the dest string", pResult == &canonicalID);
+
+    // U_FAILURE on input.
+    UnicodeString berlin("Europe/Berlin");
+    ec = U_MEMORY_ALLOCATION_ERROR;
+    pResult = &TimeZone::getCanonicalID(berlin, canonicalID, ec);
+    assertEquals("TimeZone::getCanonicalID(failure) should fail", U_MEMORY_ALLOCATION_ERROR, ec);
+    assertTrue("TimeZone::getCanonicalID(failure) should return the dest string", pResult == &canonicalID);
+
+    // Valid input should un-bogus the dest string.
+    canonicalID.setToBogus();
+    ec = U_ZERO_ERROR;
+    pResult = &TimeZone::getCanonicalID(berlin, canonicalID, ec);
+    assertSuccess("TimeZone::getCanonicalID(bogus dest) should succeed", ec, TRUE);
+    assertTrue("TimeZone::getCanonicalID(bogus dest) should return the dest string", pResult == &canonicalID);
+    assertFalse("TimeZone::getCanonicalID(bogus dest) should un-bogus the dest string", canonicalID.isBogus());
+    assertEquals("TimeZone::getCanonicalID(bogus dest) unexpected result", canonicalID, berlin, TRUE);
+}
+
 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[] = {
+        {"Africa/Bamako", "Africa/Abidjan"},
+        {"Africa/Bangui", "Africa/Lagos"},
+        {"Africa/Banjul", "Africa/Abidjan"},
+        {"Africa/Blantyre", "Africa/Maputo"},
+        {"Africa/Brazzaville", "Africa/Lagos"},
+        {"Africa/Bujumbura", "Africa/Maputo"},
+        {"Africa/Conakry", "Africa/Abidjan"},
+        {"Africa/Dakar", "Africa/Abidjan"},
+        {"Africa/Douala", "Africa/Lagos"},
+        {"Africa/Freetown", "Africa/Abidjan"},
+        {"Africa/Gaborone", "Africa/Maputo"},
+        {"Africa/Harare", "Africa/Maputo"},
         {"Africa/Khartoum", "Africa/Juba"},
-        {"America/Shiprock", "America/Denver"}, // America/Shiprock is defined as a Link to America/Denver in tzdata
+        {"Africa/Kigali", "Africa/Maputo"},
+        {"Africa/Kinshasa", "Africa/Lagos"},
+        {"Africa/Libreville", "Africa/Lagos"},
+        {"Africa/Lome", "Africa/Abidjan"},
+        {"Africa/Luanda", "Africa/Lagos"},
+        {"Africa/Lubumbashi", "Africa/Maputo"},
+        {"Africa/Lusaka", "Africa/Maputo"},
+        {"Africa/Maseru", "Africa/Johannesburg"},
+        {"Africa/Malabo", "Africa/Lagos"},
+        {"Africa/Mbabane", "Africa/Johannesburg"},
+        {"Africa/Niamey", "Africa/Lagos"},
+        {"Africa/Nouakchott", "Africa/Abidjan"},
+        {"Africa/Ouagadougou", "Africa/Abidjan"},
+        {"Africa/Porto-Novo", "Africa/Lagos"},
+        {"Africa/Sao_Tome", "Africa/Abidjan"},
+        {"America/Curacao", "America/Aruba"},
         {"America/Dominica", "America/Anguilla"},
         {"America/Grenada", "America/Anguilla"},
         {"America/Guadeloupe", "America/Anguilla"},
+        {"America/Kralendijk", "America/Aruba"},
+        {"America/Lower_Princes", "America/Aruba"},
         {"America/Marigot", "America/Anguilla"},
         {"America/Montserrat", "America/Anguilla"},
         {"America/Port_of_Spain", "America/Anguilla"},
+        {"America/Shiprock", "America/Denver"}, // America/Shiprock is defined as a Link to America/Denver in tzdata
         {"America/St_Barthelemy", "America/Anguilla"},
         {"America/St_Kitts", "America/Anguilla"},
         {"America/St_Lucia", "America/Anguilla"},
         {"America/St_Thomas", "America/Anguilla"},
         {"America/St_Vincent", "America/Anguilla"},
         {"America/Tortola", "America/Anguilla"},
         {"America/Virgin", "America/Anguilla"},
-        {"America/Curacao", "America/Aruba"},
-        {"America/Kralendijk", "America/Aruba"},
-        {"America/Lower_Princes", "America/Aruba"},
         {"Antarctica/South_Pole", "Antarctica/McMurdo"},
+        {"Arctic/Longyearbyen", "Europe/Oslo"},
         {"Atlantic/Jan_Mayen", "Europe/Oslo"},
-        {"Arctic/Longyearbyen", "Europe/Oslo"},
+        {"Atlantic/St_Helena", "Africa/Abidjan"},
+        {"Europe/Bratislava", "Europe/Prague"},
         {"Europe/Busingen", "Europe/Zurich"},
         {"Europe/Guernsey", "Europe/London"},
         {"Europe/Isle_of_Man", "Europe/London"},
         {"Europe/Jersey", "Europe/London"},
         {"Europe/Ljubljana", "Europe/Belgrade"},
+        {"Europe/Mariehamn", "Europe/Helsinki"},
         {"Europe/Podgorica", "Europe/Belgrade"},
+        {"Europe/San_Marino", "Europe/Rome"},
         {"Europe/Sarajevo", "Europe/Belgrade"},
         {"Europe/Skopje", "Europe/Belgrade"},
+        {"Europe/Vaduz", "Europe/Zurich"},
+        {"Europe/Vatican", "Europe/Rome"},
         {"Europe/Zagreb", "Europe/Belgrade"},
-        {"Europe/Bratislava", "Europe/Prague"},
-        {"Europe/Mariehamn", "Europe/Helsinki"},
-        {"Europe/San_Marino", "Europe/Rome"},
-        {"Europe/Vatican", "Europe/Rome"},
-        {"Europe/Vaduz", "Europe/Zurich"},
         {"Pacific/Auckland", "Antarctica/McMurdo"},
         {"Pacific/Johnston", "Pacific/Honolulu"},
         {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
@@ skipping 230 matching lines @@
         {"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
+        // tz file solar87 was removed from tzdata2013i
+        // {"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++) {
@@ skipping 116 matching lines @@
         UnicodeString id;
 
         TimeZone::getIDForWindowsID(UnicodeString(TESTDATA[i].winid), TESTDATA[i].region,
                                     id, sts);
         assertSuccess(UnicodeString(TESTDATA[i].winid) + "/" + TESTDATA[i].region, sts);
         assertEquals(UnicodeString(TESTDATA[i].winid) + "/" + TESTDATA[i].region, TESTDATA[i].id, id, TRUE);
     }
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */