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