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