1 /*********************************************************************** 2 * COPYRIGHT: 3 * Copyright (c) 1997-2010, International Business Machines Corporation 4 * and others. All Rights Reserved. 5 ***********************************************************************/ 6 7 #include "unicode/utypes.h" 8 9 #if !UCONFIG_NO_FORMATTING 10 11 #include "unicode/datefmt.h" 12 #include "unicode/smpdtfmt.h" 13 #include "unicode/gregocal.h" 14 #include "dtfmtrtts.h" 15 #include "caltest.h" 16 17 #include <stdio.h> 18 #include <string.h> 19 20 // ***************************************************************************** 21 // class DateFormatRoundTripTest 22 // ***************************************************************************** 23 24 // Useful for turning up subtle bugs: Change the following to TRUE, recompile, 25 // and run while at lunch. 26 // Warning -- makes test run infinite loop!!! 27 #ifndef INFINITE 28 #define INFINITE 0 29 #endif 30 31 static const UVersionInfo ICU_452 = {4,5,2,0}; 32 33 // Define this to test just a single locale 34 //#define TEST_ONE_LOC "cs_CZ" 35 36 // If SPARSENESS is > 0, we don't run each exhaustive possibility. 37 // There are 24 total possible tests per each locale. A SPARSENESS 38 // of 12 means we run half of them. A SPARSENESS of 23 means we run 39 // 1 of them. SPARSENESS _must_ be in the range 0..23. 40 int32_t DateFormatRoundTripTest::SPARSENESS = 0; 41 int32_t DateFormatRoundTripTest::TRIALS = 4; 42 int32_t DateFormatRoundTripTest::DEPTH = 5; 43 44 DateFormatRoundTripTest::DateFormatRoundTripTest() : dateFormat(0) { 45 } 46 47 DateFormatRoundTripTest::~DateFormatRoundTripTest() { 48 delete dateFormat; 49 } 50 51 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break; 52 53 void 54 DateFormatRoundTripTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par ) 55 { 56 optionv = (par && *par=='v'); 57 switch (index) { 58 CASE(0,TestDateFormatRoundTrip) 59 CASE(1, TestCentury) 60 default: name = ""; break; 61 } 62 } 63 64 UBool 65 DateFormatRoundTripTest::failure(UErrorCode status, const char* msg) 66 { 67 if(U_FAILURE(status)) { 68 errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status)); 69 return TRUE; 70 } 71 72 return FALSE; 73 } 74 75 UBool 76 DateFormatRoundTripTest::failure(UErrorCode status, const char* msg, const UnicodeString& str) 77 { 78 if(U_FAILURE(status)) { 79 UnicodeString escaped; 80 escape(str,escaped); 81 errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status) + ", str=" + escaped); 82 return TRUE; 83 } 84 85 return FALSE; 86 } 87 88 void DateFormatRoundTripTest::TestCentury() 89 { 90 UErrorCode status = U_ZERO_ERROR; 91 Locale locale("es_PA"); 92 UnicodeString pattern = "MM/dd/yy hh:mm:ss a z"; 93 SimpleDateFormat fmt(pattern, locale, status); 94 if (U_FAILURE(status)) { 95 dataerrln("Fail: construct SimpleDateFormat: %s", u_errorName(status)); 96 return; 97 } 98 UDate date[] = {-55018555891590.05, 0, 0}; 99 UnicodeString result[2]; 100 101 fmt.format(date[0], result[0]); 102 date[1] = fmt.parse(result[0], status); 103 fmt.format(date[1], result[1]); 104 date[2] = fmt.parse(result[1], status); 105 106 /* This test case worked OK by accident before. date[1] != date[0], 107 * because we use -80/+20 year window for 2-digit year parsing. 108 * (date[0] is in year 1926, date[1] is in year 2026.) result[1] set 109 * by the first format call returns "07/13/26 07:48:28 p.m. PST", 110 * which is correct, because DST was not used in year 1926 in zone 111 * America/Los_Angeles. When this is parsed, date[1] becomes a time 112 * in 2026, which is "07/13/26 08:48:28 p.m. PDT". There was a zone 113 * offset calculation bug that observed DST in 1926, which was resolved. 114 * Before the bug was resolved, result[0] == result[1] was true, 115 * but after the bug fix, the expected result is actually 116 * result[0] != result[1]. -Yoshito 117 */ 118 /* TODO: We need to review this code and clarify what we really 119 * want to test here. 120 */ 121 //if (date[1] != date[2] || result[0] != result[1]) { 122 if (date[1] != date[2]) { 123 errln("Round trip failure: \"%S\" (%f), \"%S\" (%f)", result[0].getBuffer(), date[1], result[1].getBuffer(), date[2]); 124 } 125 } 126 127 // == 128 129 void DateFormatRoundTripTest::TestDateFormatRoundTrip() 130 { 131 UErrorCode status = U_ZERO_ERROR; 132 133 getFieldCal = Calendar::createInstance(status); 134 if (U_FAILURE(status)) { 135 dataerrln("Fail: Calendar::createInstance: %s", u_errorName(status)); 136 return; 137 } 138 139 140 int32_t locCount = 0; 141 const Locale *avail = DateFormat::getAvailableLocales(locCount); 142 logln("DateFormat available locales: %d", locCount); 143 if(quick) { 144 SPARSENESS = 18; 145 logln("Quick mode: only testing SPARSENESS = 18"); 146 } 147 TimeZone *tz = TimeZone::createDefault(); 148 UnicodeString temp; 149 logln("Default TimeZone: " + tz->getID(temp)); 150 delete tz; 151 152 #ifdef TEST_ONE_LOC // define this to just test ONE locale. 153 Locale loc(TEST_ONE_LOC); 154 test(loc); 155 #if INFINITE 156 for(;;) { 157 test(loc); 158 } 159 #endif 160 161 #else 162 # if INFINITE 163 // Special infinite loop test mode for finding hard to reproduce errors 164 Locale loc = Locale::getDefault(); 165 logln("ENTERING INFINITE TEST LOOP FOR Locale: " + loc.getDisplayName(temp)); 166 for(;;) 167 test(loc); 168 # else 169 test(Locale::getDefault()); 170 171 #if 1 172 // installed locales 173 for (int i=0; i < locCount; ++i) { 174 test(avail[i]); 175 } 176 #endif 177 178 #if 1 179 // special locales 180 int32_t jCount = CalendarTest::testLocaleCount(); 181 for (int32_t j=0; j < jCount; ++j) { 182 test(Locale(CalendarTest::testLocaleID(j))); 183 } 184 #endif 185 186 # endif 187 #endif 188 189 delete getFieldCal; 190 } 191 192 static const char *styleName(DateFormat::EStyle s) 193 { 194 switch(s) 195 { 196 case DateFormat::SHORT: return "SHORT"; 197 case DateFormat::MEDIUM: return "MEDIUM"; 198 case DateFormat::LONG: return "LONG"; 199 case DateFormat::FULL: return "FULL"; 200 // case DateFormat::DEFAULT: return "DEFAULT"; 201 case DateFormat::DATE_OFFSET: return "DATE_OFFSET"; 202 case DateFormat::NONE: return "NONE"; 203 case DateFormat::DATE_TIME: return "DATE_TIME"; 204 default: return "Unknown"; 205 } 206 } 207 208 void DateFormatRoundTripTest::test(const Locale& loc) 209 { 210 UnicodeString temp; 211 #if !INFINITE 212 logln("Locale: " + loc.getDisplayName(temp)); 213 #endif 214 215 // Total possibilities = 24 216 // 4 date 217 // 4 time 218 // 16 date-time 219 UBool TEST_TABLE [24];//= new boolean[24]; 220 int32_t i = 0; 221 for(i = 0; i < 24; ++i) 222 TEST_TABLE[i] = TRUE; 223 224 // If we have some sparseness, implement it here. Sparseness decreases 225 // test time by eliminating some tests, up to 23. 226 for(i = 0; i < SPARSENESS; ) { 227 int random = (int)(randFraction() * 24); 228 if (random >= 0 && random < 24 && TEST_TABLE[i]) { 229 TEST_TABLE[i] = FALSE; 230 ++i; 231 } 232 } 233 234 int32_t itable = 0; 235 int32_t style = 0; 236 for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) { 237 if(TEST_TABLE[itable++]) { 238 logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle)style))); 239 DateFormat *df = DateFormat::createDateInstance((DateFormat::EStyle)style, loc); 240 if(df == NULL) { 241 errln(UnicodeString("Could not DF::createDateInstance ") + UnicodeString(styleName((DateFormat::EStyle)style)) + " Locale: " + loc.getDisplayName(temp)); 242 } else { 243 test(df, loc); 244 delete df; 245 } 246 } 247 } 248 249 for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) { 250 if (TEST_TABLE[itable++]) { 251 logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle)style))); 252 DateFormat *df = DateFormat::createTimeInstance((DateFormat::EStyle)style, loc); 253 if(df == NULL) { 254 errln(UnicodeString("Could not DF::createTimeInstance ") + UnicodeString(styleName((DateFormat::EStyle)style)) + " Locale: " + loc.getDisplayName(temp)); 255 } else { 256 test(df, loc, TRUE); 257 delete df; 258 } 259 } 260 } 261 262 for(int32_t dstyle = DateFormat::FULL; dstyle <= DateFormat::SHORT; ++dstyle) { 263 for(int32_t tstyle = DateFormat::FULL; tstyle <= DateFormat::SHORT; ++tstyle) { 264 if(TEST_TABLE[itable++]) { 265 logln("Testing dstyle" + UnicodeString(styleName((DateFormat::EStyle)dstyle)) + ", tstyle" + UnicodeString(styleName((DateFormat::EStyle)tstyle)) ); 266 DateFormat *df = DateFormat::createDateTimeInstance((DateFormat::EStyle)dstyle, (DateFormat::EStyle)tstyle, loc); 267 if(df == NULL) { 268 dataerrln(UnicodeString("Could not DF::createDateTimeInstance ") + UnicodeString(styleName((DateFormat::EStyle)dstyle)) + ", tstyle" + UnicodeString(styleName((DateFormat::EStyle)tstyle)) + "Locale: " + loc.getDisplayName(temp)); 269 } else { 270 test(df, loc); 271 delete df; 272 } 273 } 274 } 275 } 276 } 277 278 void DateFormatRoundTripTest::test(DateFormat *fmt, const Locale &origLocale, UBool timeOnly) 279 { 280 UnicodeString pat; 281 if(fmt->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) { 282 errln("DateFormat wasn't a SimpleDateFormat"); 283 return; 284 } 285 286 UBool isGregorian = FALSE; 287 UErrorCode minStatus = U_ZERO_ERROR; 288 UDate minDate = CalendarTest::minDateOfCalendar(*fmt->getCalendar(), isGregorian, minStatus); 289 if(U_FAILURE(minStatus)) { 290 errln((UnicodeString)"Failure getting min date for " + origLocale.getName()); 291 return; 292 } 293 //logln(UnicodeString("Min date is ") + fullFormat(minDate) + " for " + origLocale.getName()); 294 295 pat = ((SimpleDateFormat*)fmt)->toPattern(pat); 296 297 // NOTE TO MAINTAINER 298 // This indexOf check into the pattern needs to be refined to ignore 299 // quoted characters. Currently, this isn't a problem with the locale 300 // patterns we have, but it may be a problem later. 301 302 UBool hasEra = (pat.indexOf(UnicodeString("G")) != -1); 303 UBool hasZoneDisplayName = (pat.indexOf(UnicodeString("z")) != -1) || (pat.indexOf(UnicodeString("v")) != -1) 304 || (pat.indexOf(UnicodeString("V")) != -1); 305 306 // Because patterns contain incomplete data representing the Date, 307 // we must be careful of how we do the roundtrip. We start with 308 // a randomly generated Date because they're easier to generate. 309 // From this we get a string. The string is our real starting point, 310 // because this string should parse the same way all the time. Note 311 // that it will not necessarily parse back to the original date because 312 // of incompleteness in patterns. For example, a time-only pattern won't 313 // parse back to the same date. 314 315 //try { 316 for(int i = 0; i < TRIALS; ++i) { 317 UDate *d = new UDate [DEPTH]; 318 UnicodeString *s = new UnicodeString[DEPTH]; 319 320 if(isGregorian == TRUE) { 321 d[0] = generateDate(); 322 } else { 323 d[0] = generateDate(minDate); 324 } 325 326 UErrorCode status = U_ZERO_ERROR; 327 328 // We go through this loop until we achieve a match or until 329 // the maximum loop count is reached. We record the points at 330 // which the date and the string starts to match. Once matching 331 // starts, it should continue. 332 int loop; 333 int dmatch = 0; // d[dmatch].getTime() == d[dmatch-1].getTime() 334 int smatch = 0; // s[smatch].equals(s[smatch-1]) 335 for(loop = 0; loop < DEPTH; ++loop) { 336 if (loop > 0) { 337 d[loop] = fmt->parse(s[loop-1], status); 338 failure(status, "fmt->parse", s[loop-1]+" in locale: " + origLocale.getName()); 339 status = U_ZERO_ERROR; /* any error would have been reported */ 340 } 341 342 s[loop] = fmt->format(d[loop], s[loop]); 343 344 // For displaying which date is being tested 345 //logln(s[loop] + " = " + fullFormat(d[loop])); 346 347 if(s[loop].length() == 0) { 348 errln("FAIL: fmt->format gave 0-length string in " + pat + " with number " + d[loop] + " in locale " + origLocale.getName()); 349 } 350 351 if(loop > 0) { 352 if(smatch == 0) { 353 UBool match = s[loop] == s[loop-1]; 354 if(smatch == 0) { 355 if(match) 356 smatch = loop; 357 } 358 else if( ! match) 359 errln("FAIL: String mismatch after match"); 360 } 361 362 if(dmatch == 0) { 363 // {sfb} watch out here, this might not work 364 UBool match = d[loop]/*.getTime()*/ == d[loop-1]/*.getTime()*/; 365 if(dmatch == 0) { 366 if(match) 367 dmatch = loop; 368 } 369 else if( ! match) 370 errln("FAIL: Date mismatch after match"); 371 } 372 373 if(smatch != 0 && dmatch != 0) 374 break; 375 } 376 } 377 // At this point loop == DEPTH if we've failed, otherwise loop is the 378 // max(smatch, dmatch), that is, the index at which we have string and 379 // date matching. 380 381 // Date usually matches in 2. Exceptions handled below. 382 int maxDmatch = 2; 383 int maxSmatch = 1; 384 if (dmatch > maxDmatch) { 385 // Time-only pattern with zone information and a starting date in PST. 386 if(timeOnly && hasZoneDisplayName) { 387 int32_t startRaw, startDst; 388 fmt->getTimeZone().getOffset(d[0], FALSE, startRaw, startDst, status); 389 failure(status, "TimeZone::getOffset"); 390 // if the start offset is greater than the offset on Jan 1, 1970 391 // in PST, then need one more round trip. There are two cases 392 // fall into this category. The start date is 1) DST or 393 // 2) LMT (GMT-07:52:58). 394 if (startRaw + startDst > -28800000) { 395 maxDmatch = 3; 396 maxSmatch = 2; 397 } 398 } 399 } 400 401 // String usually matches in 1. Exceptions are checked for here. 402 if(smatch > maxSmatch) { // Don't compute unless necessary 403 UBool in0; 404 // Starts in BC, with no era in pattern 405 if( ! hasEra && getField(d[0], UCAL_ERA) == GregorianCalendar::BC) 406 maxSmatch = 2; 407 // Starts in DST, no year in pattern 408 else if((in0=fmt->getTimeZone().inDaylightTime(d[0], status)) && ! failure(status, "gettingDaylightTime") && 409 pat.indexOf(UnicodeString("yyyy")) == -1) 410 maxSmatch = 2; 411 // If we start not in DST, but transition into DST 412 else if (!in0 && 413 fmt->getTimeZone().inDaylightTime(d[1], status) && !failure(status, "gettingDaylightTime")) 414 maxSmatch = 2; 415 // Two digit year with no time zone change, 416 // unless timezone isn't used or we aren't close to the DST changover 417 else if (pat.indexOf(UnicodeString("y")) != -1 418 && pat.indexOf(UnicodeString("yyyy")) == -1 419 && getField(d[0], UCAL_YEAR) 420 != getField(d[dmatch], UCAL_YEAR) 421 && !failure(status, "error status [smatch>maxSmatch]") 422 && ((hasZoneDisplayName 423 && (fmt->getTimeZone().inDaylightTime(d[0], status) 424 == fmt->getTimeZone().inDaylightTime(d[dmatch], status) 425 || getField(d[0], UCAL_MONTH) == UCAL_APRIL 426 || getField(d[0], UCAL_MONTH) == UCAL_OCTOBER)) 427 || !hasZoneDisplayName) 428 ) 429 { 430 maxSmatch = 2; 431 } 432 // If zone display name is used, fallback format might be used before 1970 433 else if (hasZoneDisplayName && d[0] < 0) { 434 maxSmatch = 2; 435 } 436 } 437 438 if(dmatch > maxDmatch || smatch > maxSmatch) { // Special case for Japanese and Islamic (could have large negative years) 439 const char *type = fmt->getCalendar()->getType(); 440 if(!strcmp(type,"japanese") || (!strcmp(type,"buddhist"))) { 441 maxSmatch = 4; 442 maxDmatch = 4; 443 } 444 } 445 446 // Use @v to see verbose results on successful cases 447 UBool fail = (dmatch > maxDmatch || smatch > maxSmatch); 448 if (optionv || fail) { 449 if (fail) { 450 errln(UnicodeString("\nFAIL: Pattern: ") + pat + 451 " in Locale: " + origLocale.getName()); 452 } else { 453 errln(UnicodeString("\nOk: Pattern: ") + pat + 454 " in Locale: " + origLocale.getName()); 455 } 456 457 logln("Date iters until match=%d (max allowed=%d), string iters until match=%d (max allowed=%d)", 458 dmatch,maxDmatch, smatch, maxSmatch); 459 460 for(int j = 0; j <= loop && j < DEPTH; ++j) { 461 UnicodeString temp; 462 FieldPosition pos(FieldPosition::DONT_CARE); 463 errln((j>0?" P> ":" ") + fullFormat(d[j]) + " F> " + 464 escape(s[j], temp) + UnicodeString(" d=") + d[j] + 465 (j > 0 && d[j]/*.getTime()*/==d[j-1]/*.getTime()*/?" d==":"") + 466 (j > 0 && s[j] == s[j-1]?" s==":"")); 467 } 468 } 469 delete[] d; 470 delete[] s; 471 } 472 /*} 473 catch (ParseException e) { 474 errln("Exception: " + e.getMessage()); 475 logln(e.toString()); 476 }*/ 477 } 478 479 const UnicodeString& DateFormatRoundTripTest::fullFormat(UDate d) { 480 UErrorCode ec = U_ZERO_ERROR; 481 if (dateFormat == 0) { 482 dateFormat = new SimpleDateFormat((UnicodeString)"EEE MMM dd HH:mm:ss.SSS zzz yyyy G", ec); 483 if (U_FAILURE(ec) || dateFormat == 0) { 484 fgStr = "[FAIL: SimpleDateFormat constructor]"; 485 delete dateFormat; 486 dateFormat = 0; 487 return fgStr; 488 } 489 } 490 fgStr.truncate(0); 491 dateFormat->format(d, fgStr); 492 return fgStr; 493 } 494 495 /** 496 * Return a field of the given date 497 */ 498 int32_t DateFormatRoundTripTest::getField(UDate d, int32_t f) { 499 // Should be synchronized, but we're single threaded so it's ok 500 UErrorCode status = U_ZERO_ERROR; 501 getFieldCal->setTime(d, status); 502 failure(status, "getfieldCal->setTime"); 503 int32_t ret = getFieldCal->get((UCalendarDateFields)f, status); 504 failure(status, "getfieldCal->get"); 505 return ret; 506 } 507 508 UnicodeString& DateFormatRoundTripTest::escape(const UnicodeString& src, UnicodeString& dst ) 509 { 510 dst.remove(); 511 for (int32_t i = 0; i < src.length(); ++i) { 512 UChar c = src[i]; 513 if(c < 0x0080) 514 dst += c; 515 else { 516 dst += UnicodeString("["); 517 char buf [8]; 518 sprintf(buf, "%#x", c); 519 dst += UnicodeString(buf); 520 dst += UnicodeString("]"); 521 } 522 } 523 524 return dst; 525 } 526 527 #define U_MILLIS_PER_YEAR (365.25 * 24 * 60 * 60 * 1000) 528 529 UDate DateFormatRoundTripTest::generateDate(UDate minDate) 530 { 531 // Bring range in conformance to generateDate() below. 532 if(minDate < (U_MILLIS_PER_YEAR * -(4000-1970))) { 533 minDate = (U_MILLIS_PER_YEAR * -(4000-1970)); 534 } 535 for(int i=0;i<8;i++) { 536 double a = randFraction(); 537 538 // Range from (min) to (8000-1970) AD 539 double dateRange = (0.0 - minDate) + (U_MILLIS_PER_YEAR + (8000-1970)); 540 541 a *= dateRange; 542 543 // Now offset from minDate 544 a += minDate; 545 546 // Last sanity check 547 if(a>=minDate) { 548 return a; 549 } 550 } 551 return minDate; 552 } 553 554 UDate DateFormatRoundTripTest::generateDate() 555 { 556 double a = randFraction(); 557 558 // Now 'a' ranges from 0..1; scale it to range from 0 to 8000 years 559 a *= 8000; 560 561 // Range from (4000-1970) BC to (8000-1970) AD 562 a -= 4000; 563 564 // Now scale up to ms 565 a *= 365.25 * 24 * 60 * 60 * 1000; 566 567 //return new Date((long)a); 568 return a; 569 } 570 571 #endif /* #if !UCONFIG_NO_FORMATTING */ 572 573 //eof 574
