Index: source/test/intltest/dtfmrgts.cpp |
diff --git a/source/test/intltest/dtfmrgts.cpp b/source/test/intltest/dtfmrgts.cpp |
deleted file mode 100644 |
index c4db716a7396de666d2801709e895190152a0ccf..0000000000000000000000000000000000000000 |
--- a/source/test/intltest/dtfmrgts.cpp |
+++ /dev/null |
@@ -1,1726 +0,0 @@ |
-/******************************************************************** |
- * COPYRIGHT: |
- * Copyright (c) 1997-2015, 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) |
- CASE(27,Test9237) |
- CASE(28,TestParsing) |
- CASE(29,TestT10334) |
- CASE(30,TestT10619) |
- CASE(31,TestT10855) |
- CASE(32,TestT10906) |
- 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"); |
- |
- // this is an odd usage of "ddd" and it doesn't |
- // work now that date values are range checked per #3579. |
- 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(\"35/01/1971\")"); |
- //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 [sic] 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("MM/dd/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(UnicodeString("beginIndex = ") + fp.getBeginIndex()); |
- logln(UnicodeString("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(UnicodeString("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; |
-} |
- |
-void DateFormatRegressionTest::Test9237(void) |
-{ |
- UErrorCode status = U_ZERO_ERROR; |
- UnicodeString pattern("VVVV"); |
- |
- SimpleDateFormat fmt(pattern, status); // default locale |
- SimpleDateFormat fmtDE(pattern, Locale("de_DE"), status); |
- if (U_FAILURE(status)) { |
- dataerrln("Error constructing SimpleDateFormat"); |
- return; |
- } |
- |
- // copy constructor |
- SimpleDateFormat fmtCopyDE(fmtDE); |
- UnicodeString resDE, resCopyDE; |
- |
- fmtDE.format(0.0, resDE); |
- fmtCopyDE.format(0.0, resCopyDE); |
- |
- if (resDE != resCopyDE) { |
- errln(UnicodeString("Error: different result by the copied instance - org:") + resDE + " copy:" + resCopyDE); |
- } |
- |
- // test for assignment operator |
- fmt = fmtDE; |
- |
- UnicodeString resAssigned; |
- fmt.format(0.0, resAssigned); |
- |
- if (resDE != resAssigned) { |
- errln(UnicodeString("Error: different results by the assigned instance - org:") + resDE + " assigned:" + resAssigned); |
- } |
-} |
- |
-void DateFormatRegressionTest::TestParsing(void) { |
- UErrorCode status = U_ZERO_ERROR; |
- UnicodeString pattern("EEE-WW-MMMM-yyyy"); |
- UnicodeString text("mon-02-march-2011"); |
- int32_t expectedDay = 7; |
- |
- SimpleDateFormat format(pattern, status); |
- if (U_FAILURE(status)) { |
- dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); |
- return; |
- } |
- |
- Calendar *cal = new GregorianCalendar(status); |
- if (cal == NULL || U_FAILURE(status)) { |
- errln("Unable to create calendar - %s", u_errorName(status)); |
- return; |
- } |
- |
- ParsePosition pos(0); |
- format.parse(text, *cal, pos); |
- |
- if (cal->get(UCAL_DAY_OF_MONTH, status) != expectedDay) { |
- errln("Parsing failed: day of month should be '7' with pattern: \"" + pattern + "\" for text: \"" + text + "\""); |
- } |
- |
- delete cal; |
-} |
- |
-void DateFormatRegressionTest::TestT10334(void) { |
- UErrorCode status = U_ZERO_ERROR; |
- UnicodeString pattern("'--: 'EEE-WW-MMMM-yyyy"); |
- UnicodeString text("--mon-02-march-2011"); |
- SimpleDateFormat format(pattern, status); |
- |
- logln("pattern["+pattern+"] text["+text+"]"); |
- |
- if (U_FAILURE(status)) { |
- dataerrln("Fail creating SimpleDateFormat object - %s", u_errorName(status)); |
- return; |
- } |
- |
- format.setBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, FALSE, status); |
- format.parse(text, status); |
- if (!U_FAILURE(status)) { |
- errln("parse partial match did NOT fail in strict mode - %s", u_errorName(status)); |
- } |
- |
- status = U_ZERO_ERROR; |
- format.setBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, TRUE, status); |
- format.parse(text, status); |
- if (U_FAILURE(status)) { |
- errln("parse partial match failure in lenient mode - %s", u_errorName(status)); |
- } |
- |
- status = U_ZERO_ERROR; |
- pattern = UnicodeString("YYYY MM dd"); |
- text = UnicodeString("2013 12 10"); |
- format.applyPattern(pattern); |
- UDate referenceDate = format.parse(text, status); |
- |
- FieldPosition fp(0); |
- UnicodeString formattedString(""); |
- pattern = UnicodeString("YYYY LL dd ee cc qq QQ"); |
- format.applyPattern(pattern); |
- format.format(referenceDate, formattedString, fp, status); |
- logln("ref date: " + formattedString); |
- |
- |
- char patternArray[] = "YYYY LLL dd eee ccc qqq QQQ"; |
- pattern = UnicodeString(patternArray); |
- text = UnicodeString("2013 12 10 03 3 04 04"); |
- status = U_ZERO_ERROR; |
- format.setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, TRUE, status); |
- format.applyPattern(pattern); |
- ParsePosition pp(0); |
- format.parse(text, pp); |
- if (pp.getErrorIndex() != -1) { |
- errln("numeric parse error"); |
- } |
- |
- status = U_ZERO_ERROR; |
- format.setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, FALSE, status); |
- format.parse(text, status); |
- if (!U_FAILURE(status)) { |
- errln("numeric parse did NOT fail in strict mode", u_errorName(status)); |
- } |
- |
-} |
- |
- |
-typedef struct { |
- const char * locale; |
- UBool leniency; |
- UnicodeString parseString; |
- UnicodeString pattern; |
- UnicodeString expectedResult; // null indicates expected error |
-} TestDateFormatLeniencyItem; |
- |
- |
-void DateFormatRegressionTest::TestT10619(void) { |
- const UDate july022008 = 1215000001979.0; |
- const TestDateFormatLeniencyItem items[] = { |
- //locale leniency parse String pattern expected result |
- { "en", true, UnicodeString("2008-07 02"), UnicodeString("yyyy-LLLL dd"), UnicodeString("2008-July 02") }, |
- { "en", false, UnicodeString("2008-07 03"), UnicodeString("yyyy-LLLL dd"), UnicodeString("") }, |
- { "en", true, UnicodeString("2008-Jan. 04"), UnicodeString("yyyy-LLL dd"), UnicodeString("2008-Jan 04") }, |
- { "en", false, UnicodeString("2008-Jan. 05"), UnicodeString("yyyy-LLL dd"), UnicodeString("") }, |
- { "en", true, UnicodeString("2008-Jan--06"), UnicodeString("yyyy-MMM -- dd"), UnicodeString("2008-Jan 06") }, |
- { "en", false, UnicodeString("2008-Jan--07"), UnicodeString("yyyy-MMM -- dd"), UnicodeString("") }, |
- { "en", true, UnicodeString("6 Jan 08 2008"), UnicodeString("eee MMM dd yyyy"), UnicodeString("Sat Jan 08 2008") }, |
- { "en", false, UnicodeString("6 Jan 09 2008"), UnicodeString("eee MMM dd yyyy"), UnicodeString("") }, |
- // terminator |
- { NULL, true, UnicodeString(""), UnicodeString(""), UnicodeString("") } |
- }; |
- UErrorCode status = U_ZERO_ERROR; |
- Calendar* cal = Calendar::createInstance(status); |
- if (U_FAILURE(status)) { |
- dataerrln(UnicodeString("FAIL: Unable to create Calendar for default timezone and locale.")); |
- } else { |
- cal->setTime(july022008, status); |
- const TestDateFormatLeniencyItem * itemPtr; |
- for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) { |
- |
- Locale locale = Locale::createFromName(itemPtr->locale); |
- status = U_ZERO_ERROR; |
- ParsePosition pos(0); |
- SimpleDateFormat * sdmft = new SimpleDateFormat(itemPtr->pattern, locale, status); |
- if (U_FAILURE(status)) { |
- dataerrln("Unable to create SimpleDateFormat - %s", u_errorName(status)); |
- continue; |
- } |
- logln("parsing " + itemPtr->parseString); |
- sdmft->setLenient(itemPtr->leniency); |
- sdmft->setBooleanAttribute(UDAT_PARSE_ALLOW_WHITESPACE, itemPtr->leniency, status); |
- sdmft->setBooleanAttribute(UDAT_PARSE_ALLOW_NUMERIC, itemPtr->leniency, status); |
- sdmft->setBooleanAttribute(UDAT_PARSE_PARTIAL_LITERAL_MATCH, itemPtr->leniency, status); |
- sdmft->parse(itemPtr->parseString, pos); |
- |
- delete sdmft; |
- if(pos.getErrorIndex() > -1) { |
- if(itemPtr->expectedResult.length() != 0) { |
- errln("error: unexpected error - " + itemPtr->parseString + " - error index " + pos.getErrorIndex() + |
- " - leniency " + itemPtr->leniency); |
- continue; |
- } else { |
- continue; |
- } |
- } |
- } |
- } |
- delete cal; |
- |
-} |
- |
- |
-typedef struct { |
- UnicodeString text; |
- UnicodeString pattern; |
- int initialParsePos; |
-} T10855Data; |
- |
-void DateFormatRegressionTest::TestT10855(void) { |
- // NOTE: these should NOT parse |
- const T10855Data items[] = { |
- //parse String pattern initial parse pos |
- { UnicodeString("September 30, 1998"), UnicodeString("MM-dd-yyyy"), 0}, |
- { UnicodeString("123-73-1950"), UnicodeString("MM-dd-yyyy"), -1}, |
- { UnicodeString("12-23-1950"), UnicodeString("MM-dd-yyyy"), -1}, |
- // terminator |
- { UnicodeString(""), UnicodeString(""), 0} |
- }; |
- UErrorCode status = U_ZERO_ERROR; |
- |
- int x = 0; |
- while(items[x].pattern.length() > 0) |
- { |
- status = U_ZERO_ERROR; |
- logln("Date to parse: \""+items[x].text+"\""); |
- logln("Starting Index: %d", items[x].initialParsePos); |
- |
- SimpleDateFormat dateFmt(items[x].pattern, status); |
- if(U_FAILURE(status)) { |
- errcheckln(status, "Failed dateFmt: %s", u_errorName(status)); |
- ++x; |
- continue; |
- } |
- status = U_ZERO_ERROR; |
- |
- dateFmt.setLenient(false); |
- dateFmt.setTimeZone(*TimeZone::getGMT()); |
- |
- ParsePosition position(items[x].initialParsePos); |
- logln("set position is now: %d", position.getIndex()); |
- UDate d = dateFmt.parse(items[x].text, position); |
- if (position.getErrorIndex() != -1 || position.getIndex() == items[x].initialParsePos) { |
- logln("Parse Failed. ErrorIndex is %d - Index is %d", position.getErrorIndex(), position.getIndex()); |
- } else { |
- errln("Parse Succeeded...should have failed. Index is %d - ErrorIndex is %d", position.getIndex(), position.getErrorIndex()); |
- } |
- logln("Parsed date returns %d\n", d); |
- |
- ++x; |
- } |
-} |
- |
-void DateFormatRegressionTest::TestT10906(void) { |
- |
- UErrorCode status = U_ZERO_ERROR; |
- UnicodeString pattern = "MM-dd-yyyy"; |
- UnicodeString text = "06-10-2014"; |
- SimpleDateFormat format(pattern, status); |
- int32_t errorIdx = 0; |
- ParsePosition pp(-1); |
- format.parse(text, pp); |
- errorIdx = pp.getErrorIndex(); |
- if (errorIdx == -1) { |
- errln("failed to report invalid (negative) starting parse position"); |
- } |
-} |
- |
-#endif /* #if !UCONFIG_NO_FORMATTING */ |
- |
-//eof |