icuSources/test/intltest/dtfmtrtts.cpp

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