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