1/********************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 1997-2012, International Business Machines Corporation and
4 * others. All Rights Reserved.
5 ********************************************************************/
6
7#include "unicode/utypes.h"
8
9#if !UCONFIG_NO_FORMATTING
10
11#include "dtfmrgts.h"
12
13#include "unicode/timezone.h"
14#include "unicode/gregocal.h"
15#include "unicode/smpdtfmt.h"
16#include "unicode/datefmt.h"
17#include "unicode/simpletz.h"
18#include "unicode/resbund.h"
19
20// *****************************************************************************
21// class DateFormatRegressionTest
22// *****************************************************************************
23
24#define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break;
25
26void
27DateFormatRegressionTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
28{
29    // if (exec) logln((UnicodeString)"TestSuite DateFormatRegressionTest");
30    switch (index) {
31        CASE(0,Test4029195)
32        CASE(1,Test4052408)
33        CASE(2,Test4056591)
34        CASE(3,Test4059917)
35        CASE(4,Test4060212)
36        CASE(5,Test4061287)
37        CASE(6,Test4065240)
38        CASE(7,Test4071441)
39        CASE(8,Test4073003)
40        CASE(9,Test4089106)
41        CASE(10,Test4100302)
42        CASE(11,Test4101483)
43        CASE(12,Test4103340)
44        CASE(13,Test4103341)
45        CASE(14,Test4104136)
46        CASE(15,Test4104522)
47        CASE(16,Test4106807)
48        CASE(17,Test4108407)
49        CASE(18,Test4134203)
50        CASE(19,Test4151631)
51        CASE(20,Test4151706)
52        CASE(21,Test4162071)
53        CASE(22,Test4182066)
54        CASE(23,Test4210209)
55        CASE(24,Test714)
56        CASE(25,Test1684)
57        CASE(26,Test5554)
58        CASE(27,Test9237)
59        CASE(28,TestParsing)
60        default: name = ""; break;
61    }
62}
63
64/**
65 * @bug 4029195
66 */
67void DateFormatRegressionTest::Test4029195(void)
68{
69    UErrorCode status = U_ZERO_ERROR;
70
71    UDate today = Calendar::getNow();
72    logln((UnicodeString) "today: " + today);
73
74    SimpleDateFormat *sdf = (SimpleDateFormat*) DateFormat::createDateInstance();
75    if (failure(status, "SimpleDateFormat::createDateInstance")) {
76        return;
77    }
78    UnicodeString pat;
79    if(sdf == NULL){
80        dataerrln("Error calling DateFormat::createDateTimeInstance");
81        return;
82    }
83
84    pat = sdf->toPattern(pat);
85    logln("pattern: " + pat);
86    UnicodeString fmtd;
87    FieldPosition pos(FieldPosition::DONT_CARE);
88    fmtd = sdf->format(today, fmtd, pos);
89    logln("today: " + fmtd);
90
91    sdf->applyPattern("G yyyy DDD");
92    UnicodeString todayS;
93    todayS = sdf->format(today, todayS, pos);
94    logln("today: " + todayS);
95    //try {
96        today = sdf->parse(todayS, status);
97        failure(status, "sdf->parse");
98        logln((UnicodeString)"today date: " + today);
99    /*} catch(Exception e) {
100        logln("Error reparsing date: " + e.getMessage());
101    }*/
102
103    //try {
104        UnicodeString rt;
105        rt = sdf->format(sdf->parse(todayS, status), rt, pos);
106        failure(status, "sdf->parse");
107        logln("round trip: " + rt);
108        if(rt != todayS)
109            errln("Fail: Want " + todayS + " Got " + rt);
110    /*}
111    catch (ParseException e) {
112        errln("Fail: " + e);
113        e.printStackTrace();
114    }*/
115
116    delete sdf;
117}
118
119/**
120 * @bug 4052408
121 */
122void DateFormatRegressionTest::Test4052408(void)
123{
124
125    DateFormat *fmt = DateFormat::createDateTimeInstance(DateFormat::SHORT,
126                                                DateFormat::SHORT, Locale::getUS());
127    if (fmt == NULL) {
128        dataerrln("Error calling DateFormat::createDateTimeInstance");
129        return;
130    }
131
132    UDate dt = date(97, UCAL_MAY, 3, 8, 55);
133    UnicodeString str;
134    str = fmt->format(dt, str);
135    logln(str);
136
137    if(str != "5/3/97, 8:55 AM")
138        errln("Fail: Test broken; Want 5/3/97 8:55 AM Got " + str);
139
140    UnicodeString expected[] = {
141        (UnicodeString) "", //"ERA_FIELD",
142        (UnicodeString) "97", //"YEAR_FIELD",
143        (UnicodeString) "5", //"MONTH_FIELD",
144        (UnicodeString) "3", //"DATE_FIELD",
145        (UnicodeString) "", //"HOUR_OF_DAY1_FIELD",
146        (UnicodeString) "", //"HOUR_OF_DAY0_FIELD",
147        (UnicodeString) "55", //"MINUTE_FIELD",
148        (UnicodeString) "", //"SECOND_FIELD",
149        (UnicodeString) "", //"MILLISECOND_FIELD",
150        (UnicodeString) "", //"DAY_OF_WEEK_FIELD",
151        (UnicodeString) "", //"DAY_OF_YEAR_FIELD",
152        (UnicodeString) "", //"DAY_OF_WEEK_IN_MONTH_FIELD",
153        (UnicodeString) "", //"WEEK_OF_YEAR_FIELD",
154        (UnicodeString) "", //"WEEK_OF_MONTH_FIELD",
155        (UnicodeString) "AM", //"AM_PM_FIELD",
156        (UnicodeString) "8", //"HOUR1_FIELD",
157        (UnicodeString) "", //"HOUR0_FIELD",
158        (UnicodeString) "" //"TIMEZONE_FIELD"
159    };
160
161    //Hashtable expected;// = new Hashtable();
162    //expected.put(new LongKey(DateFormat.MONTH_FIELD), "5");
163    //expected.put(new LongKey(DateFormat.DATE_FIELD), "3");
164    //expected.put(new LongKey(DateFormat.YEAR_FIELD), "97");
165    //expected.put(new LongKey(DateFormat.HOUR1_FIELD), "8");
166    //expected.put(new LongKey(DateFormat.MINUTE_FIELD), "55");
167    //expected.put(new LongKey(DateFormat.AM_PM_FIELD), "AM");
168
169    //StringBuffer buf = new StringBuffer();
170    UnicodeString fieldNames[] = {
171        (UnicodeString) "ERA_FIELD",
172        (UnicodeString) "YEAR_FIELD",
173        (UnicodeString) "MONTH_FIELD",
174        (UnicodeString) "DATE_FIELD",
175        (UnicodeString) "HOUR_OF_DAY1_FIELD",
176        (UnicodeString) "HOUR_OF_DAY0_FIELD",
177        (UnicodeString) "MINUTE_FIELD",
178        (UnicodeString) "SECOND_FIELD",
179        (UnicodeString) "MILLISECOND_FIELD",
180        (UnicodeString) "DAY_OF_WEEK_FIELD",
181        (UnicodeString) "DAY_OF_YEAR_FIELD",
182        (UnicodeString) "DAY_OF_WEEK_IN_MONTH_FIELD",
183        (UnicodeString) "WEEK_OF_YEAR_FIELD",
184        (UnicodeString) "WEEK_OF_MONTH_FIELD",
185        (UnicodeString) "AM_PM_FIELD",
186        (UnicodeString) "HOUR1_FIELD",
187        (UnicodeString) "HOUR0_FIELD",
188        (UnicodeString) "TIMEZONE_FIELD"
189    };
190
191    UBool pass = TRUE;
192    for(int i = 0; i <= 17; ++i) {
193        FieldPosition pos(i);
194        UnicodeString buf;
195        fmt->format(dt, buf, pos);
196        //char[] dst = new char[pos.getEndIndex() - pos.getBeginIndex()];
197        UnicodeString dst;
198        buf.extractBetween(pos.getBeginIndex(), pos.getEndIndex(), dst);
199        UnicodeString str(dst);
200        logln((UnicodeString)"" + i + (UnicodeString)": " + fieldNames[i] +
201                (UnicodeString)", \"" + str + (UnicodeString)"\", " +
202                pos.getBeginIndex() + (UnicodeString)", " +
203                pos.getEndIndex());
204        UnicodeString exp = expected[i];
205        if((exp.length() == 0 && str.length() == 0) || str == exp)
206            logln(" ok");
207        else {
208            errln(UnicodeString(" expected ") + exp);
209            pass = FALSE;
210        }
211
212    }
213    if( ! pass)
214        errln("Fail: FieldPosition not set right by DateFormat");
215
216    delete fmt;
217}
218
219/**
220 * @bug 4056591
221 * Verify the function of the [s|g]et2DigitYearStart() API.
222 */
223void DateFormatRegressionTest::Test4056591(void)
224{
225    UErrorCode status = U_ZERO_ERROR;
226
227    //try {
228        SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("yyMMdd"), Locale::getUS(), status);
229        if (failure(status, "new SimpleDateFormat", TRUE)) {
230            delete fmt;
231            return;
232        }
233        UDate start = date(1809-1900, UCAL_DECEMBER, 25);
234        fmt->set2DigitYearStart(start, status);
235        failure(status, "fmt->setTwoDigitStartDate");
236        if( (fmt->get2DigitYearStart(status) != start) || failure(status, "get2DigitStartDate"))
237            errln("get2DigitYearStart broken");
238        UDate dates [] = {
239            date(1809-1900, UCAL_DECEMBER, 25),
240            date(1909-1900, UCAL_DECEMBER, 24),
241            date(1809-1900, UCAL_DECEMBER, 26),
242            date(1861-1900, UCAL_DECEMBER, 25),
243        };
244
245        UnicodeString strings [] = {
246            (UnicodeString) "091225",
247            (UnicodeString) "091224",
248            (UnicodeString) "091226",
249            (UnicodeString) "611225"
250        };
251
252        /*Object[] DATA = {
253            "091225", new Date(1809-1900, Calendar.DECEMBER, 25),
254            "091224", new Date(1909-1900, Calendar.DECEMBER, 24),
255            "091226", new Date(1809-1900, Calendar.DECEMBER, 26),
256            "611225", new Date(1861-1900, Calendar.DECEMBER, 25),
257        };*/
258
259        for(int i = 0; i < 4; i++) {
260            UnicodeString s = strings[i];
261            UDate exp = dates[i];
262            UDate got = fmt->parse(s, status);
263            failure(status, "fmt->parse");
264            logln(s + " -> " + got + "; exp " + exp);
265            if(got != exp)
266                errln("set2DigitYearStart broken");
267        }
268    /*}
269    catch (ParseException e) {
270        errln("Fail: " + e);
271        e.printStackTrace();
272    }*/
273
274    delete fmt;
275}
276
277/**
278 * @bug 4059917
279 */
280void DateFormatRegressionTest::Test4059917(void)
281{
282    UErrorCode status = U_ZERO_ERROR;
283
284    SimpleDateFormat *fmt;
285    UnicodeString myDate;
286
287    fmt = new SimpleDateFormat( UnicodeString("yyyy/MM/dd"), status );
288    if (failure(status, "new SimpleDateFormat", TRUE)) return;
289    myDate = "1997/01/01";
290    aux917( fmt, myDate );
291
292    delete fmt;
293    fmt = NULL;
294
295    fmt = new SimpleDateFormat( UnicodeString("yyyyMMdd"), status );
296    if(failure(status, "new SimpleDateFormat")) return;
297    myDate = "19970101";
298    aux917( fmt, myDate );
299
300    delete fmt;
301}
302
303void DateFormatRegressionTest::aux917( SimpleDateFormat *fmt, UnicodeString& str ) {
304    //try {
305    UnicodeString pat;
306    pat = fmt->toPattern(pat);
307    logln( "==================" );
308    logln( "testIt: pattern=" + pat +
309               " string=" + str );
310
311
312    Formattable o;
313    //Object o;
314    ParsePosition pos(0);
315    fmt->parseObject( str, o, pos );
316    //logln( UnicodeString("Parsed object: ") + o );
317
318    UErrorCode status = U_ZERO_ERROR;
319    UnicodeString formatted;
320    FieldPosition poss(FieldPosition::DONT_CARE);
321    formatted = fmt->format( o, formatted, poss, status );
322    failure(status, "fmt->format");
323    logln( "Formatted string: " + formatted );
324    if( formatted != str)
325        errln("Fail: Want " + str + " Got " + formatted);
326    /*}
327    catch (ParseException e) {
328        errln("Fail: " + e);
329        e.printStackTrace();
330    }*/
331}
332
333/**
334 * @bug 4060212
335 */
336void DateFormatRegressionTest::Test4060212(void)
337{
338    UnicodeString dateString = "1995-040.05:01:29";
339
340    logln( "dateString= " + dateString );
341    logln("Using yyyy-DDD.hh:mm:ss");
342    UErrorCode status = U_ZERO_ERROR;
343    SimpleDateFormat *formatter = new SimpleDateFormat(UnicodeString("yyyy-DDD.hh:mm:ss"), status);
344    if (failure(status, "new SimpleDateFormat", TRUE)) return;
345    ParsePosition pos(0);
346    UDate myDate = formatter->parse( dateString, pos );
347    UnicodeString myString;
348    DateFormat *fmt = DateFormat::createDateTimeInstance( DateFormat::FULL,
349                                                            DateFormat::LONG);
350    if (fmt == NULL) {
351        dataerrln("Error calling DateFormat::createDateTimeInstance");
352        delete formatter;
353        return;
354    }
355
356    myString = fmt->format( myDate, myString);
357    logln( myString );
358
359    Calendar *cal = new GregorianCalendar(status);
360    failure(status, "new GregorianCalendar");
361    cal->setTime(myDate, status);
362    failure(status, "cal->setTime");
363    if ((cal->get(UCAL_DAY_OF_YEAR, status) != 40) || failure(status, "cal->get"))
364        errln((UnicodeString) "Fail: Got " + cal->get(UCAL_DAY_OF_YEAR, status) +
365                            " Want 40");
366
367    // this is an odd usage of "ddd" and it doesn't
368    // work now that date values are range checked per #3579.
369    logln("Using yyyy-ddd.hh:mm:ss");
370    delete formatter;
371    formatter = NULL;
372    formatter = new SimpleDateFormat(UnicodeString("yyyy-ddd.hh:mm:ss"), status);
373    if(failure(status, "new SimpleDateFormat")) return;
374    pos.setIndex(0);
375    myDate = formatter->parse( dateString, pos );
376    myString = fmt->format( myDate, myString );
377    logln( myString );
378    cal->setTime(myDate, status);
379    failure(status, "cal->setTime");
380    if ((cal->get(UCAL_DAY_OF_YEAR, status) != 40) || failure(status, "cal->get"))
381        errln((UnicodeString) "Fail: Got " + cal->get(UCAL_DAY_OF_YEAR, status) +
382                            " Want 40");
383
384    delete formatter;
385    delete fmt;
386    delete cal;
387}
388
389/**
390 * @bug 4061287
391 */
392void DateFormatRegressionTest::Test4061287(void)
393{
394    UErrorCode status = U_ZERO_ERROR;
395
396    SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("dd/MM/yyyy"), status);
397    if (U_FAILURE(status)) {
398        dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status));
399        delete df;
400        return;
401    }
402    failure(status, "new SimpleDateFormat");
403    //try {
404    logln(UnicodeString("") + df->parse("35/01/1971", status));
405    failure(status, "df->parse(\"35/01/1971\")");
406    //logln(df.parse("35/01/1971").toString());
407    //}
408    /*catch (ParseException e) {
409        errln("Fail: " + e);
410        e.printStackTrace();
411    }*/
412    df->setLenient(FALSE);
413    UBool ok = FALSE;
414    //try {
415    logln(UnicodeString("") + df->parse("35/01/1971", status));
416    if(U_FAILURE(status))
417        ok = TRUE;
418    //logln(df.parse("35/01/1971").toString());
419    //} catch (ParseException e) {ok=TRUE;}
420    if(!ok)
421        errln("Fail: Lenient not working");
422    delete df;
423}
424
425/**
426 * @bug 4065240
427 */
428void DateFormatRegressionTest::Test4065240(void)
429{
430    UDate curDate;
431    DateFormat *shortdate, *fulldate;
432    UnicodeString strShortDate, strFullDate;
433    Locale saveLocale = Locale::getDefault();
434    TimeZone *saveZone = TimeZone::createDefault();
435
436    UErrorCode status = U_ZERO_ERROR;
437    //try {
438        Locale *curLocale = new Locale("de","DE");
439        Locale::setDefault(*curLocale, status);
440        failure(status, "Locale::setDefault");
441        // {sfb} adoptDefault instead of setDefault
442        //TimeZone::setDefault(TimeZone::createTimeZone("EST"));
443        TimeZone::adoptDefault(TimeZone::createTimeZone("EST"));
444        curDate = date(98, 0, 1);
445        shortdate = DateFormat::createDateInstance(DateFormat::SHORT);
446        if (shortdate == NULL){
447            dataerrln("Error calling DateFormat::createDateInstance");
448            return;
449        }
450
451        fulldate = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::LONG);
452        if (fulldate == NULL){
453            dataerrln("Error calling DateFormat::createDateTimeInstance");
454            return;
455        }
456        strShortDate = "The current date (short form) is ";
457        UnicodeString temp;
458        temp = shortdate->format(curDate, temp);
459        strShortDate += temp;
460        strFullDate = "The current date (long form) is ";
461        UnicodeString temp2;
462        fulldate->format(curDate, temp2);
463        strFullDate += temp2;
464
465        logln(strShortDate);
466        logln(strFullDate);
467
468        // {sfb} What to do with resource bundle stuff?????
469
470        // Check to see if the resource is present; if not, we can't test
471        ResourceBundle *bundle = new ResourceBundle(
472            NULL, *curLocale, status);
473        failure(status, "new ResourceBundle");
474            //(UnicodeString) "java.text.resources.DateFormatZoneData", curLocale);
475
476        // {sfb} API change to ResourceBundle -- add getLocale()
477        /*if (bundle->getLocale().getLanguage(temp) == UnicodeString("de")) {
478            // UPDATE THIS AS ZONE NAME RESOURCE FOR <EST> in de_DE is updated
479            if (!strFullDate.endsWith(UnicodeString("GMT-05:00")))
480                errln("Fail: Want GMT-05:00");
481        }
482        else {
483            logln("*** TEST COULD NOT BE COMPLETED BECAUSE DateFormatZoneData ***");
484            logln("*** FOR LOCALE de OR de_DE IS MISSING ***");
485        }*/
486    //}
487    //finally {
488    Locale::setDefault(saveLocale, status);
489    failure(status, "Locale::setDefault");
490    TimeZone::setDefault(*saveZone);
491    //}
492    delete shortdate;
493    delete fulldate;
494    delete saveZone;
495    delete curLocale;
496    delete bundle;
497}
498
499/*
500  DateFormat.equals is too narrowly defined.  As a result, MessageFormat
501  does not work correctly.  DateFormat.equals needs to be written so
502  that the Calendar sub-object is not compared using Calendar.equals,
503  but rather compared for equivalency.  This may necessitate adding a
504  (package private) method to Calendar to test for equivalency.
505
506  Currently this bug breaks MessageFormat.toPattern
507  */
508/**
509 * @bug 4071441
510 */
511void DateFormatRegressionTest::Test4071441(void)
512{
513    DateFormat *fmtA = DateFormat::createInstance();
514    DateFormat *fmtB = DateFormat::createInstance();
515
516    if (fmtA == NULL || fmtB == NULL){
517        dataerrln("Error calling DateFormat::createInstance");
518        delete fmtA;
519        delete fmtB;
520        return;
521    }
522
523    // {sfb} Is it OK to cast away const here?
524    Calendar *calA = (Calendar*) fmtA->getCalendar();
525    Calendar *calB = (Calendar*) fmtB->getCalendar();
526    if(!calA || !calB) {
527      errln("Couldn't get proper calendars, exiting");
528      delete fmtA;
529      delete fmtB;
530      return;
531    }
532    UDate epoch = date(0, 0, 0);
533    UDate xmas = date(61, UCAL_DECEMBER, 25);
534
535    UErrorCode status = U_ZERO_ERROR;
536    calA->setTime(epoch, status);
537    failure(status, "calA->setTime");
538    calB->setTime(epoch, status);
539    failure(status, "calB->setTime");
540    if (*calA != *calB)
541        errln("Fail: Can't complete test; Calendar instances unequal");
542    if (*fmtA != *fmtB)
543        errln("Fail: DateFormat unequal when Calendars equal");
544    calB->setTime(xmas, status);
545    failure(status, "calB->setTime");
546    if (*calA == *calB)
547        errln("Fail: Can't complete test; Calendar instances equal");
548    if (*fmtA != *fmtB)
549        errln("Fail: DateFormat unequal when Calendars equivalent");
550
551    logln("DateFormat.equals ok");
552
553    delete fmtA;
554    delete fmtB;
555}
556
557/* The java.text.DateFormat.parse(String) method expects for the
558  US locale a string formatted according to mm/dd/yy and parses it
559  correctly.
560
561  When given a string mm/dd/yyyy [sic] it only parses up to the first
562  two y's, typically resulting in a date in the year 1919.
563
564  Please extend the parsing method(s) to handle strings with
565  four-digit year values (probably also applicable to various
566  other locales.  */
567/**
568 * @bug 4073003
569 */
570void DateFormatRegressionTest::Test4073003(void)
571{
572    //try {
573    UErrorCode ec = U_ZERO_ERROR;
574    SimpleDateFormat fmt("MM/dd/yy", Locale::getUK(), ec);
575    if (U_FAILURE(ec)) {
576        dataerrln("FAIL: SimpleDateFormat constructor - %s", u_errorName(ec));
577        return;
578    }
579        UnicodeString tests [] = {
580            (UnicodeString) "12/25/61",
581            (UnicodeString) "12/25/1961",
582            (UnicodeString) "4/3/2010",
583            (UnicodeString) "4/3/10"
584        };
585        UErrorCode status = U_ZERO_ERROR;
586        for(int i= 0; i < 4; i+=2) {
587            UDate d = fmt.parse(tests[i], status);
588            failure(status, "fmt.parse");
589            UDate dd = fmt.parse(tests[i+1], status);
590            failure(status, "fmt.parse");
591            UnicodeString s;
592            s = fmt.format(d, s);
593            UnicodeString ss;
594            ss = fmt.format(dd, ss);
595            if (d != dd)
596                errln((UnicodeString) "Fail: " + d + " != " + dd);
597            if (s != ss)
598                errln((UnicodeString)"Fail: " + s + " != " + ss);
599            logln("Ok: " + s + " " + d);
600        }
601}
602
603/**
604 * @bug 4089106
605 */
606void DateFormatRegressionTest::Test4089106(void)
607{
608    TimeZone *def = TimeZone::createDefault();
609    //try {
610        TimeZone *z = new SimpleTimeZone((int)(1.25 * 3600000), "FAKEZONE");
611        TimeZone::setDefault(*z);
612        UErrorCode status = U_ZERO_ERROR;
613        SimpleDateFormat *f = new SimpleDateFormat(status);
614        if(U_FAILURE(status)) {
615          dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
616          delete f;
617          delete def;
618          delete z;
619          return;
620        }
621        failure(status, "new SimpleDateFormat");
622        if (f->getTimeZone()!= *z)
623            errln("Fail: SimpleTimeZone should use TimeZone.getDefault()");
624
625        //}
626    //finally {
627        TimeZone::setDefault(*def);
628    //}
629
630    delete z;
631    delete f;
632    delete def;
633}
634
635/**
636 * @bug 4100302
637 */
638
639// {sfb} not applicable in C++??
640
641void DateFormatRegressionTest::Test4100302(void)
642{
643/*    Locale locales [] =  {
644        Locale::CANADA,
645        Locale::CANADA_FRENCH,
646        Locale::CHINA,
647        Locale::CHINESE,
648        Locale::ENGLISH,
649        Locale::FRANCE,
650        Locale::FRENCH,
651        Locale::GERMAN,
652        Locale::GERMANY,
653        Locale::ITALIAN,
654        Locale::ITALY,
655        Locale::JAPAN,
656        Locale::JAPANESE,
657        Locale::KOREA,
658        Locale::KOREAN,
659        Locale::PRC,
660        Locale::SIMPLIFIED_CHINESE,
661        Locale::TAIWAN,
662        Locale::TRADITIONAL_CHINESE,
663        Locale::UK,
664        Locale::US
665        };
666    //try {
667        UBool pass = TRUE;
668        for(int i = 0; i < 21; i++) {
669
670            Format *format = DateFormat::createDateTimeInstance(DateFormat::FULL,
671                DateFormat::FULL, locales[i]);
672            byte[] bytes;
673
674            ByteArrayOutputStream baos = new ByteArrayOutputStream();
675            ObjectOutputStream oos = new ObjectOutputStream(baos);
676
677            oos.writeObject(format);
678            oos.flush();
679
680            baos.close();
681            bytes = baos.toByteArray();
682
683            ObjectInputStream ois =
684                new ObjectInputStream(new ByteArrayInputStream(bytes));
685
686            if (!format.equals(ois.readObject())) {
687                pass = FALSE;
688                logln("DateFormat instance for locale " +
689                      locales[i] + " is incorrectly serialized/deserialized.");
690            } else {
691                logln("DateFormat instance for locale " +
692                      locales[i] + " is OKAY.");
693            }
694        }
695        if (!pass) errln("Fail: DateFormat serialization/equality bug");
696    }
697    catch (IOException e) {
698        errln("Fail: " + e);
699        e.printStackTrace();
700    }
701    catch (ClassNotFoundException e) {
702        errln("Fail: " + e);
703        e.printStackTrace();
704    }
705*/}
706
707/**
708 * @bug 4101483
709 */
710void DateFormatRegressionTest::Test4101483(void)
711{
712    UErrorCode status = U_ZERO_ERROR;
713    SimpleDateFormat *sdf = new SimpleDateFormat(UnicodeString("z"), Locale::getUS(), status);
714    if (failure(status, "new SimpleDateFormat", TRUE)) return;
715    FieldPosition fp(UDAT_TIMEZONE_FIELD);
716    //Date d = date(9234567890L);
717    UDate d = 9234567890.0;
718    //StringBuffer buf = new StringBuffer("");
719    UnicodeString buf;
720    sdf->format(d, buf, fp);
721    //logln(sdf.format(d, buf, fp).toString());
722    logln(dateToString(d) + " => " + buf);
723    logln(UnicodeString("beginIndex = ") + fp.getBeginIndex());
724    logln(UnicodeString("endIndex = ") + fp.getEndIndex());
725    if (fp.getBeginIndex() == fp.getEndIndex())
726        errln("Fail: Empty field");
727
728    delete sdf;
729}
730
731/**
732 * @bug 4103340
733 * @bug 4138203
734 * This bug really only works in Locale.US, since that's what the locale
735 * used for Date.toString() is.  Bug 4138203 reports that it fails on Korean
736 * NT; it would actually have failed on any non-US locale.  Now it should
737 * work on all locales.
738 */
739void DateFormatRegressionTest::Test4103340(void)
740{
741    UErrorCode status = U_ZERO_ERROR;
742
743    // choose a date that is the FIRST of some month
744    // and some arbitrary time
745    UDate d = date(97, 3, 1, 1, 1, 1);
746    SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("MMMM"), Locale::getUS(), status);
747    if (failure(status, "new SimpleDateFormat", TRUE)) return;
748
749    UnicodeString s;
750    s = dateToString(d, s);
751    UnicodeString s2;
752    FieldPosition pos(FieldPosition::DONT_CARE);
753    s2 = df->format(d, s2, pos);
754    logln("Date=" + s);
755    logln("DF=" + s2);
756    UnicodeString substr;
757    s2.extract(0,2, substr);
758    if (s.indexOf(substr) == -1)
759      errln("Months should match");
760
761    delete df;
762}
763
764/**
765 * @bug 4103341
766 */
767void DateFormatRegressionTest::Test4103341(void)
768{
769    TimeZone *saveZone  =TimeZone::createDefault();
770    //try {
771
772    // {sfb} changed from setDefault to adoptDefault
773    TimeZone::adoptDefault(TimeZone::createTimeZone("CST"));
774    UErrorCode status = U_ZERO_ERROR;
775    SimpleDateFormat *simple = new SimpleDateFormat(UnicodeString("MM/dd/yyyy HH:mm"), status);
776    if(U_FAILURE(status)) {
777      dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
778      delete simple;
779      return;
780    }
781    failure(status, "new SimpleDateFormat");
782    TimeZone *temp = TimeZone::createDefault();
783    if(simple->getTimeZone() != *temp)
784            errln("Fail: SimpleDateFormat not using default zone");
785    //}
786    //finally {
787        TimeZone::adoptDefault(saveZone);
788    //}
789
790    delete temp;
791    delete simple;
792}
793
794/**
795 * @bug 4104136
796 */
797void DateFormatRegressionTest::Test4104136(void)
798{
799    UErrorCode status = U_ZERO_ERROR;
800    SimpleDateFormat *sdf = new SimpleDateFormat(status);
801    if(U_FAILURE(status)) {
802      dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
803      delete sdf;
804      return;
805    }
806    if(failure(status, "new SimpleDateFormat")) return;
807    UnicodeString pattern = "'time' hh:mm";
808    sdf->applyPattern(pattern);
809    logln("pattern: \"" + pattern + "\"");
810
811    UnicodeString strings [] = {
812        (UnicodeString)"time 10:30",
813        (UnicodeString) "time 10:x",
814        (UnicodeString) "time 10x"
815    };
816
817    ParsePosition ppos [] = {
818        ParsePosition(10),
819        ParsePosition(0),
820        ParsePosition(0)
821    };
822
823    UDate dates [] = {
824        date(70, UCAL_JANUARY, 1, 10, 30),
825        -1,
826        -1
827    };
828
829    /*Object[] DATA = {
830        "time 10:30", new ParsePosition(10), new Date(70, Calendar.JANUARY, 1, 10, 30),
831        "time 10:x", new ParsePosition(0), null,
832        "time 10x", new ParsePosition(0), null,
833    };*/
834
835    for(int i = 0; i < 3; i++) {
836        UnicodeString text = strings[i];
837        ParsePosition finish = ppos[i];
838        UDate exp = dates[i];
839
840        ParsePosition pos(0);
841        UDate d = sdf->parse(text, pos);
842        logln(" text: \"" + text + "\"");
843        logln(" index: %d", pos.getIndex());
844        logln((UnicodeString) " result: " + d);
845        if(pos.getIndex() != finish.getIndex())
846            errln(UnicodeString("Fail: Expected pos ") + finish.getIndex());
847        if (! ((d == 0 && exp == -1) || (d == exp)))
848            errln((UnicodeString) "Fail: Expected result " + exp);
849    }
850
851    delete sdf;
852}
853
854/**
855 * @bug 4104522
856 * CANNOT REPRODUCE
857 * According to the bug report, this test should throw a
858 * StringIndexOutOfBoundsException during the second parse.  However,
859 * this is not seen.
860 */
861void DateFormatRegressionTest::Test4104522(void)
862{
863    UErrorCode status = U_ZERO_ERROR;
864
865    SimpleDateFormat *sdf = new SimpleDateFormat(status);
866    if(U_FAILURE(status)) {
867      dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
868      delete sdf;
869      return;
870    }
871    failure(status, "new SimpleDateFormat");
872    UnicodeString pattern = "'time' hh:mm";
873    sdf->applyPattern(pattern);
874    logln("pattern: \"" + pattern + "\"");
875
876    // works correctly
877    ParsePosition pp(0);
878    UnicodeString text = "time ";
879    UDate dt = sdf->parse(text, pp);
880    logln(" text: \"" + text + "\"" +
881          " date: " + dt);
882
883    // works wrong
884    pp.setIndex(0);
885    text = "time";
886    dt = sdf->parse(text, pp);
887    logln(" text: \"" + text + "\"" +
888          " date: " + dt);
889
890    delete sdf;
891}
892
893/**
894 * @bug 4106807
895 */
896void DateFormatRegressionTest::Test4106807(void)
897{
898    UDate dt;
899    DateFormat *df = DateFormat::createDateTimeInstance();
900
901    UErrorCode status = U_ZERO_ERROR;
902    SimpleDateFormat *sdfs [] = {
903        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss"), status),
904        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss'Z'"), status),
905        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss''"), status),
906        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss'a''a'"), status),
907        new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss %"), status)
908    };
909    if(U_FAILURE(status)) {
910      dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
911      delete sdfs[0];
912      delete sdfs[1];
913      delete sdfs[2];
914      delete sdfs[3];
915      delete sdfs[4];
916      return;
917    }
918
919    failure(status, "new SimpleDateFormat");
920
921    UnicodeString strings [] = {
922        (UnicodeString) "19980211140000",
923        (UnicodeString) "19980211140000",
924        (UnicodeString) "19980211140000",
925        (UnicodeString) "19980211140000a",
926        (UnicodeString) "19980211140000 "
927    };
928
929    /*Object[] data = {
930        new SimpleDateFormat("yyyyMMddHHmmss"),       "19980211140000",
931        new SimpleDateFormat("yyyyMMddHHmmss'Z'"),    "19980211140000",
932        new SimpleDateFormat("yyyyMMddHHmmss''"),     "19980211140000",
933        new SimpleDateFormat("yyyyMMddHHmmss'a''a'"), "19980211140000a",
934        new SimpleDateFormat("yyyyMMddHHmmss %"),     "19980211140000 ",
935    };*/
936    GregorianCalendar *gc = new GregorianCalendar(status);
937    failure(status, "new GregorianCalendar");
938    TimeZone *timeZone = TimeZone::createDefault();
939
940    TimeZone *gmt = timeZone->clone();
941
942    gmt->setRawOffset(0);
943
944    for(int32_t i = 0; i < 5; i++) {
945        SimpleDateFormat *format = sdfs[i];
946        UnicodeString dateString = strings[i];
947        //try {
948            format->setTimeZone(*gmt);
949            dt = format->parse(dateString, status);
950            // {sfb} some of these parses will fail purposely
951            if(U_FAILURE(status))
952                break;
953            status = U_ZERO_ERROR;
954            UnicodeString fmtd;
955            FieldPosition pos(FieldPosition::DONT_CARE);
956            fmtd = df->format(dt, fmtd, pos);
957            logln(fmtd);
958            //logln(df->format(dt));
959            gc->setTime(dt, status);
960            failure(status, "gc->getTime");
961            logln(UnicodeString("") + gc->get(UCAL_ZONE_OFFSET, status));
962            failure(status, "gc->get");
963            UnicodeString s;
964            s = format->format(dt, s, pos);
965            logln(s);
966        /*}
967        catch (ParseException e) {
968            logln("No way Jose");
969        }*/
970    }
971
972    delete timeZone;
973    delete df;
974    for(int32_t j = 0; j < 5; j++)
975        delete sdfs [j];
976     delete gc;
977    delete gmt;
978}
979
980/*
981  Synopsis: Chinese time zone CTT is not recogonized correctly.
982  Description: Platform Chinese Windows 95 - ** Time zone set to CST **
983  */
984/**
985 * @bug 4108407
986 */
987
988// {sfb} what to do with this one ??
989void DateFormatRegressionTest::Test4108407(void)
990{
991    /*long l = System.currentTimeMillis();
992    logln("user.timezone = " + System.getProperty("user.timezone", "?"));
993    logln("Time Zone :" +
994                       DateFormat.getDateInstance().getTimeZone().getID());
995    logln("Default format :" +
996                       DateFormat.getDateInstance().format(new Date(l)));
997    logln("Full format :" +
998                       DateFormat.getDateInstance(DateFormat.FULL).format(new
999                                                                          Date(l)));
1000    logln("*** Set host TZ to CST ***");
1001    logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***");*/
1002}
1003
1004/**
1005 * @bug 4134203
1006 * SimpleDateFormat won't parse "GMT"
1007 */
1008void DateFormatRegressionTest::Test4134203(void)
1009{
1010    UErrorCode status = U_ZERO_ERROR;
1011    UnicodeString dateFormat = "MM/dd/yy HH:mm:ss zzz";
1012    SimpleDateFormat *fmt = new SimpleDateFormat(dateFormat, status);
1013    if (failure(status, "new SimpleDateFormat", TRUE)) return;
1014    ParsePosition p0(0);
1015    UDate d = fmt->parse("01/22/92 04:52:00 GMT", p0);
1016    logln(dateToString(d));
1017    if(p0 == ParsePosition(0))
1018        errln("Fail: failed to parse 'GMT'");
1019    // In the failure case an exception is thrown by parse();
1020    // if no exception is thrown, the test passes.
1021
1022    delete fmt;
1023}
1024
1025/**
1026 * @bug 4151631
1027 * SimpleDateFormat incorrect handling of 2 single quotes in format()
1028 */
1029void DateFormatRegressionTest::Test4151631(void)
1030{
1031    UnicodeString pattern = "'TO_DATE('''dd'-'MM'-'yyyy HH:mm:ss''' , ''DD-MM-YYYY HH:MI:SS'')'";
1032    logln("pattern=" + pattern);
1033    UErrorCode status = U_ZERO_ERROR;
1034    SimpleDateFormat *format = new SimpleDateFormat(pattern, Locale::getUS(), status);
1035    if (failure(status, "new SimpleDateFormat", TRUE)) return;
1036    UnicodeString result;
1037    FieldPosition pos(FieldPosition::DONT_CARE);
1038    result = format->format(date(1998-1900, UCAL_JUNE, 30, 13, 30, 0), result, pos);
1039    if (result != "TO_DATE('30-06-1998 13:30:00' , 'DD-MM-YYYY HH:MI:SS')") {
1040        errln("Fail: result=" + result);
1041    }
1042    else {
1043        logln("Pass: result=" + result);
1044    }
1045
1046    delete format;
1047}
1048
1049/**
1050 * @bug 4151706
1051 * 'z' at end of date format throws index exception in SimpleDateFormat
1052 * CANNOT REPRODUCE THIS BUG ON 1.2FCS
1053 */
1054void DateFormatRegressionTest::Test4151706(void)
1055{
1056    UnicodeString dateString("Thursday, 31-Dec-98 23:00:00 GMT");
1057    UErrorCode status = U_ZERO_ERROR;
1058    SimpleDateFormat fmt(UnicodeString("EEEE, dd-MMM-yy HH:mm:ss z"), Locale::getUS(), status);
1059    if (failure(status, "new SimpleDateFormat", TRUE)) return;
1060    //try {
1061        UDate d = fmt.parse(dateString, status);
1062        failure(status, "fmt->parse");
1063       // {sfb} what about next two lines?
1064        //if (d.getTime() != Date.UTC(1998-1900, Calendar.DECEMBER, 31, 23, 0, 0))
1065        //    errln("Incorrect value: " + d);
1066    /*} catch (Exception e) {
1067        errln("Fail: " + e);
1068    }*/
1069    UnicodeString temp;
1070    FieldPosition pos(0);
1071    logln(dateString + " -> " + fmt.format(d, temp, pos));
1072}
1073
1074/**
1075 * @bug 4162071
1076 * Cannot reproduce this bug under 1.2 FCS -- it may be a convoluted duplicate
1077 * of some other bug that has been fixed.
1078 */
1079void
1080DateFormatRegressionTest::Test4162071(void)
1081{
1082    UnicodeString dateString("Thu, 30-Jul-1999 11:51:14 GMT");
1083    UnicodeString format("EEE', 'dd-MMM-yyyy HH:mm:ss z"); // RFC 822/1123
1084    UErrorCode status = U_ZERO_ERROR;
1085    SimpleDateFormat df(format, Locale::getUS(), status);
1086    if(U_FAILURE(status)) {
1087        dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status));
1088        return;
1089    }
1090
1091    //try {
1092        UDate x = df.parse(dateString, status);
1093        if(U_SUCCESS(status))
1094            logln("Parse format \"" + format + "\" ok");
1095        else
1096            errln("Parse format \"" + format + "\" failed.");
1097        UnicodeString temp;
1098        FieldPosition pos(0);
1099        logln(dateString + " -> " + df.format(x, temp, pos));
1100    //} catch (Exception e) {
1101    //    errln("Parse format \"" + format + "\" failed.");
1102    //}
1103}
1104
1105/**
1106 * DateFormat shouldn't parse year "-1" as a two-digit year (e.g., "-1" -> 1999).
1107 */
1108void DateFormatRegressionTest::Test4182066(void) {
1109    UErrorCode status = U_ZERO_ERROR;
1110    SimpleDateFormat fmt("MM/dd/yy", Locale::getUS(), status);
1111    SimpleDateFormat dispFmt("MMM dd yyyy GG", Locale::getUS(), status);
1112    if (U_FAILURE(status)) {
1113        dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status));
1114        return;
1115    }
1116
1117    /* We expect 2-digit year formats to put 2-digit years in the right
1118     * window.  Out of range years, that is, anything less than "00" or
1119     * greater than "99", are treated as literal years.  So "1/2/3456"
1120     * becomes 3456 AD.  Likewise, "1/2/-3" becomes -3 AD == 2 BC.
1121     */
1122    const char* STRINGS[] = {
1123        "02/29/00",
1124        "01/23/01",
1125        "04/05/-1",
1126        "01/23/-9",
1127        "11/12/1314",
1128        "10/31/1",
1129        "09/12/+1",
1130        "09/12/001",
1131    };
1132    int32_t STRINGS_COUNT = (int32_t)(sizeof(STRINGS) / sizeof(STRINGS[0]));
1133    UDate FAIL_DATE = (UDate) 0;
1134    UDate DATES[] = {
1135        date(2000-1900, UCAL_FEBRUARY, 29),
1136        date(2001-1900, UCAL_JANUARY,  23),
1137        date(  -1-1900, UCAL_APRIL,     5),
1138        date(  -9-1900, UCAL_JANUARY,  23),
1139        date(1314-1900, UCAL_NOVEMBER, 12),
1140        date(   1-1900, UCAL_OCTOBER,  31),
1141        FAIL_DATE, // "+1" isn't recognized by US NumberFormat
1142        date(   1-1900, UCAL_SEPTEMBER,12),
1143    };
1144
1145    UnicodeString out;
1146    UBool pass = TRUE;
1147    for (int32_t i=0; i<STRINGS_COUNT; ++i) {
1148        UnicodeString str(STRINGS[i]);
1149        UDate expected = DATES[i];
1150        status = U_ZERO_ERROR;
1151        UDate actual = fmt.parse(str, status);
1152        if (U_FAILURE(status)) {
1153            actual = FAIL_DATE;
1154        }
1155        UnicodeString actStr;
1156        if (actual == FAIL_DATE) {
1157            actStr.append("null");
1158        } else {
1159            // Yuck: See j25
1160            ((DateFormat*)&dispFmt)->format(actual, actStr);
1161        }
1162
1163        if (expected == actual) {
1164            out.append(str + " => " + actStr + "\n");
1165        } else {
1166            UnicodeString expStr;
1167            if (expected == FAIL_DATE) {
1168                expStr.append("null");
1169            } else {
1170                // Yuck: See j25
1171                ((DateFormat*)&dispFmt)->format(expected, expStr);
1172            }
1173            out.append("FAIL: " + str + " => " + actStr
1174                       + ", expected " + expStr + "\n");
1175            pass = FALSE;
1176        }
1177    }
1178    if (pass) {
1179        log(out);
1180    } else {
1181        err(out);
1182    }
1183}
1184
1185/**
1186 * j32 {JDK Bug 4210209 4209272}
1187 * DateFormat cannot parse Feb 29 2000 when setLenient(false)
1188 */
1189void
1190DateFormatRegressionTest::Test4210209(void) {
1191    UErrorCode status = U_ZERO_ERROR;
1192    UnicodeString pattern("MMM d, yyyy");
1193    SimpleDateFormat sfmt(pattern, Locale::getUS(), status);
1194    SimpleDateFormat sdisp("MMM dd yyyy GG", Locale::getUS(), status);
1195    DateFormat& fmt = *(DateFormat*)&sfmt; // Yuck: See j25
1196    DateFormat& disp = *(DateFormat*)&sdisp; // Yuck: See j25
1197    if (U_FAILURE(status)) {
1198        dataerrln("Couldn't create SimpleDateFormat - %s", u_errorName(status));
1199        return;
1200    }
1201    Calendar* calx = (Calendar*)fmt.getCalendar(); // cast away const!
1202    calx->setLenient(FALSE);
1203    UDate d = date(2000-1900, UCAL_FEBRUARY, 29);
1204    UnicodeString s, ss;
1205    fmt.format(d, s);
1206    logln(disp.format(d, ss.remove()) + " f> " + pattern +
1207          " => \"" + s + "\"");
1208    ParsePosition pos(0);
1209    d = fmt.parse(s, pos);
1210    logln(UnicodeString("\"") + s + "\" p> " + pattern +
1211          " => " + disp.format(d, ss.remove()));
1212    logln(UnicodeString("Parse pos = ") + pos.getIndex() +
1213          ", error pos = " + pos.getErrorIndex());
1214    if (pos.getErrorIndex() != -1) {
1215        errln(UnicodeString("FAIL: Error index should be -1"));
1216    }
1217
1218    // The underlying bug is in GregorianCalendar.  If the following lines
1219    // succeed, the bug is fixed.  If the bug isn't fixed, they will throw
1220    // an exception.
1221    GregorianCalendar cal(status);
1222    if (U_FAILURE(status)) {
1223        errln("FAIL: Unable to create Calendar");
1224        return;
1225    }
1226    cal.clear();
1227    cal.setLenient(FALSE);
1228    cal.set(2000, UCAL_FEBRUARY, 29); // This should work!
1229    logln(UnicodeString("Attempt to set Calendar to Feb 29 2000: ") +
1230                        disp.format(cal.getTime(status), ss.remove()));
1231    if (U_FAILURE(status)) {
1232        errln("FAIL: Unable to set Calendar to Feb 29 2000");
1233    }
1234}
1235
1236void DateFormatRegressionTest::Test714(void)
1237{
1238    //try {
1239     UDate d(978103543000.);
1240    DateFormat *fmt = DateFormat::createDateTimeInstance(DateFormat::NONE,
1241                                                         DateFormat::MEDIUM,
1242                                                         Locale::getUS());
1243    if (fmt == NULL) {
1244        dataerrln("Error calling DateFormat::createDateTimeInstance");
1245        return;
1246    }
1247
1248    UnicodeString s;
1249        UnicodeString tests =
1250          (UnicodeString) "7:25:43 AM" ;
1251        UErrorCode status = U_ZERO_ERROR;
1252        fmt->format (d,s);
1253        if(U_FAILURE(status))
1254          {
1255            errln((UnicodeString) "Fail, errmsg " + u_errorName(status));
1256            return;
1257          }
1258
1259        if(s != tests)
1260        {
1261          errln((UnicodeString) "Fail: " + s + " != " + tests);
1262        }
1263        else
1264        {
1265          logln("OK: " + s + " == " + tests);
1266        }
1267
1268   delete fmt;
1269}
1270
1271class Test1684Data {
1272public:
1273  int32_t year;
1274  int32_t month;
1275  int32_t date;
1276  int32_t womyear;
1277  int32_t wommon;
1278  int32_t wom;
1279  int32_t dow;
1280  UnicodeString data;
1281  UnicodeString normalized;
1282
1283  Test1684Data(int32_t xyear, int32_t xmonth, int32_t xdate,
1284               int32_t xwomyear, int32_t xwommon, int32_t xwom, int32_t xdow,
1285               const char *xdata, const char *xnormalized) :
1286    year(xyear),
1287    month(xmonth-1),
1288    date(xdate),
1289    womyear(xwomyear),
1290    wommon(xwommon-1),
1291    wom(xwom),
1292    dow(xdow),
1293    data(xdata,""),
1294    normalized((xnormalized==NULL)?xdata:xnormalized,"")
1295  { }
1296};
1297
1298void DateFormatRegressionTest::Test1684(void)
1299{
1300  //      July 2001            August 2001           January 2002
1301  // Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa  Su Mo Tu We Th Fr Sa
1302  //  1  2  3  4  5  6  7            1  2  3  4         1  2  3  4  5
1303  //  8  9 10 11 12 13 14   5  6  7  8  9 10 11   6  7  8  9 10 11 12
1304  // 15 16 17 18 19 20 21  12 13 14 15 16 17 18  13 14 15 16 17 18 19
1305  // 22 23 24 25 26 27 28  19 20 21 22 23 24 25  20 21 22 23 24 25 26
1306  // 29 30 31              26 27 28 29 30 31     27 28 29 30 31
1307  Test1684Data *tests[] = {
1308    new Test1684Data(2001, 8,  6,  2001,8,2,UCAL_MONDAY,    "2001 08 02 Mon", NULL),
1309    new Test1684Data(2001, 8,  7,  2001,8,2,UCAL_TUESDAY,   "2001 08 02 Tue", NULL),
1310    new Test1684Data(2001, 8,  5,/*12,*/ 2001,8,2,UCAL_SUNDAY,    "2001 08 02 Sun", NULL),
1311    new Test1684Data(2001, 8,6, /*7,  30,*/ 2001,7,6,UCAL_MONDAY,    "2001 07 06 Mon", "2001 08 02 Mon"),
1312    new Test1684Data(2001, 8,7, /*7,  31,*/ 2001,7,6,UCAL_TUESDAY,   "2001 07 06 Tue", "2001 08 02 Tue"),
1313    new Test1684Data(2001, 8,  5,  2001,7,6,UCAL_SUNDAY,    "2001 07 06 Sun", "2001 08 02 Sun"),
1314    new Test1684Data(2001, 7,  30, 2001,8,1,UCAL_MONDAY,    "2001 08 01 Mon", "2001 07 05 Mon"),
1315    new Test1684Data(2001, 7,  31, 2001,8,1,UCAL_TUESDAY,   "2001 08 01 Tue", "2001 07 05 Tue"),
1316    new Test1684Data(2001, 7,29, /*8,  5,*/  2001,8,1,UCAL_SUNDAY,    "2001 08 01 Sun", "2001 07 05 Sun"),
1317    new Test1684Data(2001, 12, 31, 2001,12,6,UCAL_MONDAY,   "2001 12 06 Mon", NULL),
1318    new Test1684Data(2002, 1,  1,  2002,1,1,UCAL_TUESDAY,   "2002 01 01 Tue", NULL),
1319    new Test1684Data(2002, 1,  2,  2002,1,1,UCAL_WEDNESDAY, "2002 01 01 Wed", NULL),
1320    new Test1684Data(2002, 1,  3,  2002,1,1,UCAL_THURSDAY,  "2002 01 01 Thu", NULL),
1321    new Test1684Data(2002, 1,  4,  2002,1,1,UCAL_FRIDAY,    "2002 01 01 Fri", NULL),
1322    new Test1684Data(2002, 1,  5,  2002,1,1,UCAL_SATURDAY,  "2002 01 01 Sat", NULL),
1323    new Test1684Data(2001,12,30, /*2002, 1,  6,*/  2002,1,1,UCAL_SUNDAY,    "2002 01 01 Sun", "2001 12 06 Sun")
1324  };
1325
1326#define kTest1684Count  ((int32_t)(sizeof(tests)/sizeof(tests[0])))
1327
1328  int32_t pass = 0, error = 0, warning = 0;
1329  int32_t i;
1330
1331  UErrorCode status = U_ZERO_ERROR;
1332  UnicodeString pattern("yyyy MM WW EEE","");
1333  Calendar *cal = new GregorianCalendar(status);
1334  SimpleDateFormat *sdf = new SimpleDateFormat(pattern,status);
1335  if (U_FAILURE(status)) {
1336    dataerrln("Error constructing SimpleDateFormat");
1337    for(i=0;i<kTest1684Count;i++) {
1338        delete tests[i];
1339    }
1340    delete cal;
1341    delete sdf;
1342    return;
1343  }
1344  cal->setFirstDayOfWeek(UCAL_SUNDAY);
1345  cal->setMinimalDaysInFirstWeek(1);
1346
1347  sdf->adoptCalendar(cal);
1348
1349  cal = sdf->getCalendar()->clone(); // sdf may have deleted calendar
1350
1351  if(!cal || !sdf || U_FAILURE(status)) {
1352    errln(UnicodeString("Error setting up test: ") + u_errorName(status));
1353  }
1354
1355  for (i = 0; i < kTest1684Count; ++i) {
1356    Test1684Data &test = *(tests[i]);
1357    logln(UnicodeString("#") + i + UnicodeString("\n-----\nTesting round trip of ") + test.year +
1358        " " + (test.month + 1) +
1359        " " + test.date +
1360          " (written as) " + test.data);
1361
1362    cal->clear();
1363    cal->set(test.year, test.month, test.date);
1364    UDate ms = cal->getTime(status);
1365
1366    cal->clear();
1367    cal->set(UCAL_YEAR, test.womyear);
1368    cal->set(UCAL_MONTH, test.wommon);
1369    cal->set(UCAL_WEEK_OF_MONTH, test.wom);
1370    cal->set(UCAL_DAY_OF_WEEK, test.dow);
1371    UDate ms2 = cal->getTime(status);
1372
1373    if (ms2 != ms) {
1374      errln((UnicodeString)"\nError: GregorianUCAL_DOM gave " + ms +
1375            "\n       GregorianUCAL_WOM gave " + ms2);
1376      error++;
1377    } else {
1378      pass++;
1379    }
1380
1381    ms2 = sdf->parse(test.data, status);
1382    if(U_FAILURE(status)) {
1383      errln("parse exception: " + UnicodeString(u_errorName(status)));
1384    }
1385
1386    if (ms2!=ms) {
1387      errln((UnicodeString)"\nError: GregorianCalendar gave      " + ms +
1388            "\n       SimpleDateFormat.parse gave " + ms2);
1389      error++;
1390    } else {
1391      pass++;
1392    }
1393
1394    UnicodeString result;
1395    sdf->format(ms, result);
1396    if (result != test.normalized) {
1397      errln("\nWarning: format of '" + test.data + "' gave" +
1398            "\n                   '" + result + "'" +
1399            "\n          expected '" + test.normalized + "'");
1400      warning++;
1401    } else {
1402      pass++;
1403    }
1404
1405    UDate ms3;
1406    ms3 = sdf->parse(result, status);
1407    if(U_FAILURE(status)) {
1408      errln("parse exception 2: " + (UnicodeString)u_errorName(status));
1409    }
1410
1411    if (ms3!=ms) {
1412      error++;
1413      errln((UnicodeString)"\nError: Re-parse of '" + result + "' gave time of " +
1414          "\n        " + ms3 +
1415          "\n    not " + ms);
1416    } else {
1417      pass++;
1418            }
1419  }
1420
1421  UnicodeString info
1422    = UnicodeString("Passed: ") + pass + ", Warnings: " + warning + ", Errors: " + error;
1423  if (error > 0) {
1424    errln(info);
1425  } else {
1426    logln(info);
1427  }
1428
1429  for(i=0;i<kTest1684Count;i++) {
1430    delete tests[i];
1431  }
1432  delete cal;
1433  delete sdf;
1434}
1435
1436void DateFormatRegressionTest::Test5554(void)
1437{
1438  UErrorCode status = U_ZERO_ERROR;
1439  UnicodeString pattern("Z","");
1440  UnicodeString newfoundland("Canada/Newfoundland", "");
1441  TimeZone *zone = TimeZone::createTimeZone(newfoundland);
1442  Calendar *cal = new GregorianCalendar(zone, status);
1443  SimpleDateFormat *sdf = new SimpleDateFormat(pattern,status);
1444  if (U_FAILURE(status)) {
1445    dataerrln("Error constructing SimpleDateFormat");
1446    delete cal;
1447    delete sdf;
1448    return;
1449  }
1450  cal->set(2007, 1, 14);
1451  UDate date = cal->getTime(status);
1452  if (U_FAILURE(status)) {
1453    errln("Error getting time to format");
1454    return;
1455  };
1456  sdf->adoptCalendar(cal);
1457  UnicodeString result;
1458  UnicodeString correct("-0330", "");
1459  sdf->format(date, result);
1460  if (result != correct) {
1461    errln("\nError: Newfoundland Z of Jan 14, 2007 gave '" + result + "', expected '" + correct + "'");
1462  }
1463  delete sdf;
1464}
1465
1466void DateFormatRegressionTest::Test9237(void)
1467{
1468    UErrorCode status = U_ZERO_ERROR;
1469    UnicodeString pattern("VVVV");
1470
1471    SimpleDateFormat fmt(pattern, status);  // default locale
1472    SimpleDateFormat fmtDE(pattern, Locale("de_DE"), status);
1473    if (U_FAILURE(status)) {
1474        dataerrln("Error constructing SimpleDateFormat");
1475        return;
1476    }
1477
1478    // copy constructor
1479    SimpleDateFormat fmtCopyDE(fmtDE);
1480    UnicodeString resDE, resCopyDE;
1481
1482    fmtDE.format(0.0, resDE);
1483    fmtCopyDE.format(0.0, resCopyDE);
1484
1485    if (resDE != resCopyDE) {
1486        errln(UnicodeString("Error: different result by the copied instance - org:") + resDE + " copy:" + resCopyDE);
1487    }
1488
1489    // test for assignment operator
1490    fmt = fmtDE;
1491
1492    UnicodeString resAssigned;
1493    fmt.format(0.0, resAssigned);
1494
1495    if (resDE != resAssigned) {
1496        errln(UnicodeString("Error: different results by the assigned instance - org:") + resDE + " assigned:" + resAssigned);
1497    }
1498}
1499
1500void DateFormatRegressionTest::TestParsing(void) {
1501    UErrorCode status = U_ZERO_ERROR;
1502    UnicodeString pattern("EEE-WW-MMMM-yyyy");
1503    UnicodeString text("mon-02-march-2011");
1504    int32_t expectedDay = 7;
1505
1506    SimpleDateFormat format(pattern, status);
1507    if (U_FAILURE(status)) {
1508        dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status));
1509        return;
1510    }
1511
1512    Calendar *cal = new GregorianCalendar(status);
1513    if (cal == NULL || U_FAILURE(status)) {
1514        errln("Unable to create calendar - %s", u_errorName(status));
1515        return;
1516    }
1517
1518    ParsePosition pos(0);
1519    format.parse(text, *cal, pos);
1520
1521    if (cal->get(UCAL_DAY_OF_MONTH, status) != expectedDay) {
1522        errln("Parsing failed: day of month should be '7' with pattern: \"" + pattern + "\" for text: \"" + text + "\"");
1523    }
1524
1525    delete cal;
1526}
1527
1528#endif /* #if !UCONFIG_NO_FORMATTING */
1529
1530//eof
1531