Check in the pristine copy of ICU 4.6...

icu46/source/test/intltest/dtfmrgts.cpp

+/********************************************************************
+ * COPYRIGHT: 
+ * Copyright (c) 1997-2010, International Business Machines Corporation and
+ * others. All Rights Reserved.
+ ********************************************************************/
+
+#include "unicode/utypes.h"
+
+#if !UCONFIG_NO_FORMATTING
+
+#include "dtfmrgts.h"
+
+#include "unicode/timezone.h"
+#include "unicode/gregocal.h"
+#include "unicode/smpdtfmt.h"
+#include "unicode/datefmt.h"
+#include "unicode/simpletz.h"
+#include "unicode/resbund.h"
+
+// *****************************************************************************
+// class DateFormatRegressionTest
+// *****************************************************************************
+
+#define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break;
+
+void 
+DateFormatRegressionTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
+{
+    // if (exec) logln((UnicodeString)"TestSuite DateFormatRegressionTest");
+    switch (index) {
+        CASE(0,Test4029195)
+        CASE(1,Test4052408)
+        CASE(2,Test4056591)
+        CASE(3,Test4059917)
+        CASE(4,Test4060212)
+        CASE(5,Test4061287)
+        CASE(6,Test4065240)
+        CASE(7,Test4071441)
+        CASE(8,Test4073003)
+        CASE(9,Test4089106)
+        CASE(10,Test4100302)
+        CASE(11,Test4101483)
+        CASE(12,Test4103340)
+        CASE(13,Test4103341)
+        CASE(14,Test4104136)
+        CASE(15,Test4104522)
+        CASE(16,Test4106807)
+        CASE(17,Test4108407) 
+        CASE(18,Test4134203)
+        CASE(19,Test4151631)
+        CASE(20,Test4151706)
+        CASE(21,Test4162071)
+        CASE(22,Test4182066)
+        CASE(23,Test4210209)
+        CASE(24,Test714)
+        CASE(25,Test1684)
+        CASE(26,Test5554)
+        default: name = ""; break;
+    }
+}
+
+/**
+ * @bug 4029195
+ */
+void DateFormatRegressionTest::Test4029195(void) 
+{
+    UErrorCode status = U_ZERO_ERROR;
+
+    UDate today = Calendar::getNow();
+    logln((UnicodeString) "today: " + today);
+
+    SimpleDateFormat *sdf = (SimpleDateFormat*) DateFormat::createDateInstance();
+    if (failure(status, "SimpleDateFormat::createDateInstance")) {
+        return;
+    }
+    UnicodeString pat;
+    if(sdf == NULL){
+        dataerrln("Error calling DateFormat::createDateTimeInstance");
+        return;
+    }
+
+    pat = sdf->toPattern(pat);
+    logln("pattern: " + pat);
+    UnicodeString fmtd;
+    FieldPosition pos(FieldPosition::DONT_CARE);
+    fmtd = sdf->format(today, fmtd, pos);
+    logln("today: " + fmtd);
+
+    sdf->applyPattern("G yyyy DDD");
+    UnicodeString todayS;
+    todayS = sdf->format(today, todayS, pos);
+    logln("today: " + todayS);
+    //try {
+        today = sdf->parse(todayS, status);
+        failure(status, "sdf->parse");
+        logln((UnicodeString)"today date: " + today);
+    /*} catch(Exception e) {
+        logln("Error reparsing date: " + e.getMessage());
+    }*/
+
+    //try {
+        UnicodeString rt;
+        rt = sdf->format(sdf->parse(todayS, status), rt, pos);
+        failure(status, "sdf->parse");
+        logln("round trip: " + rt);
+        if(rt != todayS) 
+            errln("Fail: Want " + todayS + " Got " + rt);
+    /*}
+    catch (ParseException e) {
+        errln("Fail: " + e);
+        e.printStackTrace();
+    }*/
+
+    delete sdf;
+}
+
+/**
+ * @bug 4052408
+ */
+void DateFormatRegressionTest::Test4052408(void) 
+{
+
+    DateFormat *fmt = DateFormat::createDateTimeInstance(DateFormat::SHORT,
+                                                DateFormat::SHORT, Locale::getUS());
+    if (fmt == NULL) {
+        dataerrln("Error calling DateFormat::createDateTimeInstance");
+        return;
+    }
+
+    UDate dt = date(97, UCAL_MAY, 3, 8, 55);
+    UnicodeString str;
+    str = fmt->format(dt, str);
+    logln(str);
+    
+    if(str != "5/3/97 8:55 AM")
+        errln("Fail: Test broken; Want 5/3/97 8:55 AM Got " + str);   
+    
+    UnicodeString expected[] = {
+        (UnicodeString) "", //"ERA_FIELD",
+        (UnicodeString) "97", //"YEAR_FIELD",
+        (UnicodeString) "5", //"MONTH_FIELD",
+        (UnicodeString) "3", //"DATE_FIELD",
+        (UnicodeString) "", //"HOUR_OF_DAY1_FIELD",
+        (UnicodeString) "", //"HOUR_OF_DAY0_FIELD",
+        (UnicodeString) "55", //"MINUTE_FIELD",
+        (UnicodeString) "", //"SECOND_FIELD",
+        (UnicodeString) "", //"MILLISECOND_FIELD",
+        (UnicodeString) "", //"DAY_OF_WEEK_FIELD",
+        (UnicodeString) "", //"DAY_OF_YEAR_FIELD",
+        (UnicodeString) "", //"DAY_OF_WEEK_IN_MONTH_FIELD",
+        (UnicodeString) "", //"WEEK_OF_YEAR_FIELD",
+        (UnicodeString) "", //"WEEK_OF_MONTH_FIELD",
+        (UnicodeString) "AM", //"AM_PM_FIELD",
+        (UnicodeString) "8", //"HOUR1_FIELD",
+        (UnicodeString) "", //"HOUR0_FIELD",
+        (UnicodeString) "" //"TIMEZONE_FIELD"
+    };
+    
+    //Hashtable expected;// = new Hashtable();
+    //expected.put(new LongKey(DateFormat.MONTH_FIELD), "5");
+    //expected.put(new LongKey(DateFormat.DATE_FIELD), "3");
+    //expected.put(new LongKey(DateFormat.YEAR_FIELD), "97");
+    //expected.put(new LongKey(DateFormat.HOUR1_FIELD), "8");
+    //expected.put(new LongKey(DateFormat.MINUTE_FIELD), "55");
+    //expected.put(new LongKey(DateFormat.AM_PM_FIELD), "AM");
+    
+    //StringBuffer buf = new StringBuffer();
+    UnicodeString fieldNames[] = {
+        (UnicodeString) "ERA_FIELD",
+        (UnicodeString) "YEAR_FIELD",
+        (UnicodeString) "MONTH_FIELD",
+        (UnicodeString) "DATE_FIELD",
+        (UnicodeString) "HOUR_OF_DAY1_FIELD",
+        (UnicodeString) "HOUR_OF_DAY0_FIELD",
+        (UnicodeString) "MINUTE_FIELD",
+        (UnicodeString) "SECOND_FIELD",
+        (UnicodeString) "MILLISECOND_FIELD",
+        (UnicodeString) "DAY_OF_WEEK_FIELD",
+        (UnicodeString) "DAY_OF_YEAR_FIELD",
+        (UnicodeString) "DAY_OF_WEEK_IN_MONTH_FIELD",
+        (UnicodeString) "WEEK_OF_YEAR_FIELD",
+        (UnicodeString) "WEEK_OF_MONTH_FIELD",
+        (UnicodeString) "AM_PM_FIELD",
+        (UnicodeString) "HOUR1_FIELD",
+        (UnicodeString) "HOUR0_FIELD",
+        (UnicodeString) "TIMEZONE_FIELD"
+    };
+
+    UBool pass = TRUE;
+    for(int i = 0; i <= 17; ++i) {
+        FieldPosition pos(i);
+        UnicodeString buf;
+        fmt->format(dt, buf, pos);
+        //char[] dst = new char[pos.getEndIndex() - pos.getBeginIndex()];
+        UnicodeString dst;
+        buf.extractBetween(pos.getBeginIndex(), pos.getEndIndex(), dst);
+        UnicodeString str(dst);
+        logln((UnicodeString)"" + i + (UnicodeString)": " + fieldNames[i] +
+                (UnicodeString)", \"" + str + (UnicodeString)"\", " +
+                pos.getBeginIndex() + (UnicodeString)", " +
+                pos.getEndIndex());
+        UnicodeString exp = expected[i];
+        if((exp.length() == 0 && str.length() == 0) || str == exp)
+            logln(" ok");
+        else {
+            errln(UnicodeString(" expected ") + exp);
+            pass = FALSE;
+        }
+        
+    }
+    if( ! pass) 
+        errln("Fail: FieldPosition not set right by DateFormat");
+    
+    delete fmt;
+}
+
+/**
+ * @bug 4056591
+ * Verify the function of the [s|g]et2DigitYearStart() API.
+ */
+void DateFormatRegressionTest::Test4056591(void) 
+{
+    UErrorCode status = U_ZERO_ERROR;
+
+    //try {
+        SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("yyMMdd"), Locale::getUS(), status);
+        if (failure(status, "new SimpleDateFormat", TRUE)) {
+            delete fmt;
+            return;
+        }
+        UDate start = date(1809-1900, UCAL_DECEMBER, 25);
+        fmt->set2DigitYearStart(start, status);
+        failure(status, "fmt->setTwoDigitStartDate");
+        if( (fmt->get2DigitYearStart(status) != start) || failure(status, "get2DigitStartDate"))
+            errln("get2DigitYearStart broken");
+        UDate dates [] = {
+            date(1809-1900, UCAL_DECEMBER, 25),
+            date(1909-1900, UCAL_DECEMBER, 24),
+            date(1809-1900, UCAL_DECEMBER, 26),
+            date(1861-1900, UCAL_DECEMBER, 25),
+        };
+
+        UnicodeString strings [] = {
+            (UnicodeString) "091225",
+            (UnicodeString) "091224",
+            (UnicodeString) "091226",
+            (UnicodeString) "611225"
+        };
+
+        /*Object[] DATA = {
+            "091225", new Date(1809-1900, Calendar.DECEMBER, 25),
+            "091224", new Date(1909-1900, Calendar.DECEMBER, 24),
+            "091226", new Date(1809-1900, Calendar.DECEMBER, 26),
+            "611225", new Date(1861-1900, Calendar.DECEMBER, 25),
+        };*/
+
+        for(int i = 0; i < 4; i++) {
+            UnicodeString s = strings[i];
+            UDate exp = dates[i];
+            UDate got = fmt->parse(s, status);
+            failure(status, "fmt->parse");
+            logln(s + " -> " + got + "; exp " + exp);
+            if(got != exp) 
+                errln("set2DigitYearStart broken");
+        }
+    /*}
+    catch (ParseException e) {
+        errln("Fail: " + e);
+        e.printStackTrace();
+    }*/
+
+    delete fmt;
+}
+
+/**
+ * @bug 4059917
+ */
+void DateFormatRegressionTest::Test4059917(void) 
+{
+    UErrorCode status = U_ZERO_ERROR;
+    
+    SimpleDateFormat *fmt;
+    UnicodeString myDate;
+
+    fmt = new SimpleDateFormat( UnicodeString("yyyy/MM/dd"), status );
+    if (failure(status, "new SimpleDateFormat", TRUE)) return;
+    myDate = "1997/01/01";
+    aux917( fmt, myDate );
+    
+    delete fmt;
+    fmt = NULL;
+    
+    fmt = new SimpleDateFormat( UnicodeString("yyyyMMdd"), status );
+    if(failure(status, "new SimpleDateFormat")) return;
+    myDate = "19970101";
+    aux917( fmt, myDate );
+              
+    delete fmt;
+}
+
+void DateFormatRegressionTest::aux917( SimpleDateFormat *fmt, UnicodeString& str ) {
+    //try {
+    UnicodeString pat;
+    pat = fmt->toPattern(pat);
+    logln( "==================" );
+    logln( "testIt: pattern=" + pat +
+               " string=" + str );
+                
+        
+    Formattable o;
+    //Object o;
+    ParsePosition pos(0);
+    fmt->parseObject( str, o, pos );
+    //logln( UnicodeString("Parsed object: ") + o );
+    
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString formatted;
+    FieldPosition poss(FieldPosition::DONT_CARE);
+    formatted = fmt->format( o, formatted, poss, status );
+    failure(status, "fmt->format");
+    logln( "Formatted string: " + formatted );
+    if( formatted != str) 
+        errln("Fail: Want " + str + " Got " + formatted);
+    /*}
+    catch (ParseException e) {
+        errln("Fail: " + e);
+        e.printStackTrace();
+    }*/
+}
+
+/**
+ * @bug 4060212
+ */
+void DateFormatRegressionTest::Test4060212(void) 
+{
+    UnicodeString dateString = "1995-040.05:01:29";
+
+    logln( "dateString= " + dateString );
+    logln("Using yyyy-DDD.hh:mm:ss");
+    UErrorCode status = U_ZERO_ERROR;
+    SimpleDateFormat *formatter = new SimpleDateFormat(UnicodeString("yyyy-DDD.hh:mm:ss"), status);
+    if (failure(status, "new SimpleDateFormat", TRUE)) return;
+    ParsePosition pos(0);
+    UDate myDate = formatter->parse( dateString, pos );
+    UnicodeString myString;
+    DateFormat *fmt = DateFormat::createDateTimeInstance( DateFormat::FULL,
+                                                            DateFormat::LONG);
+    if (fmt == NULL) {
+        dataerrln("Error calling DateFormat::createDateTimeInstance");
+        delete formatter;
+        return;
+    }
+
+    myString = fmt->format( myDate, myString);
+    logln( myString );
+
+    Calendar *cal = new GregorianCalendar(status);
+    failure(status, "new GregorianCalendar");
+    cal->setTime(myDate, status);
+    failure(status, "cal->setTime");
+    if ((cal->get(UCAL_DAY_OF_YEAR, status) != 40) || failure(status, "cal->get"))
+        errln((UnicodeString) "Fail: Got " + cal->get(UCAL_DAY_OF_YEAR, status) +
+                            " Want 40");
+
+    logln("Using yyyy-ddd.hh:mm:ss");
+    delete formatter;
+    formatter = NULL;
+    formatter = new SimpleDateFormat(UnicodeString("yyyy-ddd.hh:mm:ss"), status);
+    if(failure(status, "new SimpleDateFormat")) return;
+    pos.setIndex(0);
+    myDate = formatter->parse( dateString, pos );
+    myString = fmt->format( myDate, myString );
+    logln( myString );
+    cal->setTime(myDate, status);
+    failure(status, "cal->setTime");
+    if ((cal->get(UCAL_DAY_OF_YEAR, status) != 40) || failure(status, "cal->get"))
+        errln((UnicodeString) "Fail: Got " + cal->get(UCAL_DAY_OF_YEAR, status) +
+                            " Want 40");
+
+    delete formatter;
+    delete fmt;
+    delete cal;
+}
+
+/**
+ * @bug 4061287
+ */
+void DateFormatRegressionTest::Test4061287(void) 
+{
+    UErrorCode status = U_ZERO_ERROR;
+    
+    SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("dd/MM/yyyy"), status);
+    if (U_FAILURE(status)) {
+        dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status));
+        delete df;
+        return;
+    }
+    failure(status, "new SimpleDateFormat");
+    //try {
+    logln(UnicodeString("") + df->parse("35/01/1971", status));  
+    failure(status, "df->parse");
+    //logln(df.parse("35/01/1971").toString());
+    //}
+    /*catch (ParseException e) {
+        errln("Fail: " + e);
+        e.printStackTrace();
+    }*/
+    df->setLenient(FALSE);
+    UBool ok = FALSE;
+    //try {
+    logln(UnicodeString("") + df->parse("35/01/1971", status));
+    if(U_FAILURE(status))
+        ok = TRUE;
+    //logln(df.parse("35/01/1971").toString());
+    //} catch (ParseException e) {ok=TRUE;}
+    if(!ok) 
+        errln("Fail: Lenient not working");
+    delete df;
+}
+
+/**
+ * @bug 4065240
+ */
+void DateFormatRegressionTest::Test4065240(void) 
+{
+    UDate curDate;
+    DateFormat *shortdate, *fulldate;
+    UnicodeString strShortDate, strFullDate;
+    Locale saveLocale = Locale::getDefault();
+    TimeZone *saveZone = TimeZone::createDefault();
+
+    UErrorCode status = U_ZERO_ERROR;
+    //try {
+        Locale *curLocale = new Locale("de","DE");
+        Locale::setDefault(*curLocale, status);
+        failure(status, "Locale::setDefault");
+        // {sfb} adoptDefault instead of setDefault
+        //TimeZone::setDefault(TimeZone::createTimeZone("EST"));
+        TimeZone::adoptDefault(TimeZone::createTimeZone("EST"));
+        curDate = date(98, 0, 1);
+        shortdate = DateFormat::createDateInstance(DateFormat::SHORT);
+        if (shortdate == NULL){
+            dataerrln("Error calling DateFormat::createDateInstance");
+            return;
+        }
+
+        fulldate = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::LONG);
+        if (fulldate == NULL){
+            dataerrln("Error calling DateFormat::createDateTimeInstance");
+            return;
+        }
+        strShortDate = "The current date (short form) is ";
+        UnicodeString temp;
+        temp = shortdate->format(curDate, temp);
+        strShortDate += temp;
+        strFullDate = "The current date (long form) is ";
+        UnicodeString temp2;
+        fulldate->format(curDate, temp2);
+        strFullDate += temp2;
+
+        logln(strShortDate);
+        logln(strFullDate);
+
+        // {sfb} What to do with resource bundle stuff?????
+
+        // Check to see if the resource is present; if not, we can't test
+        ResourceBundle *bundle = new ResourceBundle(
+            NULL, *curLocale, status);
+        failure(status, "new ResourceBundle");
+            //(UnicodeString) "java.text.resources.DateFormatZoneData", curLocale);
+
+        // {sfb} API change to ResourceBundle -- add getLocale()
+        /*if (bundle->getLocale().getLanguage(temp) == UnicodeString("de")) {
+            // UPDATE THIS AS ZONE NAME RESOURCE FOR <EST> in de_DE is updated
+            if (!strFullDate.endsWith(UnicodeString("GMT-05:00")))
+                errln("Fail: Want GMT-05:00");
+        }
+        else {
+            logln("*** TEST COULD NOT BE COMPLETED BECAUSE DateFormatZoneData ***");
+            logln("*** FOR LOCALE de OR de_DE IS MISSING ***");
+        }*/
+    //}
+    //finally {
+    Locale::setDefault(saveLocale, status);
+    failure(status, "Locale::setDefault");
+    TimeZone::setDefault(*saveZone);
+    //}
+    delete shortdate;
+    delete fulldate;
+    delete saveZone;
+    delete curLocale;
+    delete bundle;
+}
+
+/*
+  DateFormat.equals is too narrowly defined.  As a result, MessageFormat
+  does not work correctly.  DateFormat.equals needs to be written so
+  that the Calendar sub-object is not compared using Calendar.equals,
+  but rather compared for equivalency.  This may necessitate adding a
+  (package private) method to Calendar to test for equivalency.
+  
+  Currently this bug breaks MessageFormat.toPattern
+  */
+/**
+ * @bug 4071441
+ */
+void DateFormatRegressionTest::Test4071441(void) 
+{
+    DateFormat *fmtA = DateFormat::createInstance();
+    DateFormat *fmtB = DateFormat::createInstance();
+
+    if (fmtA == NULL || fmtB == NULL){
+        dataerrln("Error calling DateFormat::createInstance");
+        delete fmtA;
+        delete fmtB;
+        return;
+    }
+
+    // {sfb} Is it OK to cast away const here?
+    Calendar *calA = (Calendar*) fmtA->getCalendar();
+    Calendar *calB = (Calendar*) fmtB->getCalendar();
+    if(!calA || !calB) {
+      errln("Couldn't get proper calendars, exiting");
+      delete fmtA;
+      delete fmtB;
+      return;
+    }
+    UDate epoch = date(0, 0, 0);
+    UDate xmas = date(61, UCAL_DECEMBER, 25);
+
+    UErrorCode status = U_ZERO_ERROR;
+    calA->setTime(epoch, status);
+    failure(status, "calA->setTime");
+    calB->setTime(epoch, status);
+    failure(status, "calB->setTime");
+    if (*calA != *calB)
+        errln("Fail: Can't complete test; Calendar instances unequal");
+    if (*fmtA != *fmtB)
+        errln("Fail: DateFormat unequal when Calendars equal");
+    calB->setTime(xmas, status);
+    failure(status, "calB->setTime");
+    if (*calA == *calB)
+        errln("Fail: Can't complete test; Calendar instances equal");
+    if (*fmtA != *fmtB)
+        errln("Fail: DateFormat unequal when Calendars equivalent");
+
+    logln("DateFormat.equals ok");
+
+    delete fmtA;
+    delete fmtB;
+}
+
+/* The java.text.DateFormat.parse(String) method expects for the
+  US locale a string formatted according to mm/dd/yy and parses it
+  correctly.
+
+  When given a string mm/dd/yyyy it only parses up to the first
+  two y's, typically resulting in a date in the year 1919.
+  
+  Please extend the parsing method(s) to handle strings with
+  four-digit year values (probably also applicable to various
+  other locales.  */
+/**
+ * @bug 4073003
+ */
+void DateFormatRegressionTest::Test4073003(void) 
+{
+    //try {
+    UErrorCode ec = U_ZERO_ERROR;
+    SimpleDateFormat fmt("dd/MM/yy", Locale::getUK(), ec);
+    if (U_FAILURE(ec)) {
+        dataerrln("FAIL: SimpleDateFormat constructor - %s", u_errorName(ec));
+        return;
+    }
+        UnicodeString tests [] = { 
+            (UnicodeString) "12/25/61", 
+            (UnicodeString) "12/25/1961", 
+            (UnicodeString) "4/3/2010", 
+            (UnicodeString) "4/3/10" 
+        };
+        UErrorCode status = U_ZERO_ERROR;
+        for(int i= 0; i < 4; i+=2) {
+            UDate d = fmt.parse(tests[i], status);
+            failure(status, "fmt.parse");
+            UDate dd = fmt.parse(tests[i+1], status);
+            failure(status, "fmt.parse");
+            UnicodeString s;
+            s = fmt.format(d, s);
+            UnicodeString ss;
+            ss = fmt.format(dd, ss);
+            if (d != dd)
+                errln((UnicodeString) "Fail: " + d + " != " + dd);
+            if (s != ss)
+                errln((UnicodeString)"Fail: " + s + " != " + ss);
+            logln("Ok: " + s + " " + d);
+        }
+}
+
+/**
+ * @bug 4089106
+ */
+void DateFormatRegressionTest::Test4089106(void) 
+{
+    TimeZone *def = TimeZone::createDefault();
+    //try {
+        TimeZone *z = new SimpleTimeZone((int)(1.25 * 3600000), "FAKEZONE");
+        TimeZone::setDefault(*z);
+        UErrorCode status = U_ZERO_ERROR;
+        SimpleDateFormat *f = new SimpleDateFormat(status);
+        if(U_FAILURE(status)) {
+          dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
+          delete f;
+          delete def;
+          delete z;
+          return;
+        }
+        failure(status, "new SimpleDateFormat");
+        if (f->getTimeZone()!= *z)
+            errln("Fail: SimpleTimeZone should use TimeZone.getDefault()");
+        
+        //}
+    //finally {
+        TimeZone::setDefault(*def);
+    //}
+
+    delete z;
+    delete f;
+    delete def;
+}
+
+/**
+ * @bug 4100302
+ */
+
+// {sfb} not applicable in C++??
+
+void DateFormatRegressionTest::Test4100302(void) 
+{
+/*    Locale locales [] =  {
+        Locale::CANADA,
+        Locale::CANADA_FRENCH,
+        Locale::CHINA,
+        Locale::CHINESE,
+        Locale::ENGLISH,
+        Locale::FRANCE,
+        Locale::FRENCH,
+        Locale::GERMAN,
+        Locale::GERMANY,
+        Locale::ITALIAN,
+        Locale::ITALY,
+        Locale::JAPAN,
+        Locale::JAPANESE,
+        Locale::KOREA,
+        Locale::KOREAN,
+        Locale::PRC,
+        Locale::SIMPLIFIED_CHINESE,
+        Locale::TAIWAN,
+        Locale::TRADITIONAL_CHINESE,
+        Locale::UK,
+        Locale::US
+        };
+    //try {
+        UBool pass = TRUE;
+        for(int i = 0; i < 21; i++) {
+
+            Format *format = DateFormat::createDateTimeInstance(DateFormat::FULL,
+                DateFormat::FULL, locales[i]);
+            byte[] bytes;
+        
+            ByteArrayOutputStream baos = new ByteArrayOutputStream();
+            ObjectOutputStream oos = new ObjectOutputStream(baos);
+        
+            oos.writeObject(format);
+            oos.flush();
+        
+            baos.close();
+            bytes = baos.toByteArray();
+        
+            ObjectInputStream ois =
+                new ObjectInputStream(new ByteArrayInputStream(bytes));
+        
+            if (!format.equals(ois.readObject())) {
+                pass = FALSE;
+                logln("DateFormat instance for locale " +
+                      locales[i] + " is incorrectly serialized/deserialized.");
+            } else {
+                logln("DateFormat instance for locale " +
+                      locales[i] + " is OKAY.");
+            }
+        }
+        if (!pass) errln("Fail: DateFormat serialization/equality bug");      
+    }
+    catch (IOException e) {
+        errln("Fail: " + e);
+        e.printStackTrace();
+    }
+    catch (ClassNotFoundException e) {
+        errln("Fail: " + e);
+        e.printStackTrace();
+    }
+*/}
+
+/**
+ * @bug 4101483
+ */
+void DateFormatRegressionTest::Test4101483(void) 
+{
+    UErrorCode status = U_ZERO_ERROR;
+    SimpleDateFormat *sdf = new SimpleDateFormat(UnicodeString("z"), Locale::getUS(), status);
+    if (failure(status, "new SimpleDateFormat", TRUE)) return;
+    FieldPosition fp(UDAT_TIMEZONE_FIELD);
+    //Date d = date(9234567890L);
+    UDate d = 9234567890.0;
+    //StringBuffer buf = new StringBuffer("");
+    UnicodeString buf;
+    sdf->format(d, buf, fp);
+    //logln(sdf.format(d, buf, fp).toString());
+    logln(dateToString(d) + " => " + buf);
+    logln("beginIndex = " + fp.getBeginIndex());
+    logln("endIndex = " + fp.getEndIndex());
+    if (fp.getBeginIndex() == fp.getEndIndex()) 
+        errln("Fail: Empty field");
+
+    delete sdf;
+}
+
+/**
+ * @bug 4103340
+ * @bug 4138203
+ * This bug really only works in Locale.US, since that's what the locale
+ * used for Date.toString() is.  Bug 4138203 reports that it fails on Korean
+ * NT; it would actually have failed on any non-US locale.  Now it should
+ * work on all locales.
+ */
+void DateFormatRegressionTest::Test4103340(void) 
+{
+    UErrorCode status = U_ZERO_ERROR;
+
+    // choose a date that is the FIRST of some month 
+    // and some arbitrary time 
+    UDate d = date(97, 3, 1, 1, 1, 1); 
+    SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("MMMM"), Locale::getUS(), status); 
+    if (failure(status, "new SimpleDateFormat", TRUE)) return;
+
+    UnicodeString s;
+    s = dateToString(d, s);
+    UnicodeString s2;
+    FieldPosition pos(FieldPosition::DONT_CARE);
+    s2 = df->format(d, s2, pos);
+    logln("Date=" + s); 
+    logln("DF=" + s2);
+    UnicodeString substr;
+    s2.extract(0,2, substr);
+    if (s.indexOf(substr) == -1)
+      errln("Months should match");
+    
+    delete df;
+}
+
+/**
+ * @bug 4103341
+ */
+void DateFormatRegressionTest::Test4103341(void) 
+{
+    TimeZone *saveZone  =TimeZone::createDefault();
+    //try {
+        
+    // {sfb} changed from setDefault to adoptDefault
+    TimeZone::adoptDefault(TimeZone::createTimeZone("CST"));
+    UErrorCode status = U_ZERO_ERROR;
+    SimpleDateFormat *simple = new SimpleDateFormat(UnicodeString("MM/dd/yyyy HH:mm"), status);
+    if(U_FAILURE(status)) {
+      dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
+      delete simple;
+      return;
+    }
+    failure(status, "new SimpleDateFormat");
+    TimeZone *temp = TimeZone::createDefault();
+    if(simple->getTimeZone() != *temp)
+            errln("Fail: SimpleDateFormat not using default zone");
+    //}
+    //finally {
+        TimeZone::adoptDefault(saveZone);
+    //}
+
+    delete temp;
+    delete simple;
+}
+
+/**
+ * @bug 4104136
+ */
+void DateFormatRegressionTest::Test4104136(void) 
+{
+    UErrorCode status = U_ZERO_ERROR;
+    SimpleDateFormat *sdf = new SimpleDateFormat(status); 
+    if(U_FAILURE(status)) {
+      dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
+      delete sdf;
+      return;
+    }
+    if(failure(status, "new SimpleDateFormat")) return;
+    UnicodeString pattern = "'time' hh:mm"; 
+    sdf->applyPattern(pattern); 
+    logln("pattern: \"" + pattern + "\""); 
+
+    UnicodeString strings [] = {
+        (UnicodeString)"time 10:30",
+        (UnicodeString) "time 10:x",
+        (UnicodeString) "time 10x"
+    };
+
+    ParsePosition ppos [] = {
+        ParsePosition(10),
+        ParsePosition(0),
+        ParsePosition(0)
+    };
+
+    UDate dates [] = {
+        date(70, UCAL_JANUARY, 1, 10, 30),
+        -1,
+        -1
+    };
+
+    /*Object[] DATA = {
+        "time 10:30", new ParsePosition(10), new Date(70, Calendar.JANUARY, 1, 10, 30),
+        "time 10:x", new ParsePosition(0), null,
+        "time 10x", new ParsePosition(0), null,
+    };*/
+    
+    for(int i = 0; i < 3; i++) {
+        UnicodeString text = strings[i];
+        ParsePosition finish = ppos[i];
+        UDate exp = dates[i];
+        
+        ParsePosition pos(0);
+        UDate d = sdf->parse(text, pos);
+        logln(" text: \"" + text + "\""); 
+        logln(" index: %d", pos.getIndex()); 
+        logln((UnicodeString) " result: " + d);
+        if(pos.getIndex() != finish.getIndex())
+            errln("Fail: Expected pos " + finish.getIndex());
+        if (! ((d == 0 && exp == -1) || (d == exp)))
+            errln((UnicodeString) "Fail: Expected result " + exp);
+    }
+
+    delete sdf;
+}
+
+/**
+ * @bug 4104522
+ * CANNOT REPRODUCE
+ * According to the bug report, this test should throw a
+ * StringIndexOutOfBoundsException during the second parse.  However,
+ * this is not seen.
+ */
+void DateFormatRegressionTest::Test4104522(void) 
+{
+    UErrorCode status = U_ZERO_ERROR;
+    
+    SimpleDateFormat *sdf = new SimpleDateFormat(status);
+    if(U_FAILURE(status)) {
+      dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
+      delete sdf;
+      return;
+    }
+    failure(status, "new SimpleDateFormat");
+    UnicodeString pattern = "'time' hh:mm";
+    sdf->applyPattern(pattern);
+    logln("pattern: \"" + pattern + "\"");
+
+    // works correctly
+    ParsePosition pp(0);
+    UnicodeString text = "time ";
+    UDate dt = sdf->parse(text, pp);
+    logln(" text: \"" + text + "\"" +
+          " date: " + dt);
+
+    // works wrong
+    pp.setIndex(0);
+    text = "time";
+    dt = sdf->parse(text, pp);
+    logln(" text: \"" + text + "\"" +
+          " date: " + dt);
+
+    delete sdf;
+}
+
+/**
+ * @bug 4106807
+ */
+void DateFormatRegressionTest::Test4106807(void) 
+{
+    UDate dt; 
+    DateFormat *df = DateFormat::createDateTimeInstance(); 
+    
+    UErrorCode status = U_ZERO_ERROR;
+    SimpleDateFormat *sdfs [] = {
+        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss"), status),
+        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss'Z'"), status),
+        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss''"), status),
+        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss'a''a'"), status),
+        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss %"), status)
+    };
+    if(U_FAILURE(status)) {
+      dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
+      delete sdfs[0];
+      delete sdfs[1];
+      delete sdfs[2];
+      delete sdfs[3];
+      delete sdfs[4];
+      return;
+    }
+
+    failure(status, "new SimpleDateFormat");
+    
+    UnicodeString strings [] = {
+        (UnicodeString) "19980211140000",
+        (UnicodeString) "19980211140000",
+        (UnicodeString) "19980211140000",
+        (UnicodeString) "19980211140000a",
+        (UnicodeString) "19980211140000 "
+    };
+
+    /*Object[] data = {
+        new SimpleDateFormat("yyyyMMddHHmmss"),       "19980211140000",
+        new SimpleDateFormat("yyyyMMddHHmmss'Z'"),    "19980211140000",
+        new SimpleDateFormat("yyyyMMddHHmmss''"),     "19980211140000",
+        new SimpleDateFormat("yyyyMMddHHmmss'a''a'"), "19980211140000a",
+        new SimpleDateFormat("yyyyMMddHHmmss %"),     "19980211140000 ",
+    };*/
+    GregorianCalendar *gc = new GregorianCalendar(status);
+    failure(status, "new GregorianCalendar");
+    TimeZone *timeZone = TimeZone::createDefault(); 
+
+    TimeZone *gmt = timeZone->clone(); 
+
+    gmt->setRawOffset(0); 
+
+    for(int32_t i = 0; i < 5; i++) {
+        SimpleDateFormat *format = sdfs[i];
+        UnicodeString dateString = strings[i];
+        //try {
+            format->setTimeZone(*gmt); 
+            dt = format->parse(dateString, status);
+            // {sfb} some of these parses will fail purposely
+            if(U_FAILURE(status))
+                break;
+            status = U_ZERO_ERROR;
+            UnicodeString fmtd;
+            FieldPosition pos(FieldPosition::DONT_CARE);
+            fmtd = df->format(dt, fmtd, pos);
+            logln(fmtd);
+            //logln(df->format(dt)); 
+            gc->setTime(dt, status); 
+            failure(status, "gc->getTime");
+            logln(UnicodeString("") + gc->get(UCAL_ZONE_OFFSET, status));
+            failure(status, "gc->get");
+            UnicodeString s;
+            s = format->format(dt, s, pos);
+            logln(s); 
+        /*}
+        catch (ParseException e) { 
+            logln("No way Jose"); 
+        }*/ 
+    } 
+
+    delete timeZone;
+    delete df;
+    for(int32_t j = 0; j < 5; j++)
+        delete sdfs [j];
+     delete gc;
+    delete gmt;
+}
+
+/*
+  Synopsis: Chinese time zone CTT is not recogonized correctly.
+  Description: Platform Chinese Windows 95 - ** Time zone set to CST ** 
+  */
+/**
+ * @bug 4108407
+ */
+
+// {sfb} what to do with this one ?? 
+void DateFormatRegressionTest::Test4108407(void) 
+{ 
+    /*long l = System.currentTimeMillis(); 
+    logln("user.timezone = " + System.getProperty("user.timezone", "?"));
+    logln("Time Zone :" + 
+                       DateFormat.getDateInstance().getTimeZone().getID()); 
+    logln("Default format :" + 
+                       DateFormat.getDateInstance().format(new Date(l))); 
+    logln("Full format :" + 
+                       DateFormat.getDateInstance(DateFormat.FULL).format(new 
+                                                                          Date(l))); 
+    logln("*** Set host TZ to CST ***");
+    logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");*/
+} 
+
+/**
+ * @bug 4134203
+ * SimpleDateFormat won't parse "GMT"
+ */
+void DateFormatRegressionTest::Test4134203(void) 
+{
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString dateFormat = "MM/dd/yy HH:mm:ss zzz";
+    SimpleDateFormat *fmt = new SimpleDateFormat(dateFormat, status);
+    if (failure(status, "new SimpleDateFormat", TRUE)) return;
+    ParsePosition p0(0);
+    UDate d = fmt->parse("01/22/92 04:52:00 GMT", p0);
+    logln(dateToString(d));
+    if(p0 == ParsePosition(0))
+        errln("Fail: failed to parse 'GMT'");
+    // In the failure case an exception is thrown by parse();
+    // if no exception is thrown, the test passes.
+
+    delete fmt;
+}
+
+/**
+ * @bug 4151631
+ * SimpleDateFormat incorrect handling of 2 single quotes in format()
+ */
+void DateFormatRegressionTest::Test4151631(void) 
+{
+    UnicodeString pattern = "'TO_DATE('''dd'-'MM'-'yyyy HH:mm:ss''' , ''DD-MM-YYYY HH:MI:SS'')'";
+    logln("pattern=" + pattern);
+    UErrorCode status = U_ZERO_ERROR;
+    SimpleDateFormat *format = new SimpleDateFormat(pattern, Locale::getUS(), status);
+    if (failure(status, "new SimpleDateFormat", TRUE)) return;
+    UnicodeString result;
+    FieldPosition pos(FieldPosition::DONT_CARE);
+    result = format->format(date(1998-1900, UCAL_JUNE, 30, 13, 30, 0), result, pos);
+    if (result != "TO_DATE('30-06-1998 13:30:00' , 'DD-MM-YYYY HH:MI:SS')") {
+        errln("Fail: result=" + result);
+    }
+    else {
+        logln("Pass: result=" + result);
+    }
+
+    delete format;
+}
+
+/**
+ * @bug 4151706
+ * 'z' at end of date format throws index exception in SimpleDateFormat
+ * CANNOT REPRODUCE THIS BUG ON 1.2FCS
+ */
+void DateFormatRegressionTest::Test4151706(void) 
+{
+    UnicodeString dateString("Thursday, 31-Dec-98 23:00:00 GMT");
+    UErrorCode status = U_ZERO_ERROR;
+    SimpleDateFormat fmt(UnicodeString("EEEE, dd-MMM-yy HH:mm:ss z"), Locale::getUS(), status);
+    if (failure(status, "new SimpleDateFormat", TRUE)) return;
+    //try {
+        UDate d = fmt.parse(dateString, status);
+        failure(status, "fmt->parse");
+       // {sfb} what about next two lines?
+        //if (d.getTime() != Date.UTC(1998-1900, Calendar.DECEMBER, 31, 23, 0, 0))
+        //    errln("Incorrect value: " + d);
+    /*} catch (Exception e) {
+        errln("Fail: " + e);
+    }*/
+    UnicodeString temp;
+    FieldPosition pos(0);
+    logln(dateString + " -> " + fmt.format(d, temp, pos));
+}
+
+/**
+ * @bug 4162071
+ * Cannot reproduce this bug under 1.2 FCS -- it may be a convoluted duplicate
+ * of some other bug that has been fixed.
+ */
+void 
+DateFormatRegressionTest::Test4162071(void) 
+{
+    UnicodeString dateString("Thu, 30-Jul-1999 11:51:14 GMT");
+    UnicodeString format("EEE', 'dd-MMM-yyyy HH:mm:ss z"); // RFC 822/1123
+    UErrorCode status = U_ZERO_ERROR;
+    SimpleDateFormat df(format, Locale::getUS(), status);
+    if(U_FAILURE(status)) {
+        dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status));
+        return;
+    }
+    
+    //try {
+        UDate x = df.parse(dateString, status);
+        if(U_SUCCESS(status))
+            logln("Parse format \"" + format + "\" ok");
+        else
+            errln("Parse format \"" + format + "\" failed.");
+        UnicodeString temp;
+        FieldPosition pos(0);
+        logln(dateString + " -> " + df.format(x, temp, pos));
+    //} catch (Exception e) {
+    //    errln("Parse format \"" + format + "\" failed.");
+    //}
+}
+
+/**
+ * DateFormat shouldn't parse year "-1" as a two-digit year (e.g., "-1" -> 1999).
+ */
+void DateFormatRegressionTest::Test4182066(void) {
+    UErrorCode status = U_ZERO_ERROR;
+    SimpleDateFormat fmt("MM/dd/yy", Locale::getUS(), status);
+    SimpleDateFormat dispFmt("MMM dd yyyy GG", Locale::getUS(), status);
+    if (U_FAILURE(status)) {
+        dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status));
+        return;
+    }
+
+    /* We expect 2-digit year formats to put 2-digit years in the right
+     * window.  Out of range years, that is, anything less than "00" or
+     * greater than "99", are treated as literal years.  So "1/2/3456"
+     * becomes 3456 AD.  Likewise, "1/2/-3" becomes -3 AD == 2 BC.
+     */
+    const char* STRINGS[] = {
+        "02/29/00",
+        "01/23/01",
+        "04/05/-1",
+        "01/23/-9",
+        "11/12/1314",
+        "10/31/1",
+        "09/12/+1",
+        "09/12/001",
+    };
+    int32_t STRINGS_COUNT = (int32_t)(sizeof(STRINGS) / sizeof(STRINGS[0]));
+    UDate FAIL_DATE = (UDate) 0;
+    UDate DATES[] = {
+        date(2000-1900, UCAL_FEBRUARY, 29),
+        date(2001-1900, UCAL_JANUARY,  23),
+        date(  -1-1900, UCAL_APRIL,     5),
+        date(  -9-1900, UCAL_JANUARY,  23),
+        date(1314-1900, UCAL_NOVEMBER, 12),
+        date(   1-1900, UCAL_OCTOBER,  31),
+        FAIL_DATE, // "+1" isn't recognized by US NumberFormat
+        date(   1-1900, UCAL_SEPTEMBER,12),
+    };
+
+    UnicodeString out;
+    UBool pass = TRUE;
+    for (int32_t i=0; i<STRINGS_COUNT; ++i) {
+        UnicodeString str(STRINGS[i]);
+        UDate expected = DATES[i];
+        status = U_ZERO_ERROR;
+        UDate actual = fmt.parse(str, status);
+        if (U_FAILURE(status)) {
+            actual = FAIL_DATE;
+        }
+        UnicodeString actStr;
+        if (actual == FAIL_DATE) {
+            actStr.append("null");
+        } else {
+            // Yuck: See j25
+            ((DateFormat*)&dispFmt)->format(actual, actStr);
+        }
+
+        if (expected == actual) {
+            out.append(str + " => " + actStr + "\n");
+        } else {
+            UnicodeString expStr;
+            if (expected == FAIL_DATE) {
+                expStr.append("null");
+            } else {
+                // Yuck: See j25
+                ((DateFormat*)&dispFmt)->format(expected, expStr);
+            }
+            out.append("FAIL: " + str + " => " + actStr
+                       + ", expected " + expStr + "\n");
+            pass = FALSE;
+        }
+    }
+    if (pass) {
+        log(out);
+    } else {
+        err(out);
+    }
+}
+
+/**
+ * j32 {JDK Bug 4210209 4209272}
+ * DateFormat cannot parse Feb 29 2000 when setLenient(false)
+ */
+void
+DateFormatRegressionTest::Test4210209(void) {
+    UErrorCode status = U_ZERO_ERROR;
+    UnicodeString pattern("MMM d, yyyy");
+    SimpleDateFormat sfmt(pattern, Locale::getUS(), status);
+    SimpleDateFormat sdisp("MMM dd yyyy GG", Locale::getUS(), status);
+    DateFormat& fmt = *(DateFormat*)&sfmt; // Yuck: See j25
+    DateFormat& disp = *(DateFormat*)&sdisp; // Yuck: See j25
+    if (U_FAILURE(status)) {
+        dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status));
+        return;
+    }
+    Calendar* calx = (Calendar*)fmt.getCalendar(); // cast away const!
+    calx->setLenient(FALSE);
+    UDate d = date(2000-1900, UCAL_FEBRUARY, 29);
+    UnicodeString s, ss;
+    fmt.format(d, s);
+    logln(disp.format(d, ss.remove()) + " f> " + pattern +
+          " => \"" + s + "\"");
+    ParsePosition pos(0);
+    d = fmt.parse(s, pos);
+    logln(UnicodeString("\"") + s + "\" p> " + pattern +
+          " => " + disp.format(d, ss.remove()));
+    logln(UnicodeString("Parse pos = ") + pos.getIndex() +
+          ", error pos = " + pos.getErrorIndex());
+    if (pos.getErrorIndex() != -1) {
+        errln(UnicodeString("FAIL: Error index should be -1"));
+    }
+
+    // The underlying bug is in GregorianCalendar.  If the following lines
+    // succeed, the bug is fixed.  If the bug isn't fixed, they will throw
+    // an exception.
+    GregorianCalendar cal(status);
+    if (U_FAILURE(status)) {
+        errln("FAIL: Unable to create Calendar");
+        return;
+    }
+    cal.clear();
+    cal.setLenient(FALSE);
+    cal.set(2000, UCAL_FEBRUARY, 29); // This should work!
+    logln(UnicodeString("Attempt to set Calendar to Feb 29 2000: ") +
+                        disp.format(cal.getTime(status), ss.remove()));
+    if (U_FAILURE(status)) {
+        errln("FAIL: Unable to set Calendar to Feb 29 2000");
+    }
+}
+
+void DateFormatRegressionTest::Test714(void)
+{
+    //try {
+     UDate d(978103543000.);
+    DateFormat *fmt = DateFormat::createDateTimeInstance(DateFormat::NONE,
+                                                         DateFormat::MEDIUM,
+                                                         Locale::getUS());
+    if (fmt == NULL) {
+        dataerrln("Error calling DateFormat::createDateTimeInstance");
+        return;
+    }
+
+    UnicodeString s;
+        UnicodeString tests = 
+          (UnicodeString) "7:25:43 AM" ;
+        UErrorCode status = U_ZERO_ERROR;
+        fmt->format (d,s);
+        if(U_FAILURE(status))
+          {
+            errln((UnicodeString) "Fail, errmsg " + u_errorName(status));
+            return;
+          }
+        
+        if(s != tests)
+        {
+          errln((UnicodeString) "Fail: " + s + " != " + tests);
+        }
+        else
+        {
+          logln("OK: " + s + " == " + tests);
+        }
+
+   delete fmt;
+}
+
+class Test1684Data {
+public:
+  int32_t year;
+  int32_t month;
+  int32_t date;
+  int32_t womyear;
+  int32_t wommon;
+  int32_t wom;
+  int32_t dow;
+  UnicodeString data;
+  UnicodeString normalized;
+    
+  Test1684Data(int32_t xyear, int32_t xmonth, int32_t xdate,
+               int32_t xwomyear, int32_t xwommon, int32_t xwom, int32_t xdow,
+               const char *xdata, const char *xnormalized) :
+    year(xyear),
+    month(xmonth-1),
+    date(xdate),
+    womyear(xwomyear),
+    wommon(xwommon-1),
+    wom(xwom),
+    dow(xdow),
+    data(xdata,""),
+    normalized((xnormalized==NULL)?xdata:xnormalized,"")
+  { }
+};
+
+void DateFormatRegressionTest::Test1684(void)
+{
+  //      July 2001            August 2001           January 2002    
+  // Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa
+  //  1  2  3  4  5  6  7            1  2  3  4         1  2  3  4  5
+  //  8  9 10 11 12 13 14   5  6  7  8  9 10 11   6  7  8  9 10 11 12
+  // 15 16 17 18 19 20 21  12 13 14 15 16 17 18  13 14 15 16 17 18 19
+  // 22 23 24 25 26 27 28  19 20 21 22 23 24 25  20 21 22 23 24 25 26
+  // 29 30 31              26 27 28 29 30 31     27 28 29 30 31      
+  Test1684Data *tests[] = {
+    new Test1684Data(2001, 8,  6,  2001,8,2,UCAL_MONDAY,    "2001 08 02 Mon", NULL),
+    new Test1684Data(2001, 8,  7,  2001,8,2,UCAL_TUESDAY,   "2001 08 02 Tue", NULL),
+    new Test1684Data(2001, 8,  5,/*12,*/ 2001,8,2,UCAL_SUNDAY,    "2001 08 02 Sun", NULL),
+    new Test1684Data(2001, 8,6, /*7,  30,*/ 2001,7,6,UCAL_MONDAY,    "2001 07 06 Mon", "2001 08 02 Mon"),
+    new Test1684Data(2001, 8,7, /*7,  31,*/ 2001,7,6,UCAL_TUESDAY,   "2001 07 06 Tue", "2001 08 02 Tue"),
+    new Test1684Data(2001, 8,  5,  2001,7,6,UCAL_SUNDAY,    "2001 07 06 Sun", "2001 08 02 Sun"),
+    new Test1684Data(2001, 7,  30, 2001,8,1,UCAL_MONDAY,    "2001 08 01 Mon", "2001 07 05 Mon"),
+    new Test1684Data(2001, 7,  31, 2001,8,1,UCAL_TUESDAY,   "2001 08 01 Tue", "2001 07 05 Tue"),
+    new Test1684Data(2001, 7,29, /*8,  5,*/  2001,8,1,UCAL_SUNDAY,    "2001 08 01 Sun", "2001 07 05 Sun"),
+    new Test1684Data(2001, 12, 31, 2001,12,6,UCAL_MONDAY,   "2001 12 06 Mon", NULL),
+    new Test1684Data(2002, 1,  1,  2002,1,1,UCAL_TUESDAY,   "2002 01 01 Tue", NULL),
+    new Test1684Data(2002, 1,  2,  2002,1,1,UCAL_WEDNESDAY, "2002 01 01 Wed", NULL),
+    new Test1684Data(2002, 1,  3,  2002,1,1,UCAL_THURSDAY,  "2002 01 01 Thu", NULL),
+    new Test1684Data(2002, 1,  4,  2002,1,1,UCAL_FRIDAY,    "2002 01 01 Fri", NULL),
+    new Test1684Data(2002, 1,  5,  2002,1,1,UCAL_SATURDAY,  "2002 01 01 Sat", NULL),
+    new Test1684Data(2001,12,30, /*2002, 1,  6,*/  2002,1,1,UCAL_SUNDAY,    "2002 01 01 Sun", "2001 12 06 Sun")
+  };
+
+#define kTest1684Count  ((int32_t)(sizeof(tests)/sizeof(tests[0])))
+
+  int32_t pass = 0, error = 0, warning = 0;
+  int32_t i;
+
+  UErrorCode status = U_ZERO_ERROR;
+  UnicodeString pattern("yyyy MM WW EEE","");
+  Calendar *cal = new GregorianCalendar(status);
+  SimpleDateFormat *sdf = new SimpleDateFormat(pattern,status);
+  if (U_FAILURE(status)) {
+    dataerrln("Error constructing SimpleDateFormat");
+    for(i=0;i<kTest1684Count;i++) {
+        delete tests[i];
+    }
+    delete cal;
+    delete sdf;
+    return;
+  }
+  cal->setFirstDayOfWeek(UCAL_SUNDAY);
+  cal->setMinimalDaysInFirstWeek(1);
+
+  sdf->adoptCalendar(cal);
+
+  cal = sdf->getCalendar()->clone(); // sdf may have deleted calendar
+
+  if(!cal || !sdf || U_FAILURE(status)) {
+    errln(UnicodeString("Error setting up test: ") + u_errorName(status));
+  }
+
+  for (i = 0; i < kTest1684Count; ++i) {
+    Test1684Data &test = *(tests[i]);
+    logln(UnicodeString("#") + i + UnicodeString("\n-----\nTesting round trip of ") + test.year +
+        " " + (test.month + 1) +
+        " " + test.date +
+          " (written as) " + test.data);
+    
+    cal->clear();
+    cal->set(test.year, test.month, test.date);
+    UDate ms = cal->getTime(status);
+    
+    cal->clear();
+    cal->set(UCAL_YEAR, test.womyear);
+    cal->set(UCAL_MONTH, test.wommon);
+    cal->set(UCAL_WEEK_OF_MONTH, test.wom);
+    cal->set(UCAL_DAY_OF_WEEK, test.dow);
+    UDate ms2 = cal->getTime(status);
+            
+    if (ms2 != ms) {
+      errln((UnicodeString)"\nError: GregorianUCAL_DOM gave " + ms +
+            "\n       GregorianUCAL_WOM gave " + ms2);
+      error++;
+    } else {
+      pass++;
+    }
+    
+    ms2 = sdf->parse(test.data, status);
+    if(U_FAILURE(status)) {
+      errln("parse exception: " + UnicodeString(u_errorName(status)));
+    }
+    
+    if (ms2!=ms) {
+      errln((UnicodeString)"\nError: GregorianCalendar gave      " + ms +
+            "\n       SimpleDateFormat.parse gave " + ms2);
+      error++;
+    } else {
+      pass++;
+    }
+
+    UnicodeString result;
+    sdf->format(ms, result);
+    if (result != test.normalized) {
+      errln("\nWarning: format of '" + test.data + "' gave" +
+            "\n                   '" + result + "'" +
+            "\n          expected '" + test.normalized + "'");
+      warning++;
+    } else {
+      pass++;
+    }
+            
+    UDate ms3;
+    ms3 = sdf->parse(result, status);
+    if(U_FAILURE(status)) {
+      errln("parse exception 2: " + (UnicodeString)u_errorName(status));
+    }
+    
+    if (ms3!=ms) {
+      error++;
+      errln((UnicodeString)"\nError: Re-parse of '" + result + "' gave time of " +
+          "\n        " + ms3 +
+          "\n    not " + ms);
+    } else {
+      pass++;
+            }
+  }
+
+  UnicodeString info 
+    = UnicodeString("Passed: ") + pass + ", Warnings: " + warning + ", Errors: " + error;
+  if (error > 0) {
+    errln(info);
+  } else {
+    logln(info);
+  }
+
+  for(i=0;i<kTest1684Count;i++) {
+    delete tests[i];
+  }
+  delete cal;
+  delete sdf;
+}
+
+void DateFormatRegressionTest::Test5554(void)
+{
+  UErrorCode status = U_ZERO_ERROR;
+  UnicodeString pattern("Z","");
+  UnicodeString newfoundland("Canada/Newfoundland", "");
+  TimeZone *zone = TimeZone::createTimeZone(newfoundland);
+  Calendar *cal = new GregorianCalendar(zone, status);
+  SimpleDateFormat *sdf = new SimpleDateFormat(pattern,status);
+  if (U_FAILURE(status)) {
+    dataerrln("Error constructing SimpleDateFormat");
+    delete cal;
+    delete sdf;
+    return;
+  }
+  cal->set(2007, 1, 14);
+  UDate date = cal->getTime(status);
+  if (U_FAILURE(status)) {
+    errln("Error getting time to format");
+    return;
+  };
+  sdf->adoptCalendar(cal);
+  UnicodeString result;
+  UnicodeString correct("-0330", "");
+  sdf->format(date, result);
+  if (result != correct) {
+    errln("\nError: Newfoundland Z of Jan 14, 2007 gave '" + result + "', expected '" + correct + "'");
+  }
+  delete sdf;
+}
+
+#endif /* #if !UCONFIG_NO_FORMATTING */
+
+//eof