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