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 #include "unicode/utypes.h" 9 10 #if !UCONFIG_NO_FORMATTING 11 12 #include "unicode/simpletz.h" 13 #include "unicode/smpdtfmt.h" 14 #include "unicode/strenum.h" 15 #include "unicode/gregocal.h" 16 #include "tzregts.h" 17 #include "calregts.h" 18 #include "cmemory.h" 19 20 // ***************************************************************************** 21 // class TimeZoneRegressionTest 22 // ***************************************************************************** 23 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break 24 25 void 26 TimeZoneRegressionTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) 27 { 28 // if (exec) logln((UnicodeString)"TestSuite NumberFormatRegressionTest"); 29 switch (index) { 30 31 CASE(0, Test4052967); 32 CASE(1, Test4073209); 33 CASE(2, Test4073215); 34 CASE(3, Test4084933); 35 CASE(4, Test4096952); 36 CASE(5, Test4109314); 37 CASE(6, Test4126678); 38 CASE(7, Test4151406); 39 CASE(8, Test4151429); 40 CASE(9, Test4154537); 41 CASE(10, Test4154542); 42 CASE(11, Test4154650); 43 CASE(12, Test4154525); 44 CASE(13, Test4162593); 45 CASE(14, TestJ186); 46 CASE(15, TestJ449); 47 CASE(16, TestJDK12API); 48 CASE(17, Test4176686); 49 CASE(18, Test4184229); 50 CASE(19, TestNegativeDaylightSaving); 51 default: name = ""; break; 52 } 53 } 54 55 UBool 56 TimeZoneRegressionTest::failure(UErrorCode status, const char* msg) 57 { 58 if(U_FAILURE(status)) { 59 errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status)); 60 return TRUE; 61 } 62 63 return FALSE; 64 } 65 66 /** 67 * @bug 4052967 68 */ 69 void TimeZoneRegressionTest:: Test4052967() { 70 // {sfb} not applicable in C++ ? 71 /*logln("*** CHECK TIMEZONE AGAINST HOST OS SETTING ***"); 72 logln("user.timezone:" + System.getProperty("user.timezone", "<not set>")); 73 logln(new Date().toString()); 74 logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");*/ 75 } 76 77 /** 78 * @bug 4073209 79 */ 80 void TimeZoneRegressionTest:: Test4073209() { 81 TimeZone *z1 = TimeZone::createTimeZone("PST"); 82 TimeZone *z2 = TimeZone::createTimeZone("PST"); 83 if (z1 == z2) 84 errln("Fail: TimeZone should return clones"); 85 delete z1; 86 delete z2; 87 } 88 89 UDate TimeZoneRegressionTest::findTransitionBinary(const SimpleTimeZone& tz, UDate min, UDate max) { 90 UErrorCode status = U_ZERO_ERROR; 91 UBool startsInDST = tz.inDaylightTime(min, status); 92 if (failure(status, "SimpleTimeZone::inDaylightTime")) return 0; 93 if (tz.inDaylightTime(max, status) == startsInDST) { 94 logln((UnicodeString)"Error: inDaylightTime() != " + ((!startsInDST)?"TRUE":"FALSE")); 95 return 0; 96 } 97 if (failure(status, "SimpleTimeZone::inDaylightTime")) return 0; 98 while ((max - min) > 100) { // Min accuracy in ms 99 UDate mid = (min + max) / 2; 100 if (tz.inDaylightTime(mid, status) == startsInDST) { 101 min = mid; 102 } else { 103 max = mid; 104 } 105 if (failure(status, "SimpleTimeZone::inDaylightTime")) return 0; 106 } 107 return (min + max) / 2; 108 } 109 110 UDate TimeZoneRegressionTest::findTransitionStepwise(const SimpleTimeZone& tz, UDate min, UDate max) { 111 UErrorCode status = U_ZERO_ERROR; 112 UBool startsInDST = tz.inDaylightTime(min, status); 113 if (failure(status, "SimpleTimeZone::inDaylightTime")) return 0; 114 while (min < max) { 115 if (tz.inDaylightTime(min, status) != startsInDST) { 116 return min; 117 } 118 if (failure(status, "SimpleTimeZone::inDaylightTime")) return 0; 119 min += (UDate)24*60*60*1000; // one day 120 } 121 return 0; 122 } 123 124 /** 125 * @bug 4073215 126 */ 127 // {sfb} will this work using a Calendar? 128 void TimeZoneRegressionTest:: Test4073215() 129 { 130 UErrorCode status = U_ZERO_ERROR; 131 UnicodeString str, str2; 132 SimpleTimeZone *z = new SimpleTimeZone(0, "GMT"); 133 if (z->useDaylightTime()) 134 errln("Fail: Fix test to start with non-DST zone"); 135 z->setStartRule(UCAL_FEBRUARY, 1, UCAL_SUNDAY, 0, status); 136 failure(status, "z->setStartRule()"); 137 z->setEndRule(UCAL_MARCH, -1, UCAL_SUNDAY, 0, status); 138 failure(status, "z->setStartRule()"); 139 if (!z->useDaylightTime()) 140 errln("Fail: DST not active"); 141 142 GregorianCalendar cal(1997, UCAL_JANUARY, 31, status); 143 if(U_FAILURE(status)) { 144 dataerrln("Error creating calendar %s", u_errorName(status)); 145 return; 146 } 147 failure(status, "new GregorianCalendar"); 148 cal.adoptTimeZone(z); 149 150 SimpleDateFormat sdf((UnicodeString)"E d MMM yyyy G HH:mm", status); 151 if(U_FAILURE(status)) { 152 dataerrln("Error creating date format %s", u_errorName(status)); 153 return; 154 } 155 sdf.setCalendar(cal); 156 failure(status, "new SimpleDateFormat"); 157 158 UDate jan31, mar1, mar31; 159 160 UBool indt = z->inDaylightTime(jan31=cal.getTime(status), status); 161 failure(status, "inDaylightTime or getTime call on Jan 31"); 162 if (indt) { 163 errln("Fail: Jan 31 inDaylightTime=TRUE, exp FALSE"); 164 } 165 cal.set(1997, UCAL_MARCH, 1); 166 indt = z->inDaylightTime(mar1=cal.getTime(status), status); 167 failure(status, "inDaylightTime or getTime call on Mar 1"); 168 if (!indt) { 169 UnicodeString str; 170 sdf.format(cal.getTime(status), str); 171 failure(status, "getTime"); 172 errln((UnicodeString)"Fail: " + str + " inDaylightTime=FALSE, exp TRUE"); 173 } 174 cal.set(1997, UCAL_MARCH, 31); 175 indt = z->inDaylightTime(mar31=cal.getTime(status), status); 176 failure(status, "inDaylightTime or getTime call on Mar 31"); 177 if (indt) { 178 errln("Fail: Mar 31 inDaylightTime=TRUE, exp FALSE"); 179 } 180 181 /* 182 cal.set(1997, Calendar::DECEMBER, 31); 183 UDate dec31 = cal.getTime(status); 184 failure(status, "getTime"); 185 UDate trans = findTransitionStepwise(*z, jan31, dec31); 186 logln((UnicodeString)"Stepwise from " + 187 sdf.format(jan31, str.remove()) + "; transition at " + 188 (trans?sdf.format(trans, str2.remove()):(UnicodeString)"NONE")); 189 trans = findTransitionStepwise(*z, mar1, dec31); 190 logln((UnicodeString)"Stepwise from " + 191 sdf.format(mar1, str.remove()) + "; transition at " + 192 (trans?sdf.format(trans, str2.remove()):(UnicodeString)"NONE")); 193 trans = findTransitionStepwise(*z, mar31, dec31); 194 logln((UnicodeString)"Stepwise from " + 195 sdf.format(mar31, str.remove()) + "; transition at " + 196 (trans?sdf.format(trans, str2.remove()):(UnicodeString)"NONE")); 197 */ 198 } 199 200 /** 201 * @bug 4084933 202 * The expected behavior of TimeZone around the boundaries is: 203 * (Assume transition time of 2:00 AM) 204 * day of onset 1:59 AM STD = display name 1:59 AM ST 205 * 2:00 AM STD = display name 3:00 AM DT 206 * day of end 0:59 AM STD = display name 1:59 AM DT 207 * 1:00 AM STD = display name 1:00 AM ST 208 */ 209 void TimeZoneRegressionTest:: Test4084933() { 210 UErrorCode status = U_ZERO_ERROR; 211 TimeZone *tz = TimeZone::createTimeZone("PST"); 212 213 int32_t offset1 = tz->getOffset(1, 214 1997, UCAL_OCTOBER, 26, UCAL_SUNDAY, (2*60*60*1000), status); 215 int32_t offset2 = tz->getOffset(1, 216 1997, UCAL_OCTOBER, 26, UCAL_SUNDAY, (2*60*60*1000)-1, status); 217 218 int32_t offset3 = tz->getOffset(1, 219 1997, UCAL_OCTOBER, 26, UCAL_SUNDAY, (1*60*60*1000), status); 220 int32_t offset4 = tz->getOffset(1, 221 1997, UCAL_OCTOBER, 26, UCAL_SUNDAY, (1*60*60*1000)-1, status); 222 223 /* 224 * The following was added just for consistency. It shows that going *to* Daylight 225 * Savings Time (PDT) does work at 2am. 226 */ 227 int32_t offset5 = tz->getOffset(1, 228 1997, UCAL_APRIL, 6, UCAL_SUNDAY, (2*60*60*1000), status); 229 int32_t offset6 = tz->getOffset(1, 230 1997, UCAL_APRIL, 6, UCAL_SUNDAY, (2*60*60*1000)-1, status); 231 int32_t offset5a = tz->getOffset(1, 232 1997, UCAL_APRIL, 6, UCAL_SUNDAY, (3*60*60*1000), status); 233 int32_t offset6a = tz->getOffset(1, 234 1997, UCAL_APRIL, 6, UCAL_SUNDAY, (3*60*60*1000)-1, status); 235 int32_t offset7 = tz->getOffset(1, 236 1997, UCAL_APRIL, 6, UCAL_SUNDAY, (1*60*60*1000), status); 237 int32_t offset8 = tz->getOffset(1, 238 1997, UCAL_APRIL, 6, UCAL_SUNDAY, (1*60*60*1000)-1, status); 239 int32_t SToffset = (int32_t)(-8 * 60*60*1000L); 240 int32_t DToffset = (int32_t)(-7 * 60*60*1000L); 241 242 #define ERR_IF_FAIL(x) if(x) { dataerrln("FAIL: TimeZone misbehaving - %s", #x); } 243 244 ERR_IF_FAIL(U_FAILURE(status)) 245 ERR_IF_FAIL(offset1 != SToffset) 246 ERR_IF_FAIL(offset2 != SToffset) 247 ERR_IF_FAIL(offset3 != SToffset) 248 ERR_IF_FAIL(offset4 != DToffset) 249 ERR_IF_FAIL(offset5 != DToffset) 250 ERR_IF_FAIL(offset6 != SToffset) 251 ERR_IF_FAIL(offset5a != DToffset) 252 ERR_IF_FAIL(offset6a != DToffset) 253 ERR_IF_FAIL(offset7 != SToffset) 254 ERR_IF_FAIL(offset8 != SToffset) 255 256 #undef ERR_IF_FAIL 257 258 delete tz; 259 } 260 261 /** 262 * @bug 4096952 263 */ 264 void TimeZoneRegressionTest:: Test4096952() { 265 // {sfb} serialization not applicable 266 /* 267 UnicodeString ZONES [] = { UnicodeString("GMT"), UnicodeString("MET"), UnicodeString("IST") }; 268 UBool pass = TRUE; 269 //try { 270 for (int32_t i=0; i < ZONES.length; ++i) { 271 TimeZone *zone = TimeZone::createTimeZone(ZONES[i]); 272 UnicodeString id; 273 if (zone->getID(id) != ZONES[i]) 274 errln("Fail: Test broken; zones not instantiating"); 275 276 ByteArrayOutputStream baos; 277 ObjectOutputStream ostream = 278 new ObjectOutputStream(baos = new 279 ByteArrayOutputStream()); 280 ostream.writeObject(zone); 281 ostream.close(); 282 baos.close(); 283 ObjectInputStream istream = 284 new ObjectInputStream(new 285 ByteArrayInputStream(baos.toByteArray())); 286 TimeZone frankenZone = (TimeZone) istream.readObject(); 287 //logln("Zone: " + zone); 288 //logln("FrankenZone: " + frankenZone); 289 if (!zone.equals(frankenZone)) { 290 logln("TimeZone " + zone.getID() + 291 " not equal to serialized/deserialized one"); 292 pass = false; 293 } 294 } 295 if (!pass) errln("Fail: TimeZone serialization/equality bug"); 296 } 297 catch (IOException e) { 298 errln("Fail: " + e); 299 e.print32_tStackTrace(); 300 } 301 catch (ClassNotFoundException e) { 302 errln("Fail: " + e); 303 e.print32_tStackTrace(); 304 } 305 */ 306 } 307 308 /** 309 * @bug 4109314 310 */ 311 void TimeZoneRegressionTest:: Test4109314() { 312 UErrorCode status = U_ZERO_ERROR; 313 GregorianCalendar *testCal = (GregorianCalendar*)Calendar::createInstance(status); 314 if(U_FAILURE(status)) { 315 dataerrln("Error creating calendar %s", u_errorName(status)); 316 delete testCal; 317 return; 318 } 319 failure(status, "Calendar::createInstance"); 320 TimeZone *PST = TimeZone::createTimeZone("PST"); 321 /*Object[] testData = { 322 PST, new Date(98,Calendar.APRIL,4,22,0), new Date(98, Calendar.APRIL, 5,6,0), 323 PST, new Date(98,Calendar.OCTOBER,24,22,0), new Date(98,Calendar.OCTOBER,25,6,0), 324 };*/ 325 UDate testData [] = { 326 CalendarRegressionTest::makeDate(98,UCAL_APRIL,4,22,0), 327 CalendarRegressionTest::makeDate(98, UCAL_APRIL,5,6,0), 328 CalendarRegressionTest::makeDate(98,UCAL_OCTOBER,24,22,0), 329 CalendarRegressionTest::makeDate(98,UCAL_OCTOBER,25,6,0) 330 }; 331 UBool pass = TRUE; 332 for (int32_t i = 0; i < 4; i+=2) { 333 //testCal->setTimeZone((TimeZone) testData[i]); 334 testCal->setTimeZone(*PST); 335 UDate t = testData[i]; 336 UDate end = testData[i+1]; 337 while(testCal->getTime(status) < end) { 338 testCal->setTime(t, status); 339 if ( ! checkCalendar314(testCal, PST)) 340 pass = FALSE; 341 t += 60*60*1000.0; 342 } 343 } 344 if ( ! pass) 345 errln("Fail: TZ API inconsistent"); 346 347 delete testCal; 348 delete PST; 349 } 350 351 UBool 352 TimeZoneRegressionTest::checkCalendar314(GregorianCalendar *testCal, TimeZone *testTZ) 353 { 354 UErrorCode status = U_ZERO_ERROR; 355 // GregorianCalendar testCal = (GregorianCalendar)aCal.clone(); 356 357 int32_t tzOffset, tzRawOffset; 358 float tzOffsetFloat,tzRawOffsetFloat; 359 // Here is where the user made an error. They were passing in the value of 360 // the MILLSECOND field; you need to pass in the millis in the day in STANDARD 361 // time. 362 UDate millis = testCal->get(UCAL_MILLISECOND, status) + 363 1000.0 * (testCal->get(UCAL_SECOND, status) + 364 60.0 * (testCal->get(UCAL_MINUTE, status) + 365 60.0 * (testCal->get(UCAL_HOUR_OF_DAY, status)))) - 366 testCal->get(UCAL_DST_OFFSET, status); 367 368 /* Fix up millis to be in range. ASSUME THAT WE ARE NOT AT THE 369 * BEGINNING OR END OF A MONTH. We must add this code because 370 * getOffset() has been changed to be more strict about the parameters 371 * it receives -- it turns out that this test was passing in illegal 372 * values. */ 373 int32_t date = testCal->get(UCAL_DATE, status); 374 int32_t dow = testCal->get(UCAL_DAY_OF_WEEK, status); 375 while(millis < 0) { 376 millis += U_MILLIS_PER_DAY; 377 --date; 378 dow = UCAL_SUNDAY + ((dow - UCAL_SUNDAY + 6) % 7); 379 } 380 while (millis >= U_MILLIS_PER_DAY) { 381 millis -= U_MILLIS_PER_DAY; 382 ++date; 383 dow = UCAL_SUNDAY + ((dow - UCAL_SUNDAY + 1) % 7); 384 } 385 386 tzOffset = testTZ->getOffset((uint8_t)testCal->get(UCAL_ERA, status), 387 testCal->get(UCAL_YEAR, status), 388 testCal->get(UCAL_MONTH, status), 389 date, 390 (uint8_t)dow, 391 (int32_t)millis, 392 status); 393 tzRawOffset = testTZ->getRawOffset(); 394 tzOffsetFloat = (float)tzOffset/(float)3600000; 395 tzRawOffsetFloat = (float)tzRawOffset/(float)3600000; 396 397 UDate testDate = testCal->getTime(status); 398 399 UBool inDaylightTime = testTZ->inDaylightTime(testDate, status); 400 SimpleDateFormat *sdf = new SimpleDateFormat((UnicodeString)"MM/dd/yyyy HH:mm", status); 401 sdf->setCalendar(*testCal); 402 UnicodeString inDaylightTimeString; 403 404 UBool passed; 405 406 if(inDaylightTime) 407 { 408 inDaylightTimeString = " DST "; 409 passed = (tzOffset == (tzRawOffset + 3600000)); 410 } 411 else 412 { 413 inDaylightTimeString = " "; 414 passed = (tzOffset == tzRawOffset); 415 } 416 417 UnicodeString output; 418 FieldPosition pos(FieldPosition::DONT_CARE); 419 output = testTZ->getID(output) + " " + sdf->format(testDate, output, pos) + 420 " Offset(" + tzOffsetFloat + ")" + 421 " RawOffset(" + tzRawOffsetFloat + ")" + 422 " " + millis/(float)3600000 + " " + 423 inDaylightTimeString; 424 425 if (passed) 426 output += " "; 427 else 428 output += "ERROR"; 429 430 if (passed) 431 logln(output); 432 else 433 errln(output); 434 435 delete sdf; 436 return passed; 437 } 438 439 /** 440 * @bug 4126678 441 * CANNOT REPRODUDE 442 * 443 * Yet another _alleged_ bug in TimeZone::getOffset(), a method that never 444 * should have been made public. It's simply too hard to use correctly. 445 * 446 * The original test code failed to do the following: 447 * (1) Call Calendar::setTime() before getting the fields! 448 * (2) Use the right millis (as usual) for getOffset(); they were passing 449 * in the MILLIS field, instead of the STANDARD MILLIS IN DAY. 450 * When you fix these two problems, the test passes, as expected. 451 */ 452 void TimeZoneRegressionTest:: Test4126678() 453 { 454 UErrorCode status = U_ZERO_ERROR; 455 Calendar *cal = Calendar::createInstance(status); 456 if(U_FAILURE(status)) { 457 dataerrln("Error creating calendar %s", u_errorName(status)); 458 delete cal; 459 return; 460 } 461 failure(status, "Calendar::createInstance"); 462 TimeZone *tz = TimeZone::createTimeZone("PST"); 463 cal->adoptTimeZone(tz); 464 465 cal->set(1998, UCAL_APRIL, 5, 10, 0); 466 467 if (! tz->useDaylightTime() || U_FAILURE(status)) 468 dataerrln("We're not in Daylight Savings Time and we should be. - %s", u_errorName(status)); 469 470 //cal.setTime(dt); 471 int32_t era = cal->get(UCAL_ERA, status); 472 int32_t year = cal->get(UCAL_YEAR, status); 473 int32_t month = cal->get(UCAL_MONTH, status); 474 int32_t day = cal->get(UCAL_DATE, status); 475 int32_t dayOfWeek = cal->get(UCAL_DAY_OF_WEEK, status); 476 int32_t millis = cal->get(UCAL_MILLISECOND, status) + 477 (cal->get(UCAL_SECOND, status) + 478 (cal->get(UCAL_MINUTE, status) + 479 (cal->get(UCAL_HOUR, status) * 60) * 60) * 1000) - 480 cal->get(UCAL_DST_OFFSET, status); 481 482 failure(status, "cal->get"); 483 int32_t offset = tz->getOffset((uint8_t)era, year, month, day, (uint8_t)dayOfWeek, millis, status); 484 int32_t raw_offset = tz->getRawOffset(); 485 486 if (offset == raw_offset) 487 dataerrln("Offsets should match"); 488 489 delete cal; 490 } 491 492 /** 493 * @bug 4151406 494 * TimeZone::getAvailableIDs(int32_t) throws exception for certain values, 495 * due to a faulty constant in TimeZone::java. 496 */ 497 void TimeZoneRegressionTest:: Test4151406() { 498 int32_t max = 0; 499 for (int32_t h=-28; h<=30; ++h) { 500 // h is in half-hours from GMT; rawoffset is in millis 501 int32_t rawoffset = h * 1800000; 502 int32_t hh = (h<0) ? -h : h; 503 UnicodeString hname = UnicodeString((h<0) ? "GMT-" : "GMT+") + 504 ((hh/2 < 10) ? "0" : "") + 505 (hh/2) + ':' + 506 ((hh%2==0) ? "00" : "30"); 507 //try { 508 UErrorCode ec = U_ZERO_ERROR; 509 int32_t count; 510 StringEnumeration* ids = TimeZone::createEnumeration(rawoffset); 511 if (ids == NULL) { 512 dataerrln("Fail: TimeZone::createEnumeration(rawoffset)"); 513 continue; 514 } 515 count = ids->count(ec); 516 if (count> max) 517 max = count; 518 if (count > 0) { 519 logln(hname + ' ' + (UnicodeString)count + (UnicodeString)" e.g. " + *ids->snext(ec)); 520 } else { 521 logln(hname + ' ' + count); 522 } 523 // weiv 11/27/2002: why uprv_free? This should be a delete 524 delete ids; 525 //delete [] ids; 526 //uprv_free(ids); 527 /*} catch (Exception e) { 528 errln(hname + ' ' + "Fail: " + e); 529 }*/ 530 } 531 logln("Maximum zones per offset = %d", max); 532 } 533 534 /** 535 * @bug 4151429 536 */ 537 void TimeZoneRegressionTest:: Test4151429() { 538 // {sfb} silly test in C++, since we are using an enum and not an int 539 //try { 540 /*TimeZone *tz = TimeZone::createTimeZone("GMT"); 541 UnicodeString name; 542 tz->getDisplayName(TRUE, TimeZone::LONG, 543 Locale.getDefault(), name); 544 errln("IllegalArgumentException not thrown by TimeZone::getDisplayName()");*/ 545 //} catch(IllegalArgumentException e) {} 546 } 547 548 /** 549 * @bug 4154537 550 * SimpleTimeZone::hasSameRules() doesn't work for zones with no DST 551 * and different DST parameters. 552 */ 553 void TimeZoneRegressionTest:: Test4154537() { 554 UErrorCode status = U_ZERO_ERROR; 555 // tz1 and tz2 have no DST and different rule parameters 556 SimpleTimeZone *tz1 = new SimpleTimeZone(0, "1", 0, 0, 0, 0, 2, 0, 0, 0, status); 557 SimpleTimeZone *tz2 = new SimpleTimeZone(0, "2", 1, 0, 0, 0, 3, 0, 0, 0, status); 558 // tza and tzA have the same rule params 559 SimpleTimeZone *tza = new SimpleTimeZone(0, "a", 0, 1, 0, 0, 3, 2, 0, 0, status); 560 SimpleTimeZone *tzA = new SimpleTimeZone(0, "A", 0, 1, 0, 0, 3, 2, 0, 0, status); 561 // tzb differs from tza 562 SimpleTimeZone *tzb = new SimpleTimeZone(0, "b", 0, 1, 0, 0, 3, 1, 0, 0, status); 563 564 if(U_FAILURE(status)) 565 errln("Couldn't create TimeZones"); 566 567 if (tz1->useDaylightTime() || tz2->useDaylightTime() || 568 !tza->useDaylightTime() || !tzA->useDaylightTime() || 569 !tzb->useDaylightTime()) { 570 errln("Test is broken -- rewrite it"); 571 } 572 if (!tza->hasSameRules(*tzA) || tza->hasSameRules(*tzb)) { 573 errln("Fail: hasSameRules() broken for zones with rules"); 574 } 575 if (!tz1->hasSameRules(*tz2)) { 576 errln("Fail: hasSameRules() returns false for zones without rules"); 577 //errln("zone 1 = " + tz1); 578 //errln("zone 2 = " + tz2); 579 } 580 581 delete tz1; 582 delete tz2; 583 delete tza; 584 delete tzA; 585 delete tzb; 586 } 587 588 /** 589 * @bug 4154542 590 * SimpleTimeZOne constructors, setStartRule(), and setEndRule() don't 591 * check for out-of-range arguments. 592 */ 593 void TimeZoneRegressionTest:: Test4154542() 594 { 595 const int32_t GOOD = 1; 596 const int32_t BAD = 0; 597 598 const int32_t GOOD_MONTH = UCAL_JANUARY; 599 const int32_t GOOD_DAY = 1; 600 const int32_t GOOD_DAY_OF_WEEK = UCAL_SUNDAY; 601 const int32_t GOOD_TIME = 0; 602 603 int32_t DATA [] = { 604 GOOD, INT32_MIN, 0, INT32_MAX, INT32_MIN, 605 GOOD, UCAL_JANUARY, -5, UCAL_SUNDAY, 0, 606 GOOD, UCAL_DECEMBER, 5, UCAL_SATURDAY, 24*60*60*1000, 607 BAD, UCAL_DECEMBER, 5, UCAL_SATURDAY, 24*60*60*1000+1, 608 BAD, UCAL_DECEMBER, 5, UCAL_SATURDAY, -1, 609 BAD, UCAL_JANUARY, -6, UCAL_SUNDAY, 0, 610 BAD, UCAL_DECEMBER, 6, UCAL_SATURDAY, 24*60*60*1000, 611 GOOD, UCAL_DECEMBER, 1, 0, 0, 612 GOOD, UCAL_DECEMBER, 31, 0, 0, 613 BAD, UCAL_APRIL, 31, 0, 0, 614 BAD, UCAL_DECEMBER, 32, 0, 0, 615 BAD, UCAL_JANUARY-1, 1, UCAL_SUNDAY, 0, 616 BAD, UCAL_DECEMBER+1, 1, UCAL_SUNDAY, 0, 617 GOOD, UCAL_DECEMBER, 31, -UCAL_SUNDAY, 0, 618 GOOD, UCAL_DECEMBER, 31, -UCAL_SATURDAY, 0, 619 BAD, UCAL_DECEMBER, 32, -UCAL_SATURDAY, 0, 620 BAD, UCAL_DECEMBER, -32, -UCAL_SATURDAY, 0, 621 BAD, UCAL_DECEMBER, 31, -UCAL_SATURDAY-1, 0, 622 }; 623 SimpleTimeZone *zone = new SimpleTimeZone(0, "Z"); 624 for (int32_t i=0; i < 18*5; i+=5) { 625 UBool shouldBeGood = (DATA[i] == GOOD); 626 int32_t month = DATA[i+1]; 627 int32_t day = DATA[i+2]; 628 int32_t dayOfWeek = DATA[i+3]; 629 int32_t time = DATA[i+4]; 630 631 UErrorCode status = U_ZERO_ERROR; 632 633 //Exception ex = null; 634 //try { 635 zone->setStartRule(month, day, dayOfWeek, time, status); 636 //} catch (IllegalArgumentException e) { 637 // ex = e; 638 //} 639 if (U_SUCCESS(status) != shouldBeGood) { 640 errln(UnicodeString("setStartRule(month=") + month + ", day=" + day + 641 ", dayOfWeek=" + dayOfWeek + ", time=" + time + 642 (shouldBeGood ? (") should work") 643 : ") should fail but doesn't")); 644 } 645 646 //ex = null; 647 //try { 648 status = U_ZERO_ERROR; 649 zone->setEndRule(month, day, dayOfWeek, time, status); 650 //} catch (IllegalArgumentException e) { 651 // ex = e; 652 //} 653 if (U_SUCCESS(status) != shouldBeGood) { 654 errln(UnicodeString("setEndRule(month=") + month + ", day=" + day + 655 ", dayOfWeek=" + dayOfWeek + ", time=" + time + 656 (shouldBeGood ? (") should work") 657 : ") should fail but doesn't")); 658 } 659 660 //ex = null; 661 //try { 662 // {sfb} need to look into ctor problems! (UErrorCode vs. dst signature confusion) 663 status = U_ZERO_ERROR; 664 SimpleTimeZone *temp = new SimpleTimeZone(0, "Z", 665 (int8_t)month, (int8_t)day, (int8_t)dayOfWeek, time, 666 (int8_t)GOOD_MONTH, (int8_t)GOOD_DAY, (int8_t)GOOD_DAY_OF_WEEK, 667 GOOD_TIME,status); 668 //} catch (IllegalArgumentException e) { 669 // ex = e; 670 //} 671 if (U_SUCCESS(status) != shouldBeGood) { 672 errln(UnicodeString("SimpleTimeZone(month=") + month + ", day=" + day + 673 ", dayOfWeek=" + dayOfWeek + ", time=" + time + 674 (shouldBeGood ? (", <end>) should work")// + ex) 675 : ", <end>) should fail but doesn't")); 676 } 677 678 delete temp; 679 //ex = null; 680 //try { 681 status = U_ZERO_ERROR; 682 temp = new SimpleTimeZone(0, "Z", 683 (int8_t)GOOD_MONTH, (int8_t)GOOD_DAY, (int8_t)GOOD_DAY_OF_WEEK, 684 GOOD_TIME, 685 (int8_t)month, (int8_t)day, (int8_t)dayOfWeek, time,status); 686 //} catch (IllegalArgumentException e) { 687 // ex = e; 688 //} 689 if (U_SUCCESS(status) != shouldBeGood) { 690 errln(UnicodeString("SimpleTimeZone(<start>, month=") + month + ", day=" + day + 691 ", dayOfWeek=" + dayOfWeek + ", time=" + time + 692 (shouldBeGood ? (") should work")// + ex) 693 : ") should fail but doesn't")); 694 } 695 delete temp; 696 } 697 delete zone; 698 } 699 700 701 /** 702 * @bug 4154525 703 * SimpleTimeZone accepts illegal DST savings values. These values 704 * must be non-zero. There is no upper limit at this time. 705 */ 706 void 707 TimeZoneRegressionTest::Test4154525() 708 { 709 const int32_t GOOD = 1, BAD = 0; 710 711 int32_t DATA [] = { 712 1, GOOD, 713 0, BAD, 714 -1, GOOD, // #13566 updates SimpleTimeZone to support negative DST saving amount 715 60*60*1000, GOOD, 716 INT32_MAX, GOOD, // no upper limit on DST savings at this time 717 INT32_MIN, GOOD // no lower limit as well 718 }; 719 720 UErrorCode status = U_ZERO_ERROR; 721 for(int32_t i = 0; i < 10; i+=2) { 722 int32_t savings = DATA[i]; 723 UBool valid = DATA[i+1] == GOOD; 724 UnicodeString method; 725 for(int32_t j=0; j < 2; ++j) { 726 SimpleTimeZone *z=NULL; 727 switch (j) { 728 case 0: 729 method = "constructor"; 730 z = new SimpleTimeZone(0, "id", 731 UCAL_JANUARY, 1, 0, 0, 732 UCAL_MARCH, 1, 0, 0, 733 savings, status); // <- what we're interested in 734 break; 735 case 1: 736 method = "setDSTSavings()"; 737 z = new SimpleTimeZone(0, "GMT"); 738 z->setDSTSavings(savings, status); 739 break; 740 } 741 742 if(U_FAILURE(status)) { 743 if(valid) { 744 errln(UnicodeString("Fail: DST savings of ") + savings + " to " + method + " gave " + u_errorName(status)); 745 } 746 else { 747 logln(UnicodeString("Pass: DST savings of ") + savings + " to " + method + " gave " + u_errorName(status)); 748 } 749 } 750 else { 751 if(valid) { 752 logln(UnicodeString("Pass: DST savings of ") + savings + " accepted by " + method); 753 } 754 else { 755 errln(UnicodeString("Fail: DST savings of ") + savings + " accepted by " + method); 756 } 757 } 758 status = U_ZERO_ERROR; 759 delete z; 760 } 761 } 762 } 763 764 /** 765 * @bug 4154650 766 * SimpleTimeZone.getOffset accepts illegal arguments. 767 */ 768 void 769 TimeZoneRegressionTest::Test4154650() 770 { 771 const int32_t GOOD = 1, BAD = 0; 772 const int32_t GOOD_ERA = GregorianCalendar::AD, GOOD_YEAR = 1998, GOOD_MONTH = UCAL_AUGUST; 773 const int32_t GOOD_DAY = 2, GOOD_DOW = UCAL_SUNDAY, GOOD_TIME = 16*3600000; 774 775 int32_t DATA []= { 776 GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, 777 778 GOOD, GregorianCalendar::BC, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, 779 GOOD, GregorianCalendar::AD, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, 780 BAD, GregorianCalendar::BC-1, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, 781 BAD, GregorianCalendar::AD+1, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, GOOD_TIME, 782 783 GOOD, GOOD_ERA, GOOD_YEAR, UCAL_JANUARY, GOOD_DAY, GOOD_DOW, GOOD_TIME, 784 GOOD, GOOD_ERA, GOOD_YEAR, UCAL_DECEMBER, GOOD_DAY, GOOD_DOW, GOOD_TIME, 785 BAD, GOOD_ERA, GOOD_YEAR, UCAL_JANUARY-1, GOOD_DAY, GOOD_DOW, GOOD_TIME, 786 BAD, GOOD_ERA, GOOD_YEAR, UCAL_DECEMBER+1, GOOD_DAY, GOOD_DOW, GOOD_TIME, 787 788 GOOD, GOOD_ERA, GOOD_YEAR, UCAL_JANUARY, 1, GOOD_DOW, GOOD_TIME, 789 GOOD, GOOD_ERA, GOOD_YEAR, UCAL_JANUARY, 31, GOOD_DOW, GOOD_TIME, 790 BAD, GOOD_ERA, GOOD_YEAR, UCAL_JANUARY, 0, GOOD_DOW, GOOD_TIME, 791 BAD, GOOD_ERA, GOOD_YEAR, UCAL_JANUARY, 32, GOOD_DOW, GOOD_TIME, 792 793 GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, UCAL_SUNDAY, GOOD_TIME, 794 GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, UCAL_SATURDAY, GOOD_TIME, 795 BAD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, UCAL_SUNDAY-1, GOOD_TIME, 796 BAD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, UCAL_SATURDAY+1, GOOD_TIME, 797 798 GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, 0, 799 GOOD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, 24*3600000-1, 800 BAD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, -1, 801 BAD, GOOD_ERA, GOOD_YEAR, GOOD_MONTH, GOOD_DAY, GOOD_DOW, 24*3600000, 802 }; 803 804 int32_t dataLen = UPRV_LENGTHOF(DATA); 805 806 UErrorCode status = U_ZERO_ERROR; 807 TimeZone *tz = TimeZone::createDefault(); 808 for(int32_t i = 0; i < dataLen; i += 7) { 809 UBool good = DATA[i] == GOOD; 810 //IllegalArgumentException e = null; 811 //try { 812 /*int32_t offset = */ 813 tz->getOffset((uint8_t)DATA[i+1], DATA[i+2], DATA[i+3], 814 DATA[i+4], (uint8_t)DATA[i+5], DATA[i+6], status); 815 //} catch (IllegalArgumentException ex) { 816 // e = ex; 817 //} 818 if(good != U_SUCCESS(status)) { 819 UnicodeString errMsg; 820 if (good) { 821 errMsg = (UnicodeString(") threw ") + u_errorName(status)); 822 } 823 else { 824 errMsg = UnicodeString(") accepts invalid args", ""); 825 } 826 errln(UnicodeString("Fail: getOffset(") + 827 DATA[i+1] + ", " + DATA[i+2] + ", " + DATA[i+3] + ", " + 828 DATA[i+4] + ", " + DATA[i+5] + ", " + DATA[i+6] + 829 errMsg); 830 } 831 status = U_ZERO_ERROR; // reset 832 } 833 delete tz; 834 } 835 836 /** 837 * @bug 4162593 838 * TimeZone broken at midnight. The TimeZone code fails to handle 839 * transitions at midnight correctly. 840 */ 841 void 842 TimeZoneRegressionTest::Test4162593() 843 { 844 UErrorCode status = U_ZERO_ERROR; 845 SimpleDateFormat *fmt = new SimpleDateFormat("z", Locale::getUS(), status); 846 if(U_FAILURE(status)) { 847 dataerrln("Error creating calendar %s", u_errorName(status)); 848 delete fmt; 849 return; 850 } 851 const int32_t ONE_HOUR = 60*60*1000; 852 853 SimpleTimeZone *asuncion = new SimpleTimeZone(-4*ONE_HOUR, "America/Asuncion" /*PY%sT*/, 854 UCAL_OCTOBER, 1, 0 /*DOM*/, 0*ONE_HOUR, 855 UCAL_MARCH, 1, 0 /*DOM*/, 0*ONE_HOUR, 1*ONE_HOUR, status); 856 857 /* Zone 858 * Starting time 859 * Transition expected between start+1H and start+2H 860 */ 861 TimeZone *DATA_TZ [] = { 862 0, 0, 0 }; 863 864 int32_t DATA_INT [] [5] = { 865 // These years must be AFTER the Gregorian cutover 866 {1998, UCAL_SEPTEMBER, 30, 22, 0}, 867 {2000, UCAL_FEBRUARY, 28, 22, 0}, 868 {2000, UCAL_FEBRUARY, 29, 22, 0}, 869 }; 870 871 UBool DATA_BOOL [] = { 872 TRUE, 873 FALSE, 874 TRUE, 875 }; 876 877 UnicodeString zone [4];// = new String[4]; 878 DATA_TZ[0] = 879 new SimpleTimeZone(2*ONE_HOUR, "Asia/Damascus" /*EE%sT*/, 880 UCAL_APRIL, 1, 0 /*DOM*/, 0*ONE_HOUR, 881 UCAL_OCTOBER, 1, 0 /*DOM*/, 0*ONE_HOUR, 1*ONE_HOUR, status); 882 DATA_TZ[1] = asuncion; DATA_TZ[2] = asuncion; 883 884 for(int32_t j = 0; j < 3; j++) { 885 TimeZone *tz = (TimeZone*)DATA_TZ[j]; 886 TimeZone::setDefault(*tz); 887 fmt->setTimeZone(*tz); 888 889 // Must construct the Date object AFTER setting the default zone 890 int32_t *p = (int32_t*)DATA_INT[j]; 891 UDate d = CalendarRegressionTest::makeDate(p[0], p[1], p[2], p[3], p[4]); 892 UBool transitionExpected = DATA_BOOL[j]; 893 894 UnicodeString temp; 895 logln(tz->getID(temp) + ":"); 896 for (int32_t i = 0; i < 4; ++i) { 897 FieldPosition pos(FieldPosition::DONT_CARE); 898 zone[i].remove(); 899 zone[i] = fmt->format(d+ i*ONE_HOUR, zone[i], pos); 900 logln(UnicodeString("") + i + ": " + d + " / " + zone[i]); 901 //d += (double) ONE_HOUR; 902 } 903 if(zone[0] == zone[1] && 904 (zone[1] == zone[2]) != transitionExpected && 905 zone[2] == zone[3]) { 906 logln(UnicodeString("Ok: transition ") + transitionExpected); 907 } 908 else { 909 errln("Fail: boundary transition incorrect"); 910 } 911 } 912 delete fmt; 913 delete asuncion; 914 delete DATA_TZ[0]; 915 } 916 917 /** 918 * getDisplayName doesn't work with unusual savings/offsets. 919 */ 920 void TimeZoneRegressionTest::Test4176686() { 921 // Construct a zone that does not observe DST but 922 // that does have a DST savings (which should be ignored). 923 UErrorCode status = U_ZERO_ERROR; 924 int32_t offset = 90 * 60000; // 1:30 925 SimpleTimeZone* z1 = new SimpleTimeZone(offset, "_std_zone_"); 926 z1->setDSTSavings(45 * 60000, status); // 0:45 927 928 // Construct a zone that observes DST for the first 6 months. 929 SimpleTimeZone* z2 = new SimpleTimeZone(offset, "_dst_zone_"); 930 z2->setDSTSavings(45 * 60000, status); // 0:45 931 z2->setStartRule(UCAL_JANUARY, 1, 0, status); 932 z2->setEndRule(UCAL_JULY, 1, 0, status); 933 934 // Also check DateFormat 935 DateFormat* fmt1 = new SimpleDateFormat(UnicodeString("z"), status); 936 if (U_FAILURE(status)) { 937 dataerrln("Failure trying to construct: %s", u_errorName(status)); 938 return; 939 } 940 fmt1->setTimeZone(*z1); // Format uses standard zone 941 DateFormat* fmt2 = new SimpleDateFormat(UnicodeString("z"), status); 942 if(!assertSuccess("trying to construct", status))return; 943 fmt2->setTimeZone(*z2); // Format uses DST zone 944 Calendar* tempcal = Calendar::createInstance(status); 945 tempcal->clear(); 946 tempcal->set(1970, UCAL_FEBRUARY, 1); 947 UDate dst = tempcal->getTime(status); // Time in DST 948 tempcal->set(1970, UCAL_AUGUST, 1); 949 UDate std = tempcal->getTime(status); // Time in standard 950 951 // Description, Result, Expected Result 952 UnicodeString a,b,c,d,e,f,g,h,i,j,k,l; 953 UnicodeString DATA[] = { 954 "z1->getDisplayName(false, SHORT)/std zone", 955 z1->getDisplayName(FALSE, TimeZone::SHORT, a), "GMT+1:30", 956 "z1->getDisplayName(false, LONG)/std zone", 957 z1->getDisplayName(FALSE, TimeZone::LONG, b), "GMT+01:30", 958 "z1->getDisplayName(true, SHORT)/std zone", 959 z1->getDisplayName(TRUE, TimeZone::SHORT, c), "GMT+1:30", 960 "z1->getDisplayName(true, LONG)/std zone", 961 z1->getDisplayName(TRUE, TimeZone::LONG, d ), "GMT+01:30", 962 "z2->getDisplayName(false, SHORT)/dst zone", 963 z2->getDisplayName(FALSE, TimeZone::SHORT, e), "GMT+1:30", 964 "z2->getDisplayName(false, LONG)/dst zone", 965 z2->getDisplayName(FALSE, TimeZone::LONG, f ), "GMT+01:30", 966 "z2->getDisplayName(true, SHORT)/dst zone", 967 z2->getDisplayName(TRUE, TimeZone::SHORT, g), "GMT+2:15", 968 "z2->getDisplayName(true, LONG)/dst zone", 969 z2->getDisplayName(TRUE, TimeZone::LONG, h ), "GMT+02:15", 970 "DateFormat.format(std)/std zone", fmt1->format(std, i), "GMT+1:30", 971 "DateFormat.format(dst)/std zone", fmt1->format(dst, j), "GMT+1:30", 972 "DateFormat.format(std)/dst zone", fmt2->format(std, k), "GMT+1:30", 973 "DateFormat.format(dst)/dst zone", fmt2->format(dst, l), "GMT+2:15", 974 }; 975 976 for (int32_t idx=0; idx<UPRV_LENGTHOF(DATA); idx+=3) { 977 if (DATA[idx+1]!=(DATA[idx+2])) { 978 errln("FAIL: " + DATA[idx] + " -> " + DATA[idx+1] + ", exp " + DATA[idx+2]); 979 } 980 } 981 delete z1; 982 delete z2; 983 delete fmt1; 984 delete fmt2; 985 delete tempcal; 986 } 987 988 /** 989 * Make sure setStartRule and setEndRule set the DST savings to nonzero 990 * if it was zero. 991 */ 992 void TimeZoneRegressionTest::TestJ186() { 993 UErrorCode status = U_ZERO_ERROR; 994 // NOTE: Setting the DST savings to zero is illegal, so we 995 // are limited in the testing we can do here. This is why 996 // lines marked //~ are commented out. 997 SimpleTimeZone z(0, "ID"); 998 //~z.setDSTSavings(0, status); // Must do this! 999 z.setStartRule(UCAL_FEBRUARY, 1, UCAL_SUNDAY, 0, status); 1000 failure(status, "setStartRule()"); 1001 if (z.useDaylightTime()) { 1002 errln("Fail: useDaylightTime true with start rule only"); 1003 } 1004 //~if (z.getDSTSavings() != 0) { 1005 //~ errln("Fail: dst savings != 0 with start rule only"); 1006 //~} 1007 z.setEndRule(UCAL_MARCH, -1, UCAL_SUNDAY, 0, status); 1008 failure(status, "setStartRule()"); 1009 if (!z.useDaylightTime()) { 1010 errln("Fail: useDaylightTime false with rules set"); 1011 } 1012 if (z.getDSTSavings() == 0) { 1013 errln("Fail: dst savings == 0 with rules set"); 1014 } 1015 } 1016 1017 /** 1018 * Test to see if DateFormat understands zone equivalency groups. It 1019 * might seem that this should be a DateFormat test, but it's really a 1020 * TimeZone test -- the changes to DateFormat are minor. 1021 * 1022 * We use two known, stable zones that shouldn't change much over time 1023 * -- America/Vancouver and America/Los_Angeles. However, they MAY 1024 * change at some point -- if that happens, replace them with any two 1025 * zones in an equivalency group where one zone has localized name 1026 * data, and the other doesn't, in some locale. 1027 */ 1028 void TimeZoneRegressionTest::TestJ449() { 1029 UErrorCode status = U_ZERO_ERROR; 1030 UnicodeString str; 1031 1032 // Modify the following three as necessary. The two IDs must 1033 // specify two zones in the same equivalency group. One must have 1034 // locale data in 'loc'; the other must not. 1035 const char* idWithLocaleData = "America/Los_Angeles"; 1036 const char* idWithoutLocaleData = "US/Pacific"; 1037 const Locale loc("en", "", ""); 1038 1039 TimeZone *zoneWith = TimeZone::createTimeZone(idWithLocaleData); 1040 TimeZone *zoneWithout = TimeZone::createTimeZone(idWithoutLocaleData); 1041 // Make sure we got valid zones 1042 if (zoneWith->getID(str) != UnicodeString(idWithLocaleData) || 1043 zoneWithout->getID(str) != UnicodeString(idWithoutLocaleData)) { 1044 dataerrln(UnicodeString("Fail: Unable to create zones - wanted ") + idWithLocaleData + ", got " + zoneWith->getID(str) + ", and wanted " + idWithoutLocaleData + " but got " + zoneWithout->getID(str)); 1045 } else { 1046 GregorianCalendar calWith(*zoneWith, status); 1047 GregorianCalendar calWithout(*zoneWithout, status); 1048 SimpleDateFormat fmt("MMM d yyyy hh:mm a zzz", loc, status); 1049 if (U_FAILURE(status)) { 1050 errln("Fail: Unable to create GregorianCalendar/SimpleDateFormat"); 1051 } else { 1052 UDate date = 0; 1053 UnicodeString strWith, strWithout; 1054 fmt.setCalendar(calWith); 1055 fmt.format(date, strWith); 1056 fmt.setCalendar(calWithout); 1057 fmt.format(date, strWithout); 1058 if (strWith == strWithout) { 1059 logln((UnicodeString)"Ok: " + idWithLocaleData + " -> " + 1060 strWith + "; " + idWithoutLocaleData + " -> " + 1061 strWithout); 1062 } else { 1063 errln((UnicodeString)"FAIL: " + idWithLocaleData + " -> " + 1064 strWith + "; " + idWithoutLocaleData + " -> " + 1065 strWithout); 1066 } 1067 } 1068 } 1069 1070 delete zoneWith; 1071 delete zoneWithout; 1072 } 1073 1074 // test new API for JDK 1.2 8/31 putback 1075 void 1076 TimeZoneRegressionTest::TestJDK12API() 1077 { 1078 // TimeZone *pst = TimeZone::createTimeZone("PST"); 1079 // TimeZone *cst1 = TimeZone::createTimeZone("CST"); 1080 UErrorCode ec = U_ZERO_ERROR; 1081 //d,-28800,3,1,-1,120,w,9,-1,1,120,w,60 1082 TimeZone *pst = new SimpleTimeZone(-28800*U_MILLIS_PER_SECOND, 1083 "PST", 1084 3,1,-1,120*U_MILLIS_PER_MINUTE, 1085 SimpleTimeZone::WALL_TIME, 1086 9,-1,1,120*U_MILLIS_PER_MINUTE, 1087 SimpleTimeZone::WALL_TIME, 1088 60*U_MILLIS_PER_MINUTE,ec); 1089 //d,-21600,3,1,-1,120,w,9,-1,1,120,w,60 1090 TimeZone *cst1 = new SimpleTimeZone(-21600*U_MILLIS_PER_SECOND, 1091 "CST", 1092 3,1,-1,120*U_MILLIS_PER_MINUTE, 1093 SimpleTimeZone::WALL_TIME, 1094 9,-1,1,120*U_MILLIS_PER_MINUTE, 1095 SimpleTimeZone::WALL_TIME, 1096 60*U_MILLIS_PER_MINUTE,ec); 1097 if (U_FAILURE(ec)) { 1098 errln("FAIL: SimpleTimeZone constructor"); 1099 return; 1100 } 1101 1102 SimpleTimeZone *cst = dynamic_cast<SimpleTimeZone *>(cst1); 1103 1104 if(pst->hasSameRules(*cst)) { 1105 errln("FAILURE: PST and CST have same rules"); 1106 } 1107 1108 UErrorCode status = U_ZERO_ERROR; 1109 int32_t offset1 = pst->getOffset(1, 1110 1997, UCAL_OCTOBER, 26, UCAL_SUNDAY, (2*60*60*1000), status); 1111 failure(status, "getOffset() failed"); 1112 1113 1114 int32_t offset2 = cst->getOffset(1, 1115 1997, UCAL_OCTOBER, 26, UCAL_SUNDAY, (2*60*60*1000), 31, status); 1116 failure(status, "getOffset() failed"); 1117 1118 if(offset1 == offset2) 1119 errln("FAILURE: Sunday Oct. 26 1997 2:00 has same offset for PST and CST"); 1120 1121 // verify error checking 1122 pst->getOffset(1, 1123 1997, UCAL_FIELD_COUNT+1, 26, UCAL_SUNDAY, (2*60*60*1000), status); 1124 if(U_SUCCESS(status)) 1125 errln("FAILURE: getOffset() succeeded with -1 for month"); 1126 1127 status = U_ZERO_ERROR; 1128 cst->setDSTSavings(60*60*1000, status); 1129 failure(status, "setDSTSavings() failed"); 1130 1131 int32_t savings = cst->getDSTSavings(); 1132 if(savings != 60*60*1000) { 1133 errln("setDSTSavings() failed"); 1134 } 1135 1136 delete pst; 1137 delete cst; 1138 } 1139 /** 1140 * SimpleTimeZone allows invalid DOM values. 1141 */ 1142 void TimeZoneRegressionTest::Test4184229() { 1143 SimpleTimeZone* zone = NULL; 1144 UErrorCode status = U_ZERO_ERROR; 1145 zone = new SimpleTimeZone(0, "A", 0, -1, 0, 0, 0, 0, 0, 0, status); 1146 if(U_SUCCESS(status)){ 1147 errln("Failed. No exception has been thrown for DOM -1 startDay"); 1148 }else{ 1149 logln("(a) " + UnicodeString( u_errorName(status))); 1150 } 1151 status = U_ZERO_ERROR; 1152 delete zone; 1153 1154 zone = new SimpleTimeZone(0, "A", 0, 0, 0, 0, 0, -1, 0, 0, status); 1155 if(U_SUCCESS(status)){ 1156 errln("Failed. No exception has been thrown for DOM -1 endDay"); 1157 }else{ 1158 logln("(b) " + UnicodeString(u_errorName(status))); 1159 } 1160 status = U_ZERO_ERROR; 1161 delete zone; 1162 1163 zone = new SimpleTimeZone(0, "A", 0, -1, 0, 0, 0, 0, 0, 1000, status); 1164 if(U_SUCCESS(status)){ 1165 errln("Failed. No exception has been thrown for DOM -1 startDay+savings"); 1166 }else{ 1167 logln("(c) " + UnicodeString(u_errorName(status))); 1168 } 1169 status = U_ZERO_ERROR; 1170 delete zone; 1171 zone = new SimpleTimeZone(0, "A", 0, 0, 0, 0, 0, -1, 0, 0, 1000, status); 1172 if(U_SUCCESS(status)){ 1173 errln("Failed. No exception has been thrown for DOM -1 endDay+ savings"); 1174 }else{ 1175 logln("(d) " + UnicodeString(u_errorName(status))); 1176 } 1177 status = U_ZERO_ERROR; 1178 delete zone; 1179 // Make a valid constructor call for subsequent tests. 1180 zone = new SimpleTimeZone(0, "A", 0, 1, 0, 0, 0, 1, 0, 0, status); 1181 1182 zone->setStartRule(0, -1, 0, 0, status); 1183 if(U_SUCCESS(status)){ 1184 errln("Failed. No exception has been thrown for DOM -1 setStartRule +savings"); 1185 } else{ 1186 logln("(e) " + UnicodeString(u_errorName(status))); 1187 } 1188 zone->setStartRule(0, -1, 0, status); 1189 if(U_SUCCESS(status)){ 1190 errln("Failed. No exception has been thrown for DOM -1 setStartRule"); 1191 } else{ 1192 logln("(f) " + UnicodeString(u_errorName(status))); 1193 } 1194 1195 zone->setEndRule(0, -1, 0, 0, status); 1196 if(U_SUCCESS(status)){ 1197 errln("Failed. No exception has been thrown for DOM -1 setEndRule+savings"); 1198 } else{ 1199 logln("(g) " + UnicodeString(u_errorName(status))); 1200 } 1201 1202 zone->setEndRule(0, -1, 0, status); 1203 if(U_SUCCESS(status)){ 1204 errln("Failed. No exception has been thrown for DOM -1 setEndRule"); 1205 } else{ 1206 logln("(h) " + UnicodeString(u_errorName(status))); 1207 } 1208 delete zone; 1209 } 1210 1211 void TimeZoneRegressionTest::TestNegativeDaylightSaving() { 1212 UErrorCode status = U_ZERO_ERROR; 1213 int32_t stdOff = 1 * 60*60*1000; // Standard offset UTC+1 1214 int save = -1 * 60*60*1000; // DST saving amount -1 hour 1215 SimpleTimeZone stzDublin(stdOff, "Dublin-2018", 1216 UCAL_OCTOBER, -1, -UCAL_SUNDAY, 2*60*60*1000, 1217 UCAL_MARCH, -1, -UCAL_SUNDAY, 1*60*60*1000, 1218 save, status); 1219 failure(status, "SimpleTimeZone constructor"); 1220 1221 if (save != stzDublin.getDSTSavings()) { 1222 errln((UnicodeString)"FAIL: DST saving is not " + save); 1223 } 1224 1225 GregorianCalendar cal(* TimeZone::getGMT(), status); 1226 failure(status, "GregorianCalendar constructor"); 1227 1228 UDate testDate; 1229 int32_t rawOffset; 1230 int32_t dstOffset; 1231 1232 cal.set(2018, UCAL_JANUARY, 15, 0, 0, 0); 1233 testDate = cal.getTime(status); 1234 failure(status, "calendar getTime() - Jan 15"); 1235 1236 if (!stzDublin.inDaylightTime(testDate, status)) { 1237 errln("FAIL: The test date (Jan 15) must be in DST."); 1238 } 1239 failure(status, "inDaylightTime() - Jan 15"); 1240 1241 stzDublin.getOffset(testDate, FALSE, rawOffset, dstOffset, status); 1242 failure(status, "getOffset() - Jan 15"); 1243 if (rawOffset != stdOff || dstOffset != save) { 1244 errln((UnicodeString)"FAIL: Expected [stdoff=" + stdOff + ",save=" + save 1245 + "] on the test date (Jan 15), actual[stdoff=" + rawOffset 1246 + ",save=" + dstOffset + "]"); 1247 } 1248 1249 cal.set(2018, UCAL_JULY, 15, 0, 0, 0); 1250 testDate = cal.getTime(status); 1251 failure(status, "calendar getTime() - Jul 15"); 1252 1253 if (stzDublin.inDaylightTime(testDate, status)) { 1254 errln("FAIL: The test date (Jul 15) must be in DST."); 1255 } 1256 failure(status, "inDaylightTime() - Jul 15"); 1257 1258 stzDublin.getOffset(testDate, FALSE, rawOffset, dstOffset, status); 1259 failure(status, "getOffset() - Jul 15"); 1260 if (rawOffset != stdOff || dstOffset != 0) { 1261 errln((UnicodeString)"FAIL: Expected [stdoff=" + stdOff + ",save=" + 0 1262 + "] on the test date (Jul 15), actual[stdoff=" + rawOffset 1263 + ",save=" + dstOffset + "]"); 1264 } 1265 } 1266 1267 1268 #endif /* #if !UCONFIG_NO_FORMATTING */ 1269
