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