1 // Copyright (C) 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /*********************************************************************** 4 * COPYRIGHT: 5 * Copyright (c) 1997-2015, International Business Machines Corporation 6 * and others. All Rights Reserved. 7 ***********************************************************************/ 8 9 #include "unicode/utypes.h" 10 11 #if !UCONFIG_NO_FORMATTING 12 13 #include "callimts.h" 14 #include "caltest.h" 15 #include "unicode/calendar.h" 16 #include "unicode/gregocal.h" 17 #include "unicode/datefmt.h" 18 #include "unicode/smpdtfmt.h" 19 #include "cstring.h" 20 #include "mutex.h" 21 #include "putilimp.h" 22 #include "simplethread.h" 23 24 U_NAMESPACE_USE 25 void CalendarLimitTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) 26 { 27 if (exec) logln("TestSuite TestCalendarLimit"); 28 switch (index) { 29 // Re-enable this later 30 case 0: 31 name = "TestCalendarExtremeLimit"; 32 if (exec) { 33 logln("TestCalendarExtremeLimit---"); logln(""); 34 TestCalendarExtremeLimit(); 35 } 36 break; 37 case 1: 38 name = "TestLimits"; 39 if (exec) { 40 logln("TestLimits---"); logln(""); 41 TestLimits(); 42 } 43 break; 44 45 default: name = ""; break; 46 } 47 } 48 49 50 // ***************************************************************************** 51 // class CalendarLimitTest 52 // ***************************************************************************** 53 54 // ------------------------------------- 55 void 56 CalendarLimitTest::test(UDate millis, icu::Calendar* cal, icu::DateFormat* fmt) 57 { 58 static const UDate kDrift = 1e-10; 59 UErrorCode exception = U_ZERO_ERROR; 60 UnicodeString theDate; 61 UErrorCode status = U_ZERO_ERROR; 62 cal->setTime(millis, exception); 63 if (U_SUCCESS(exception)) { 64 fmt->format(millis, theDate); 65 UDate dt = fmt->parse(theDate, status); 66 // allow a small amount of error (drift) 67 if(! withinErr(dt, millis, kDrift)) { 68 errln("FAIL:round trip for large milli, got: %.1lf wanted: %.1lf. (delta %.2lf greater than %.2lf)", 69 dt, millis, uprv_fabs(millis-dt), uprv_fabs(dt*kDrift)); 70 logln(UnicodeString(" ") + theDate + " " + CalendarTest::calToStr(*cal)); 71 } else { 72 logln(UnicodeString("OK: got ") + dt + ", wanted " + millis); 73 logln(UnicodeString(" ") + theDate); 74 } 75 } 76 } 77 78 // ------------------------------------- 79 80 // bug 986c: deprecate nextDouble/previousDouble 81 //|double 82 //|CalendarLimitTest::nextDouble(double a) 83 //|{ 84 //| return uprv_nextDouble(a, TRUE); 85 //|} 86 //| 87 //|double 88 //|CalendarLimitTest::previousDouble(double a) 89 //|{ 90 //| return uprv_nextDouble(a, FALSE); 91 //|} 92 93 UBool 94 CalendarLimitTest::withinErr(double a, double b, double err) 95 { 96 return ( uprv_fabs(a - b) < uprv_fabs(a * err) ); 97 } 98 99 void 100 CalendarLimitTest::TestCalendarExtremeLimit() 101 { 102 UErrorCode status = U_ZERO_ERROR; 103 Calendar *cal = Calendar::createInstance(status); 104 if (failure(status, "Calendar::createInstance", TRUE)) return; 105 cal->adoptTimeZone(TimeZone::createTimeZone("GMT")); 106 DateFormat *fmt = DateFormat::createDateTimeInstance(); 107 if(!fmt || !cal) { 108 dataerrln("can't open cal and/or fmt"); 109 return; 110 } 111 fmt->adoptCalendar(cal); 112 ((SimpleDateFormat*) fmt)->applyPattern("HH:mm:ss.SSS Z, EEEE, MMMM d, yyyy G"); 113 114 115 // This test used to test the algorithmic limits of the dates that 116 // GregorianCalendar could handle. However, the algorithm has 117 // been rewritten completely since then and the prior limits no 118 // longer apply. Instead, we now do basic round-trip testing of 119 // some extreme (but still manageable) dates. 120 UDate m; 121 logln("checking 1e16..1e17"); 122 for ( m = 1e16; m < 1e17; m *= 1.1) { 123 test(m, cal, fmt); 124 } 125 logln("checking -1e14..-1e15"); 126 for ( m = -1e14; m > -1e15; m *= 1.1) { 127 test(m, cal, fmt); 128 } 129 130 // This is 2^52 - 1, the largest allowable mantissa with a 0 131 // exponent in a 64-bit double 132 UDate VERY_EARLY_MILLIS = - 4503599627370495.0; 133 UDate VERY_LATE_MILLIS = 4503599627370495.0; 134 135 // I am removing the previousDouble and nextDouble calls below for 136 // two reasons: 1. As part of jitterbug 986, I am deprecating 137 // these methods and removing calls to them. 2. This test is a 138 // non-critical boundary behavior test. 139 test(VERY_EARLY_MILLIS, cal, fmt); 140 //test(previousDouble(VERY_EARLY_MILLIS), cal, fmt); 141 test(VERY_LATE_MILLIS, cal, fmt); 142 //test(nextDouble(VERY_LATE_MILLIS), cal, fmt); 143 delete fmt; 144 } 145 146 namespace { 147 148 struct TestCase { 149 const char *type; 150 UBool hasLeapMonth; 151 UDate actualTestStart; 152 int32_t actualTestEnd; 153 }; 154 155 const UDate DEFAULT_START = 944006400000.0; // 1999-12-01T00:00Z 156 const int32_t DEFAULT_END = -120; // Default for non-quick is run 2 minutes 157 158 TestCase TestCases[] = { 159 {"gregorian", FALSE, DEFAULT_START, DEFAULT_END}, 160 {"japanese", FALSE, 596937600000.0, DEFAULT_END}, // 1988-12-01T00:00Z, Showa 63 161 {"buddhist", FALSE, DEFAULT_START, DEFAULT_END}, 162 {"roc", FALSE, DEFAULT_START, DEFAULT_END}, 163 {"persian", FALSE, DEFAULT_START, DEFAULT_END}, 164 {"islamic-civil", FALSE, DEFAULT_START, DEFAULT_END}, 165 {"islamic", FALSE, DEFAULT_START, 800000}, // Approx. 2250 years from now, after which 166 // some rounding errors occur in Islamic calendar 167 {"hebrew", TRUE, DEFAULT_START, DEFAULT_END}, 168 {"chinese", TRUE, DEFAULT_START, DEFAULT_END}, 169 {"dangi", TRUE, DEFAULT_START, DEFAULT_END}, 170 {"indian", FALSE, DEFAULT_START, DEFAULT_END}, 171 {"coptic", FALSE, DEFAULT_START, DEFAULT_END}, 172 {"ethiopic", FALSE, DEFAULT_START, DEFAULT_END}, 173 {"ethiopic-amete-alem", FALSE, DEFAULT_START, DEFAULT_END} 174 }; 175 176 struct { 177 int32_t fIndex; 178 UBool next (int32_t &rIndex) { 179 Mutex lock; 180 if (fIndex >= UPRV_LENGTHOF(TestCases)) { 181 return FALSE; 182 } 183 rIndex = fIndex++; 184 return TRUE; 185 } 186 void reset() { 187 fIndex = 0; 188 } 189 } gTestCaseIterator; 190 191 } // anonymous name space 192 193 void 194 CalendarLimitTest::TestLimits(void) { 195 gTestCaseIterator.reset(); 196 197 ThreadPool<CalendarLimitTest> threads(this, threadCount, &CalendarLimitTest::TestLimitsThread); 198 threads.start(); 199 threads.join(); 200 } 201 202 203 void CalendarLimitTest::TestLimitsThread(int32_t threadNum) { 204 logln("thread %d starting", threadNum); 205 int32_t testIndex = 0; 206 LocalPointer<Calendar> cal; 207 while (gTestCaseIterator.next(testIndex)) { 208 TestCase &testCase = TestCases[testIndex]; 209 logln("begin test of %s calendar.", testCase.type); 210 UErrorCode status = U_ZERO_ERROR; 211 char buf[64]; 212 uprv_strcpy(buf, "root@calendar="); 213 strcat(buf, testCase.type); 214 cal.adoptInstead(Calendar::createInstance(buf, status)); 215 if (failure(status, "Calendar::createInstance", TRUE)) { 216 continue; 217 } 218 if (uprv_strcmp(cal->getType(), testCase.type) != 0) { 219 errln((UnicodeString)"FAIL: Wrong calendar type: " + cal->getType() 220 + " Requested: " + testCase.type); 221 continue; 222 } 223 doTheoreticalLimitsTest(*(cal.getAlias()), testCase.hasLeapMonth); 224 doLimitsTest(*(cal.getAlias()), testCase.actualTestStart, testCase.actualTestEnd); 225 logln("end test of %s calendar.", testCase.type); 226 } 227 } 228 229 230 void 231 CalendarLimitTest::doTheoreticalLimitsTest(Calendar& cal, UBool leapMonth) { 232 const char* calType = cal.getType(); 233 234 int32_t nDOW = cal.getMaximum(UCAL_DAY_OF_WEEK); 235 int32_t maxDOY = cal.getMaximum(UCAL_DAY_OF_YEAR); 236 int32_t lmaxDOW = cal.getLeastMaximum(UCAL_DAY_OF_YEAR); 237 int32_t maxWOY = cal.getMaximum(UCAL_WEEK_OF_YEAR); 238 int32_t lmaxWOY = cal.getLeastMaximum(UCAL_WEEK_OF_YEAR); 239 int32_t maxM = cal.getMaximum(UCAL_MONTH) + 1; 240 int32_t lmaxM = cal.getLeastMaximum(UCAL_MONTH) + 1; 241 int32_t maxDOM = cal.getMaximum(UCAL_DAY_OF_MONTH); 242 int32_t lmaxDOM = cal.getLeastMaximum(UCAL_DAY_OF_MONTH); 243 int32_t maxDOWIM = cal.getMaximum(UCAL_DAY_OF_WEEK_IN_MONTH); 244 int32_t lmaxDOWIM = cal.getLeastMaximum(UCAL_DAY_OF_WEEK_IN_MONTH); 245 int32_t maxWOM = cal.getMaximum(UCAL_WEEK_OF_MONTH); 246 int32_t lmaxWOM = cal.getLeastMaximum(UCAL_WEEK_OF_MONTH); 247 int32_t minDaysInFirstWeek = cal.getMinimalDaysInFirstWeek(); 248 249 // Day of year 250 int32_t expected; 251 if (!leapMonth) { 252 expected = maxM*maxDOM; 253 if (maxDOY > expected) { 254 errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of DAY_OF_YEAR is too big: " 255 + maxDOY + "/expected: <=" + expected); 256 } 257 expected = lmaxM*lmaxDOM; 258 if (lmaxDOW < expected) { 259 errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of DAY_OF_YEAR is too small: " 260 + lmaxDOW + "/expected: >=" + expected); 261 } 262 } 263 264 // Week of year 265 expected = maxDOY/nDOW + 1; 266 if (maxWOY > expected) { 267 errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of WEEK_OF_YEAR is too big: " 268 + maxWOY + "/expected: <=" + expected); 269 } 270 expected = lmaxDOW/nDOW; 271 if (lmaxWOY < expected) { 272 errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of WEEK_OF_YEAR is too small: " 273 + lmaxWOY + "/expected >=" + expected); 274 } 275 276 // Day of week in month 277 expected = (maxDOM + nDOW - 1)/nDOW; 278 if (maxDOWIM != expected) { 279 errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of DAY_OF_WEEK_IN_MONTH is incorrect: " 280 + maxDOWIM + "/expected: " + expected); 281 } 282 expected = (lmaxDOM + nDOW - 1)/nDOW; 283 if (lmaxDOWIM != expected) { 284 errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of DAY_OF_WEEK_IN_MONTH is incorrect: " 285 + lmaxDOWIM + "/expected: " + expected); 286 } 287 288 // Week of month 289 expected = (maxDOM + (nDOW - 1) + (nDOW - minDaysInFirstWeek)) / nDOW; 290 if (maxWOM != expected) { 291 errln((UnicodeString)"FAIL: [" + calType + "] Maximum value of WEEK_OF_MONTH is incorrect: " 292 + maxWOM + "/expected: " + expected); 293 } 294 expected = (lmaxDOM + (nDOW - minDaysInFirstWeek)) / nDOW; 295 if (lmaxWOM != expected) { 296 errln((UnicodeString)"FAIL: [" + calType + "] Least maximum value of WEEK_OF_MONTH is incorrect: " 297 + lmaxWOM + "/expected: " + expected); 298 } 299 } 300 301 void 302 CalendarLimitTest::doLimitsTest(Calendar& cal, UDate startDate, int32_t endTime) { 303 int32_t testTime = quick ? ( endTime / 40 ) : endTime; 304 doLimitsTest(cal, NULL /*default fields*/, startDate, testTime); 305 } 306 307 void 308 CalendarLimitTest::doLimitsTest(Calendar& cal, 309 const int32_t* fieldsToTest, 310 UDate startDate, 311 int32_t testDuration) { 312 static const int32_t FIELDS[] = { 313 UCAL_ERA, 314 UCAL_YEAR, 315 UCAL_MONTH, 316 UCAL_WEEK_OF_YEAR, 317 UCAL_WEEK_OF_MONTH, 318 UCAL_DAY_OF_MONTH, 319 UCAL_DAY_OF_YEAR, 320 UCAL_DAY_OF_WEEK_IN_MONTH, 321 UCAL_YEAR_WOY, 322 UCAL_EXTENDED_YEAR, 323 -1, 324 }; 325 326 static const char* FIELD_NAME[] = { 327 "ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH", 328 "DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK", 329 "DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY", 330 "MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET", 331 "DST_OFFSET", "YEAR_WOY", "DOW_LOCAL", "EXTENDED_YEAR", 332 "JULIAN_DAY", "MILLISECONDS_IN_DAY", 333 "IS_LEAP_MONTH" 334 }; 335 336 UErrorCode status = U_ZERO_ERROR; 337 int32_t i, j; 338 UnicodeString ymd; 339 340 GregorianCalendar greg(status); 341 if (failure(status, "new GregorianCalendar")) { 342 return; 343 } 344 greg.setTime(startDate, status); 345 if (failure(status, "GregorianCalendar::setTime")) { 346 return; 347 } 348 logln((UnicodeString)"Start: " + startDate); 349 350 if (fieldsToTest == NULL) { 351 fieldsToTest = FIELDS; 352 } 353 354 355 // Keep a record of minima and maxima that we actually see. 356 // These are kept in an array of arrays of hashes. 357 int32_t limits[UCAL_FIELD_COUNT][4]; 358 for (j = 0; j < UCAL_FIELD_COUNT; j++) { 359 limits[j][0] = INT32_MAX; 360 limits[j][1] = INT32_MIN; 361 limits[j][2] = INT32_MAX; 362 limits[j][3] = INT32_MIN; 363 } 364 365 // This test can run for a long time; show progress. 366 UDate millis = ucal_getNow(); 367 UDate mark = millis + 5000; // 5 sec 368 millis -= testDuration * 1000; // stop time if testDuration<0 369 370 for (i = 0; 371 testDuration > 0 ? i < testDuration 372 : ucal_getNow() < millis; 373 ++i) { 374 if (ucal_getNow() >= mark) { 375 logln((UnicodeString)"(" + i + " days)"); 376 mark += 5000; // 5 sec 377 } 378 UDate testMillis = greg.getTime(status); 379 cal.setTime(testMillis, status); 380 cal.setMinimalDaysInFirstWeek(1); 381 if (failure(status, "Calendar set/getTime")) { 382 return; 383 } 384 for (j = 0; fieldsToTest[j] >= 0; ++j) { 385 UCalendarDateFields f = (UCalendarDateFields)fieldsToTest[j]; 386 int32_t v = cal.get(f, status); 387 int32_t minActual = cal.getActualMinimum(f, status); 388 int32_t maxActual = cal.getActualMaximum(f, status); 389 int32_t minLow = cal.getMinimum(f); 390 int32_t minHigh = cal.getGreatestMinimum(f); 391 int32_t maxLow = cal.getLeastMaximum(f); 392 int32_t maxHigh = cal.getMaximum(f); 393 394 if (limits[j][0] > minActual) { 395 // the minimum 396 limits[j][0] = minActual; 397 } 398 if (limits[j][1] < minActual) { 399 // the greatest minimum 400 limits[j][1] = minActual; 401 } 402 if (limits[j][2] > maxActual) { 403 // the least maximum 404 limits[j][2] = maxActual; 405 } 406 if (limits[j][3] < maxActual) { 407 // the maximum 408 limits[j][3] = maxActual; 409 } 410 411 if (minActual < minLow || minActual > minHigh) { 412 errln((UnicodeString)"Fail: [" + cal.getType() + "] " + 413 ymdToString(cal, ymd) + 414 " Range for min of " + FIELD_NAME[f] + "(" + f + 415 ")=" + minLow + ".." + minHigh + 416 ", actual_min=" + minActual); 417 } 418 if (maxActual < maxLow || maxActual > maxHigh) { 419 if ( uprv_strcmp(cal.getType(), "chinese") == 0 && 420 testMillis >= 2842992000000.0 && testMillis <= 2906668800000.0 && 421 logKnownIssue("12620", "chinese calendar failures for some actualMax tests")) { 422 logln((UnicodeString)"KnownFail: [" + cal.getType() + "] " + 423 ymdToString(cal, ymd) + 424 " Range for max of " + FIELD_NAME[f] + "(" + f + 425 ")=" + maxLow + ".." + maxHigh + 426 ", actual_max=" + maxActual); 427 } else { 428 errln((UnicodeString)"Fail: [" + cal.getType() + "] " + 429 ymdToString(cal, ymd) + 430 " Range for max of " + FIELD_NAME[f] + "(" + f + 431 ")=" + maxLow + ".." + maxHigh + 432 ", actual_max=" + maxActual); 433 } 434 } 435 if (v < minActual || v > maxActual) { 436 // timebomb per #9967, fix with #9972 437 if ( uprv_strcmp(cal.getType(), "dangi") == 0 && 438 testMillis >= 1865635198000.0 && 439 logKnownIssue("9972", "as per #9967")) { // Feb 2029 gregorian, end of dangi 4361 440 logln((UnicodeString)"KnownFail: [" + cal.getType() + "] " + 441 ymdToString(cal, ymd) + 442 " " + FIELD_NAME[f] + "(" + f + ")=" + v + 443 ", actual=" + minActual + ".." + maxActual + 444 ", allowed=(" + minLow + ".." + minHigh + ")..(" + 445 maxLow + ".." + maxHigh + ")"); 446 } else if ( uprv_strcmp(cal.getType(), "chinese") == 0 && 447 testMillis >= 2842992000000.0 && testMillis <= 2906668800000.0 && 448 logKnownIssue("12620", "chinese calendar failures for some actualMax tests")) { 449 logln((UnicodeString)"KnownFail: [" + cal.getType() + "] " + 450 ymdToString(cal, ymd) + 451 " " + FIELD_NAME[f] + "(" + f + ")=" + v + 452 ", actual=" + minActual + ".." + maxActual + 453 ", allowed=(" + minLow + ".." + minHigh + ")..(" + 454 maxLow + ".." + maxHigh + ")"); 455 } else { 456 errln((UnicodeString)"Fail: [" + cal.getType() + "] " + 457 ymdToString(cal, ymd) + 458 " " + FIELD_NAME[f] + "(" + f + ")=" + v + 459 ", actual=" + minActual + ".." + maxActual + 460 ", allowed=(" + minLow + ".." + minHigh + ")..(" + 461 maxLow + ".." + maxHigh + ")"); 462 } 463 } 464 } 465 greg.add(UCAL_DAY_OF_YEAR, 1, status); 466 if (failure(status, "Calendar::add")) { 467 return; 468 } 469 } 470 471 // Check actual maxima and minima seen against ranges returned 472 // by API. 473 UnicodeString buf; 474 for (j = 0; fieldsToTest[j] >= 0; ++j) { 475 int32_t rangeLow, rangeHigh; 476 UBool fullRangeSeen = TRUE; 477 UCalendarDateFields f = (UCalendarDateFields)fieldsToTest[j]; 478 479 buf.remove(); 480 buf.append((UnicodeString)"[" + cal.getType() + "] " + FIELD_NAME[f]); 481 482 // Minumum 483 rangeLow = cal.getMinimum(f); 484 rangeHigh = cal.getGreatestMinimum(f); 485 if (limits[j][0] != rangeLow || limits[j][1] != rangeHigh) { 486 fullRangeSeen = FALSE; 487 } 488 buf.append((UnicodeString)" minima range=" + rangeLow + ".." + rangeHigh); 489 buf.append((UnicodeString)" minima actual=" + limits[j][0] + ".." + limits[j][1]); 490 491 // Maximum 492 rangeLow = cal.getLeastMaximum(f); 493 rangeHigh = cal.getMaximum(f); 494 if (limits[j][2] != rangeLow || limits[j][3] != rangeHigh) { 495 fullRangeSeen = FALSE; 496 } 497 buf.append((UnicodeString)" maxima range=" + rangeLow + ".." + rangeHigh); 498 buf.append((UnicodeString)" maxima actual=" + limits[j][2] + ".." + limits[j][3]); 499 500 if (fullRangeSeen) { 501 logln((UnicodeString)"OK: " + buf); 502 } else { 503 // This may or may not be an error -- if the range of dates 504 // we scan over doesn't happen to contain a minimum or 505 // maximum, it doesn't mean some other range won't. 506 logln((UnicodeString)"Warning: " + buf); 507 } 508 } 509 510 logln((UnicodeString)"End: " + greg.getTime(status)); 511 } 512 513 UnicodeString& 514 CalendarLimitTest::ymdToString(const Calendar& cal, UnicodeString& str) { 515 UErrorCode status = U_ZERO_ERROR; 516 str.remove(); 517 str.append((UnicodeString)"" + cal.get(UCAL_EXTENDED_YEAR, status) 518 + "/" + (cal.get(UCAL_MONTH, status) + 1) 519 + (cal.get(UCAL_IS_LEAP_MONTH, status) == 1 ? "(leap)" : "") 520 + "/" + cal.get(UCAL_DATE, status) 521 + " " + cal.get(UCAL_HOUR_OF_DAY, status) 522 + ":" + cal.get(UCAL_MINUTE, status) 523 + " zone(hrs) " + cal.get(UCAL_ZONE_OFFSET, status)/(60.0*60.0*1000.0) 524 + " dst(hrs) " + cal.get(UCAL_DST_OFFSET, status)/(60.0*60.0*1000.0) 525 + ", time(millis)=" + cal.getTime(status)); 526 return str; 527 } 528 529 #endif /* #if !UCONFIG_NO_FORMATTING */ 530 531 // eof 532
