Check in the pristine copy of ICU 4.6...

icu46/source/test/intltest/dtfmtrtts.cpp

+/***********************************************************************
+ * COPYRIGHT: 
+ * Copyright (c) 1997-2010, International Business Machines Corporation
+ * and others. All Rights Reserved.
+ ***********************************************************************/
+ 
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "unicode/datefmt.h"
+#include "unicode/smpdtfmt.h"
+#include "unicode/gregocal.h"
+#include "dtfmtrtts.h"
+#include "caltest.h"
+
+#include <stdio.h>
+#include <string.h>
+
+// *****************************************************************************
+// class DateFormatRoundTripTest
+// *****************************************************************************
+
+// Useful for turning up subtle bugs: Change the following to TRUE, recompile,
+// and run while at lunch.
+// Warning -- makes test run infinite loop!!!
+#ifndef INFINITE
+#define INFINITE 0
+#endif
+
+static const UVersionInfo ICU_452 = {4,5,2,0};
+
+// Define this to test just a single locale
+//#define TEST_ONE_LOC  "cs_CZ"
+
+// If SPARSENESS is > 0, we don't run each exhaustive possibility.
+// There are 24 total possible tests per each locale.  A SPARSENESS
+// of 12 means we run half of them.  A SPARSENESS of 23 means we run
+// 1 of them.  SPARSENESS _must_ be in the range 0..23.
+int32_t DateFormatRoundTripTest::SPARSENESS = 0;
+int32_t DateFormatRoundTripTest::TRIALS = 4;
+int32_t DateFormatRoundTripTest::DEPTH = 5;
+
+DateFormatRoundTripTest::DateFormatRoundTripTest() : dateFormat(0) {
+}
+
+DateFormatRoundTripTest::~DateFormatRoundTripTest() {
+    delete dateFormat;
+}
+
+#define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break;
+
+void 
+DateFormatRoundTripTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* par )
+{
+    optionv = (par && *par=='v');
+    switch (index) {
+        CASE(0,TestDateFormatRoundTrip)
+        CASE(1, TestCentury)
+        default: name = ""; break;
+    }
+}
+
+UBool 
+DateFormatRoundTripTest::failure(UErrorCode status, const char* msg)
+{
+    if(U_FAILURE(status)) {
+        errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status));
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+UBool 
+DateFormatRoundTripTest::failure(UErrorCode status, const char* msg, const UnicodeString& str)
+{
+    if(U_FAILURE(status)) {
+        UnicodeString escaped;
+        escape(str,escaped);
+        errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status) + ", str=" + escaped);
+        return TRUE;
+    }
+
+    return FALSE;
+}
+
+void DateFormatRoundTripTest::TestCentury()
+{
+    UErrorCode status = U_ZERO_ERROR;
+    Locale locale("es_PA");
+    UnicodeString pattern = "MM/dd/yy hh:mm:ss a z";
+    SimpleDateFormat fmt(pattern, locale, status);
+    if (U_FAILURE(status)) {
+        dataerrln("Fail: construct SimpleDateFormat: %s", u_errorName(status));
+        return;
+    }
+    UDate date[] = {-55018555891590.05, 0, 0};
+    UnicodeString result[2];
+
+    fmt.format(date[0], result[0]);
+    date[1] = fmt.parse(result[0], status);
+    fmt.format(date[1], result[1]);
+    date[2] = fmt.parse(result[1], status);
+
+    /* This test case worked OK by accident before.  date[1] != date[0],
+     * because we use -80/+20 year window for 2-digit year parsing.
+     * (date[0] is in year 1926, date[1] is in year 2026.)  result[1] set
+     * by the first format call returns "07/13/26 07:48:28 p.m. PST",
+     * which is correct, because DST was not used in year 1926 in zone
+     * America/Los_Angeles.  When this is parsed, date[1] becomes a time
+     * in 2026, which is "07/13/26 08:48:28 p.m. PDT".  There was a zone
+     * offset calculation bug that observed DST in 1926, which was resolved.
+     * Before the bug was resolved, result[0] == result[1] was true,
+     * but after the bug fix, the expected result is actually
+     * result[0] != result[1]. -Yoshito
+     */
+    /* TODO: We need to review this code and clarify what we really
+     * want to test here.
+     */
+    //if (date[1] != date[2] || result[0] != result[1]) {
+    if (date[1] != date[2]) {
+        errln("Round trip failure: \"%S\" (%f), \"%S\" (%f)", result[0].getBuffer(), date[1], result[1].getBuffer(), date[2]);
+    }
+}
+
+// ==
+
+void DateFormatRoundTripTest::TestDateFormatRoundTrip() 
+{
+    UErrorCode status = U_ZERO_ERROR;
+
+    getFieldCal = Calendar::createInstance(status);
+    if (U_FAILURE(status)) {
+        dataerrln("Fail: Calendar::createInstance: %s", u_errorName(status));
+        return;
+    }
+
+
+    int32_t locCount = 0;
+    const Locale *avail = DateFormat::getAvailableLocales(locCount);
+    logln("DateFormat available locales: %d", locCount);
+    if(quick) {
+        SPARSENESS = 18;
+        logln("Quick mode: only testing SPARSENESS = 18");
+    }
+    TimeZone *tz = TimeZone::createDefault();
+    UnicodeString temp;
+    logln("Default TimeZone:             " + tz->getID(temp));
+    delete tz;
+
+#ifdef TEST_ONE_LOC // define this to just test ONE locale.
+    Locale loc(TEST_ONE_LOC);
+    test(loc);
+#if INFINITE
+    for(;;) {
+      test(loc);
+    }
+#endif
+
+#else
+# if INFINITE
+    // Special infinite loop test mode for finding hard to reproduce errors
+    Locale loc = Locale::getDefault();
+    logln("ENTERING INFINITE TEST LOOP FOR Locale: " + loc.getDisplayName(temp));
+    for(;;) 
+        test(loc);
+# else
+    test(Locale::getDefault());
+
+#if 1
+    // installed locales
+    for (int i=0; i < locCount; ++i) {
+            test(avail[i]);
+    }
+#endif
+
+#if 1
+    // special locales
+    int32_t jCount = CalendarTest::testLocaleCount();
+    for (int32_t j=0; j < jCount; ++j) {
+        test(Locale(CalendarTest::testLocaleID(j)));
+    }
+#endif
+
+# endif
+#endif
+
+    delete getFieldCal;
+}
+
+static const char *styleName(DateFormat::EStyle s)
+{
+    switch(s)
+    {
+    case DateFormat::SHORT: return "SHORT";
+    case DateFormat::MEDIUM: return "MEDIUM";
+    case DateFormat::LONG: return "LONG";
+    case DateFormat::FULL: return "FULL";
+//  case DateFormat::DEFAULT: return "DEFAULT";
+    case DateFormat::DATE_OFFSET: return "DATE_OFFSET";
+    case DateFormat::NONE: return "NONE";
+    case DateFormat::DATE_TIME: return "DATE_TIME";
+    default: return "Unknown";
+    }
+}
+
+void DateFormatRoundTripTest::test(const Locale& loc) 
+{
+    UnicodeString temp;
+#if !INFINITE
+    logln("Locale: " + loc.getDisplayName(temp));
+#endif
+
+    // Total possibilities = 24
+    //  4 date
+    //  4 time
+    //  16 date-time
+    UBool TEST_TABLE [24];//= new boolean[24];
+    int32_t i = 0;
+    for(i = 0; i < 24; ++i) 
+        TEST_TABLE[i] = TRUE;
+
+    // If we have some sparseness, implement it here.  Sparseness decreases
+    // test time by eliminating some tests, up to 23.
+    for(i = 0; i < SPARSENESS; ) {
+        int random = (int)(randFraction() * 24);
+        if (random >= 0 && random < 24 && TEST_TABLE[i]) {
+            TEST_TABLE[i] = FALSE;
+            ++i;
+        }
+    }
+
+    int32_t itable = 0;
+    int32_t style = 0;
+    for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) {
+        if(TEST_TABLE[itable++]) {
+            logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle)style)));
+            DateFormat *df = DateFormat::createDateInstance((DateFormat::EStyle)style, loc);
+            if(df == NULL) {
+              errln(UnicodeString("Could not DF::createDateInstance ") + UnicodeString(styleName((DateFormat::EStyle)style)) +      " Locale: " + loc.getDisplayName(temp));
+            } else {
+              test(df, loc);
+              delete df;
+            }
+        }
+    }
+    
+    for(style = DateFormat::FULL; style <= DateFormat::SHORT; ++style) {
+        if (TEST_TABLE[itable++]) {
+          logln("Testing style " + UnicodeString(styleName((DateFormat::EStyle)style)));
+            DateFormat *df = DateFormat::createTimeInstance((DateFormat::EStyle)style, loc);
+            if(df == NULL) {
+              errln(UnicodeString("Could not DF::createTimeInstance ") + UnicodeString(styleName((DateFormat::EStyle)style)) + " Locale: " + loc.getDisplayName(temp));
+            } else {
+              test(df, loc, TRUE);
+              delete df;
+            }
+        }
+    }
+    
+    for(int32_t dstyle = DateFormat::FULL; dstyle <= DateFormat::SHORT; ++dstyle) {
+        for(int32_t tstyle = DateFormat::FULL; tstyle <= DateFormat::SHORT; ++tstyle) {
+            if(TEST_TABLE[itable++]) {
+                logln("Testing dstyle" + UnicodeString(styleName((DateFormat::EStyle)dstyle)) + ", tstyle" + UnicodeString(styleName((DateFormat::EStyle)tstyle)) );
+                DateFormat *df = DateFormat::createDateTimeInstance((DateFormat::EStyle)dstyle, (DateFormat::EStyle)tstyle, loc);
+                if(df == NULL) {
+                    dataerrln(UnicodeString("Could not DF::createDateTimeInstance ") + UnicodeString(styleName((DateFormat::EStyle)dstyle)) + ", tstyle" + UnicodeString(styleName((DateFormat::EStyle)tstyle))    + "Locale: " + loc.getDisplayName(temp));
+                } else {
+                    test(df, loc);
+                    delete df;
+                }
+            }
+        }
+    }
+}
+
+void DateFormatRoundTripTest::test(DateFormat *fmt, const Locale &origLocale, UBool timeOnly) 
+{
+    UnicodeString pat;
+    if(fmt->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {
+        errln("DateFormat wasn't a SimpleDateFormat");
+        return;
+    }
+    
+    UBool isGregorian = FALSE;
+    UErrorCode minStatus = U_ZERO_ERROR;
+    UDate minDate = CalendarTest::minDateOfCalendar(*fmt->getCalendar(), isGregorian, minStatus);
+    if(U_FAILURE(minStatus)) {
+      errln((UnicodeString)"Failure getting min date for " + origLocale.getName());
+      return;
+    } 
+    //logln(UnicodeString("Min date is ") + fullFormat(minDate)  + " for " + origLocale.getName());
+
+    pat = ((SimpleDateFormat*)fmt)->toPattern(pat);
+
+    // NOTE TO MAINTAINER
+    // This indexOf check into the pattern needs to be refined to ignore
+    // quoted characters.  Currently, this isn't a problem with the locale
+    // patterns we have, but it may be a problem later.
+
+    UBool hasEra = (pat.indexOf(UnicodeString("G")) != -1);
+    UBool hasZoneDisplayName = (pat.indexOf(UnicodeString("z")) != -1) || (pat.indexOf(UnicodeString("v")) != -1) 
+        || (pat.indexOf(UnicodeString("V")) != -1);
+
+    // Because patterns contain incomplete data representing the Date,
+    // we must be careful of how we do the roundtrip.  We start with
+    // a randomly generated Date because they're easier to generate.
+    // From this we get a string.  The string is our real starting point,
+    // because this string should parse the same way all the time.  Note
+    // that it will not necessarily parse back to the original date because
+    // of incompleteness in patterns.  For example, a time-only pattern won't
+    // parse back to the same date.
+
+    //try {
+        for(int i = 0; i < TRIALS; ++i) {
+            UDate *d                = new UDate    [DEPTH];
+            UnicodeString *s    = new UnicodeString[DEPTH];
+
+            if(isGregorian == TRUE) {
+              d[0] = generateDate();
+            } else {
+              d[0] = generateDate(minDate);
+            }
+
+            UErrorCode status = U_ZERO_ERROR;
+
+            // We go through this loop until we achieve a match or until
+            // the maximum loop count is reached.  We record the points at
+            // which the date and the string starts to match.  Once matching
+            // starts, it should continue.
+            int loop;
+            int dmatch = 0; // d[dmatch].getTime() == d[dmatch-1].getTime()
+            int smatch = 0; // s[smatch].equals(s[smatch-1])
+            for(loop = 0; loop < DEPTH; ++loop) {
+                if (loop > 0)  {
+                    d[loop] = fmt->parse(s[loop-1], status);
+                    failure(status, "fmt->parse", s[loop-1]+" in locale: " + origLocale.getName());
+                    status = U_ZERO_ERROR; /* any error would have been reported */
+                }
+
+                s[loop] = fmt->format(d[loop], s[loop]);
+                
+                // For displaying which date is being tested
+                //logln(s[loop] + " = " + fullFormat(d[loop]));
+                
+                if(s[loop].length() == 0) {
+                  errln("FAIL: fmt->format gave 0-length string in " + pat + " with number " + d[loop] + " in locale " + origLocale.getName());
+                }
+
+                if(loop > 0) {
+                    if(smatch == 0) {
+                        UBool match = s[loop] == s[loop-1];
+                        if(smatch == 0) {
+                            if(match) 
+                                smatch = loop;
+                        }
+                        else if( ! match) 
+                            errln("FAIL: String mismatch after match");
+                    }
+
+                    if(dmatch == 0) {
+                        // {sfb} watch out here, this might not work
+                        UBool match = d[loop]/*.getTime()*/ == d[loop-1]/*.getTime()*/;
+                        if(dmatch == 0) {
+                            if(match) 
+                                dmatch = loop;
+                        }
+                        else if( ! match) 
+                            errln("FAIL: Date mismatch after match");
+                    }
+
+                    if(smatch != 0 && dmatch != 0) 
+                        break;
+                }
+            }
+            // At this point loop == DEPTH if we've failed, otherwise loop is the
+            // max(smatch, dmatch), that is, the index at which we have string and
+            // date matching.
+
+            // Date usually matches in 2.  Exceptions handled below.
+            int maxDmatch = 2;
+            int maxSmatch = 1;
+            if (dmatch > maxDmatch) {
+                // Time-only pattern with zone information and a starting date in PST.
+                if(timeOnly && hasZoneDisplayName) {
+                    int32_t startRaw, startDst;
+                    fmt->getTimeZone().getOffset(d[0], FALSE, startRaw, startDst, status);
+                    failure(status, "TimeZone::getOffset");
+                    // if the start offset is greater than the offset on Jan 1, 1970
+                    // in PST, then need one more round trip.  There are two cases
+                    // fall into this category.  The start date is 1) DST or
+                    // 2) LMT (GMT-07:52:58).
+                    if (startRaw + startDst > -28800000) {
+                        maxDmatch = 3;
+                        maxSmatch = 2;
+                    }
+                }
+            }
+
+            // String usually matches in 1.  Exceptions are checked for here.
+            if(smatch > maxSmatch) { // Don't compute unless necessary
+                UBool in0;
+                // Starts in BC, with no era in pattern
+                if( ! hasEra && getField(d[0], UCAL_ERA) == GregorianCalendar::BC)
+                    maxSmatch = 2;
+                // Starts in DST, no year in pattern
+                else if((in0=fmt->getTimeZone().inDaylightTime(d[0], status)) && ! failure(status, "gettingDaylightTime") &&
+                         pat.indexOf(UnicodeString("yyyy")) == -1)
+                    maxSmatch = 2;
+                // If we start not in DST, but transition into DST
+                else if (!in0 &&
+                         fmt->getTimeZone().inDaylightTime(d[1], status) && !failure(status, "gettingDaylightTime"))
+                    maxSmatch = 2;
+                // Two digit year with no time zone change,
+                // unless timezone isn't used or we aren't close to the DST changover
+                else if (pat.indexOf(UnicodeString("y")) != -1
+                        && pat.indexOf(UnicodeString("yyyy")) == -1
+                        && getField(d[0], UCAL_YEAR)
+                            != getField(d[dmatch], UCAL_YEAR)
+                        && !failure(status, "error status [smatch>maxSmatch]")
+                        && ((hasZoneDisplayName
+                         && (fmt->getTimeZone().inDaylightTime(d[0], status)
+                                == fmt->getTimeZone().inDaylightTime(d[dmatch], status)
+                            || getField(d[0], UCAL_MONTH) == UCAL_APRIL
+                            || getField(d[0], UCAL_MONTH) == UCAL_OCTOBER))
+                         || !hasZoneDisplayName)
+                         )
+                {
+                    maxSmatch = 2;
+                }
+                // If zone display name is used, fallback format might be used before 1970
+                else if (hasZoneDisplayName && d[0] < 0) {
+                    maxSmatch = 2;
+                }
+            }
+
+            if(dmatch > maxDmatch || smatch > maxSmatch) { // Special case for Japanese and Islamic (could have large negative years)
+              const char *type = fmt->getCalendar()->getType();
+              if(!strcmp(type,"japanese") || (!strcmp(type,"buddhist"))) {
+                maxSmatch = 4;
+                maxDmatch = 4;
+              }
+            }
+
+            // Use @v to see verbose results on successful cases
+            UBool fail = (dmatch > maxDmatch || smatch > maxSmatch);
+            if (optionv || fail) {
+                if (fail) {
+                    errln(UnicodeString("\nFAIL: Pattern: ") + pat +
+                          " in Locale: " + origLocale.getName());
+                } else {
+                    errln(UnicodeString("\nOk: Pattern: ") + pat +
+                          " in Locale: " + origLocale.getName());
+                }
+                
+                logln("Date iters until match=%d (max allowed=%d), string iters until match=%d (max allowed=%d)",
+                      dmatch,maxDmatch, smatch, maxSmatch);
+
+                for(int j = 0; j <= loop && j < DEPTH; ++j) {
+                    UnicodeString temp;
+                    FieldPosition pos(FieldPosition::DONT_CARE);
+                    errln((j>0?" P> ":"    ") + fullFormat(d[j]) + " F> " +
+                          escape(s[j], temp) + UnicodeString(" d=") + d[j] + 
+                          (j > 0 && d[j]/*.getTime()*/==d[j-1]/*.getTime()*/?" d==":"") +
+                          (j > 0 && s[j] == s[j-1]?" s==":""));
+                }
+            }
+            delete[] d;
+            delete[] s;
+        }
+    /*}
+    catch (ParseException e) {
+        errln("Exception: " + e.getMessage());
+        logln(e.toString());
+    }*/
+}
+
+const UnicodeString& DateFormatRoundTripTest::fullFormat(UDate d) {
+    UErrorCode ec = U_ZERO_ERROR;
+    if (dateFormat == 0) {
+        dateFormat = new SimpleDateFormat((UnicodeString)"EEE MMM dd HH:mm:ss.SSS zzz yyyy G", ec);
+        if (U_FAILURE(ec) || dateFormat == 0) {
+            fgStr = "[FAIL: SimpleDateFormat constructor]";
+            delete dateFormat;
+            dateFormat = 0;
+            return fgStr;
+        }
+    }
+    fgStr.truncate(0);
+    dateFormat->format(d, fgStr);
+    return fgStr;
+}
+
+/**
+ * Return a field of the given date
+ */
+int32_t DateFormatRoundTripTest::getField(UDate d, int32_t f) {
+    // Should be synchronized, but we're single threaded so it's ok
+    UErrorCode status = U_ZERO_ERROR;
+    getFieldCal->setTime(d, status);
+    failure(status, "getfieldCal->setTime");
+    int32_t ret = getFieldCal->get((UCalendarDateFields)f, status);
+    failure(status, "getfieldCal->get");
+    return ret;
+}
+
+UnicodeString& DateFormatRoundTripTest::escape(const UnicodeString& src, UnicodeString& dst ) 
+{
+    dst.remove();
+    for (int32_t i = 0; i < src.length(); ++i) {
+        UChar c = src[i];
+        if(c < 0x0080) 
+            dst += c;
+        else {
+            dst += UnicodeString("[");
+            char buf [8];
+            sprintf(buf, "%#x", c);
+            dst += UnicodeString(buf);
+            dst += UnicodeString("]");
+        }
+    }
+
+    return dst;
+}
+
+#define U_MILLIS_PER_YEAR (365.25 * 24 * 60 * 60 * 1000)
+
+UDate DateFormatRoundTripTest::generateDate(UDate minDate)
+{
+  // Bring range in conformance to generateDate() below.
+  if(minDate < (U_MILLIS_PER_YEAR * -(4000-1970))) {
+    minDate = (U_MILLIS_PER_YEAR * -(4000-1970));
+  }
+  for(int i=0;i<8;i++) {
+    double a = randFraction();
+    
+    // Range from (min) to  (8000-1970) AD
+    double dateRange = (0.0 - minDate) + (U_MILLIS_PER_YEAR + (8000-1970));
+    
+    a *= dateRange;
+
+    // Now offset from minDate
+    a += minDate;
+   
+    // Last sanity check
+    if(a>=minDate) {
+      return a;
+    }
+  }
+  return minDate;
+}
+
+UDate DateFormatRoundTripTest::generateDate() 
+{
+    double a = randFraction();
+    
+    // Now 'a' ranges from 0..1; scale it to range from 0 to 8000 years
+    a *= 8000;
+    
+    // Range from (4000-1970) BC to (8000-1970) AD
+    a -= 4000;
+    
+    // Now scale up to ms
+    a *= 365.25 * 24 * 60 * 60 * 1000;
+
+    //return new Date((long)a);
+    return a;
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
+
+//eof