Home | History | Annotate | Download | only in intltest
      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