source/test/cintltst/ccaltst.c

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /********************************************************************
   4  * Copyright (c) 1997-2016, International Business Machines
   5  * Corporation and others. All Rights Reserved.
   6  ********************************************************************
   7  *
   8  * File CCALTST.C
   9  *
  10  * Modification History:
  11  *        Name                     Description
  12  *     Madhu Katragadda               Creation
  13  ********************************************************************
  14  */
  15
  16 /* C API AND FUNCTIONALITY TEST FOR CALENDAR (ucol.h)*/
  17
  18 #include "unicode/utypes.h"
  19
  20 #if !UCONFIG_NO_FORMATTING
  21
  22 #include <stdlib.h>
  23 #include <string.h>
  24
  25 #include "unicode/uloc.h"
  26 #include "unicode/ucal.h"
  27 #include "unicode/udat.h"
  28 #include "unicode/ustring.h"
  29 #include "cintltst.h"
  30 #include "ccaltst.h"
  31 #include "cformtst.h"
  32 #include "cmemory.h"
  33 #include "cstring.h"
  34 #include "ulist.h"
  35
  36 void TestGregorianChange(void);
  37 void TestFieldDifference(void);
  38 void TestAddRollEra0AndEraBounds(void);
  39 void TestGetTZTransition(void);
  40
  41 void TestGetWindowsTimeZoneID(void);
  42 void TestGetTimeZoneIDByWindowsID(void);
  43
  44 void addCalTest(TestNode** root);
  45
  46 void addCalTest(TestNode** root)
  47 {
  48
  49     addTest(root, &TestCalendar, "tsformat/ccaltst/TestCalendar");
  50     addTest(root, &TestGetSetDateAPI, "tsformat/ccaltst/TestGetSetDateAPI");
  51     addTest(root, &TestFieldGetSet, "tsformat/ccaltst/TestFieldGetSet");
  52     addTest(root, &TestAddRollExtensive, "tsformat/ccaltst/TestAddRollExtensive");
  53     addTest(root, &TestGetLimits, "tsformat/ccaltst/TestGetLimits");
  54     addTest(root, &TestDOWProgression, "tsformat/ccaltst/TestDOWProgression");
  55     addTest(root, &TestGMTvsLocal, "tsformat/ccaltst/TestGMTvsLocal");
  56     addTest(root, &TestGregorianChange, "tsformat/ccaltst/TestGregorianChange");
  57     addTest(root, &TestGetKeywordValuesForLocale, "tsformat/ccaltst/TestGetKeywordValuesForLocale");
  58     addTest(root, &TestWeekend, "tsformat/ccaltst/TestWeekend");
  59     addTest(root, &TestFieldDifference, "tsformat/ccaltst/TestFieldDifference");
  60     addTest(root, &TestAmbiguousWallTime, "tsformat/ccaltst/TestAmbiguousWallTime");
  61     addTest(root, &TestAddRollEra0AndEraBounds, "tsformat/ccaltst/TestAddRollEra0AndEraBounds");
  62     addTest(root, &TestGetTZTransition, "tsformat/ccaltst/TestGetTZTransition");
  63     addTest(root, &TestGetWindowsTimeZoneID, "tsformat/ccaltst/TestGetWindowsTimeZoneID");
  64     addTest(root, &TestGetTimeZoneIDByWindowsID, "tsformat/ccaltst/TestGetTimeZoneIDByWindowsID");
  65 }
  66
  67 /* "GMT" */
  68 static const UChar fgGMTID [] = { 0x0047, 0x004d, 0x0054, 0x0000 };
  69
  70 /* "PST" */
  71 static const UChar PST[] = {0x50, 0x53, 0x54, 0x00}; /* "PST" */
  72
  73 static const UChar EUROPE_PARIS[] = {0x45, 0x75, 0x72, 0x6F, 0x70, 0x65, 0x2F, 0x50, 0x61, 0x72, 0x69, 0x73, 0x00}; /* "Europe/Paris" */
  74
  75 static const UChar AMERICA_LOS_ANGELES[] = {0x41, 0x6D, 0x65, 0x72, 0x69, 0x63, 0x61, 0x2F,
  76     0x4C, 0x6F, 0x73, 0x5F, 0x41, 0x6E, 0x67, 0x65, 0x6C, 0x65, 0x73, 0x00}; /* America/Los_Angeles */
  77
  78 typedef struct {
  79     const char *    locale;
  80     UCalendarType   calType;
  81     const char *    expectedResult;
  82 } UCalGetTypeTest;
  83
  84 static const UCalGetTypeTest ucalGetTypeTests[] = {
  85     { "en_US",                   UCAL_GREGORIAN, "gregorian" },
  86     { "ja_JP@calendar=japanese", UCAL_DEFAULT,   "japanese"  },
  87     { "th_TH",                   UCAL_GREGORIAN, "gregorian" },
  88     { "th_TH",                   UCAL_DEFAULT,   "buddhist"  },
  89     { "th-TH-u-ca-gregory",      UCAL_DEFAULT,   "gregorian" },
  90     { "ja_JP@calendar=japanese", UCAL_GREGORIAN, "gregorian" },
  91     { "fr_CH",                   UCAL_DEFAULT,   "gregorian" },
  92     { "fr_SA",                   UCAL_DEFAULT,   "islamic-umalqura" },
  93     { "fr_CH@rg=sazzzz",         UCAL_DEFAULT,   "islamic-umalqura" },
  94     { "fr_CH@calendar=japanese;rg=sazzzz", UCAL_DEFAULT, "japanese" },
  95     { "fr_TH@rg=SA",             UCAL_DEFAULT,   "buddhist"  }, /* ignore malformed rg tag */
  96     { "th@rg=SA",                UCAL_DEFAULT,   "buddhist"  }, /* ignore malformed rg tag */
  97     { "",                        UCAL_GREGORIAN, "gregorian" },
  98     { NULL,                      UCAL_GREGORIAN, "gregorian" },
  99     { NULL, 0, NULL } /* terminator */
 100 };
 101
 102 static void TestCalendar()
 103 {
 104     UCalendar *caldef = 0, *caldef2 = 0, *calfr = 0, *calit = 0, *calfrclone = 0;
 105     UEnumeration* uenum = NULL;
 106     int32_t count, count2, i,j;
 107     UChar tzID[4];
 108     UChar *tzdname = 0;
 109     UErrorCode status = U_ZERO_ERROR;
 110     UDate now;
 111     UDateFormat *datdef = 0;
 112     UChar *result = 0;
 113     int32_t resultlength, resultlengthneeded;
 114     char tempMsgBuf[256];
 115     UChar zone1[32], zone2[32];
 116     const char *tzver = 0;
 117     UChar canonicalID[64];
 118     UBool isSystemID = FALSE;
 119     const UCalGetTypeTest * ucalGetTypeTestPtr;
 120
 121 #ifdef U_USE_UCAL_OBSOLETE_2_8
 122     /*Testing countAvailableTimeZones*/
 123     int32_t offset=0;
 124     log_verbose("\nTesting ucal_countAvailableTZIDs\n");
 125     count=ucal_countAvailableTZIDs(offset);
 126     log_verbose("The number of timezone id's present with offset 0 are %d:\n", count);
 127     if(count < 5) /* Don't hard code an exact == test here! */
 128         log_err("FAIL: error in the ucal_countAvailableTZIDs - got %d expected at least 5 total\n", count);
 129
 130     /*Testing getAvailableTZIDs*/
 131     log_verbose("\nTesting ucal_getAvailableTZIDs");
 132     for(i=0;i<count;i++){
 133         ucal_getAvailableTZIDs(offset, i, &status);
 134         if(U_FAILURE(status)){
 135             log_err("FAIL: ucal_getAvailableTZIDs returned %s\n", u_errorName(status));
 136         }
 137         log_verbose("%s\n", u_austrcpy(tempMsgBuf, ucal_getAvailableTZIDs(offset, i, &status)));
 138     }
 139     /*get Illegal TZID where index >= count*/
 140     ucal_getAvailableTZIDs(offset, i, &status);
 141     if(status != U_INDEX_OUTOFBOUNDS_ERROR){
 142         log_err("FAIL:for TZID index >= count Expected INDEX_OUTOFBOUNDS_ERROR Got %s\n", u_errorName(status));
 143     }
 144     status=U_ZERO_ERROR;
 145 #endif
 146
 147     /*Test ucal_openTimeZones, ucal_openCountryTimeZones and ucal_openTimeZoneIDEnumeration */
 148     for (j=0; j<6; ++j) {
 149         const char *api = "?";
 150         const int32_t offsetMinus5 = -5*60*60*1000;
 151         switch (j) {
 152         case 0:
 153             api = "ucal_openTimeZones()";
 154             uenum = ucal_openTimeZones(&status);
 155             break;
 156         case 1:
 157             api = "ucal_openCountryTimeZones(US)";
 158             uenum = ucal_openCountryTimeZones("US", &status);
 159             break;
 160         case 2:
 161             api = "ucal_openTimeZoneIDEnumerarion(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL)";
 162             uenum = ucal_openTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL, NULL, NULL, &status);
 163             break;
 164         case 3:
 165             api = "ucal_openTimeZoneIDEnumerarion(UCAL_ZONE_TYPE_CANONICAL_LOCATION, CA, NULL)";
 166             uenum = ucal_openTimeZoneIDEnumeration(UCAL_ZONE_TYPE_CANONICAL_LOCATION, "CA", NULL, &status);
 167             break;
 168         case 4:
 169             api = "ucal_openTimeZoneIDEnumerarion(UCAL_ZONE_TYPE_ANY, NULL, -5 hour)";
 170             uenum = ucal_openTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, NULL, &offsetMinus5, &status);
 171             break;
 172         case 5:
 173             api = "ucal_openTimeZoneIDEnumerarion(UCAL_ZONE_TYPE_ANY, US, -5 hour)";
 174             uenum = ucal_openTimeZoneIDEnumeration(UCAL_ZONE_TYPE_ANY, "US", &offsetMinus5, &status);
 175             break;
 176         }
 177         if (U_FAILURE(status)) {
 178             log_err_status(status, "FAIL: %s failed with %s\n", api,
 179                     u_errorName(status));
 180         } else {
 181             const char* id;
 182             int32_t len;
 183             count = uenum_count(uenum, &status);
 184             log_verbose("%s returned %d timezone id's:\n", api, count);
 185             if (count < 5) { /* Don't hard code an exact == test here! */
 186                 log_data_err("FAIL: in %s, got %d, expected at least 5 -> %s (Are you missing data?)\n", api, count, u_errorName(status));
 187             }
 188             uenum_reset(uenum, &status);
 189             if (U_FAILURE(status)){
 190                 log_err("FAIL: uenum_reset for %s returned %s\n",
 191                         api, u_errorName(status));
 192             }
 193             for (i=0; i<count; i++) {
 194                 id = uenum_next(uenum, &len, &status);
 195                 if (U_FAILURE(status)){
 196                     log_err("FAIL: uenum_next for %s returned %s\n",
 197                             api, u_errorName(status));
 198                 } else {
 199                     log_verbose("%s\n", id);
 200                 }
 201             }
 202             /* Next one should be NULL */
 203             id = uenum_next(uenum, &len, &status);
 204             if (id != NULL) {
 205                 log_err("FAIL: uenum_next for %s returned %s, expected NULL\n",
 206                         api, id);
 207             }
 208         }
 209         uenum_close(uenum);
 210     }
 211
 212     /*Test ucal_getDSTSavings*/
 213     status = U_ZERO_ERROR;
 214     i = ucal_getDSTSavings(fgGMTID, &status);
 215     if (U_FAILURE(status)) {
 216         log_err("FAIL: ucal_getDSTSavings(GMT) => %s\n",
 217                 u_errorName(status));
 218     } else if (i != 0) {
 219         log_data_err("FAIL: ucal_getDSTSavings(GMT) => %d, expect 0 (Are you missing data?)\n", i);
 220     }
 221     i = ucal_getDSTSavings(PST, &status);
 222     if (U_FAILURE(status)) {
 223         log_err("FAIL: ucal_getDSTSavings(PST) => %s\n",
 224                 u_errorName(status));
 225     } else if (i != 1*60*60*1000) {
 226         log_err("FAIL: ucal_getDSTSavings(PST) => %d, expect %d\n", i, 1*60*60*1000);
 227     }
 228
 229     /*Test ucal_set/getDefaultTimeZone*/
 230     status = U_ZERO_ERROR;
 231     i = ucal_getDefaultTimeZone(zone1, UPRV_LENGTHOF(zone1), &status);
 232     if (U_FAILURE(status)) {
 233         log_err("FAIL: ucal_getDefaultTimeZone() => %s\n",
 234                 u_errorName(status));
 235     } else {
 236         ucal_setDefaultTimeZone(EUROPE_PARIS, &status);
 237         if (U_FAILURE(status)) {
 238             log_err("FAIL: ucal_setDefaultTimeZone(Europe/Paris) => %s\n",
 239                     u_errorName(status));
 240         } else {
 241             i = ucal_getDefaultTimeZone(zone2, UPRV_LENGTHOF(zone2), &status);
 242             if (U_FAILURE(status)) {
 243                 log_err("FAIL: ucal_getDefaultTimeZone() => %s\n",
 244                         u_errorName(status));
 245             } else {
 246                 if (u_strcmp(zone2, EUROPE_PARIS) != 0) {
 247                     log_data_err("FAIL: ucal_getDefaultTimeZone() did not return Europe/Paris (Are you missing data?)\n");
 248                 }
 249             }
 250         }
 251         status = U_ZERO_ERROR;
 252         ucal_setDefaultTimeZone(zone1, &status);
 253     }
 254
 255     /*Test ucal_getTZDataVersion*/
 256     status = U_ZERO_ERROR;
 257     tzver = ucal_getTZDataVersion(&status);
 258     if (U_FAILURE(status)) {
 259         log_err_status(status, "FAIL: ucal_getTZDataVersion() => %s\n", u_errorName(status));
 260     } else if (uprv_strlen(tzver) != 5 /*4 digits + 1 letter*/) {
 261         log_err("FAIL: Bad version string was returned by ucal_getTZDataVersion\n");
 262     } else {
 263         log_verbose("PASS: ucal_getTZDataVersion returned %s\n", tzver);
 264     }
 265
 266     /*Testing ucal_getCanonicalTimeZoneID*/
 267     status = U_ZERO_ERROR;
 268     resultlength = ucal_getCanonicalTimeZoneID(PST, -1,
 269         canonicalID, UPRV_LENGTHOF(canonicalID), &isSystemID, &status);
 270     if (U_FAILURE(status)) {
 271         log_data_err("FAIL: error in ucal_getCanonicalTimeZoneID : %s\n", u_errorName(status));
 272     } else {
 273         if (u_strcmp(AMERICA_LOS_ANGELES, canonicalID) != 0) {
 274             log_data_err("FAIL: ucal_getCanonicalTimeZoneID(%s) returned %s : expected - %s (Are you missing data?)\n",
 275                 PST, canonicalID, AMERICA_LOS_ANGELES);
 276         }
 277         if (!isSystemID) {
 278             log_data_err("FAIL: ucal_getCanonicalTimeZoneID(%s) set %d to isSystemID (Are you missing data?)\n",
 279                 PST, isSystemID);
 280         }
 281     }
 282
 283     /*Testing the  ucal_open() function*/
 284     status = U_ZERO_ERROR;
 285     log_verbose("\nTesting the ucal_open()\n");
 286     u_uastrcpy(tzID, "PST");
 287     caldef=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
 288     if(U_FAILURE(status)){
 289         log_data_err("FAIL: error in ucal_open caldef : %s\n - (Are you missing data?)", u_errorName(status));
 290     }
 291
 292     caldef2=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
 293     if(U_FAILURE(status)){
 294         log_data_err("FAIL: error in ucal_open caldef : %s - (Are you missing data?)\n", u_errorName(status));
 295     }
 296     u_strcpy(tzID, fgGMTID);
 297     calfr=ucal_open(tzID, u_strlen(tzID), "fr_FR", UCAL_TRADITIONAL, &status);
 298     if(U_FAILURE(status)){
 299         log_data_err("FAIL: error in ucal_open calfr : %s - (Are you missing data?)\n", u_errorName(status));
 300     }
 301     calit=ucal_open(tzID, u_strlen(tzID), "it_IT", UCAL_TRADITIONAL, &status);
 302     if(U_FAILURE(status))    {
 303         log_data_err("FAIL: error in ucal_open calit : %s - (Are you missing data?)\n", u_errorName(status));
 304     }
 305
 306     /*Testing the  clone() function*/
 307     calfrclone = ucal_clone(calfr, &status);
 308     if(U_FAILURE(status)){
 309         log_data_err("FAIL: error in ucal_clone calfr : %s - (Are you missing data?)\n", u_errorName(status));
 310     }
 311
 312     /*Testing udat_getAvailable() and udat_countAvailable()*/
 313     log_verbose("\nTesting getAvailableLocales and countAvailable()\n");
 314     count=ucal_countAvailable();
 315     /* use something sensible w/o hardcoding the count */
 316     if(count > 0) {
 317         log_verbose("PASS: ucal_countAvailable() works fine\n");
 318         log_verbose("The no: of locales for which calendars are avilable are %d\n", count);
 319     } else {
 320         log_data_err("FAIL: Error in countAvailable()\n");
 321     }
 322
 323     for(i=0;i<count;i++) {
 324        log_verbose("%s\n", ucal_getAvailable(i));
 325     }
 326
 327
 328     /*Testing the equality between calendar's*/
 329     log_verbose("\nTesting ucal_equivalentTo()\n");
 330     if(caldef && caldef2 && calfr && calit) {
 331       if(ucal_equivalentTo(caldef, caldef2) == FALSE || ucal_equivalentTo(caldef, calfr)== TRUE ||
 332         ucal_equivalentTo(caldef, calit)== TRUE || ucal_equivalentTo(calfr, calfrclone) == FALSE) {
 333           log_data_err("FAIL: Error. equivalentTo test failed (Are you missing data?)\n");
 334       } else {
 335           log_verbose("PASS: equivalentTo test passed\n");
 336       }
 337     }
 338
 339
 340     /*Testing the current time and date using ucal_getnow()*/
 341     log_verbose("\nTesting the ucal_getNow function to check if it is fetching tbe current time\n");
 342     now=ucal_getNow();
 343     /* open the date format and format the date to check the output */
 344     datdef=udat_open(UDAT_FULL,UDAT_FULL ,NULL, NULL, 0,NULL,0,&status);
 345     if(U_FAILURE(status)){
 346         log_data_err("FAIL: error in creating the dateformat : %s (Are you missing data?)\n", u_errorName(status));
 347         return;
 348     }
 349     log_verbose("PASS: The current date and time fetched is %s\n", u_austrcpy(tempMsgBuf, myDateFormat(datdef, now)) );
 350
 351
 352     /*Testing the TimeZoneDisplayName */
 353     log_verbose("\nTesting the fetching of time zone display name\n");
 354     /*for the US locale */
 355     resultlength=0;
 356     resultlengthneeded=ucal_getTimeZoneDisplayName(caldef, UCAL_DST, "en_US", NULL, resultlength, &status);
 357
 358     if(status==U_BUFFER_OVERFLOW_ERROR)
 359     {
 360         status=U_ZERO_ERROR;
 361         resultlength=resultlengthneeded+1;
 362         result=(UChar*)malloc(sizeof(UChar) * resultlength);
 363         ucal_getTimeZoneDisplayName(caldef, UCAL_DST, "en_US", result, resultlength, &status);
 364     }
 365     if(U_FAILURE(status))    {
 366         log_err("FAIL: Error in getting the timezone display name : %s\n", u_errorName(status));
 367     }
 368     else{
 369         log_verbose("PASS: getting the time zone display name successful : %s, %d needed \n",
 370             u_errorName(status), resultlengthneeded);
 371     }
 372
 373
 374 #define expectPDT "Pacific Daylight Time"
 375
 376     tzdname=(UChar*)malloc(sizeof(UChar) * (sizeof(expectPDT)+1));
 377     u_uastrcpy(tzdname, expectPDT);
 378     if(u_strcmp(tzdname, result)==0){
 379         log_verbose("PASS: got the correct time zone display name %s\n", u_austrcpy(tempMsgBuf, result) );
 380     }
 381     else{
 382         log_err("FAIL: got the wrong time zone(DST) display name %s, wanted %s\n", austrdup(result) , expectPDT);
 383     }
 384
 385     ucal_getTimeZoneDisplayName(caldef, UCAL_SHORT_DST, "en_US", result, resultlength, &status);
 386     u_uastrcpy(tzdname, "PDT");
 387     if(u_strcmp(tzdname, result) != 0){
 388         log_err("FAIL: got the wrong time zone(SHORT_DST) display name %s, wanted %s\n", austrdup(result), austrdup(tzdname));
 389     }
 390
 391     ucal_getTimeZoneDisplayName(caldef, UCAL_STANDARD, "en_US", result, resultlength, &status);
 392     u_uastrcpy(tzdname, "Pacific Standard Time");
 393     if(u_strcmp(tzdname, result) != 0){
 394         log_err("FAIL: got the wrong time zone(STANDARD) display name %s, wanted %s\n", austrdup(result), austrdup(tzdname));
 395     }
 396
 397     ucal_getTimeZoneDisplayName(caldef, UCAL_SHORT_STANDARD, "en_US", result, resultlength, &status);
 398     u_uastrcpy(tzdname, "PST");
 399     if(u_strcmp(tzdname, result) != 0){
 400         log_err("FAIL: got the wrong time zone(SHORT_STANDARD) display name %s, wanted %s\n", austrdup(result), austrdup(tzdname));
 401     }
 402
 403
 404     /*testing the setAttributes and getAttributes of a UCalendar*/
 405     log_verbose("\nTesting the getAttributes and set Attributes\n");
 406     count=ucal_getAttribute(calit, UCAL_LENIENT);
 407     count2=ucal_getAttribute(calfr, UCAL_LENIENT);
 408     ucal_setAttribute(calit, UCAL_LENIENT, 0);
 409     ucal_setAttribute(caldef, UCAL_LENIENT, count2);
 410     if( ucal_getAttribute(calit, UCAL_LENIENT) !=0 ||
 411         ucal_getAttribute(calfr, UCAL_LENIENT)!=ucal_getAttribute(caldef, UCAL_LENIENT) )
 412         log_err("FAIL: there is an error in getAttributes or setAttributes\n");
 413     else
 414         log_verbose("PASS: attribute set and got successfully\n");
 415         /*set it back to orginal value */
 416     log_verbose("Setting it back to normal\n");
 417     ucal_setAttribute(calit, UCAL_LENIENT, count);
 418     if(ucal_getAttribute(calit, UCAL_LENIENT)!=count)
 419         log_err("FAIL: Error in setting the attribute back to normal\n");
 420
 421     /*setting the first day of the week to other values  */
 422     count=ucal_getAttribute(calit, UCAL_FIRST_DAY_OF_WEEK);
 423     for (i=1; i<=7; ++i) {
 424         ucal_setAttribute(calit, UCAL_FIRST_DAY_OF_WEEK,i);
 425         if (ucal_getAttribute(calit, UCAL_FIRST_DAY_OF_WEEK) != i)
 426             log_err("FAIL: set/getFirstDayOfWeek failed\n");
 427     }
 428     /*get bogus Attribute*/
 429     count=ucal_getAttribute(calit, (UCalendarAttribute)99); /* BOGUS_ATTRIBUTE */
 430     if(count != -1){
 431         log_err("FAIL: get/bogus attribute should return -1\n");
 432     }
 433
 434     /*set it back to normal */
 435     ucal_setAttribute(calit, UCAL_FIRST_DAY_OF_WEEK,count);
 436     /*setting minimal days of the week to other values */
 437     count=ucal_getAttribute(calit, UCAL_MINIMAL_DAYS_IN_FIRST_WEEK);
 438     for (i=1; i<=7; ++i) {
 439         ucal_setAttribute(calit, UCAL_MINIMAL_DAYS_IN_FIRST_WEEK,i);
 440         if (ucal_getAttribute(calit, UCAL_MINIMAL_DAYS_IN_FIRST_WEEK) != i)
 441             log_err("FAIL: set/getMinimalDaysInFirstWeek failed\n");
 442     }
 443     /*set it back to normal */
 444     ucal_setAttribute(calit, UCAL_MINIMAL_DAYS_IN_FIRST_WEEK,count);
 445
 446
 447     /*testing if the UCalendar's timezone is currently in day light saving's time*/
 448     log_verbose("\nTesting if the UCalendar is currently in daylight saving's time\n");
 449     ucal_setDateTime(caldef, 1999, UCAL_MARCH, 3, 10, 45, 20, &status);
 450     ucal_inDaylightTime(caldef, &status );
 451     if(U_FAILURE(status))    {
 452         log_err("Error in ucal_inDaylightTime: %s\n", u_errorName(status));
 453     }
 454     if(!ucal_inDaylightTime(caldef, &status))
 455         log_verbose("PASS: It is not in daylight saving's time\n");
 456     else
 457         log_err("FAIL: It is not in daylight saving's time\n");
 458
 459     /*closing the UCalendar*/
 460     ucal_close(caldef);
 461     ucal_close(caldef2);
 462     ucal_close(calfr);
 463     ucal_close(calit);
 464     ucal_close(calfrclone);
 465
 466     /*testing ucal_getType, and ucal_open with UCAL_GREGORIAN*/
 467     for (ucalGetTypeTestPtr = ucalGetTypeTests; ucalGetTypeTestPtr->expectedResult != NULL; ++ucalGetTypeTestPtr) {
 468         const char * localeToDisplay = (ucalGetTypeTestPtr->locale != NULL)? ucalGetTypeTestPtr->locale: "<NULL>";
 469         status = U_ZERO_ERROR;
 470         caldef = ucal_open(NULL, 0, ucalGetTypeTestPtr->locale, ucalGetTypeTestPtr->calType, &status);
 471         if ( U_SUCCESS(status) ) {
 472             const char * calType = ucal_getType(caldef, &status);
 473             if ( U_SUCCESS(status) && calType != NULL ) {
 474                 if ( uprv_strcmp( calType, ucalGetTypeTestPtr->expectedResult ) != 0 ) {
 475                     log_err("FAIL: ucal_open %s type %d does not return %s calendar\n", localeToDisplay,
 476                                                 ucalGetTypeTestPtr->calType, ucalGetTypeTestPtr->expectedResult);
 477                 }
 478             } else {
 479                 log_err("FAIL: ucal_open %s type %d, then ucal_getType fails\n", localeToDisplay, ucalGetTypeTestPtr->calType);
 480             }
 481             ucal_close(caldef);
 482         } else {
 483             log_err("FAIL: ucal_open %s type %d fails\n", localeToDisplay, ucalGetTypeTestPtr->calType);
 484         }
 485     }
 486
 487     /*closing the UDateFormat used */
 488     udat_close(datdef);
 489     free(result);
 490     free(tzdname);
 491 }
 492
 493 /*------------------------------------------------------*/
 494 /*Testing the getMillis, setMillis, setDate and setDateTime functions extensively*/
 495
 496 static void TestGetSetDateAPI()
 497 {
 498     UCalendar *caldef = 0, *caldef2 = 0, *caldef3 = 0;
 499     UChar tzID[4];
 500     UDate d1;
 501     int32_t hour;
 502     int32_t zoneOffset;
 503     UDateFormat *datdef = 0;
 504     UErrorCode status=U_ZERO_ERROR;
 505     UDate d2= 837039928046.0;
 506     UChar temp[30];
 507         double testMillis;
 508         int32_t dateBit;
 509     UChar id[4];
 510     int32_t idLen;
 511
 512     log_verbose("\nOpening the calendars()\n");
 513     u_strcpy(tzID, fgGMTID);
 514     /*open the calendars used */
 515     caldef=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
 516     caldef2=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
 517     caldef3=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
 518     /*open the dateformat */
 519     /* this is supposed to open default date format, but later on it treats it like it is "en_US"
 520        - very bad if you try to run the tests on machine where default locale is NOT "en_US" */
 521     /*datdef=udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,NULL,fgGMTID,-1, &status);*/
 522     datdef=udat_open(UDAT_DEFAULT,UDAT_DEFAULT ,"en_US",fgGMTID,-1,NULL,0, &status);
 523     if(U_FAILURE(status))
 524     {
 525         log_data_err("error in creating the dateformat : %s (Are you missing data?)\n", u_errorName(status));
 526         return;
 527     }
 528
 529     /*Testing getMillis and setMillis */
 530     log_verbose("\nTesting the date and time fetched in millis for a calendar using getMillis\n");
 531     d1=ucal_getMillis(caldef, &status);
 532     if(U_FAILURE(status)){
 533         log_err("Error in getMillis : %s\n", u_errorName(status));
 534     }
 535
 536     /*testing setMillis */
 537     log_verbose("\nTesting the set date and time function using setMillis\n");
 538     ucal_setMillis(caldef, d2, &status);
 539     if(U_FAILURE(status)){
 540         log_err("Error in setMillis : %s\n", u_errorName(status));
 541     }
 542
 543     /*testing if the calendar date is set properly or not  */
 544     d1=ucal_getMillis(caldef, &status);
 545     if(u_strcmp(myDateFormat(datdef, d1), myDateFormat(datdef, d2))!=0)
 546         log_err("error in setMillis or getMillis\n");
 547     /*-------------------*/
 548
 549     /*testing large negative millis*/
 550         /*test a previously failed millis and beyond the lower bounds - ICU trac #9403 */
 551         // -184303902611600000.0         - just beyond lower bounds (#9403 sets U_ILLEGAL_ARGUMENT_ERROR in strict mode)
 552         // -46447814188001000.0          - fixed by #9403
 553
 554     log_verbose("\nTesting very large valid millis & invalid setMillis values (in both strict & lienent modes) detected\n");
 555
 556         testMillis = -46447814188001000.0;      // point where floorDivide in handleComputeFields failed as per #9403
 557         log_verbose("using value[%lf]\n", testMillis);
 558     ucal_setAttribute(caldef3, UCAL_LENIENT, 0);
 559     ucal_setMillis(caldef3, testMillis, &status);
 560         if(U_FAILURE(status)){
 561                 log_err("Fail: setMillis incorrectly detected invalid value : for millis : %e : returned  : %s\n", testMillis, u_errorName(status));
 562                 status = U_ZERO_ERROR;
 563         }
 564
 565     log_verbose("\nTesting invalid setMillis values detected\n");
 566         testMillis = -184303902611600000.0;
 567         log_verbose("using value[%lf]\n", testMillis);
 568     ucal_setAttribute(caldef3, UCAL_LENIENT, 1);
 569         ucal_setMillis(caldef3, testMillis, &status);
 570         if(U_FAILURE(status)){
 571                 log_err("Fail: setMillis incorrectly detected invalid value : for millis : %e : returned  : %s\n", testMillis, u_errorName(status));
 572                 status = U_ZERO_ERROR;
 573         } else {
 574         dateBit = ucal_get(caldef2, UCAL_MILLISECOND, &status);
 575         if(testMillis == dateBit)
 576         {
 577                     log_err("Fail: error in setMillis, allowed invalid value %e : returns millisecond : %d", testMillis, dateBit);
 578         } else {
 579             log_verbose("Pass: setMillis correctly pinned min, returned : %d", dateBit);
 580         }
 581         }
 582
 583     log_verbose("\nTesting invalid setMillis values detected\n");
 584         testMillis = -184303902611600000.0;
 585         log_verbose("using value[%lf]\n", testMillis);
 586     ucal_setAttribute(caldef3, UCAL_LENIENT, 0);
 587         ucal_setMillis(caldef3, testMillis, &status);
 588         if(U_FAILURE(status)){
 589                 log_verbose("Pass: Illegal argument error as expected : for millis : %e : returned  : %s\n", testMillis, u_errorName(status));
 590                 status = U_ZERO_ERROR;
 591         } else {
 592                 dateBit = ucal_get(caldef3, UCAL_DAY_OF_MONTH, &status);
 593                 log_err("Fail: error in setMillis, allowed invalid value %e : returns DayOfMonth : %d", testMillis, dateBit);
 594         }
 595         /*-------------------*/
 596
 597
 598     ctest_setTimeZone(NULL, &status);
 599
 600     /*testing ucal_setTimeZone() and ucal_getTimeZoneID function*/
 601     log_verbose("\nTesting if the function ucal_setTimeZone() and ucal_getTimeZoneID work fine\n");
 602     idLen = ucal_getTimeZoneID(caldef2, id, UPRV_LENGTHOF(id), &status);
 603     (void)idLen;    /* Suppress set but not used warning. */
 604     if (U_FAILURE(status)) {
 605         log_err("Error in getTimeZoneID : %s\n", u_errorName(status));
 606     } else if (u_strcmp(id, fgGMTID) != 0) {
 607         log_err("FAIL: getTimeZoneID returns a wrong ID: actual=%d, expected=%s\n", austrdup(id), austrdup(fgGMTID));
 608     } else {
 609         log_verbose("PASS: getTimeZoneID works fine\n");
 610     }
 611
 612     ucal_setMillis(caldef2, d2, &status);
 613     if(U_FAILURE(status)){
 614         log_err("Error in getMillis : %s\n", u_errorName(status));
 615     }
 616     hour=ucal_get(caldef2, UCAL_HOUR_OF_DAY, &status);
 617
 618     u_uastrcpy(tzID, "PST");
 619     ucal_setTimeZone(caldef2,tzID, 3, &status);
 620     if(U_FAILURE(status)){
 621         log_err("Error in setting the time zone using ucal_setTimeZone(): %s\n", u_errorName(status));
 622     }
 623     else
 624         log_verbose("ucal_setTimeZone worked fine\n");
 625
 626     idLen = ucal_getTimeZoneID(caldef2, id, UPRV_LENGTHOF(id), &status);
 627     if (U_FAILURE(status)) {
 628         log_err("Error in getTimeZoneID : %s\n", u_errorName(status));
 629     } else if (u_strcmp(id, tzID) != 0) {
 630         log_err("FAIL: getTimeZoneID returns a wrong ID: actual=%d, expected=%s\n", austrdup(id), austrdup(tzID));
 631     } else {
 632         log_verbose("PASS: getTimeZoneID works fine\n");
 633     }
 634
 635     if(hour == ucal_get(caldef2, UCAL_HOUR_OF_DAY, &status))
 636         log_err("FAIL: Error setting the time zone doesn't change the represented time\n");
 637     else if((hour-8 + 1) != ucal_get(caldef2, UCAL_HOUR_OF_DAY, &status)) /*because it is not in daylight savings time */
 638         log_err("FAIL: Error setTimeZone doesn't change the represented time correctly with 8 hour offset\n");
 639     else
 640         log_verbose("PASS: setTimeZone works fine\n");
 641
 642     /*testing setTimeZone roundtrip */
 643     log_verbose("\nTesting setTimeZone() roundtrip\n");
 644     u_strcpy(tzID, fgGMTID);
 645     ucal_setTimeZone(caldef2, tzID, 3, &status);
 646     if(U_FAILURE(status)){
 647         log_err("Error in setting the time zone using ucal_setTimeZone(): %s\n", u_errorName(status));
 648     }
 649     if(d2==ucal_getMillis(caldef2, &status))
 650         log_verbose("PASS: setTimeZone roundtrip test passed\n");
 651     else
 652         log_err("FAIL: setTimeZone roundtrip test failed\n");
 653
 654     zoneOffset = ucal_get(caldef2, UCAL_ZONE_OFFSET, &status);
 655     if(U_FAILURE(status)){
 656         log_err("Error in getting the time zone using ucal_get() after using ucal_setTimeZone(): %s\n", u_errorName(status));
 657     }
 658     else if (zoneOffset != 0) {
 659         log_err("Error in getting the time zone using ucal_get() after using ucal_setTimeZone() offset=%d\n", zoneOffset);
 660     }
 661
 662     ucal_setTimeZone(caldef2, NULL, -1, &status);
 663     if(U_FAILURE(status)){
 664         log_err("Error in setting the time zone using ucal_setTimeZone(): %s\n", u_errorName(status));
 665     }
 666     if(ucal_getMillis(caldef2, &status))
 667         log_verbose("PASS: setTimeZone roundtrip test passed\n");
 668     else
 669         log_err("FAIL: setTimeZone roundtrip test failed\n");
 670
 671     zoneOffset = ucal_get(caldef2, UCAL_ZONE_OFFSET, &status);
 672     if(U_FAILURE(status)){
 673         log_err("Error in getting the time zone using ucal_get() after using ucal_setTimeZone(): %s\n", u_errorName(status));
 674     }
 675     else if (zoneOffset != -28800000) {
 676         log_err("Error in getting the time zone using ucal_get() after using ucal_setTimeZone() offset=%d\n", zoneOffset);
 677     }
 678
 679     ctest_resetTimeZone();
 680
 681 /*----------------------------*     */
 682
 683
 684
 685     /*Testing  if setDate works fine  */
 686     log_verbose("\nTesting the ucal_setDate() function \n");
 687     u_uastrcpy(temp, "Dec 17, 1971, 11:05:28 PM");
 688     ucal_setDate(caldef,1971, UCAL_DECEMBER, 17, &status);
 689     if(U_FAILURE(status)){
 690         log_err("error in setting the calendar date : %s\n", u_errorName(status));
 691     }
 692     /*checking if the calendar date is set properly or not  */
 693     d1=ucal_getMillis(caldef, &status);
 694     if(u_strcmp(myDateFormat(datdef, d1), temp)==0)
 695         log_verbose("PASS:setDate works fine\n");
 696     else
 697         log_err("FAIL:Error in setDate()\n");
 698
 699
 700     /* Testing setDate Extensively with various input values */
 701     log_verbose("\nTesting ucal_setDate() extensively\n");
 702     ucal_setDate(caldef, 1999, UCAL_JANUARY, 10, &status);
 703     verify1("1999  10th day of January  is :", caldef, datdef, 1999, UCAL_JANUARY, 10);
 704     ucal_setDate(caldef, 1999, UCAL_DECEMBER, 3, &status);
 705     verify1("1999 3rd day of December  is :", caldef, datdef, 1999, UCAL_DECEMBER, 3);
 706     ucal_setDate(caldef, 2000, UCAL_MAY, 3, &status);
 707     verify1("2000 3rd day of May is :", caldef, datdef, 2000, UCAL_MAY, 3);
 708     ucal_setDate(caldef, 1999, UCAL_AUGUST, 32, &status);
 709     verify1("1999 32th day of August is :", caldef, datdef, 1999, UCAL_SEPTEMBER, 1);
 710     ucal_setDate(caldef, 1999, UCAL_MARCH, 0, &status);
 711     verify1("1999 0th day of March is :", caldef, datdef, 1999, UCAL_FEBRUARY, 28);
 712     ucal_setDate(caldef, 0, UCAL_MARCH, 12, &status);
 713
 714     /*--------------------*/
 715
 716     /*Testing if setDateTime works fine */
 717     log_verbose("\nTesting the ucal_setDateTime() function \n");
 718     u_uastrcpy(temp, "May 3, 1972, 4:30:42 PM");
 719     ucal_setDateTime(caldef,1972, UCAL_MAY, 3, 16, 30, 42, &status);
 720     if(U_FAILURE(status)){
 721         log_err("error in setting the calendar date : %s\n", u_errorName(status));
 722     }
 723     /*checking  if the calendar date is set properly or not  */
 724     d1=ucal_getMillis(caldef, &status);
 725     if(u_strcmp(myDateFormat(datdef, d1), temp)==0)
 726         log_verbose("PASS: setDateTime works fine\n");
 727     else
 728         log_err("FAIL: Error in setDateTime\n");
 729
 730
 731
 732     /*Testing setDateTime extensively with various input values*/
 733     log_verbose("\nTesting ucal_setDateTime() function extensively\n");
 734     ucal_setDateTime(caldef, 1999, UCAL_OCTOBER, 10, 6, 45, 30, &status);
 735     verify2("1999  10th day of October  at 6:45:30 is :", caldef, datdef, 1999, UCAL_OCTOBER, 10, 6, 45, 30, 0 );
 736     ucal_setDateTime(caldef, 1999, UCAL_MARCH, 3, 15, 10, 55, &status);
 737     verify2("1999 3rd day of March   at 15:10:55 is :", caldef, datdef, 1999, UCAL_MARCH, 3, 3, 10, 55, 1);
 738     ucal_setDateTime(caldef, 1999, UCAL_MAY, 3, 25, 30, 45, &status);
 739     verify2("1999 3rd day of May at 25:30:45 is :", caldef, datdef, 1999, UCAL_MAY, 4, 1, 30, 45, 0);
 740     ucal_setDateTime(caldef, 1999, UCAL_AUGUST, 32, 22, 65, 40, &status);
 741     verify2("1999 32th day of August at 22:65:40 is :", caldef, datdef, 1999, UCAL_SEPTEMBER, 1, 11, 5, 40,1);
 742     ucal_setDateTime(caldef, 1999, UCAL_MARCH, 12, 0, 0, 0,&status);
 743     verify2("1999 12th day of March at 0:0:0 is :", caldef, datdef, 1999, UCAL_MARCH, 12, 0, 0, 0, 0);
 744     ucal_setDateTime(caldef, 1999, UCAL_MARCH, 12, -10, -10,0, &status);
 745     verify2("1999 12th day of March is at -10:-10:0 :", caldef, datdef, 1999, UCAL_MARCH, 11, 1, 50, 0, 1);
 746
 747
 748
 749     /*close caldef and datdef*/
 750     ucal_close(caldef);
 751     ucal_close(caldef2);
 752     ucal_close(caldef3);
 753     udat_close(datdef);
 754 }
 755
 756 /*----------------------------------------------------------- */
 757 /**
 758  * Confirm the functioning of the calendar field related functions.
 759  */
 760 static void TestFieldGetSet()
 761 {
 762     UCalendar *cal = 0;
 763     UChar tzID[4];
 764     UDateFormat *datdef = 0;
 765     UDate d1 = 0;
 766     UErrorCode status=U_ZERO_ERROR;
 767     (void)d1;   /* Suppress set but not used warning. */
 768     log_verbose("\nFetching pointer to UCalendar using the ucal_open()\n");
 769     u_strcpy(tzID, fgGMTID);
 770     /*open the calendar used */
 771     cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
 772     if (U_FAILURE(status)) {
 773         log_data_err("ucal_open failed: %s - (Are you missing data?)\n", u_errorName(status));
 774         return;
 775     }
 776     datdef=udat_open(UDAT_SHORT,UDAT_SHORT ,NULL,fgGMTID,-1,NULL, 0, &status);
 777     if(U_FAILURE(status))
 778     {
 779         log_data_err("error in creating the dateformat : %s (Are you missing data?)\n", u_errorName(status));
 780     }
 781
 782     /*Testing ucal_get()*/
 783     log_verbose("\nTesting the ucal_get() function of Calendar\n");
 784     ucal_setDateTime(cal, 1999, UCAL_MARCH, 12, 5, 25, 30, &status);
 785     if(U_FAILURE(status)){
 786         log_data_err("error in the setDateTime() : %s (Are you missing data?)\n", u_errorName(status));
 787     }
 788     if(ucal_get(cal, UCAL_YEAR, &status)!=1999 || ucal_get(cal, UCAL_MONTH, &status)!=2 ||
 789         ucal_get(cal, UCAL_DATE, &status)!=12 || ucal_get(cal, UCAL_HOUR, &status)!=5)
 790         log_data_err("error in ucal_get() -> %s (Are you missing data?)\n", u_errorName(status));
 791     else if(ucal_get(cal, UCAL_DAY_OF_WEEK_IN_MONTH, &status)!=2 || ucal_get(cal, UCAL_DAY_OF_WEEK, &status)!=6
 792         || ucal_get(cal, UCAL_WEEK_OF_MONTH, &status)!=2 || ucal_get(cal, UCAL_WEEK_OF_YEAR, &status)!= 11)
 793         log_err("FAIL: error in ucal_get()\n");
 794     else
 795         log_verbose("PASS: ucal_get() works fine\n");
 796
 797     /*Testing the ucal_set() , ucal_clear() functions of calendar*/
 798     log_verbose("\nTesting the set, and clear  field functions of calendar\n");
 799     ucal_setAttribute(cal, UCAL_LENIENT, 0);
 800     ucal_clear(cal);
 801     ucal_set(cal, UCAL_YEAR, 1997);
 802     ucal_set(cal, UCAL_MONTH, UCAL_JUNE);
 803     ucal_set(cal, UCAL_DATE, 3);
 804     verify1("1997 third day of June = ", cal, datdef, 1997, UCAL_JUNE, 3);
 805     ucal_clear(cal);
 806     ucal_set(cal, UCAL_YEAR, 1997);
 807     ucal_set(cal, UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
 808     ucal_set(cal, UCAL_MONTH, UCAL_JUNE);
 809     ucal_set(cal, UCAL_DAY_OF_WEEK_IN_MONTH, 1);
 810     verify1("1997 first Tuesday in June = ", cal, datdef, 1997, UCAL_JUNE, 3);
 811     ucal_clear(cal);
 812     ucal_set(cal, UCAL_YEAR, 1997);
 813     ucal_set(cal, UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
 814     ucal_set(cal, UCAL_MONTH, UCAL_JUNE);
 815     ucal_set(cal, UCAL_DAY_OF_WEEK_IN_MONTH, - 1);
 816     verify1("1997 last Tuesday in June = ", cal, datdef,1997,   UCAL_JUNE, 24);
 817     /*give undesirable input    */
 818     status = U_ZERO_ERROR;
 819     ucal_clear(cal);
 820     ucal_set(cal, UCAL_YEAR, 1997);
 821     ucal_set(cal, UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
 822     ucal_set(cal, UCAL_MONTH, UCAL_JUNE);
 823     ucal_set(cal, UCAL_DAY_OF_WEEK_IN_MONTH, 0);
 824     d1 = ucal_getMillis(cal, &status);
 825     if (status != U_ILLEGAL_ARGUMENT_ERROR) {
 826         log_err("FAIL: U_ILLEGAL_ARGUMENT_ERROR was not returned for : 1997 zero-th Tuesday in June\n");
 827     } else {
 828         log_verbose("PASS: U_ILLEGAL_ARGUMENT_ERROR as expected\n");
 829     }
 830     status = U_ZERO_ERROR;
 831     ucal_clear(cal);
 832     ucal_set(cal, UCAL_YEAR, 1997);
 833     ucal_set(cal, UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
 834     ucal_set(cal, UCAL_MONTH, UCAL_JUNE);
 835     ucal_set(cal, UCAL_WEEK_OF_MONTH, 1);
 836     verify1("1997 Tuesday in week 1 of June = ", cal,datdef, 1997, UCAL_JUNE, 3);
 837     ucal_clear(cal);
 838     ucal_set(cal, UCAL_YEAR, 1997);
 839     ucal_set(cal, UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
 840     ucal_set(cal, UCAL_MONTH, UCAL_JUNE);
 841     ucal_set(cal, UCAL_WEEK_OF_MONTH, 5);
 842     verify1("1997 Tuesday in week 5 of June = ", cal,datdef, 1997, UCAL_JULY, 1);
 843     status = U_ZERO_ERROR;
 844     ucal_clear(cal);
 845     ucal_set(cal, UCAL_YEAR, 1997);
 846     ucal_set(cal, UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
 847     ucal_set(cal, UCAL_MONTH, UCAL_JUNE);
 848     ucal_set(cal, UCAL_WEEK_OF_MONTH, 0);
 849     ucal_setAttribute(cal, UCAL_MINIMAL_DAYS_IN_FIRST_WEEK,1);
 850     d1 = ucal_getMillis(cal,&status);
 851     if (status != U_ILLEGAL_ARGUMENT_ERROR){
 852         log_err("FAIL: U_ILLEGAL_ARGUMENT_ERROR was not returned for : 1997 Tuesday zero-th week in June\n");
 853     } else {
 854         log_verbose("PASS: U_ILLEGAL_ARGUMENT_ERROR as expected\n");
 855     }
 856     status = U_ZERO_ERROR;
 857     ucal_clear(cal);
 858     ucal_set(cal, UCAL_YEAR_WOY, 1997);
 859     ucal_set(cal, UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
 860     ucal_set(cal, UCAL_WEEK_OF_YEAR, 1);
 861     verify1("1997 Tuesday in week 1 of year = ", cal, datdef,1996, UCAL_DECEMBER, 31);
 862     ucal_clear(cal);
 863     ucal_set(cal, UCAL_YEAR, 1997);
 864     ucal_set(cal, UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
 865     ucal_set(cal, UCAL_WEEK_OF_YEAR, 10);
 866     verify1("1997 Tuesday in week 10 of year = ", cal,datdef, 1997, UCAL_MARCH, 4);
 867     ucal_clear(cal);
 868     ucal_set(cal, UCAL_YEAR, 1999);
 869     ucal_set(cal, UCAL_DAY_OF_YEAR, 1);
 870     verify1("1999 1st day of the year =", cal, datdef, 1999, UCAL_JANUARY, 1);
 871     ucal_set(cal, UCAL_MONTH, -3);
 872     d1 = ucal_getMillis(cal,&status);
 873     if (status != U_ILLEGAL_ARGUMENT_ERROR){
 874         log_err("FAIL: U_ILLEGAL_ARGUMENT_ERROR was not returned for : 1999 -3th month\n");
 875     } else {
 876         log_verbose("PASS: U_ILLEGAL_ARGUMENT_ERROR as expected\n");
 877     }
 878
 879     ucal_setAttribute(cal, UCAL_LENIENT, 1);
 880
 881     ucal_set(cal, UCAL_MONTH, -3);
 882     verify1("1999 -3th month should be", cal, datdef, 1998, UCAL_OCTOBER, 1);
 883
 884
 885     /*testing isSet and clearField()*/
 886     if(!ucal_isSet(cal, UCAL_WEEK_OF_YEAR))
 887         log_err("FAIL: error in isSet\n");
 888     else
 889         log_verbose("PASS: isSet working fine\n");
 890     ucal_clearField(cal, UCAL_WEEK_OF_YEAR);
 891     if(ucal_isSet(cal, UCAL_WEEK_OF_YEAR))
 892         log_err("FAIL: there is an error in clearField or isSet\n");
 893     else
 894         log_verbose("PASS :clearField working fine\n");
 895
 896     /*-------------------------------*/
 897
 898     ucal_close(cal);
 899     udat_close(datdef);
 900 }
 901
 902 typedef struct {
 903     const char * zone;
 904     int32_t      year;
 905     int32_t      month;
 906     int32_t      day;
 907     int32_t      hour;
 908 } TransitionItem;
 909
 910 static const TransitionItem transitionItems[] = {
 911     { "America/Caracas", 2007, UCAL_DECEMBER,  8, 10 }, /* day before change in UCAL_ZONE_OFFSET */
 912     { "US/Pacific",      2011,    UCAL_MARCH, 12, 10 }, /* day before change in UCAL_DST_OFFSET */
 913     { NULL,                 0,             0,  0,  0 }
 914 };
 915
 916 /* ------------------------------------- */
 917 /**
 918  * Execute adding and rolling in Calendar extensively,
 919  */
 920 static void TestAddRollExtensive()
 921 {
 922     const TransitionItem * itemPtr;
 923     UCalendar *cal = 0;
 924     int32_t i,limit;
 925     UChar tzID[32];
 926     UCalendarDateFields e;
 927     int32_t y,m,d,hr,min,sec,ms;
 928     int32_t maxlimit = 40;
 929     UErrorCode status = U_ZERO_ERROR;
 930     y = 1997; m = UCAL_FEBRUARY; d = 1; hr = 1; min = 1; sec = 0; ms = 0;
 931
 932     log_verbose("Testing add and roll extensively\n");
 933
 934     u_uastrcpy(tzID, "PST");
 935     /*open the calendar used */
 936     cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_GREGORIAN, &status);;
 937     if (U_FAILURE(status)) {
 938         log_data_err("ucal_open() failed : %s - (Are you missing data?)\n", u_errorName(status));
 939         return;
 940     }
 941
 942     ucal_set(cal, UCAL_YEAR, y);
 943     ucal_set(cal, UCAL_MONTH, m);
 944     ucal_set(cal, UCAL_DATE, d);
 945     ucal_setAttribute(cal, UCAL_MINIMAL_DAYS_IN_FIRST_WEEK,1);
 946
 947     /* Confirm that adding to various fields works.*/
 948     log_verbose("\nTesting to confirm that adding to various fields works with ucal_add()\n");
 949     checkDate(cal, y, m, d);
 950     ucal_add(cal,UCAL_YEAR, 1, &status);
 951     if (U_FAILURE(status)) { log_err("ucal_add failed: %s\n", u_errorName(status)); return; }
 952     y++;
 953     checkDate(cal, y, m, d);
 954     ucal_add(cal,UCAL_MONTH, 12, &status);
 955     if (U_FAILURE(status)) { log_err("ucal_add failed: %s\n", u_errorName(status) ); return; }
 956     y+=1;
 957     checkDate(cal, y, m, d);
 958     ucal_add(cal,UCAL_DATE, 1, &status);
 959     if (U_FAILURE(status)) { log_err("ucal_add failed: %s\n", u_errorName(status) ); return; }
 960     d++;
 961     checkDate(cal, y, m, d);
 962     ucal_add(cal,UCAL_DATE, 2, &status);
 963     if (U_FAILURE(status)) { log_err("ucal_add failed: %s\n", u_errorName(status) ); return; }
 964     d += 2;
 965     checkDate(cal, y, m, d);
 966     ucal_add(cal,UCAL_DATE, 28, &status);
 967     if (U_FAILURE(status)) { log_err("ucal_add failed: %s\n", u_errorName(status) ); return; }
 968     ++m;
 969     checkDate(cal, y, m, d);
 970     ucal_add(cal, (UCalendarDateFields)-1, 10, &status);
 971     if(status==U_ILLEGAL_ARGUMENT_ERROR)
 972         log_verbose("Pass: Illegal argument error as expected\n");
 973     else{
 974         log_err("Fail: No, illegal argument error as expected. Got....: %s\n", u_errorName(status));
 975     }
 976     status=U_ZERO_ERROR;
 977
 978
 979     /*confirm that applying roll to various fields works fine*/
 980     log_verbose("\nTesting to confirm that ucal_roll() works\n");
 981     ucal_roll(cal, UCAL_DATE, -1, &status);
 982     if (U_FAILURE(status)) { log_err("ucal_roll failed: %s\n", u_errorName(status) ); return; }
 983     d -=1;
 984     checkDate(cal, y, m, d);
 985     ucal_roll(cal, UCAL_MONTH, -2, &status);
 986     if (U_FAILURE(status)) { log_err("ucal_roll failed: %s\n", u_errorName(status) ); return; }
 987     m -=2;
 988     checkDate(cal, y, m, d);
 989     ucal_roll(cal, UCAL_DATE, 1, &status);
 990     if (U_FAILURE(status)) { log_err("ucal_roll failed: %s\n", u_errorName(status) ); return; }
 991     d +=1;
 992     checkDate(cal, y, m, d);
 993     ucal_roll(cal, UCAL_MONTH, -12, &status);
 994     if (U_FAILURE(status)) { log_err("ucal_roll failed: %s\n", u_errorName(status) ); return; }
 995     checkDate(cal, y, m, d);
 996     ucal_roll(cal, UCAL_YEAR, -1, &status);
 997     if (U_FAILURE(status)) { log_err("ucal_roll failed: %s\n", u_errorName(status) ); return; }
 998     y -=1;
 999     checkDate(cal, y, m, d);
1000     ucal_roll(cal, UCAL_DATE, 29, &status);
1001     if (U_FAILURE(status)) { log_err("ucal_roll failed: %s\n", u_errorName(status) ); return; }
1002     d = 2;
1003     checkDate(cal, y, m, d);
1004     ucal_roll(cal, (UCalendarDateFields)-1, 10, &status);
1005     if(status==U_ILLEGAL_ARGUMENT_ERROR)
1006         log_verbose("Pass: illegal arguement error as expected\n");
1007     else{
1008         log_err("Fail: no illegal argument error got..: %s\n", u_errorName(status));
1009         return;
1010     }
1011     status=U_ZERO_ERROR;
1012     ucal_clear(cal);
1013     ucal_setDateTime(cal, 1999, UCAL_FEBRUARY, 28, 10, 30, 45,  &status);
1014     if(U_FAILURE(status)){
1015         log_err("error is setting the datetime: %s\n", u_errorName(status));
1016     }
1017     ucal_add(cal, UCAL_MONTH, 1, &status);
1018     checkDate(cal, 1999, UCAL_MARCH, 28);
1019     ucal_add(cal, UCAL_MILLISECOND, 1000, &status);
1020     checkDateTime(cal, 1999, UCAL_MARCH, 28, 10, 30, 46, 0, UCAL_MILLISECOND);
1021
1022     ucal_close(cal);
1023 /*--------------- */
1024     status=U_ZERO_ERROR;
1025     /* Testing add and roll extensively */
1026     log_verbose("\nTesting the ucal_add() and ucal_roll() functions extensively\n");
1027     y = 1997; m = UCAL_FEBRUARY; d = 1; hr = 1; min = 1; sec = 0; ms = 0;
1028     cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
1029     if (U_FAILURE(status)) {
1030         log_err("ucal_open failed: %s\n", u_errorName(status));
1031         return;
1032     }
1033     ucal_set(cal, UCAL_YEAR, y);
1034     ucal_set(cal, UCAL_MONTH, m);
1035     ucal_set(cal, UCAL_DATE, d);
1036     ucal_set(cal, UCAL_HOUR, hr);
1037     ucal_set(cal, UCAL_MINUTE, min);
1038     ucal_set(cal, UCAL_SECOND,sec);
1039     ucal_set(cal, UCAL_MILLISECOND, ms);
1040     ucal_setAttribute(cal, UCAL_MINIMAL_DAYS_IN_FIRST_WEEK,1);
1041     status=U_ZERO_ERROR;
1042
1043     log_verbose("\nTesting UCalendar add...\n");
1044     for(e = UCAL_YEAR;e < UCAL_FIELD_COUNT; e=(UCalendarDateFields)((int32_t)e + 1)) {
1045         limit = maxlimit;
1046         status = U_ZERO_ERROR;
1047         for (i = 0; i < limit; i++) {
1048             ucal_add(cal, e, 1, &status);
1049             if (U_FAILURE(status)) { limit = i; status = U_ZERO_ERROR; }
1050         }
1051         for (i = 0; i < limit; i++) {
1052             ucal_add(cal, e, -1, &status);
1053             if (U_FAILURE(status)) {
1054                 log_err("ucal_add -1 failed: %s\n", u_errorName(status));
1055                 return;
1056             }
1057         }
1058         checkDateTime(cal, y, m, d, hr, min, sec, ms, e);
1059     }
1060     log_verbose("\nTesting calendar ucal_roll()...\n");
1061     for(e = UCAL_YEAR;e < UCAL_FIELD_COUNT; e=(UCalendarDateFields)((int32_t)e + 1)) {
1062         limit = maxlimit;
1063         status = U_ZERO_ERROR;
1064         for (i = 0; i < limit; i++) {
1065             ucal_roll(cal, e, 1, &status);
1066             if (U_FAILURE(status)) {
1067                 limit = i;
1068                 status = U_ZERO_ERROR;
1069             }
1070         }
1071         for (i = 0; i < limit; i++) {
1072             ucal_roll(cal, e, -1, &status);
1073             if (U_FAILURE(status)) {
1074                 log_err("ucal_roll -1 failed: %s\n", u_errorName(status));
1075                 return;
1076             }
1077         }
1078         checkDateTime(cal, y, m, d, hr, min, sec, ms, e);
1079     }
1080
1081     ucal_close(cal);
1082 /*--------------- */
1083     log_verbose("\nTesting ucal_add() across ZONE_OFFSET and DST_OFFSE transitions.\n");
1084     for (itemPtr = transitionItems; itemPtr->zone != NULL; itemPtr++) {
1085         status=U_ZERO_ERROR;
1086         u_uastrcpy(tzID, itemPtr->zone);
1087         cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_GREGORIAN, &status);
1088         if (U_FAILURE(status)) {
1089             log_err("ucal_open failed for zone %s: %s\n", itemPtr->zone, u_errorName(status));
1090             continue;
1091         }
1092         ucal_setDateTime(cal, itemPtr->year, itemPtr->month, itemPtr->day, itemPtr->hour, 0, 0, &status);
1093         ucal_add(cal, UCAL_DATE, 1, &status);
1094         hr = ucal_get(cal, UCAL_HOUR_OF_DAY, &status);
1095         if ( U_FAILURE(status) ) {
1096             log_err("ucal_add failed adding day across transition for zone %s: %s\n", itemPtr->zone, u_errorName(status));
1097         } else if ( hr != itemPtr->hour ) {
1098             log_err("ucal_add produced wrong hour %d when adding day across transition for zone %s\n", hr, itemPtr->zone);
1099         } else {
1100             ucal_add(cal, UCAL_DATE, -1, &status);
1101             hr = ucal_get(cal, UCAL_HOUR_OF_DAY, &status);
1102             if ( U_FAILURE(status) ) {
1103                 log_err("ucal_add failed subtracting day across transition for zone %s: %s\n", itemPtr->zone, u_errorName(status));
1104             } else if ( hr != itemPtr->hour ) {
1105                 log_err("ucal_add produced wrong hour %d when subtracting day across transition for zone %s\n", hr, itemPtr->zone);
1106             }
1107         }
1108         ucal_close(cal);
1109     }
1110 }
1111
1112 /*------------------------------------------------------ */
1113 /*Testing the Limits for various Fields of Calendar*/
1114 static void TestGetLimits()
1115 {
1116     UCalendar *cal = 0;
1117     int32_t min, max, gr_min, le_max, ac_min, ac_max, val;
1118     UChar tzID[4];
1119     UErrorCode status = U_ZERO_ERROR;
1120
1121
1122     u_uastrcpy(tzID, "PST");
1123     /*open the calendar used */
1124     cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_GREGORIAN, &status);;
1125     if (U_FAILURE(status)) {
1126         log_data_err("ucal_open() for gregorian calendar failed in TestGetLimits: %s - (Are you missing data?)\n", u_errorName(status));
1127         return;
1128     }
1129
1130     log_verbose("\nTesting the getLimits function for various fields\n");
1131
1132
1133
1134     ucal_setDate(cal, 1999, UCAL_MARCH, 5, &status); /* Set the date to be March 5, 1999 */
1135     val = ucal_get(cal, UCAL_DAY_OF_WEEK, &status);
1136     min = ucal_getLimit(cal, UCAL_DAY_OF_WEEK, UCAL_MINIMUM, &status);
1137     max = ucal_getLimit(cal, UCAL_DAY_OF_WEEK, UCAL_MAXIMUM, &status);
1138     if ( (min != UCAL_SUNDAY || max != UCAL_SATURDAY ) && (min > val && val > max)  && (val != UCAL_FRIDAY)){
1139            log_err("FAIL: Min/max bad\n");
1140            log_err("FAIL: Day of week %d out of range\n", val);
1141            log_err("FAIL: FAIL: Day of week should be SUNDAY Got %d\n", val);
1142     }
1143     else
1144         log_verbose("getLimits successful\n");
1145
1146     val = ucal_get(cal, UCAL_DAY_OF_WEEK_IN_MONTH, &status);
1147     min = ucal_getLimit(cal, UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_MINIMUM, &status);
1148     max = ucal_getLimit(cal, UCAL_DAY_OF_WEEK_IN_MONTH, UCAL_MAXIMUM, &status);
1149     if ( (min != 0 || max != 5 ) && (min > val && val > max)  && (val != 1)){
1150            log_err("FAIL: Min/max bad\n");
1151            log_err("FAIL: Day of week in month %d out of range\n", val);
1152            log_err("FAIL: FAIL: Day of week in month should be SUNDAY Got %d\n", val);
1153
1154     }
1155     else
1156         log_verbose("getLimits successful\n");
1157
1158     min=ucal_getLimit(cal, UCAL_MONTH, UCAL_MINIMUM, &status);
1159     max=ucal_getLimit(cal, UCAL_MONTH, UCAL_MAXIMUM, &status);
1160     gr_min=ucal_getLimit(cal, UCAL_MONTH, UCAL_GREATEST_MINIMUM, &status);
1161     le_max=ucal_getLimit(cal, UCAL_MONTH, UCAL_LEAST_MAXIMUM, &status);
1162     ac_min=ucal_getLimit(cal, UCAL_MONTH, UCAL_ACTUAL_MINIMUM, &status);
1163     ac_max=ucal_getLimit(cal, UCAL_MONTH, UCAL_ACTUAL_MAXIMUM, &status);
1164     if(U_FAILURE(status)){
1165         log_err("Error in getLimits: %s\n", u_errorName(status));
1166     }
1167     if(min!=0 || max!=11 || gr_min!=0 || le_max!=11 || ac_min!=0 || ac_max!=11)
1168         log_err("There is and error in getLimits in fetching the values\n");
1169     else
1170         log_verbose("getLimits successful\n");
1171
1172     ucal_setDateTime(cal, 1999, UCAL_MARCH, 5, 4, 10, 35, &status);
1173     val=ucal_get(cal, UCAL_HOUR_OF_DAY, &status);
1174     min=ucal_getLimit(cal, UCAL_HOUR_OF_DAY, UCAL_MINIMUM, &status);
1175     max=ucal_getLimit(cal, UCAL_HOUR_OF_DAY, UCAL_MAXIMUM, &status);
1176     gr_min=ucal_getLimit(cal, UCAL_MINUTE, UCAL_GREATEST_MINIMUM, &status);
1177     le_max=ucal_getLimit(cal, UCAL_MINUTE, UCAL_LEAST_MAXIMUM, &status);
1178     ac_min=ucal_getLimit(cal, UCAL_MINUTE, UCAL_ACTUAL_MINIMUM, &status);
1179     ac_max=ucal_getLimit(cal, UCAL_SECOND, UCAL_ACTUAL_MAXIMUM, &status);
1180     if( (min!=0 || max!= 11 || gr_min!=0 || le_max!=60 || ac_min!=0 || ac_max!=60) &&
1181         (min>val && val>max) && val!=4){
1182
1183         log_err("FAIL: Min/max bad\n");
1184         log_err("FAIL: Hour of Day %d out of range\n", val);
1185         log_err("FAIL: HOUR_OF_DAY should be 4 Got %d\n", val);
1186     }
1187     else
1188         log_verbose("getLimits successful\n");
1189
1190
1191     /*get BOGUS_LIMIT type*/
1192     val=ucal_getLimit(cal, UCAL_SECOND, (UCalendarLimitType)99, &status);
1193     if(val != -1){
1194         log_err("FAIL: ucal_getLimit() with BOGUS type should return -1\n");
1195     }
1196     status=U_ZERO_ERROR;
1197
1198
1199     ucal_close(cal);
1200 }
1201
1202
1203
1204 /* ------------------------------------- */
1205
1206 /**
1207  * Test that the days of the week progress properly when add is called repeatedly
1208  * for increments of 24 days.
1209  */
1210 static void TestDOWProgression()
1211 {
1212     int32_t initialDOW, DOW, newDOW, expectedDOW;
1213     UCalendar *cal = 0;
1214     UDateFormat *datfor = 0;
1215     UDate date1;
1216     int32_t delta=24;
1217     UErrorCode status = U_ZERO_ERROR;
1218     UChar tzID[4];
1219     char tempMsgBuf[256];
1220     u_strcpy(tzID, fgGMTID);
1221     /*open the calendar used */
1222     cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);;
1223     if (U_FAILURE(status)) {
1224         log_data_err("ucal_open failed: %s - (Are you missing data?)\n", u_errorName(status));
1225         return;
1226     }
1227
1228     datfor=udat_open(UDAT_MEDIUM,UDAT_MEDIUM ,NULL, fgGMTID,-1,NULL, 0, &status);
1229     if(U_FAILURE(status)){
1230         log_data_err("error in creating the dateformat : %s (Are you missing data?)\n", u_errorName(status));
1231     }
1232
1233
1234     ucal_setDate(cal, 1999, UCAL_JANUARY, 1, &status);
1235
1236     log_verbose("\nTesting the DOW progression\n");
1237
1238     initialDOW = ucal_get(cal, UCAL_DAY_OF_WEEK, &status);
1239     if (U_FAILURE(status)) { log_data_err("ucal_get() failed: %s (Are you missing data?)\n", u_errorName(status) ); return; }
1240     newDOW = initialDOW;
1241     do {
1242         DOW = newDOW;
1243         log_verbose("DOW = %d...\n", DOW);
1244         date1=ucal_getMillis(cal, &status);
1245         if(U_FAILURE(status)){ log_err("ucal_getMiilis() failed: %s\n", u_errorName(status)); return;}
1246         log_verbose("%s\n", u_austrcpy(tempMsgBuf, myDateFormat(datfor, date1)));
1247
1248         ucal_add(cal,UCAL_DAY_OF_WEEK, delta, &status);
1249         if (U_FAILURE(status)) { log_err("ucal_add() failed: %s\n", u_errorName(status)); return; }
1250
1251         newDOW = ucal_get(cal, UCAL_DAY_OF_WEEK, &status);
1252         if (U_FAILURE(status)) { log_err("ucal_get() failed: %s\n", u_errorName(status)); return; }
1253         expectedDOW = 1 + (DOW + delta - 1) % 7;
1254         date1=ucal_getMillis(cal, &status);
1255         if(U_FAILURE(status)){ log_err("ucal_getMiilis() failed: %s\n", u_errorName(status)); return;}
1256         if (newDOW != expectedDOW) {
1257             log_err("Day of week should be %d instead of %d on %s", expectedDOW, newDOW,
1258                 u_austrcpy(tempMsgBuf, myDateFormat(datfor, date1)) );
1259             return;
1260         }
1261     }
1262     while (newDOW != initialDOW);
1263
1264     ucal_close(cal);
1265     udat_close(datfor);
1266 }
1267
1268 /* ------------------------------------- */
1269
1270 /**
1271  * Confirm that the offset between local time and GMT behaves as expected.
1272  */
1273 static void TestGMTvsLocal()
1274 {
1275     log_verbose("\nTesting the offset between the GMT and local time\n");
1276     testZones(1999, 1, 1, 12, 0, 0);
1277     testZones(1999, 4, 16, 18, 30, 0);
1278     testZones(1998, 12, 17, 19, 0, 0);
1279 }
1280
1281 /* ------------------------------------- */
1282
1283 static void testZones(int32_t yr, int32_t mo, int32_t dt, int32_t hr, int32_t mn, int32_t sc)
1284 {
1285     int32_t offset,utc, expected;
1286     UCalendar *gmtcal = 0, *cal = 0;
1287     UDate date1;
1288     double temp;
1289     UDateFormat *datfor = 0;
1290     UErrorCode status = U_ZERO_ERROR;
1291     UChar tzID[4];
1292     char tempMsgBuf[256];
1293
1294     u_strcpy(tzID, fgGMTID);
1295     gmtcal=ucal_open(tzID, 3, "en_US", UCAL_TRADITIONAL, &status);;
1296     if (U_FAILURE(status)) {
1297         log_data_err("ucal_open failed: %s - (Are you missing data?)\n", u_errorName(status));
1298         return;
1299     }
1300     u_uastrcpy(tzID, "PST");
1301     cal = ucal_open(tzID, 3, "en_US", UCAL_TRADITIONAL, &status);
1302     if (U_FAILURE(status)) {
1303         log_err("ucal_open failed: %s\n", u_errorName(status));
1304         return;
1305     }
1306
1307     datfor=udat_open(UDAT_MEDIUM,UDAT_MEDIUM ,NULL, fgGMTID,-1,NULL, 0, &status);
1308     if(U_FAILURE(status)){
1309         log_data_err("error in creating the dateformat : %s (Are you missing data?)\n", u_errorName(status));
1310     }
1311
1312     ucal_setDateTime(gmtcal, yr, mo - 1, dt, hr, mn, sc, &status);
1313     if (U_FAILURE(status)) {
1314         log_data_err("ucal_setDateTime failed: %s (Are you missing data?)\n", u_errorName(status));
1315         return;
1316     }
1317     ucal_set(gmtcal, UCAL_MILLISECOND, 0);
1318     date1 = ucal_getMillis(gmtcal, &status);
1319     if (U_FAILURE(status)) {
1320         log_err("ucal_getMillis failed: %s\n", u_errorName(status));
1321         return;
1322     }
1323     log_verbose("date = %s\n", u_austrcpy(tempMsgBuf, myDateFormat(datfor, date1)) );
1324
1325
1326     ucal_setMillis(cal, date1, &status);
1327     if (U_FAILURE(status)) {
1328         log_err("ucal_setMillis() failed: %s\n", u_errorName(status));
1329         return;
1330     }
1331
1332     offset = ucal_get(cal, UCAL_ZONE_OFFSET, &status);
1333     offset += ucal_get(cal, UCAL_DST_OFFSET, &status);
1334
1335     if (U_FAILURE(status)) {
1336         log_err("ucal_get() failed: %s\n", u_errorName(status));
1337         return;
1338     }
1339     temp=(double)((double)offset / 1000.0 / 60.0 / 60.0);
1340     /*printf("offset for %s %f hr\n", austrdup(myDateFormat(datfor, date1)), temp);*/
1341
1342     utc = ((ucal_get(cal, UCAL_HOUR_OF_DAY, &status) * 60 +
1343                     ucal_get(cal, UCAL_MINUTE, &status)) * 60 +
1344                    ucal_get(cal, UCAL_SECOND, &status)) * 1000 +
1345                     ucal_get(cal, UCAL_MILLISECOND, &status) - offset;
1346     if (U_FAILURE(status)) {
1347         log_err("ucal_get() failed: %s\n", u_errorName(status));
1348         return;
1349     }
1350
1351     expected = ((hr * 60 + mn) * 60 + sc) * 1000;
1352     if (utc != expected) {
1353         temp=(double)(utc - expected)/ 1000 / 60 / 60.0;
1354         log_err("FAIL: Discrepancy of %d  millis = %fhr\n", utc-expected, temp );
1355     }
1356     else
1357         log_verbose("PASS: the offset between local and GMT is correct\n");
1358     ucal_close(gmtcal);
1359     ucal_close(cal);
1360     udat_close(datfor);
1361 }
1362
1363 /* ------------------------------------- */
1364
1365
1366
1367
1368 /* INTERNAL FUNCTIONS USED */
1369 /*------------------------------------------------------------------------------------------- */
1370
1371 /* ------------------------------------- */
1372 static void checkDateTime(UCalendar* c,
1373                         int32_t y, int32_t m, int32_t d,
1374                         int32_t hr, int32_t min, int32_t sec,
1375                         int32_t ms, UCalendarDateFields field)
1376
1377 {
1378     UErrorCode status = U_ZERO_ERROR;
1379     if (ucal_get(c, UCAL_YEAR, &status) != y ||
1380         ucal_get(c, UCAL_MONTH, &status) != m ||
1381         ucal_get(c, UCAL_DATE, &status) != d ||
1382         ucal_get(c, UCAL_HOUR, &status) != hr ||
1383         ucal_get(c, UCAL_MINUTE, &status) != min ||
1384         ucal_get(c, UCAL_SECOND, &status) != sec ||
1385         ucal_get(c, UCAL_MILLISECOND, &status) != ms) {
1386         log_err("U_FAILURE for field  %d, Expected y/m/d h:m:s:ms of %d/%d/%d %d:%d:%d:%d  got %d/%d/%d %d:%d:%d:%d\n",
1387             (int32_t)field, y, m + 1, d, hr, min, sec, ms,
1388                     ucal_get(c, UCAL_YEAR, &status),
1389                     ucal_get(c, UCAL_MONTH, &status) + 1,
1390                     ucal_get(c, UCAL_DATE, &status),
1391                     ucal_get(c, UCAL_HOUR, &status),
1392                     ucal_get(c, UCAL_MINUTE, &status) + 1,
1393                     ucal_get(c, UCAL_SECOND, &status),
1394                     ucal_get(c, UCAL_MILLISECOND, &status) );
1395
1396                     if (U_FAILURE(status)){
1397                     log_err("ucal_get failed: %s\n", u_errorName(status));
1398                     return;
1399                     }
1400
1401      }
1402     else
1403         log_verbose("Confirmed: %d/%d/%d %d:%d:%d:%d\n", y, m + 1, d, hr, min, sec, ms);
1404
1405 }
1406
1407 /* ------------------------------------- */
1408 static void checkDate(UCalendar* c, int32_t y, int32_t m, int32_t d)
1409 {
1410     UErrorCode status = U_ZERO_ERROR;
1411     if (ucal_get(c,UCAL_YEAR, &status) != y ||
1412         ucal_get(c, UCAL_MONTH, &status) != m ||
1413         ucal_get(c, UCAL_DATE, &status) != d) {
1414
1415         log_err("FAILURE: Expected y/m/d of %d/%d/%d  got %d/%d/%d\n", y, m + 1, d,
1416                     ucal_get(c, UCAL_YEAR, &status),
1417                     ucal_get(c, UCAL_MONTH, &status) + 1,
1418                     ucal_get(c, UCAL_DATE, &status) );
1419
1420         if (U_FAILURE(status)) {
1421             log_err("ucal_get failed: %s\n", u_errorName(status));
1422             return;
1423         }
1424     }
1425     else
1426         log_verbose("Confirmed: %d/%d/%d\n", y, m + 1, d);
1427
1428
1429 }
1430
1431 /* ------------------------------------- */
1432
1433 /* ------------------------------------- */
1434
1435 static void verify1(const char* msg, UCalendar* c, UDateFormat* dat, int32_t year, int32_t month, int32_t day)
1436 {
1437     UDate d1;
1438     UErrorCode status = U_ZERO_ERROR;
1439     if (ucal_get(c, UCAL_YEAR, &status) == year &&
1440         ucal_get(c, UCAL_MONTH, &status) == month &&
1441         ucal_get(c, UCAL_DATE, &status) == day) {
1442         if (U_FAILURE(status)) {
1443             log_err("FAIL: Calendar::get failed: %s\n", u_errorName(status));
1444             return;
1445         }
1446         log_verbose("PASS: %s\n", msg);
1447         d1=ucal_getMillis(c, &status);
1448         if (U_FAILURE(status)) {
1449             log_err("ucal_getMillis failed: %s\n", u_errorName(status));
1450             return;
1451         }
1452     /*log_verbose(austrdup(myDateFormat(dat, d1)) );*/
1453     }
1454     else {
1455         log_err("FAIL: %s\n", msg);
1456         d1=ucal_getMillis(c, &status);
1457         if (U_FAILURE(status)) {
1458             log_err("ucal_getMillis failed: %s\n", u_errorName(status) );
1459             return;
1460         }
1461         log_err("Got %s  Expected %d/%d/%d \n", austrdup(myDateFormat(dat, d1)), year, month + 1, day );
1462         return;
1463     }
1464
1465
1466 }
1467
1468 /* ------------------------------------ */
1469 static void verify2(const char* msg, UCalendar* c, UDateFormat* dat, int32_t year, int32_t month, int32_t day,
1470                                                                      int32_t hour, int32_t min, int32_t sec, int32_t am_pm)
1471 {
1472     UDate d1;
1473     UErrorCode status = U_ZERO_ERROR;
1474     char tempMsgBuf[256];
1475
1476     if (ucal_get(c, UCAL_YEAR, &status) == year &&
1477         ucal_get(c, UCAL_MONTH, &status) == month &&
1478         ucal_get(c, UCAL_DATE, &status) == day &&
1479         ucal_get(c, UCAL_HOUR, &status) == hour &&
1480         ucal_get(c, UCAL_MINUTE, &status) == min &&
1481         ucal_get(c, UCAL_SECOND, &status) == sec &&
1482         ucal_get(c, UCAL_AM_PM, &status) == am_pm ){
1483         if (U_FAILURE(status)) {
1484             log_err("FAIL: Calendar::get failed: %s\n", u_errorName(status));
1485             return;
1486         }
1487         log_verbose("PASS: %s\n", msg);
1488         d1=ucal_getMillis(c, &status);
1489         if (U_FAILURE(status)) {
1490             log_err("ucal_getMillis failed: %s\n", u_errorName(status));
1491             return;
1492         }
1493         log_verbose("%s\n" , u_austrcpy(tempMsgBuf, myDateFormat(dat, d1)) );
1494     }
1495     else {
1496         log_err("FAIL: %s\n", msg);
1497         d1=ucal_getMillis(c, &status);
1498         if (U_FAILURE(status)) {
1499             log_err("ucal_getMillis failed: %s\n", u_errorName(status));
1500             return;
1501         }
1502         log_err("Got %s Expected %d/%d/%d/ %d:%d:%d  %s\n", austrdup(myDateFormat(dat, d1)),
1503             year, month + 1, day, hour, min, sec, (am_pm==0) ? "AM": "PM");
1504
1505         return;
1506     }
1507
1508
1509 }
1510
1511 void TestGregorianChange() {
1512     static const UChar utc[] = { 0x45, 0x74, 0x63, 0x2f, 0x47, 0x4d, 0x54, 0 }; /* "Etc/GMT" */
1513     const int32_t dayMillis = 86400 * INT64_C(1000);    /* 1 day = 86400 seconds */
1514     UCalendar *cal;
1515     UDate date;
1516     UErrorCode errorCode = U_ZERO_ERROR;
1517
1518     /* Test ucal_setGregorianChange() on a Gregorian calendar. */
1519     errorCode = U_ZERO_ERROR;
1520     cal = ucal_open(utc, -1, "", UCAL_GREGORIAN, &errorCode);
1521     if(U_FAILURE(errorCode)) {
1522         log_data_err("ucal_open(UTC) failed: %s - (Are you missing data?)\n", u_errorName(errorCode));
1523         return;
1524     }
1525     ucal_setGregorianChange(cal, -365 * (dayMillis * (UDate)1), &errorCode);
1526     if(U_FAILURE(errorCode)) {
1527         log_err("ucal_setGregorianChange(1969) failed: %s\n", u_errorName(errorCode));
1528     } else {
1529         date = ucal_getGregorianChange(cal, &errorCode);
1530         if(U_FAILURE(errorCode) || date != -365 * (dayMillis * (UDate)1)) {
1531             log_err("ucal_getGregorianChange() failed: %s, date = %f\n", u_errorName(errorCode), date);
1532         }
1533     }
1534     ucal_close(cal);
1535
1536     /* Test ucal_setGregorianChange() on a non-Gregorian calendar where it should fail. */
1537     errorCode = U_ZERO_ERROR;
1538     cal = ucal_open(utc, -1, "th@calendar=buddhist", UCAL_TRADITIONAL, &errorCode);
1539     if(U_FAILURE(errorCode)) {
1540         log_err("ucal_open(UTC, non-Gregorian) failed: %s\n", u_errorName(errorCode));
1541         return;
1542     }
1543     ucal_setGregorianChange(cal, -730 * (dayMillis * (UDate)1), &errorCode);
1544     if(errorCode != U_UNSUPPORTED_ERROR) {
1545         log_err("ucal_setGregorianChange(non-Gregorian calendar) did not yield U_UNSUPPORTED_ERROR but %s\n",
1546                 u_errorName(errorCode));
1547     }
1548     errorCode = U_ZERO_ERROR;
1549     date = ucal_getGregorianChange(cal, &errorCode);
1550     if(errorCode != U_UNSUPPORTED_ERROR) {
1551         log_err("ucal_getGregorianChange(non-Gregorian calendar) did not yield U_UNSUPPORTED_ERROR but %s\n",
1552                 u_errorName(errorCode));
1553     }
1554     ucal_close(cal);
1555 }
1556
1557 static void TestGetKeywordValuesForLocale() {
1558 #define PREFERRED_SIZE 16
1559 #define MAX_NUMBER_OF_KEYWORDS 5
1560     const char *PREFERRED[PREFERRED_SIZE][MAX_NUMBER_OF_KEYWORDS+1] = {
1561             { "root",        "gregorian", NULL, NULL, NULL, NULL },
1562             { "und",         "gregorian", NULL, NULL, NULL, NULL },
1563             { "en_US",       "gregorian", NULL, NULL, NULL, NULL },
1564             { "en_029",      "gregorian", NULL, NULL, NULL, NULL },
1565             { "th_TH",       "buddhist", "gregorian", NULL, NULL, NULL },
1566             { "und_TH",      "buddhist", "gregorian", NULL, NULL, NULL },
1567             { "en_TH",       "buddhist", "gregorian", NULL, NULL, NULL },
1568             { "he_IL",       "gregorian", "hebrew", "islamic", "islamic-civil", "islamic-tbla" },
1569             { "ar_EG",       "gregorian", "coptic", "islamic", "islamic-civil", "islamic-tbla" },
1570             { "ja",          "gregorian", "japanese", NULL, NULL, NULL },
1571             { "ps_Guru_IN",  "gregorian", "indian", NULL, NULL, NULL },
1572             { "th@calendar=gregorian", "buddhist", "gregorian", NULL, NULL, NULL },
1573             { "en@calendar=islamic",   "gregorian", NULL, NULL, NULL, NULL },
1574             { "zh_TW",       "gregorian", "roc", "chinese", NULL, NULL },
1575             { "ar_IR",       "persian", "gregorian", "islamic", "islamic-civil", "islamic-tbla" },
1576             { "th@rg=SAZZZZ", "islamic-umalqura", "gregorian", "islamic", "islamic-rgsa", NULL },
1577     };
1578     const int32_t EXPECTED_SIZE[PREFERRED_SIZE] = { 1, 1, 1, 1, 2, 2, 2, 5, 5, 2, 2, 2, 1, 3, 5, 4 };
1579     UErrorCode status = U_ZERO_ERROR;
1580     int32_t i, size, j;
1581     UEnumeration *all, *pref;
1582     const char *loc = NULL;
1583     UBool matchPref, matchAll;
1584     const char *value;
1585     int32_t valueLength;
1586     UList *ALLList = NULL;
1587
1588     UEnumeration *ALL = ucal_getKeywordValuesForLocale("calendar", uloc_getDefault(), FALSE, &status);
1589     if (U_SUCCESS(status)) {
1590         for (i = 0; i < PREFERRED_SIZE; i++) {
1591             pref = NULL;
1592             all = NULL;
1593             loc = PREFERRED[i][0];
1594             pref = ucal_getKeywordValuesForLocale("calendar", loc, TRUE, &status);
1595             matchPref = FALSE;
1596             matchAll = FALSE;
1597
1598             value = NULL;
1599             valueLength = 0;
1600
1601             if (U_SUCCESS(status) && uenum_count(pref, &status) == EXPECTED_SIZE[i]) {
1602                 matchPref = TRUE;
1603                 for (j = 0; j < EXPECTED_SIZE[i]; j++) {
1604                     if ((value = uenum_next(pref, &valueLength, &status)) != NULL && U_SUCCESS(status)) {
1605                         if (uprv_strcmp(value, PREFERRED[i][j+1]) != 0) {
1606                             matchPref = FALSE;
1607                             break;
1608                         }
1609                     } else {
1610                         matchPref = FALSE;
1611                         log_err("ERROR getting keyword value for locale \"%s\"\n", loc);
1612                         break;
1613                     }
1614                 }
1615             }
1616
1617             if (!matchPref) {
1618                 log_err("FAIL: Preferred values for locale \"%s\" does not match expected.\n", loc);
1619                 break;
1620             }
1621             uenum_close(pref);
1622
1623             all = ucal_getKeywordValuesForLocale("calendar", loc, FALSE, &status);
1624
1625             size = uenum_count(all, &status);
1626
1627             if (U_SUCCESS(status) && size == uenum_count(ALL, &status)) {
1628                 matchAll = TRUE;
1629                 ALLList = ulist_getListFromEnum(ALL);
1630                 for (j = 0; j < size; j++) {
1631                     if ((value = uenum_next(all, &valueLength, &status)) != NULL && U_SUCCESS(status)) {
1632                         if (!ulist_containsString(ALLList, value, uprv_strlen(value))) {
1633                             log_err("Locale %s have %s not in ALL\n", loc, value);
1634                             matchAll = FALSE;
1635                             break;
1636                         }
1637                     } else {
1638                         matchAll = FALSE;
1639                         log_err("ERROR getting \"all\" keyword value for locale \"%s\"\n", loc);
1640                         break;
1641                     }
1642                 }
1643             }
1644             if (!matchAll) {
1645                 log_err("FAIL: All values for locale \"%s\" does not match expected.\n", loc);
1646             }
1647
1648             uenum_close(all);
1649         }
1650     } else {
1651         log_err_status(status, "Failed to get ALL keyword values for default locale %s: %s.\n", uloc_getDefault(), u_errorName(status));
1652     }
1653     uenum_close(ALL);
1654 }
1655
1656 /*
1657  * Weekend tests, ported from
1658  * icu4j/trunk/main/tests/core/src/com/ibm/icu/dev/test/calendar/IBMCalendarTest.java
1659  * and extended a bit. Notes below from IBMCalendarTest.java ...
1660  * This test tests for specific locale data. This is probably okay
1661  * as far as US data is concerned, but if the Arabic/Yemen data
1662  * changes, this test will have to be updated.
1663  */
1664
1665 typedef struct {
1666     int32_t year;
1667     int32_t month;
1668     int32_t day;
1669     int32_t hour;
1670     int32_t millisecOffset;
1671     UBool   isWeekend;
1672 } TestWeekendDates;
1673 typedef struct {
1674     const char * locale;
1675     const        TestWeekendDates * dates;
1676     int32_t      numDates;
1677 } TestWeekendDatesList;
1678
1679 static const TestWeekendDates weekendDates_en_US[] = {
1680     { 2000, UCAL_MARCH, 17, 23,  0, 0 }, /* Fri 23:00        */
1681     { 2000, UCAL_MARCH, 18,  0, -1, 0 }, /* Fri 23:59:59.999 */
1682     { 2000, UCAL_MARCH, 18,  0,  0, 1 }, /* Sat 00:00        */
1683     { 2000, UCAL_MARCH, 18, 15,  0, 1 }, /* Sat 15:00        */
1684     { 2000, UCAL_MARCH, 19, 23,  0, 1 }, /* Sun 23:00        */
1685     { 2000, UCAL_MARCH, 20,  0, -1, 1 }, /* Sun 23:59:59.999 */
1686     { 2000, UCAL_MARCH, 20,  0,  0, 0 }, /* Mon 00:00        */
1687     { 2000, UCAL_MARCH, 20,  8,  0, 0 }, /* Mon 08:00        */
1688 };
1689 static const TestWeekendDates weekendDates_ar_OM[] = {
1690     { 2000, UCAL_MARCH, 15, 23,  0, 0 }, /* Wed 23:00        */
1691     { 2000, UCAL_MARCH, 16,  0, -1, 0 }, /* Wed 23:59:59.999 */
1692     { 2000, UCAL_MARCH, 16,  0,  0, 0 }, /* Thu 00:00        */
1693     { 2000, UCAL_MARCH, 16, 15,  0, 0 }, /* Thu 15:00        */
1694     { 2000, UCAL_MARCH, 17, 23,  0, 1 }, /* Fri 23:00        */
1695     { 2000, UCAL_MARCH, 18,  0, -1, 1 }, /* Fri 23:59:59.999 */
1696     { 2000, UCAL_MARCH, 18,  0,  0, 1 }, /* Sat 00:00        */
1697     { 2000, UCAL_MARCH, 18,  8,  0, 1 }, /* Sat 08:00        */
1698 };
1699 static const TestWeekendDatesList testDates[] = {
1700     { "en_US", weekendDates_en_US, UPRV_LENGTHOF(weekendDates_en_US) },
1701     { "ar_OM", weekendDates_ar_OM, UPRV_LENGTHOF(weekendDates_ar_OM) },
1702 };
1703
1704 typedef struct {
1705     UCalendarDaysOfWeek  dayOfWeek;
1706     UCalendarWeekdayType dayType;
1707     int32_t              transition; /* transition time if dayType is UCAL_WEEKEND_ONSET or UCAL_WEEKEND_CEASE; else must be 0 */
1708 } TestDaysOfWeek;
1709 typedef struct {
1710     const char *           locale;
1711     const TestDaysOfWeek * days;
1712     int32_t                numDays;
1713 } TestDaysOfWeekList;
1714
1715 static const TestDaysOfWeek daysOfWeek_en_US[] = {
1716     { UCAL_MONDAY,   UCAL_WEEKDAY,       0        },
1717     { UCAL_FRIDAY,   UCAL_WEEKDAY,       0        },
1718     { UCAL_SATURDAY, UCAL_WEEKEND,       0        },
1719     { UCAL_SUNDAY,   UCAL_WEEKEND,       0        },
1720 };
1721 static const TestDaysOfWeek daysOfWeek_ar_OM[] = { /* Friday:Saturday */
1722     { UCAL_WEDNESDAY,UCAL_WEEKDAY,       0        },
1723     { UCAL_THURSDAY, UCAL_WEEKDAY,       0        },
1724     { UCAL_FRIDAY,   UCAL_WEEKEND,       0        },
1725     { UCAL_SATURDAY, UCAL_WEEKEND,       0        },
1726 };
1727 static const TestDaysOfWeek daysOfWeek_hi_IN[] = { /* Sunday only */
1728     { UCAL_MONDAY,   UCAL_WEEKDAY,       0        },
1729     { UCAL_FRIDAY,   UCAL_WEEKDAY,       0        },
1730     { UCAL_SATURDAY, UCAL_WEEKDAY,       0        },
1731     { UCAL_SUNDAY,   UCAL_WEEKEND,       0        },
1732 };
1733 static const TestDaysOfWeekList testDays[] = {
1734     { "en_US", daysOfWeek_en_US, UPRV_LENGTHOF(daysOfWeek_en_US) },
1735     { "ar_OM", daysOfWeek_ar_OM, UPRV_LENGTHOF(daysOfWeek_ar_OM) },
1736     { "hi_IN", daysOfWeek_hi_IN, UPRV_LENGTHOF(daysOfWeek_hi_IN) },
1737     { "en_US@rg=OMZZZZ", daysOfWeek_ar_OM, UPRV_LENGTHOF(daysOfWeek_ar_OM) },
1738     { "hi@rg=USZZZZ",    daysOfWeek_en_US, UPRV_LENGTHOF(daysOfWeek_en_US) },
1739 };
1740
1741 static const UChar logDateFormat[] = { 0x0045,0x0045,0x0045,0x0020,0x004D,0x004D,0x004D,0x0020,0x0064,0x0064,0x0020,0x0079,
1742                                        0x0079,0x0079,0x0079,0x0020,0x0047,0x0020,0x0048,0x0048,0x003A,0x006D,0x006D,0x003A,
1743                                        0x0073,0x0073,0x002E,0x0053,0x0053,0x0053,0 }; /* "EEE MMM dd yyyy G HH:mm:ss.SSS" */
1744 enum { kFormattedDateMax = 2*UPRV_LENGTHOF(logDateFormat) };
1745
1746 static void TestWeekend() {
1747     const TestWeekendDatesList * testDatesPtr = testDates;
1748     const TestDaysOfWeekList *   testDaysPtr = testDays;
1749     int32_t count, subCount;
1750
1751     UErrorCode fmtStatus = U_ZERO_ERROR;
1752     UDateFormat * fmt = udat_open(UDAT_NONE, UDAT_NONE, "en", NULL, 0, NULL, 0, &fmtStatus);
1753     if (U_SUCCESS(fmtStatus)) {
1754         udat_applyPattern(fmt, FALSE, logDateFormat, -1);
1755     } else {
1756         log_data_err("Unable to create UDateFormat - %s\n", u_errorName(fmtStatus));
1757         return;
1758     }
1759     for (count = UPRV_LENGTHOF(testDates); count-- > 0; ++testDatesPtr) {
1760         UErrorCode status = U_ZERO_ERROR;
1761         UCalendar * cal = ucal_open(NULL, 0, testDatesPtr->locale, UCAL_GREGORIAN, &status);
1762         log_verbose("locale: %s\n", testDatesPtr->locale);
1763         if (U_SUCCESS(status)) {
1764             const TestWeekendDates * weekendDatesPtr = testDatesPtr->dates;
1765             for (subCount = testDatesPtr->numDates; subCount--; ++weekendDatesPtr) {
1766                 UDate dateToTest;
1767                 UBool isWeekend;
1768                 char  fmtDateBytes[kFormattedDateMax] = "<could not format test date>"; /* initialize for failure */
1769
1770                 ucal_clear(cal);
1771                 ucal_setDateTime(cal, weekendDatesPtr->year, weekendDatesPtr->month, weekendDatesPtr->day,
1772                                  weekendDatesPtr->hour, 0, 0, &status);
1773                 dateToTest = ucal_getMillis(cal, &status) + weekendDatesPtr->millisecOffset;
1774                 isWeekend = ucal_isWeekend(cal, dateToTest, &status);
1775                 if (U_SUCCESS(fmtStatus)) {
1776                     UChar fmtDate[kFormattedDateMax];
1777                     (void)udat_format(fmt, dateToTest, fmtDate, kFormattedDateMax, NULL, &fmtStatus);
1778                     if (U_SUCCESS(fmtStatus)) {
1779                         u_austrncpy(fmtDateBytes, fmtDate, kFormattedDateMax);
1780                         fmtDateBytes[kFormattedDateMax-1] = 0;
1781                     } else {
1782                         fmtStatus = U_ZERO_ERROR;
1783                     }
1784                 }
1785                 if ( U_FAILURE(status) ) {
1786                     log_err("FAIL: locale %s date %s isWeekend() status %s\n", testDatesPtr->locale, fmtDateBytes, u_errorName(status) );
1787                     status = U_ZERO_ERROR;
1788                 } else if ( (isWeekend!=0) != (weekendDatesPtr->isWeekend!=0) ) {
1789                     log_err("FAIL: locale %s date %s isWeekend %d, expected the opposite\n", testDatesPtr->locale, fmtDateBytes, isWeekend );
1790                 } else {
1791                     log_verbose("OK:   locale %s date %s isWeekend %d\n", testDatesPtr->locale, fmtDateBytes, isWeekend );
1792                 }
1793             }
1794             ucal_close(cal);
1795         } else {
1796             log_data_err("FAIL: ucal_open for locale %s failed: %s - (Are you missing data?)\n", testDatesPtr->locale, u_errorName(status) );
1797         }
1798     }
1799     if (U_SUCCESS(fmtStatus)) {
1800         udat_close(fmt);
1801     }
1802
1803     for (count = UPRV_LENGTHOF(testDays); count-- > 0; ++testDaysPtr) {
1804         UErrorCode status = U_ZERO_ERROR;
1805         UCalendar * cal = ucal_open(NULL, 0, testDaysPtr->locale, UCAL_GREGORIAN, &status);
1806         log_verbose("locale: %s\n", testDaysPtr->locale);
1807         if (U_SUCCESS(status)) {
1808             const TestDaysOfWeek * daysOfWeekPtr = testDaysPtr->days;
1809             for (subCount = testDaysPtr->numDays; subCount--; ++daysOfWeekPtr) {
1810                 int32_t transition = 0;
1811                 UCalendarWeekdayType dayType = ucal_getDayOfWeekType(cal, daysOfWeekPtr->dayOfWeek, &status);
1812                 if ( dayType == UCAL_WEEKEND_ONSET || dayType == UCAL_WEEKEND_CEASE ) {
1813                     transition = ucal_getWeekendTransition(cal, daysOfWeekPtr->dayOfWeek, &status);
1814                 }
1815                 if ( U_FAILURE(status) ) {
1816                     log_err("FAIL: locale %s DOW %d getDayOfWeekType() status %s\n", testDaysPtr->locale, daysOfWeekPtr->dayOfWeek, u_errorName(status) );
1817                     status = U_ZERO_ERROR;
1818                 } else if ( dayType != daysOfWeekPtr->dayType || transition != daysOfWeekPtr->transition ) {
1819                     log_err("FAIL: locale %s DOW %d type %d, expected %d\n", testDaysPtr->locale, daysOfWeekPtr->dayOfWeek, dayType, daysOfWeekPtr->dayType );
1820                 } else {
1821                     log_verbose("OK:   locale %s DOW %d type %d\n", testDaysPtr->locale, daysOfWeekPtr->dayOfWeek, dayType );
1822                 }
1823             }
1824             ucal_close(cal);
1825         } else {
1826             log_data_err("FAIL: ucal_open for locale %s failed: %s - (Are you missing data?)\n", testDaysPtr->locale, u_errorName(status) );
1827         }
1828     }
1829 }
1830
1831 /**
1832  * TestFieldDifference
1833  */
1834
1835 typedef struct {
1836     const UChar * timezone;
1837     const char *  locale;
1838     UDate         start;
1839     UDate         target;
1840     UBool         progressive; /* TRUE to compute progressive difference for each field, FALSE to reset calendar after each call */
1841     int32_t       yDiff;
1842     int32_t       MDiff;
1843     int32_t       dDiff;
1844     int32_t       HDiff;
1845     int32_t       mDiff;
1846     int32_t       sDiff; /* 0x7FFFFFFF indicates overflow error expected */
1847 } TFDItem;
1848
1849 static const UChar tzUSPacific[] = { 0x55,0x53,0x2F,0x50,0x61,0x63,0x69,0x66,0x69,0x63,0 }; /* "US/Pacific" */
1850 static const UChar tzGMT[] = { 0x47,0x4D,0x54,0 }; /* "GMT" */
1851
1852 static const TFDItem tfdItems[] = {
1853     /* timezone    locale          start              target           progres  yDf  MDf    dDf     HDf       mDf         sDf */
1854     /* For these we compute the progressive difference for each field - not resetting the calendar after each call */
1855     { tzUSPacific, "en_US",        1267459800000.0,   1277772600000.0,  TRUE,     0,   3,    27,      9,       40,          0 }, /* 2010-Mar-01 08:10 -> 2010-Jun-28 17:50 */
1856     { tzUSPacific, "en_US",        1267459800000.0,   1299089280000.0,  TRUE,     1,   0,     1,      1,       58,          0 }, /* 2010-Mar-01 08:10 -> 2011-Mar-02 10:08 */
1857     /* For these we compute the total difference for each field - resetting the calendar after each call */
1858     { tzGMT,       "en_US",        0.0,               1073692800000.0,  FALSE,   34, 408, 12427, 298248, 17894880, 1073692800 }, /* 1970-Jan-01 00:00 -> 2004-Jan-10 00:00 */
1859     { tzGMT,       "en_US",        0.0,               1073779200000.0,  FALSE,   34, 408, 12428, 298272, 17896320, 1073779200 }, /* 1970-Jan-01 00:00 -> 2004-Jan-11 00:00 */
1860     { tzGMT,       "en_US",        0.0,               2147472000000.0,  FALSE,   68, 816, 24855, 596520, 35791200, 2147472000 }, /* 1970-Jan-01 00:00 -> 2038-Jan-19 00:00 */
1861     { tzGMT,       "en_US",        0.0,               2147558400000.0,  FALSE,   68, 816, 24856, 596544, 35792640, 0x7FFFFFFF }, /* 1970-Jan-01 00:00 -> 2038-Jan-20 00:00, seconds diff overflow */
1862     { tzGMT,       "en_US",        0.0,              -1073692800000.0,  FALSE,  -34,-408,-12427,-298248,-17894880,-1073692800 }, /* 1970-Jan-01 00:00 -> 1935-Dec-24 00:00 */
1863     { tzGMT,       "en_US",        0.0,              -1073779200000.0,  FALSE,  -34,-408,-12428,-298272,-17896320,-1073779200 }, /* 1970-Jan-01 00:00 -> 1935-Dec-23 00:00 */
1864     /* check fwd/backward on either side of era boundary and across era boundary */
1865     { tzGMT,       "en_US",       -61978089600000.0,-61820409600000.0,  FALSE,    4,  59,  1825,  43800,  2628000,  157680000 }, /* CE   5-Dec-31 00:00 -> CE  10-Dec-30 00:00 */
1866     { tzGMT,       "en_US",       -61820409600000.0,-61978089600000.0,  FALSE,   -4, -59, -1825, -43800, -2628000, -157680000 }, /* CE  10-Dec-30 00:00 -> CE   5-Dec-31 00:00 */
1867     { tzGMT,       "en_US",       -62451129600000.0,-62293449600000.0,  FALSE,    4,  59,  1825,  43800,  2628000,  157680000 }, /* BCE 10-Jan-04 00:00 -> BCE  5-Jan-03 00:00 */
1868     { tzGMT,       "en_US",       -62293449600000.0,-62451129600000.0,  FALSE,   -4, -59, -1825, -43800, -2628000, -157680000 }, /* BCE  5-Jan-03 00:00 -> BCE 10-Jan-04 00:00 */
1869     { tzGMT,       "en_US",       -62293449600000.0,-61978089600000.0,  FALSE,    9, 119,  3650,  87600,  5256000,  315360000 }, /* BCE  5-Jan-03 00:00 -> CE   5-Dec-31 00:00 */
1870     { tzGMT,       "en_US",       -61978089600000.0,-62293449600000.0,  FALSE,   -9,-119, -3650, -87600, -5256000, -315360000 }, /* CE   5-Dec-31 00:00 -> BCE  5-Jan-03 00:00 */
1871     { tzGMT, "en@calendar=roc",    -1672704000000.0, -1515024000000.0,  FALSE,    4,  59,  1825,  43800,  2628000,  157680000 }, /* MG   5-Dec-30 00:00 -> MG  10-Dec-29 00:00 */
1872     { tzGMT, "en@calendar=roc",    -1515024000000.0, -1672704000000.0,  FALSE,   -4, -59, -1825, -43800, -2628000, -157680000 }, /* MG  10-Dec-29 00:00 -> MG   5-Dec-30 00:00 */
1873     { tzGMT, "en@calendar=roc",    -2145744000000.0, -1988064000000.0,  FALSE,    4,  59,  1825,  43800,  2628000,  157680000 }, /* BMG 10-Jan-03 00:00 -> BMG  5-Jan-02 00:00 */
1874     { tzGMT, "en@calendar=roc",    -1988064000000.0, -2145744000000.0,  FALSE,   -4, -59, -1825, -43800, -2628000, -157680000 }, /* BMG  5-Jan-02 00:00 -> BMG 10-Jan-03 00:00 */
1875     { tzGMT, "en@calendar=roc",    -1988064000000.0, -1672704000000.0,  FALSE,    9, 119,  3650,  87600,  5256000,  315360000 }, /* BMG  5-Jan-02 00:00 -> MG   5-Dec-30 00:00 */
1876     { tzGMT, "en@calendar=roc",    -1672704000000.0, -1988064000000.0,  FALSE,   -9,-119, -3650, -87600, -5256000, -315360000 }, /* MG   5-Dec-30 00:00 -> BMG  5-Jan-02 00:00 */
1877     { tzGMT, "en@calendar=coptic",-53026531200000.0,-52868851200000.0,  FALSE,    4,  64,  1825,  43800,  2628000,  157680000 }, /* Er1  5-Nas-05 00:00 -> Er1 10-Nas-04 00:00 */
1878     { tzGMT, "en@calendar=coptic",-52868851200000.0,-53026531200000.0,  FALSE,   -4, -64, -1825, -43800, -2628000, -157680000 }, /* Er1 10-Nas-04 00:00 -> Er1  5-Nas-05 00:00 */
1879     { tzGMT, "en@calendar=coptic",-53499571200000.0,-53341891200000.0,  FALSE,    4,  64,  1825,  43800,  2628000,  157680000 }, /* Er0 10-Tou-04 00:00 -> Er0  5-Tou-02 00:00 */
1880     { tzGMT, "en@calendar=coptic",-53341891200000.0,-53499571200000.0,  FALSE,   -4, -64, -1825, -43800, -2628000, -157680000 }, /* Er0  5-Tou-02 00:00 -> Er0 10-Tou-04 00:00 */
1881     { tzGMT, "en@calendar=coptic",-53341891200000.0,-53026531200000.0,  FALSE,    9, 129,  3650,  87600,  5256000,  315360000 }, /* Er0  5-Tou-02 00:00 -> Er1  5-Nas-05 00:00 */
1882     { tzGMT, "en@calendar=coptic",-53026531200000.0,-53341891200000.0,  FALSE,   -9,-129, -3650, -87600, -5256000, -315360000 }, /* Er1  5-Nas-05 00:00 -> Er0  5-Tou-02 00:00 */
1883     { NULL,        NULL,           0.0,               0.0,              FALSE,    0,   0,     0,      0,        0,          0 }  /* terminator */
1884 };
1885
1886 void TestFieldDifference() {
1887     const TFDItem * tfdItemPtr;
1888     for (tfdItemPtr = tfdItems; tfdItemPtr->timezone != NULL; tfdItemPtr++) {
1889         UErrorCode status = U_ZERO_ERROR;
1890         UCalendar* ucal = ucal_open(tfdItemPtr->timezone, -1, tfdItemPtr->locale, UCAL_DEFAULT, &status);
1891         if (U_FAILURE(status)) {
1892             log_err("FAIL: for locale \"%s\", ucal_open had status %s\n", tfdItemPtr->locale, u_errorName(status) );
1893         } else {
1894             int32_t yDf, MDf, dDf, HDf, mDf, sDf;
1895             if (tfdItemPtr->progressive) {
1896                 ucal_setMillis(ucal, tfdItemPtr->start, &status);
1897                 yDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_YEAR, &status);
1898                 MDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_MONTH, &status);
1899                 dDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_DATE, &status);
1900                 HDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_HOUR, &status);
1901                 mDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_MINUTE, &status);
1902                 sDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_SECOND, &status);
1903                 if (U_FAILURE(status)) {
1904                     log_err("FAIL: for locale \"%s\", start %.1f, target %.1f, ucal_setMillis or ucal_getFieldDifference had status %s\n",
1905                             tfdItemPtr->locale, tfdItemPtr->start, tfdItemPtr->target, u_errorName(status) );
1906                 } else if ( yDf !=  tfdItemPtr->yDiff ||
1907                             MDf !=  tfdItemPtr->MDiff ||
1908                             dDf !=  tfdItemPtr->dDiff ||
1909                             HDf !=  tfdItemPtr->HDiff ||
1910                             mDf !=  tfdItemPtr->mDiff ||
1911                             sDf !=  tfdItemPtr->sDiff ) {
1912                     log_data_err("FAIL: for locale \"%s\", start %.1f, target %.1f, expected y-M-d-H-m-s progressive diffs %d-%d-%d-%d-%d-%d, got %d-%d-%d-%d-%d-%d\n",
1913                             tfdItemPtr->locale, tfdItemPtr->start, tfdItemPtr->target,
1914                             tfdItemPtr->yDiff, tfdItemPtr->MDiff, tfdItemPtr->dDiff, tfdItemPtr->HDiff, tfdItemPtr->mDiff, tfdItemPtr->sDiff,
1915                             yDf, MDf, dDf, HDf, mDf, sDf);
1916                 }
1917             } else {
1918                 ucal_setMillis(ucal, tfdItemPtr->start, &status);
1919                 yDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_YEAR, &status);
1920                 ucal_setMillis(ucal, tfdItemPtr->start, &status);
1921                 MDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_MONTH, &status);
1922                 ucal_setMillis(ucal, tfdItemPtr->start, &status);
1923                 dDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_DATE, &status);
1924                 ucal_setMillis(ucal, tfdItemPtr->start, &status);
1925                 HDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_HOUR, &status);
1926                 ucal_setMillis(ucal, tfdItemPtr->start, &status);
1927                 mDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_MINUTE, &status);
1928                 if (U_FAILURE(status)) {
1929                     log_err("FAIL: for locale \"%s\", start %.1f, target %.1f, ucal_setMillis or ucal_getFieldDifference (y-M-d-H-m) had status %s\n",
1930                             tfdItemPtr->locale, tfdItemPtr->start, tfdItemPtr->target, u_errorName(status) );
1931                 } else if ( yDf !=  tfdItemPtr->yDiff ||
1932                             MDf !=  tfdItemPtr->MDiff ||
1933                             dDf !=  tfdItemPtr->dDiff ||
1934                             HDf !=  tfdItemPtr->HDiff ||
1935                             mDf !=  tfdItemPtr->mDiff ) {
1936                     log_data_err("FAIL: for locale \"%s\", start %.1f, target %.1f, expected y-M-d-H-m total diffs %d-%d-%d-%d-%d, got %d-%d-%d-%d-%d\n",
1937                             tfdItemPtr->locale, tfdItemPtr->start, tfdItemPtr->target,
1938                             tfdItemPtr->yDiff, tfdItemPtr->MDiff, tfdItemPtr->dDiff, tfdItemPtr->HDiff, tfdItemPtr->mDiff,
1939                             yDf, MDf, dDf, HDf, mDf);
1940                 }
1941                 ucal_setMillis(ucal, tfdItemPtr->start, &status);
1942                 sDf = ucal_getFieldDifference(ucal, tfdItemPtr->target, UCAL_SECOND, &status);
1943                 if (tfdItemPtr->sDiff != 0x7FFFFFFF) {
1944                     if (U_FAILURE(status)) {
1945                         log_err("FAIL: for locale \"%s\", start %.1f, target %.1f, ucal_setMillis or ucal_getFieldDifference (seconds) had status %s\n",
1946                                 tfdItemPtr->locale, tfdItemPtr->start, tfdItemPtr->target, u_errorName(status) );
1947                     } else if (sDf !=  tfdItemPtr->sDiff) {
1948                         log_data_err("FAIL: for locale \"%s\", start %.1f, target %.1f, expected seconds progressive diff %d, got %d\n",
1949                                 tfdItemPtr->locale, tfdItemPtr->start, tfdItemPtr->target, tfdItemPtr->sDiff, sDf);
1950                     }
1951                 } else if (!U_FAILURE(status)) {
1952                     log_err("FAIL: for locale \"%s\", start %.1f, target %.1f, for ucal_getFieldDifference (seconds) expected overflow error, got none\n",
1953                             tfdItemPtr->locale, tfdItemPtr->start, tfdItemPtr->target );
1954                 }
1955             }
1956             ucal_close(ucal);
1957         }
1958     }
1959 }
1960
1961 void TestAmbiguousWallTime() {
1962     UErrorCode status = U_ZERO_ERROR;
1963     UChar tzID[32];
1964     UCalendar* ucal;
1965     UDate t, expected;
1966
1967     u_uastrcpy(tzID, "America/New_York");
1968     ucal = ucal_open(tzID, -1, NULL, UCAL_DEFAULT, &status);
1969     if (U_FAILURE(status)) {
1970         log_err("FAIL: Failed to create a calendar");
1971         return;
1972     }
1973
1974     if (ucal_getAttribute(ucal, UCAL_REPEATED_WALL_TIME) != UCAL_WALLTIME_LAST) {
1975         log_err("FAIL: Default UCAL_REPEATED_WALL_TIME value is not UCAL_WALLTIME_LAST");
1976     }
1977
1978     if (ucal_getAttribute(ucal, UCAL_SKIPPED_WALL_TIME) != UCAL_WALLTIME_LAST) {
1979         log_err("FAIL: Default UCAL_SKIPPED_WALL_TIME value is not UCAL_WALLTIME_LAST");
1980     }
1981
1982     /* UCAL_WALLTIME_FIRST on US fall transition */
1983     ucal_setAttribute(ucal, UCAL_REPEATED_WALL_TIME, UCAL_WALLTIME_FIRST);
1984     ucal_clear(ucal);
1985     ucal_setDateTime(ucal, 2011, 11-1, 6, 1, 30, 0, &status);
1986     t = ucal_getMillis(ucal, &status);
1987     expected = 1320557400000.0; /* 2011-11-06T05:30:00Z */
1988     if (U_FAILURE(status)) {
1989         log_err("FAIL: Calculating time 2011-11-06 01:30:00 with UCAL_WALLTIME_FIRST - %s\n", u_errorName(status));
1990         status = U_ZERO_ERROR;
1991     } else if (t != expected) {
1992         log_data_err("FAIL: 2011-11-06 01:30:00 with UCAL_WALLTIME_FIRST - got: %f, expected: %f\n", t, expected);
1993     }
1994
1995     /* UCAL_WALLTIME_LAST on US fall transition */
1996     ucal_setAttribute(ucal, UCAL_REPEATED_WALL_TIME, UCAL_WALLTIME_LAST);
1997     ucal_clear(ucal);
1998     ucal_setDateTime(ucal, 2011, 11-1, 6, 1, 30, 0, &status);
1999     t = ucal_getMillis(ucal, &status);
2000     expected = 1320561000000.0; /* 2011-11-06T06:30:00Z */
2001     if (U_FAILURE(status)) {
2002         log_err("FAIL: Calculating time 2011-11-06 01:30:00 with UCAL_WALLTIME_LAST - %s\n", u_errorName(status));
2003         status = U_ZERO_ERROR;
2004     } else if (t != expected) {
2005         log_data_err("FAIL: 2011-11-06 01:30:00 with UCAL_WALLTIME_LAST - got: %f, expected: %f\n", t, expected);
2006     }
2007
2008     /* UCAL_WALLTIME_FIRST on US spring transition */
2009     ucal_setAttribute(ucal, UCAL_SKIPPED_WALL_TIME, UCAL_WALLTIME_FIRST);
2010     ucal_clear(ucal);
2011     ucal_setDateTime(ucal, 2011, 3-1, 13, 2, 30, 0, &status);
2012     t = ucal_getMillis(ucal, &status);
2013     expected = 1299997800000.0; /* 2011-03-13T06:30:00Z */
2014     if (U_FAILURE(status)) {
2015         log_err("FAIL: Calculating time 2011-03-13 02:30:00 with UCAL_WALLTIME_FIRST - %s\n", u_errorName(status));
2016         status = U_ZERO_ERROR;
2017     } else if (t != expected) {
2018         log_data_err("FAIL: 2011-03-13 02:30:00 with UCAL_WALLTIME_FIRST - got: %f, expected: %f\n", t, expected);
2019     }
2020
2021     /* UCAL_WALLTIME_LAST on US spring transition */
2022     ucal_setAttribute(ucal, UCAL_SKIPPED_WALL_TIME, UCAL_WALLTIME_LAST);
2023     ucal_clear(ucal);
2024     ucal_setDateTime(ucal, 2011, 3-1, 13, 2, 30, 0, &status);
2025     t = ucal_getMillis(ucal, &status);
2026     expected = 1300001400000.0; /* 2011-03-13T07:30:00Z */
2027     if (U_FAILURE(status)) {
2028         log_err("FAIL: Calculating time 2011-03-13 02:30:00 with UCAL_WALLTIME_LAST - %s\n", u_errorName(status));
2029         status = U_ZERO_ERROR;
2030     } else if (t != expected) {
2031         log_data_err("FAIL: 2011-03-13 02:30:00 with UCAL_WALLTIME_LAST - got: %f, expected: %f\n", t, expected);
2032     }
2033
2034     /* UCAL_WALLTIME_NEXT_VALID on US spring transition */
2035     ucal_setAttribute(ucal, UCAL_SKIPPED_WALL_TIME, UCAL_WALLTIME_NEXT_VALID);
2036     ucal_clear(ucal);
2037     ucal_setDateTime(ucal, 2011, 3-1, 13, 2, 30, 0, &status);
2038     t = ucal_getMillis(ucal, &status);
2039     expected = 1299999600000.0; /* 2011-03-13T07:00:00Z */
2040     if (U_FAILURE(status)) {
2041         log_err("FAIL: Calculating time 2011-03-13 02:30:00 with UCAL_WALLTIME_NEXT_VALID - %s\n", u_errorName(status));
2042         status = U_ZERO_ERROR;
2043     } else if (t != expected) {
2044         log_data_err("FAIL: 2011-03-13 02:30:00 with UCAL_WALLTIME_NEXT_VALID - got: %f, expected: %f\n", t, expected);
2045     }
2046
2047     /* non-lenient on US spring transition */
2048     ucal_setAttribute(ucal, UCAL_LENIENT, 0);
2049     ucal_clear(ucal);
2050     ucal_setDateTime(ucal, 2011, 3-1, 13, 2, 30, 0, &status);
2051     t = ucal_getMillis(ucal, &status);
2052     if (U_SUCCESS(status)) {
2053         /* must return error */
2054         log_data_err("FAIL: Non-lenient did not fail with 2011-03-13 02:30:00\n");
2055         status = U_ZERO_ERROR;
2056     }
2057
2058     ucal_close(ucal);
2059 }
2060
2061 /**
2062  * TestAddRollEra0AndEraBounds, for #9226
2063  */
2064
2065  typedef struct {
2066      const char * locale;
2067      UBool era0YearsGoBackwards; /* until we have API to get this, per #9393 */
2068  } EraTestItem;
2069
2070 static const EraTestItem eraTestItems[] = {
2071     /* calendars with non-modern era 0 that goes backwards, max era == 1 */
2072     { "en@calendar=gregorian", TRUE },
2073     { "en@calendar=roc", TRUE },
2074     { "en@calendar=coptic", TRUE },
2075     /* calendars with non-modern era 0 that goes forwards, max era > 1 */
2076     { "en@calendar=japanese", FALSE },
2077     { "en@calendar=chinese", FALSE },
2078     /* calendars with non-modern era 0 that goes forwards, max era == 1 */
2079     { "en@calendar=ethiopic", FALSE },
2080     /* calendars with only one era  = 0, forwards */
2081     { "en@calendar=buddhist", FALSE },
2082     { "en@calendar=hebrew", FALSE },
2083     { "en@calendar=islamic", FALSE },
2084     { "en@calendar=indian", FALSE },
2085     { "en@calendar=persian", FALSE },
2086     { "en@calendar=ethiopic-amete-alem", FALSE },
2087     { NULL, FALSE }
2088 };
2089
2090 static const UChar zoneGMT[] = { 0x47,0x4D,0x54,0 };
2091
2092 void TestAddRollEra0AndEraBounds() {
2093     const EraTestItem * eraTestItemPtr;
2094     for (eraTestItemPtr = eraTestItems; eraTestItemPtr->locale != NULL; eraTestItemPtr++) {
2095         UErrorCode status = U_ZERO_ERROR;
2096         UCalendar *ucalTest = ucal_open(zoneGMT, -1, eraTestItemPtr->locale, UCAL_DEFAULT, &status);
2097         if ( U_SUCCESS(status) ) {
2098             int32_t yrBefore, yrAfter, yrMax, eraAfter, eraMax, eraNow;
2099
2100             status = U_ZERO_ERROR;
2101             ucal_clear(ucalTest);
2102             ucal_set(ucalTest, UCAL_YEAR, 2);
2103             ucal_set(ucalTest, UCAL_ERA, 0);
2104             yrBefore = ucal_get(ucalTest, UCAL_YEAR, &status);
2105             ucal_add(ucalTest, UCAL_YEAR, 1, &status);
2106             yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2107             if (U_FAILURE(status)) {
2108                 log_err("FAIL: set era 0 year 2 then add 1 year and get year for %s, error %s\n",
2109                         eraTestItemPtr->locale, u_errorName(status));
2110             } else if ( (eraTestItemPtr->era0YearsGoBackwards && yrAfter>yrBefore) ||
2111                         (!eraTestItemPtr->era0YearsGoBackwards && yrAfter<yrBefore) ) {
2112                 log_err("FAIL: era 0 add 1 year does not move forward in time for %s\n", eraTestItemPtr->locale);
2113             }
2114
2115             status = U_ZERO_ERROR;
2116             ucal_clear(ucalTest);
2117             ucal_set(ucalTest, UCAL_YEAR, 2);
2118             ucal_set(ucalTest, UCAL_ERA, 0);
2119             yrBefore = ucal_get(ucalTest, UCAL_YEAR, &status);
2120             ucal_roll(ucalTest, UCAL_YEAR, 1, &status);
2121             yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2122             if (U_FAILURE(status)) {
2123                 log_err("FAIL: set era 0 year 2 then roll 1 year and get year for %s, error %s\n",
2124                         eraTestItemPtr->locale, u_errorName(status));
2125             } else if ( (eraTestItemPtr->era0YearsGoBackwards && yrAfter>yrBefore) ||
2126                         (!eraTestItemPtr->era0YearsGoBackwards && yrAfter<yrBefore) ) {
2127                 log_err("FAIL: era 0 roll 1 year does not move forward in time for %s\n", eraTestItemPtr->locale);
2128             }
2129
2130             status = U_ZERO_ERROR;
2131             ucal_clear(ucalTest);
2132             ucal_set(ucalTest, UCAL_YEAR, 1);
2133             ucal_set(ucalTest, UCAL_ERA, 0);
2134             if (eraTestItemPtr->era0YearsGoBackwards) {
2135                 ucal_roll(ucalTest, UCAL_YEAR, 1, &status); /* roll forward in time to era 0 boundary */
2136                 yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2137                 eraAfter = ucal_get(ucalTest, UCAL_ERA, &status);
2138                 if (U_FAILURE(status)) {
2139                     log_err("FAIL: set era 0 year 1 then roll 1 year and get year,era for %s, error %s\n",
2140                             eraTestItemPtr->locale, u_errorName(status));
2141                 /* all calendars with era0YearsGoBackwards have "unbounded" era0 year values, so we should pin at yr 1 */
2142                 } else if (eraAfter != 0 || yrAfter != 1) {
2143                     log_err("FAIL: era 0 roll 1 year from year 1 does not stay within era or pin to year 1 for %s (get era %d year %d)\n",
2144                             eraTestItemPtr->locale, eraAfter, yrAfter);
2145                 }
2146             } else {
2147                 /* roll backward in time to where era 0 years go negative, except for the Chinese
2148                    calendar, which uses negative eras instead of having years outside the range 1-60 */
2149                 const char * calType = ucal_getType(ucalTest, &status);
2150                 ucal_roll(ucalTest, UCAL_YEAR, -2, &status);
2151                 yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2152                 eraAfter = ucal_get(ucalTest, UCAL_ERA, &status);
2153                 if (U_FAILURE(status)) {
2154                     log_err("FAIL: set era 0 year 1 then roll -2 years and get year,era for %s, error %s\n",
2155                             eraTestItemPtr->locale, u_errorName(status));
2156                 } else if ( uprv_strcmp(calType,"chinese")!=0 && (eraAfter != 0 || yrAfter != -1) ) {
2157                     log_err("FAIL: era 0 roll -2 years from year 1 does not stay within era or produce year -1 for %s (get era %d year %d)\n",
2158                             eraTestItemPtr->locale, eraAfter, yrAfter);
2159                 }
2160             }
2161
2162             status = U_ZERO_ERROR;
2163             ucal_clear(ucalTest);
2164             {
2165                 int32_t eraMin = ucal_getLimit(ucalTest, UCAL_ERA, UCAL_MINIMUM, &status);
2166                 const char * calType = ucal_getType(ucalTest, &status);
2167                 if (eraMin != 0 && uprv_strcmp(calType, "chinese") != 0) {
2168                     log_err("FAIL: ucal_getLimit returns minimum era %d (should be 0) for calType %s, error %s\n", eraMin, calType, u_errorName(status));
2169                 }
2170             }
2171
2172             status = U_ZERO_ERROR;
2173             ucal_clear(ucalTest);
2174             ucal_set(ucalTest, UCAL_YEAR, 1);
2175             ucal_set(ucalTest, UCAL_ERA, 0);
2176             eraMax = ucal_getLimit(ucalTest, UCAL_ERA, UCAL_MAXIMUM, &status);
2177             if ( U_SUCCESS(status) && eraMax > 0 ) {
2178                 /* try similar tests for era 1 (if calendar has it), in which years always go forward */
2179                 status = U_ZERO_ERROR;
2180                 ucal_clear(ucalTest);
2181                 ucal_set(ucalTest, UCAL_YEAR, 2);
2182                 ucal_set(ucalTest, UCAL_ERA, 1);
2183                 yrBefore = ucal_get(ucalTest, UCAL_YEAR, &status);
2184                 ucal_add(ucalTest, UCAL_YEAR, 1, &status);
2185                 yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2186                 if (U_FAILURE(status)) {
2187                     log_err("FAIL: set era 1 year 2 then add 1 year and get year for %s, error %s\n",
2188                             eraTestItemPtr->locale, u_errorName(status));
2189                 } else if ( yrAfter<yrBefore ) {
2190                     log_err("FAIL: era 1 add 1 year does not move forward in time for %s\n", eraTestItemPtr->locale);
2191                 }
2192
2193                 status = U_ZERO_ERROR;
2194                 ucal_clear(ucalTest);
2195                 ucal_set(ucalTest, UCAL_YEAR, 2);
2196                 ucal_set(ucalTest, UCAL_ERA, 1);
2197                 yrBefore = ucal_get(ucalTest, UCAL_YEAR, &status);
2198                 ucal_roll(ucalTest, UCAL_YEAR, 1, &status);
2199                 yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2200                 if (U_FAILURE(status)) {
2201                     log_err("FAIL: set era 1 year 2 then roll 1 year and get year for %s, error %s\n",
2202                             eraTestItemPtr->locale, u_errorName(status));
2203                 } else if ( yrAfter<yrBefore ) {
2204                     log_err("FAIL: era 1 roll 1 year does not move forward in time for %s\n", eraTestItemPtr->locale);
2205                 }
2206
2207                 status = U_ZERO_ERROR;
2208                 ucal_clear(ucalTest);
2209                 ucal_set(ucalTest, UCAL_YEAR, 1);
2210                 ucal_set(ucalTest, UCAL_ERA, 1);
2211                 yrMax = ucal_getLimit(ucalTest, UCAL_YEAR, UCAL_ACTUAL_MAXIMUM, &status); /* max year value for era 1 */
2212                 ucal_roll(ucalTest, UCAL_YEAR, -1, &status); /* roll down which should pin or wrap to end */
2213                 yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2214                 eraAfter = ucal_get(ucalTest, UCAL_ERA, &status);
2215                 if (U_FAILURE(status)) {
2216                     log_err("FAIL: set era 1 year 1 then roll -1 year and get year,era for %s, error %s\n",
2217                             eraTestItemPtr->locale, u_errorName(status));
2218                 /* if yrMax is reasonable we should wrap to that, else we should pin at yr 1 */
2219                 } else if (yrMax >= 32768) {
2220                     if (eraAfter != 1 || yrAfter != 1) {
2221                         log_err("FAIL: era 1 roll -1 year from year 1 does not stay within era or pin to year 1 for %s (get era %d year %d)\n",
2222                                 eraTestItemPtr->locale, eraAfter, yrAfter);
2223                     }
2224                 } else if (eraAfter != 1 || yrAfter != yrMax) {
2225                     log_err("FAIL: era 1 roll -1 year from year 1 does not stay within era or wrap to year %d for %s (get era %d year %d)\n",
2226                             yrMax, eraTestItemPtr->locale, eraAfter, yrAfter);
2227                 } else {
2228                     /* now roll up which should wrap to beginning */
2229                     ucal_roll(ucalTest, UCAL_YEAR, 1, &status); /* now roll up which should wrap to beginning */
2230                     yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2231                     eraAfter = ucal_get(ucalTest, UCAL_ERA, &status);
2232                     if (U_FAILURE(status)) {
2233                         log_err("FAIL: era 1 roll 1 year from end and get year,era for %s, error %s\n",
2234                                 eraTestItemPtr->locale, u_errorName(status));
2235                     } else if (eraAfter != 1 || yrAfter != 1) {
2236                         log_err("FAIL: era 1 roll 1 year from year %d does not stay within era or wrap to year 1 for %s (get era %d year %d)\n",
2237                                 yrMax, eraTestItemPtr->locale, eraAfter, yrAfter);
2238                     }
2239                 }
2240
2241                 /* if current era  > 1, try the same roll tests for current era */
2242                 ucal_setMillis(ucalTest, ucal_getNow(), &status);
2243                 eraNow = ucal_get(ucalTest, UCAL_ERA, &status);
2244                 if ( U_SUCCESS(status) && eraNow > 1 ) {
2245                     status = U_ZERO_ERROR;
2246                     ucal_clear(ucalTest);
2247                     ucal_set(ucalTest, UCAL_YEAR, 1);
2248                     ucal_set(ucalTest, UCAL_ERA, eraNow);
2249                     yrMax = ucal_getLimit(ucalTest, UCAL_YEAR, UCAL_ACTUAL_MAXIMUM, &status); /* max year value for this era */
2250                     ucal_roll(ucalTest, UCAL_YEAR, -1, &status);
2251                     yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2252                     eraAfter = ucal_get(ucalTest, UCAL_ERA, &status);
2253                     if (U_FAILURE(status)) {
2254                         log_err("FAIL: set era %d year 1 then roll -1 year and get year,era for %s, error %s\n",
2255                                 eraNow, eraTestItemPtr->locale, u_errorName(status));
2256                     /* if yrMax is reasonable we should wrap to that, else we should pin at yr 1 */
2257                     } else if (yrMax >= 32768) {
2258                         if (eraAfter != eraNow || yrAfter != 1) {
2259                             log_err("FAIL: era %d roll -1 year from year 1 does not stay within era or pin to year 1 for %s (get era %d year %d)\n",
2260                                     eraNow, eraTestItemPtr->locale, eraAfter, yrAfter);
2261                         }
2262                     } else if (eraAfter != eraNow || yrAfter != yrMax) {
2263                         log_err("FAIL: era %d roll -1 year from year 1 does not stay within era or wrap to year %d for %s (get era %d year %d)\n",
2264                                 eraNow, yrMax, eraTestItemPtr->locale, eraAfter, yrAfter);
2265                     } else {
2266                         /* now roll up which should wrap to beginning */
2267                         ucal_roll(ucalTest, UCAL_YEAR, 1, &status); /* now roll up which should wrap to beginning */
2268                         yrAfter = ucal_get(ucalTest, UCAL_YEAR, &status);
2269                         eraAfter = ucal_get(ucalTest, UCAL_ERA, &status);
2270                         if (U_FAILURE(status)) {
2271                             log_err("FAIL: era %d roll 1 year from end and get year,era for %s, error %s\n",
2272                                     eraNow, eraTestItemPtr->locale, u_errorName(status));
2273                         } else if (eraAfter != eraNow || yrAfter != 1) {
2274                             log_err("FAIL: era %d roll 1 year from year %d does not stay within era or wrap to year 1 for %s (get era %d year %d)\n",
2275                                     eraNow, yrMax, eraTestItemPtr->locale, eraAfter, yrAfter);
2276                         }
2277                     }
2278                 }
2279             }
2280
2281             ucal_close(ucalTest);
2282         } else {
2283             log_data_err("FAIL: ucal_open fails for zone GMT, locale %s, UCAL_DEFAULT\n", eraTestItemPtr->locale);
2284         }
2285     }
2286 }
2287
2288 /**
2289  * TestGetTZTransition, for #9606
2290  */
2291
2292 typedef struct {
2293     const char *descrip;    /* test description */
2294     const UChar * zoneName; /* pointer to zero-terminated zone name */
2295     int32_t year;           /* starting point for test is gregorian calendar noon on day specified by y,M,d here */
2296     int32_t month;
2297     int32_t day;
2298     UBool hasPrev;          /* does it have a previous transition from starting point? If so we test inclusive from that */
2299     UBool hasNext;          /* does it have a next transition from starting point? If so we test inclusive from that */
2300 } TZTransitionItem;
2301
2302 /* have zoneGMT above */
2303 static const UChar zoneUSPacific[] = { 0x55,0x53,0x2F,0x50,0x61,0x63,0x69,0x66,0x69,0x63,0 }; /* "US/Pacific" */
2304 static const UChar zoneCairo[]     = { 0x41,0x66,0x72,0x69,0x63,0x61,0x2F,0x43,0x61,0x69,0x72,0x6F,0 }; /* "Africa/Cairo", DST cancelled since 2011 */
2305 static const UChar zoneIceland[]   = { 0x41,0x74,0x6C,0x61,0x6E,0x74,0x69,0x63,0x2F,0x52,0x65,0x79,0x6B,0x6A,0x61,0x76,0x69,0x6B,0 }; /* "Atlantic/Reykjavik", always on DST (since when?) */
2306
2307 static const TZTransitionItem tzTransitionItems[] = {
2308     { "USPacific mid 2012", zoneUSPacific, 2012, UCAL_JULY, 1, TRUE , TRUE  },
2309     { "USPacific mid  100", zoneUSPacific,  100, UCAL_JULY, 1, FALSE, TRUE  }, /* no transitions before 100 CE... */
2310     { "Cairo     mid 2012", zoneCairo,     2012, UCAL_JULY, 1, TRUE , TRUE  }, /* DST cancelled since 2011 (Changed since 2014c) */
2311     { "Iceland   mid 2012", zoneIceland,   2012, UCAL_JULY, 1, TRUE , FALSE }, /* always on DST */
2312     { NULL,                 NULL,             0,         0, 0, FALSE, FALSE } /* terminator */
2313 };
2314
2315 void TestGetTZTransition() {
2316     UErrorCode status = U_ZERO_ERROR;
2317     UCalendar * ucal = ucal_open(zoneGMT, -1, "en", UCAL_GREGORIAN, &status);
2318     if ( U_SUCCESS(status) ) {
2319         const TZTransitionItem * itemPtr;
2320         for (itemPtr = tzTransitionItems; itemPtr->descrip != NULL; itemPtr++) {
2321             UDate curMillis;
2322             ucal_setTimeZone(ucal, itemPtr->zoneName, -1, &status);
2323             ucal_setDateTime(ucal, itemPtr->year, itemPtr->month, itemPtr->day, 12, 0, 0, &status);
2324             curMillis = ucal_getMillis(ucal, &status);
2325             (void)curMillis;    /* Suppress set but not used warning. */
2326             if ( U_SUCCESS(status) ) {
2327                 UDate transition1, transition2;
2328                 UBool result;
2329
2330                 result = ucal_getTimeZoneTransitionDate(ucal, UCAL_TZ_TRANSITION_PREVIOUS, &transition1, &status);
2331                 if (U_FAILURE(status) || result != itemPtr->hasPrev) {
2332                     log_data_err("FAIL: %s ucal_getTimeZoneTransitionDate prev status %s, expected result %d but got %d\n",
2333                             itemPtr->descrip, u_errorName(status), itemPtr->hasPrev, result);
2334                 } else if (result) {
2335                     ucal_setMillis(ucal, transition1, &status);
2336                     result = ucal_getTimeZoneTransitionDate(ucal, UCAL_TZ_TRANSITION_PREVIOUS_INCLUSIVE, &transition2, &status);
2337                     if (U_FAILURE(status) || !result || transition2 != transition1) {
2338                         log_err("FAIL: %s ucal_getTimeZoneTransitionDate prev_inc status %s, result %d, expected date %.1f but got %.1f\n",
2339                                 itemPtr->descrip, u_errorName(status), result, transition1, transition2);
2340                     }
2341                 }
2342                 status = U_ZERO_ERROR;
2343
2344                 result = ucal_getTimeZoneTransitionDate(ucal, UCAL_TZ_TRANSITION_NEXT, &transition1, &status);
2345                 if (U_FAILURE(status) || result != itemPtr->hasNext) {
2346                     log_data_err("FAIL: %s ucal_getTimeZoneTransitionDate next status %s, expected result %d but got %d\n",
2347                             itemPtr->descrip, u_errorName(status), itemPtr->hasNext, result);
2348                 } else if (result) {
2349                     ucal_setMillis(ucal, transition1, &status);
2350                     result = ucal_getTimeZoneTransitionDate(ucal, UCAL_TZ_TRANSITION_NEXT_INCLUSIVE, &transition2, &status);
2351                     if (U_FAILURE(status) || !result || transition2 != transition1) {
2352                         log_err("FAIL: %s ucal_getTimeZoneTransitionDate next_inc status %s, result %d, expected date %.1f but got %.1f\n",
2353                                 itemPtr->descrip, u_errorName(status), result, transition1, transition2);
2354                     }
2355                 }
2356                 status = U_ZERO_ERROR;
2357             } else {
2358                 log_data_err("FAIL setup: can't setup calendar for %s, status %s\n",
2359                             itemPtr->descrip, u_errorName(status));
2360                 status = U_ZERO_ERROR;
2361             }
2362         }
2363         ucal_close(ucal);
2364     } else {
2365         log_data_err("FAIL setup: ucal_open status %s\n", u_errorName(status));
2366     }
2367 }
2368
2369 static const UChar winEastern[] = /* Eastern Standard Time */
2370     {0x45,0x61,0x73,0x74,0x65,0x72,0x6E,0x20,0x53,0x74,0x61,0x6E,0x64,0x61,0x72,0x64,0x20,0x54,0x69,0x6D,0x65,0x00};
2371
2372 static const UChar tzNewYork[] = /* America/New_York */
2373     {0x41,0x6D,0x65,0x72,0x69,0x63,0x61,0x2F,0x4E,0x65,0x77,0x5F,0x59,0x6F,0x72,0x6B,0x00};
2374 static const UChar tzTronto[] = /* America/Toronto */
2375     {0x41,0x6D,0x65,0x72,0x69,0x63,0x61,0x2F,0x54,0x6F,0x72,0x6F,0x6E,0x74,0x6F,0x00};
2376
2377 static const UChar sBogus[] = /* Bogus */
2378     {0x42,0x6F,0x67,0x75,0x73,0x00};
2379
2380 void TestGetWindowsTimeZoneID() {
2381     UErrorCode status;
2382     UChar winID[64];
2383     int32_t len;
2384
2385     {
2386         status = U_ZERO_ERROR;
2387         len = ucal_getWindowsTimeZoneID(tzNewYork, u_strlen(tzNewYork), winID, UPRV_LENGTHOF(winID), &status);
2388         if (U_FAILURE(status)) {
2389             log_data_err("FAIL: Windows ID for America/New_York, status %s\n", u_errorName(status));
2390         } else if (len != u_strlen(winEastern) || u_strncmp(winID, winEastern, len) != 0) {
2391             log_data_err("FAIL: Windows ID for America/New_York\n");
2392         }
2393     }
2394     {
2395         status = U_ZERO_ERROR;
2396         len = ucal_getWindowsTimeZoneID(tzTronto, u_strlen(tzTronto), winID, UPRV_LENGTHOF(winID), &status);
2397         if (U_FAILURE(status)) {
2398             log_data_err("FAIL: Windows ID for America/Toronto, status %s\n", u_errorName(status));
2399         } else if (len != u_strlen(winEastern) || u_strncmp(winID, winEastern, len) != 0) {
2400             log_data_err("FAIL: Windows ID for America/Toronto\n");
2401         }
2402     }
2403     {
2404         status = U_ZERO_ERROR;
2405         len = ucal_getWindowsTimeZoneID(sBogus, u_strlen(sBogus), winID, UPRV_LENGTHOF(winID), &status);
2406         if (U_FAILURE(status)) {
2407             log_data_err("FAIL: Windows ID for Bogus, status %s\n", u_errorName(status));
2408         } else if (len != 0) {
2409             log_data_err("FAIL: Windows ID for Bogus\n");
2410         }
2411     }
2412 }
2413
2414 void TestGetTimeZoneIDByWindowsID() {
2415     UErrorCode status;
2416     UChar tzID[64];
2417     int32_t len;
2418
2419     {
2420         status = U_ZERO_ERROR;
2421         len = ucal_getTimeZoneIDForWindowsID(winEastern, -1, NULL, tzID, UPRV_LENGTHOF(tzID), &status);
2422         if (U_FAILURE(status)) {
2423             log_data_err("FAIL: TZ ID for Eastern Standard Time, status %s\n", u_errorName(status));
2424         } else if (len != u_strlen(tzNewYork) || u_strncmp(tzID, tzNewYork, len) != 0) {
2425             log_err("FAIL: TZ ID for Eastern Standard Time\n");
2426         }
2427     }
2428     {
2429         status = U_ZERO_ERROR;
2430         len = ucal_getTimeZoneIDForWindowsID(winEastern, u_strlen(winEastern), "US", tzID, UPRV_LENGTHOF(tzID), &status);
2431         if (U_FAILURE(status)) {
2432             log_data_err("FAIL: TZ ID for Eastern Standard Time - US, status %s\n", u_errorName(status));
2433         } else if (len != u_strlen(tzNewYork) || u_strncmp(tzID, tzNewYork, len) != 0) {
2434             log_err("FAIL: TZ ID for Eastern Standard Time - US\n");
2435         }
2436     }
2437     {
2438         status = U_ZERO_ERROR;
2439         len = ucal_getTimeZoneIDForWindowsID(winEastern, u_strlen(winEastern), "CA", tzID, UPRV_LENGTHOF(tzID), &status);
2440         if (U_FAILURE(status)) {
2441             log_data_err("FAIL: TZ ID for Eastern Standard Time - CA, status %s\n", u_errorName(status));
2442         } else if (len != u_strlen(tzTronto) || u_strncmp(tzID, tzTronto, len) != 0) {
2443             log_err("FAIL: TZ ID for Eastern Standard Time - CA\n");
2444         }
2445     }
2446
2447     {
2448         status = U_ZERO_ERROR;
2449         len = ucal_getTimeZoneIDForWindowsID(sBogus, -1, NULL, tzID, UPRV_LENGTHOF(tzID), &status);
2450         if (U_FAILURE(status)) {
2451             log_data_err("FAIL: TZ ID for Bogus, status %s\n", u_errorName(status));
2452         } else if (len != 0) {
2453             log_err("FAIL: TZ ID for Bogus\n");
2454         }
2455     }
2456 }
2457
2458
2459 #endif /* #if !UCONFIG_NO_FORMATTING */