1 /***********************************************************************
3 * Copyright (c) 1997-2014, International Business Machines Corporation
4 * and others. All Rights Reserved.
5 ***********************************************************************/
7 #include "unicode/utypes.h"
9 #if !UCONFIG_NO_FORMATTING
11 #include "unicode/datefmt.h"
12 #include "unicode/smpdtfmt.h"
13 #include "unicode/gregocal.h"
14 #include "dtfmtrtts.h"
21 // *****************************************************************************
22 // class DateFormatRoundTripTest
23 // *****************************************************************************
25 // Useful for turning up subtle bugs: Change the following to TRUE, recompile,
26 // and run while at lunch.
27 // Warning -- makes test run infinite loop!!!
32 // Define this to test just a single locale
33 //#define TEST_ONE_LOC "cs_CZ"
35 // If SPARSENESS is > 0, we don't run each exhaustive possibility.
36 // There are 24 total possible tests per each locale. A SPARSENESS
37 // of 12 means we run half of them. A SPARSENESS of 23 means we run
38 // 1 of them. SPARSENESS _must_ be in the range 0..23.
39 int32_t DateFormatRoundTripTest::SPARSENESS = 0;
40 int32_t DateFormatRoundTripTest::TRIALS = 4;
41 int32_t DateFormatRoundTripTest::DEPTH = 5;
43 DateFormatRoundTripTest::DateFormatRoundTripTest() : dateFormat(0) {
46 DateFormatRoundTripTest::~DateFormatRoundTripTest() {
50 #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break;
53 DateFormatRoundTripTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
55 optionv = (par && *par=='v');
57 CASE(0,TestDateFormatRoundTrip)
59 default: name = ""; break;
64 DateFormatRoundTripTest::failure(UErrorCode status, const char* msg)
66 if(U_FAILURE(status)) {
67 errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status));
75 DateFormatRoundTripTest::failure(UErrorCode status, const char* msg, const UnicodeString& str)
77 if(U_FAILURE(status)) {
78 UnicodeString escaped;
80 errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status) + ", str=" + escaped);
87 void DateFormatRoundTripTest::TestCentury()
89 UErrorCode status = U_ZERO_ERROR;
90 Locale locale("es_PA");
91 UnicodeString pattern = "MM/dd/yy hh:mm:ss a z";
92 SimpleDateFormat fmt(pattern, locale, status);
93 if (U_FAILURE(status)) {
94 dataerrln("Fail: construct SimpleDateFormat: %s", u_errorName(status));
97 UDate date[] = {-55018555891590.05, 0, 0};
98 UnicodeString result[2];
100 fmt.format(date[0], result[0]);
101 date[1] = fmt.parse(result[0], status);
102 fmt.format(date[1], result[1]);
103 date[2] = fmt.parse(result[1], status);
105 /* This test case worked OK by accident before. date[1] != date[0],
106 * because we use -80/+20 year window for 2-digit year parsing.
107 * (date[0] is in year 1926, date[1] is in year 2026.) result[1] set
108 * by the first format call returns "07/13/26 07:48:28 p.m. PST",
109 * which is correct, because DST was not used in year 1926 in zone
110 * America/Los_Angeles. When this is parsed, date[1] becomes a time
111 * in 2026, which is "07/13/26 08:48:28 p.m. PDT". There was a zone
112 * offset calculation bug that observed DST in 1926, which was resolved.
113 * Before the bug was resolved, result[0] == result[1] was true,
114 * but after the bug fix, the expected result is actually
115 * result[0] != result[1]. -Yoshito
117 /* TODO: We need to review this code and clarify what we really
120 //if (date[1] != date[2] || result[0] != result[1]) {
121 if (date[1] != date[2]) {
122 errln("Round trip failure: \"%S\" (%f), \"%S\" (%f)", result[0].getBuffer(), date[1], result[1].getBuffer(), date[2]);
128 void DateFormatRoundTripTest::TestDateFormatRoundTrip()
130 UErrorCode status = U_ZERO_ERROR;
132 getFieldCal = Calendar::createInstance(status);
133 if (U_FAILURE(status)) {
134 dataerrln("Fail: Calendar::createInstance: %s", u_errorName(status));
139 int32_t locCount = 0;
140 const Locale *avail = DateFormat::getAvailableLocales(locCount);
141 logln("DateFormat available locales: %d", locCount);
144 logln("Quick mode: only testing SPARSENESS = 18");
146 TimeZone *tz = TimeZone::createDefault();
148 logln("Default TimeZone: " + tz->getID(temp));
151 #ifdef TEST_ONE_LOC // define this to just test ONE locale.
152 Locale loc(TEST_ONE_LOC);
162 // Special infinite loop test mode for finding hard to reproduce errors
163 Locale loc = Locale::getDefault();
164 logln("ENTERING INFINITE TEST LOOP FOR Locale: " + loc.getDisplayName(temp));
168 test(Locale::getDefault());
172 for (int i=0; i < locCount; ++i) {
179 int32_t jCount = CalendarTest::testLocaleCount();
180 for (int32_t j=0; j < jCount; ++j) {
181 test(Locale(CalendarTest::testLocaleID(j)));
191 static const char *styleName(DateFormat::EStyle s)
195 case DateFormat::SHORT: return "SHORT";
196 case DateFormat::MEDIUM: return "MEDIUM";
197 case DateFormat::LONG: return "LONG";
198 case DateFormat::FULL: return "FULL";
199 // case DateFormat::DEFAULT: return "DEFAULT";
200 case DateFormat::DATE_OFFSET: return "DATE_OFFSET";
201 case DateFormat::NONE: return "NONE";
202 case DateFormat::DATE_TIME: return "DATE_TIME";
203 default: return "Unknown";
207 void DateFormatRoundTripTest::test(const Locale& loc)
211 logln("Locale: " + loc.getDisplayName(temp));
214 // Total possibilities = 24
218 UBool TEST_TABLE [24];//= new boolean[24];
220 for(i = 0; i < 24; ++i)
221 TEST_TABLE[i] = TRUE;
223 // If we have some sparseness, implement it here. Sparseness decreases
224 // test time by eliminating some tests, up to 23.
225 for(i = 0; i < SPARSENESS; ) {
226 int random = (int)(randFraction() * 24);
227 if (random >= 0 && random < 24 && TEST_TABLE[i]) {
228 TEST_TABLE[i] = FALSE;
235 for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) {
236 if(TEST_TABLE[itable++]) {
237 logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle)style)));
238 DateFormat *df = DateFormat::createDateInstance((DateFormat::EStyle)style, loc);
240 errln(UnicodeString("Could not DF::createDateInstance ") + UnicodeString(styleName((DateFormat::EStyle)style)) + " Locale: " + loc.getDisplayName(temp));
248 for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) {
249 if (TEST_TABLE[itable++]) {
250 logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle)style)));
251 DateFormat *df = DateFormat::createTimeInstance((DateFormat::EStyle)style, loc);
253 errln(UnicodeString("Could not DF::createTimeInstance ") + UnicodeString(styleName((DateFormat::EStyle)style)) + " Locale: " + loc.getDisplayName(temp));
261 for(int32_t dstyle = DateFormat::FULL; dstyle <= DateFormat::SHORT; ++dstyle) {
262 for(int32_t tstyle = DateFormat::FULL; tstyle <= DateFormat::SHORT; ++tstyle) {
263 if(TEST_TABLE[itable++]) {
264 logln("Testing dstyle" + UnicodeString(styleName((DateFormat::EStyle)dstyle)) + ", tstyle" + UnicodeString(styleName((DateFormat::EStyle)tstyle)) );
265 DateFormat *df = DateFormat::createDateTimeInstance((DateFormat::EStyle)dstyle, (DateFormat::EStyle)tstyle, loc);
267 dataerrln(UnicodeString("Could not DF::createDateTimeInstance ") + UnicodeString(styleName((DateFormat::EStyle)dstyle)) + ", tstyle" + UnicodeString(styleName((DateFormat::EStyle)tstyle)) + "Locale: " + loc.getDisplayName(temp));
277 void DateFormatRoundTripTest::test(DateFormat *fmt, const Locale &origLocale, UBool timeOnly)
280 if(fmt->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {
281 errln("DateFormat wasn't a SimpleDateFormat");
285 UBool isGregorian = FALSE;
286 UErrorCode minStatus = U_ZERO_ERROR;
287 if(fmt->getCalendar() == NULL) {
288 errln((UnicodeString)"DateFormatRoundTripTest::test, DateFormat getCalendar() returns null for " + origLocale.getName());
291 UDate minDate = CalendarTest::minDateOfCalendar(*fmt->getCalendar(), isGregorian, minStatus);
292 if(U_FAILURE(minStatus)) {
293 errln((UnicodeString)"Failure getting min date for " + origLocale.getName());
296 //logln(UnicodeString("Min date is ") + fullFormat(minDate) + " for " + origLocale.getName());
298 pat = ((SimpleDateFormat*)fmt)->toPattern(pat);
300 // NOTE TO MAINTAINER
301 // This indexOf check into the pattern needs to be refined to ignore
302 // quoted characters. Currently, this isn't a problem with the locale
303 // patterns we have, but it may be a problem later.
305 UBool hasEra = (pat.indexOf(UnicodeString("G")) != -1);
306 UBool hasZoneDisplayName = (pat.indexOf(UnicodeString("z")) != -1) || (pat.indexOf(UnicodeString("v")) != -1)
307 || (pat.indexOf(UnicodeString("V")) != -1);
309 // Because patterns contain incomplete data representing the Date,
310 // we must be careful of how we do the roundtrip. We start with
311 // a randomly generated Date because they're easier to generate.
312 // From this we get a string. The string is our real starting point,
313 // because this string should parse the same way all the time. Note
314 // that it will not necessarily parse back to the original date because
315 // of incompleteness in patterns. For example, a time-only pattern won't
316 // parse back to the same date.
319 for(int i = 0; i < TRIALS; ++i) {
320 UDate *d = new UDate [DEPTH];
321 UnicodeString *s = new UnicodeString[DEPTH];
323 if(isGregorian == TRUE) {
324 d[0] = generateDate();
326 d[0] = generateDate(minDate);
329 UErrorCode status = U_ZERO_ERROR;
331 // We go through this loop until we achieve a match or until
332 // the maximum loop count is reached. We record the points at
333 // which the date and the string starts to match. Once matching
334 // starts, it should continue.
336 int dmatch = 0; // d[dmatch].getTime() == d[dmatch-1].getTime()
337 int smatch = 0; // s[smatch].equals(s[smatch-1])
338 for(loop = 0; loop < DEPTH; ++loop) {
340 d[loop] = fmt->parse(s[loop-1], status);
341 failure(status, "fmt->parse", s[loop-1]+" in locale: " + origLocale.getName() + " with pattern: " + pat);
342 status = U_ZERO_ERROR; /* any error would have been reported */
345 s[loop] = fmt->format(d[loop], s[loop]);
347 // For displaying which date is being tested
348 //logln(s[loop] + " = " + fullFormat(d[loop]));
350 if(s[loop].length() == 0) {
351 errln("FAIL: fmt->format gave 0-length string in " + pat + " with number " + d[loop] + " in locale " + origLocale.getName());
356 UBool match = s[loop] == s[loop-1];
362 errln("FAIL: String mismatch after match");
366 // {sfb} watch out here, this might not work
367 UBool match = d[loop]/*.getTime()*/ == d[loop-1]/*.getTime()*/;
373 errln("FAIL: Date mismatch after match");
376 if(smatch != 0 && dmatch != 0)
380 // At this point loop == DEPTH if we've failed, otherwise loop is the
381 // max(smatch, dmatch), that is, the index at which we have string and
384 // Date usually matches in 2. Exceptions handled below.
387 if (dmatch > maxDmatch) {
388 // Time-only pattern with zone information and a starting date in PST.
389 if(timeOnly && hasZoneDisplayName) {
390 int32_t startRaw, startDst;
391 fmt->getTimeZone().getOffset(d[0], FALSE, startRaw, startDst, status);
392 failure(status, "TimeZone::getOffset");
393 // if the start offset is greater than the offset on Jan 1, 1970
394 // in PST, then need one more round trip. There are two cases
395 // fall into this category. The start date is 1) DST or
396 // 2) LMT (GMT-07:52:58).
397 if (startRaw + startDst > -28800000) {
404 // String usually matches in 1. Exceptions are checked for here.
405 if(smatch > maxSmatch) { // Don't compute unless necessary
407 // Starts in BC, with no era in pattern
408 if( ! hasEra && getField(d[0], UCAL_ERA) == GregorianCalendar::BC)
410 // Starts in DST, no year in pattern
411 else if((in0=fmt->getTimeZone().inDaylightTime(d[0], status)) && ! failure(status, "gettingDaylightTime") &&
412 pat.indexOf(UnicodeString("yyyy")) == -1)
414 // If we start not in DST, but transition into DST
416 fmt->getTimeZone().inDaylightTime(d[1], status) && !failure(status, "gettingDaylightTime"))
418 // Two digit year with no time zone change,
419 // unless timezone isn't used or we aren't close to the DST changover
420 else if (pat.indexOf(UnicodeString("y")) != -1
421 && pat.indexOf(UnicodeString("yyyy")) == -1
422 && getField(d[0], UCAL_YEAR)
423 != getField(d[dmatch], UCAL_YEAR)
424 && !failure(status, "error status [smatch>maxSmatch]")
425 && ((hasZoneDisplayName
426 && (fmt->getTimeZone().inDaylightTime(d[0], status)
427 == fmt->getTimeZone().inDaylightTime(d[dmatch], status)
428 || getField(d[0], UCAL_MONTH) == UCAL_APRIL
429 || getField(d[0], UCAL_MONTH) == UCAL_OCTOBER))
430 || !hasZoneDisplayName)
435 // If zone display name is used, fallback format might be used before 1970
436 else if (hasZoneDisplayName && d[0] < 0) {
442 * Special case for Japanese and Buddhist (could have large negative years)
443 * Also, Hebrew calendar need help handling leap month.
445 if(dmatch > maxDmatch || smatch > maxSmatch) {
446 const char *type = fmt->getCalendar()->getType();
447 if(!strcmp(type,"japanese") || (!strcmp(type,"buddhist"))) {
450 } else if(!strcmp(type,"hebrew")) {
456 // Use @v to see verbose results on successful cases
457 UBool fail = (dmatch > maxDmatch || smatch > maxSmatch);
458 if (optionv || fail) {
460 errln(UnicodeString("\nFAIL: Pattern: ") + pat +
461 " in Locale: " + origLocale.getName());
463 errln(UnicodeString("\nOk: Pattern: ") + pat +
464 " in Locale: " + origLocale.getName());
467 logln("Date iters until match=%d (max allowed=%d), string iters until match=%d (max allowed=%d)",
468 dmatch,maxDmatch, smatch, maxSmatch);
470 for(int j = 0; j <= loop && j < DEPTH; ++j) {
472 FieldPosition pos(FieldPosition::DONT_CARE);
473 errln((j>0?" P> ":" ") + fullFormat(d[j]) + " F> " +
474 escape(s[j], temp) + UnicodeString(" d=") + d[j] +
475 (j > 0 && d[j]/*.getTime()*/==d[j-1]/*.getTime()*/?" d==":"") +
476 (j > 0 && s[j] == s[j-1]?" s==":""));
483 catch (ParseException e) {
484 errln("Exception: " + e.getMessage());
489 const UnicodeString& DateFormatRoundTripTest::fullFormat(UDate d) {
490 UErrorCode ec = U_ZERO_ERROR;
491 if (dateFormat == 0) {
492 dateFormat = new SimpleDateFormat((UnicodeString)"EEE MMM dd HH:mm:ss.SSS zzz yyyy G", ec);
493 if (U_FAILURE(ec) || dateFormat == 0) {
494 fgStr = "[FAIL: SimpleDateFormat constructor]";
501 dateFormat->format(d, fgStr);
506 * Return a field of the given date
508 int32_t DateFormatRoundTripTest::getField(UDate d, int32_t f) {
509 // Should be synchronized, but we're single threaded so it's ok
510 UErrorCode status = U_ZERO_ERROR;
511 getFieldCal->setTime(d, status);
512 failure(status, "getfieldCal->setTime");
513 int32_t ret = getFieldCal->get((UCalendarDateFields)f, status);
514 failure(status, "getfieldCal->get");
518 UnicodeString& DateFormatRoundTripTest::escape(const UnicodeString& src, UnicodeString& dst )
521 for (int32_t i = 0; i < src.length(); ++i) {
526 dst += UnicodeString("[");
528 sprintf(buf, "%#x", c);
529 dst += UnicodeString(buf);
530 dst += UnicodeString("]");
537 #define U_MILLIS_PER_YEAR (365.25 * 24 * 60 * 60 * 1000)
539 UDate DateFormatRoundTripTest::generateDate(UDate minDate)
541 // Bring range in conformance to generateDate() below.
542 if(minDate < (U_MILLIS_PER_YEAR * -(4000-1970))) {
543 minDate = (U_MILLIS_PER_YEAR * -(4000-1970));
545 for(int i=0;i<8;i++) {
546 double a = randFraction();
548 // Range from (min) to (8000-1970) AD
549 double dateRange = (0.0 - minDate) + (U_MILLIS_PER_YEAR + (8000-1970));
553 // Now offset from minDate
564 UDate DateFormatRoundTripTest::generateDate()
566 double a = randFraction();
568 // Now 'a' ranges from 0..1; scale it to range from 0 to 8000 years
571 // Range from (4000-1970) BC to (8000-1970) AD
574 // Now scale up to ms
575 a *= 365.25 * 24 * 60 * 60 * 1000;
577 //return new Date((long)a);
581 #endif /* #if !UCONFIG_NO_FORMATTING */