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