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