1 // 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /******************************************************************** 4 * Copyright (c) 1997-2016, International Business Machines 5 * Corporation and others. All Rights Reserved. 6 ******************************************************************** 7 * 8 * File CCALTST.C 9 * 10 * Modification History: 11 * Name Description 12 * Madhu Katragadda Creation 13 ******************************************************************** 14 */ 15 16 /* C API AND FUNCTIONALITY TEST FOR CALENDAR (ucol.h)*/ 17 18 #include "unicode/utypes.h" 19 20 #if !UCONFIG_NO_FORMATTING 21 22 #include <stdlib.h> 23 #include <string.h> 24 25 #include "unicode/uloc.h" 26 #include "unicode/ucal.h" 27 #include "unicode/udat.h" 28 #include "unicode/ustring.h" 29 #include "cintltst.h" 30 #include "ccaltst.h" 31 #include "cformtst.h" 32 #include "cmemory.h" 33 #include "cstring.h" 34 #include "ulist.h" 35 36 void TestGregorianChange(void); 37 void TestFieldDifference(void); 38 void TestAddRollEra0AndEraBounds(void); 39 void TestGetTZTransition(void); 40 41 void TestGetWindowsTimeZoneID(void); 42 void TestGetTimeZoneIDByWindowsID(void); 43 44 void addCalTest(TestNode** root); 45 46 void addCalTest(TestNode** root) 47 { 48 49 addTest(root, &TestCalendar, "tsformat/ccaltst/TestCalendar"); 50 addTest(root, &TestGetSetDateAPI, "tsformat/ccaltst/TestGetSetDateAPI"); 51 addTest(root, &TestFieldGetSet, "tsformat/ccaltst/TestFieldGetSet"); 52 addTest(root, &TestAddRollExtensive, "tsformat/ccaltst/TestAddRollExtensive"); 53 addTest(root, &TestGetLimits, "tsformat/ccaltst/TestGetLimits"); 54 addTest(root, &TestDOWProgression, "tsformat/ccaltst/TestDOWProgression"); 55 addTest(root, &TestGMTvsLocal, "tsformat/ccaltst/TestGMTvsLocal"); 56 addTest(root, &TestGregorianChange, "tsformat/ccaltst/TestGregorianChange"); 57 addTest(root, &TestGetKeywordValuesForLocale, "tsformat/ccaltst/TestGetKeywordValuesForLocale"); 58 addTest(root, &TestWeekend, "tsformat/ccaltst/TestWeekend"); 59 addTest(root, &TestFieldDifference, "tsformat/ccaltst/TestFieldDifference"); 60 addTest(root, &TestAmbiguousWallTime, "tsformat/ccaltst/TestAmbiguousWallTime"); 61 addTest(root, &TestAddRollEra0AndEraBounds, "tsformat/ccaltst/TestAddRollEra0AndEraBounds"); 62 addTest(root, &TestGetTZTransition, "tsformat/ccaltst/TestGetTZTransition"); 63 addTest(root, &TestGetWindowsTimeZoneID, "tsformat/ccaltst/TestGetWindowsTimeZoneID"); 64 addTest(root, &TestGetTimeZoneIDByWindowsID, "tsformat/ccaltst/TestGetTimeZoneIDByWindowsID"); 65 } 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 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[1024]; // u_austrcpy() of some formatted dates & times. 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 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 */ 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 */ 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*/ 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 */ 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 */ 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 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 /* ------------------------------------- */ 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 /* ------------------------------------- */ 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 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 /* ------------------------------------ */ 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 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 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 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 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 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, "en_US", 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 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 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 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 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
