/******************************************************************** * COPYRIGHT: * Copyright (c) 1997-2001, International Business Machines Corporation and * others. All Rights Reserved. ********************************************************************/ #include "unicode/utypes.h" #if !UCONFIG_NO_FORMATTING #include "calregts.h" #include "unicode/gregocal.h" #include "unicode/simpletz.h" #include "unicode/smpdtfmt.h" #include "unicode/strenum.h" #include "cmemory.h" #include // ***************************************************************************** // class CalendarRegressionTest // ***************************************************************************** // these numbers correspond to using LONG_MIN and LONG_MAX in Java // this is 2^52 - 1, the largest allowable mantissa with a 0 exponent in a 64-bit double const UDate CalendarRegressionTest::EARLIEST_SUPPORTED_MILLIS = - 4503599627370495.0; const UDate CalendarRegressionTest::LATEST_SUPPORTED_MILLIS = 4503599627370495.0; #define CASE(id,test) case id: name = #test; if (exec) { logln(#test "---"); logln((UnicodeString)""); test(); } break void CalendarRegressionTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) { // if (exec) logln((UnicodeString)"TestSuite NumberFormatRegressionTest"); switch (index) { CASE(0,test4100311); CASE(1,test4074758); CASE(2,test4028518); CASE(3,test4031502); CASE(4,test4035301); CASE(5,test4040996); CASE(6,test4051765); CASE(7,test4061476); CASE(8,test4070502); CASE(9,test4071197); CASE(10,test4071385); CASE(11,test4073929); CASE(12,test4083167); CASE(13,test4086724); CASE(14,test4095407); CASE(15,test4096231); CASE(16,test4096539); CASE(17,test41003112); CASE(18,test4103271); CASE(19,test4106136); CASE(20,test4108764); CASE(21,test4114578); CASE(22,test4118384); CASE(23,test4125881); CASE(24,test4125892); CASE(25,test4141665); CASE(26,test4142933); CASE(27,test4145158); CASE(28,test4145983); CASE(29,test4147269); CASE(30,Test4149677); CASE(31,Test4162587); CASE(32,Test4165343); CASE(33,Test4166109); CASE(34,Test4167060); CASE(35,Test4197699); CASE(36,TestJ81); CASE(37,TestJ438); CASE(38,TestLeapFieldDifference); CASE(39,TestMalaysianInstance); CASE(40,test4059654); CASE(41,test4092362); CASE(42,TestWeekShift); CASE(43,TestTimeZoneTransitionAdd); default: name = ""; break; } } const char* CalendarRegressionTest::FIELD_NAME [] = { "ERA", "YEAR", "MONTH", "WEEK_OF_YEAR", "WEEK_OF_MONTH", "DAY_OF_MONTH", "DAY_OF_YEAR", "DAY_OF_WEEK", "DAY_OF_WEEK_IN_MONTH", "AM_PM", "HOUR", "HOUR_OF_DAY", "MINUTE", "SECOND", "MILLISECOND", "ZONE_OFFSET", "DST_OFFSET", "YEAR_WOY", "DOW_LOCAL" }; UBool CalendarRegressionTest::failure(UErrorCode status, const char* msg) { if(U_FAILURE(status)) { errln(UnicodeString("FAIL: ") + msg + " failed, error " + u_errorName(status)); return TRUE; } return FALSE; } /* * bug 4100311 */ void CalendarRegressionTest::test4100311() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *cal = (GregorianCalendar*)Calendar::createInstance(status); failure(status, "Calendar::createInstance(status)"); cal->set(UCAL_YEAR, 1997); cal->set(UCAL_DAY_OF_YEAR, 1); UDate d = cal->getTime(status); // Should be Jan 1 failure(status, "cal->getTime"); logln(UnicodeString("") + d); delete cal; } /** * @bug 4074758 */ void CalendarRegressionTest::test4074758() { //Set system time to between 12-1 (am or pm) and then run UErrorCode status = U_ZERO_ERROR; GregorianCalendar *cal = new GregorianCalendar(status); failure(status, "new GregorianCalendar"); for (int32_t h=0; h<25; ++h) { cal->set(97, UCAL_JANUARY, 1, h, 34); //System.out.print(d); logln(UnicodeString("HOUR=") + cal->get(UCAL_HOUR, status)); //prints 0 failure(status, "cal->get"); logln(UnicodeString("HOUR_OF_DAY=") + cal->get(UCAL_HOUR_OF_DAY, status)); failure(status, "cal->get"); } delete cal; } void CalendarRegressionTest::test4028518() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *cal1 = new GregorianCalendar(status) ; failure(status, "new GregorianCalendar"); GregorianCalendar *cal2 = (GregorianCalendar*) cal1->clone() ; printdate(cal1, "cal1: ") ; printdate(cal2, "cal2 - cloned(): ") ; cal1->add(UCAL_DATE, 1, status) ; failure(status, "cal1->add"); printdate(cal1, "cal1 after adding 1 day:") ; printdate(cal2, "cal2 should be unmodified:") ; delete cal1; delete cal2; } void CalendarRegressionTest::printdate(GregorianCalendar *cal, const char *string) { UErrorCode status = U_ZERO_ERROR; logln(UnicodeString(string, "")); log(UnicodeString("") + cal->get(UCAL_MONTH, status)) ; failure(status, "cal->get"); int32_t date = cal->get(UCAL_DATE, status) + 1 ; failure(status, "cal->get"); log(UnicodeString("/") + date) ; logln(UnicodeString("/") + cal->get(UCAL_YEAR, status)) ; failure(status, "cal->get"); } /** * @bug 4031502 */ void CalendarRegressionTest::test4031502() { // This bug actually occurs on Windows NT as well, and doesn't // require the host zone to be set; it can be set in Java. UErrorCode status = U_ZERO_ERROR; int32_t count = 0; StringEnumeration* ids = TimeZone::createEnumeration(); UBool bad = FALSE; for (int32_t i=0; icount(status); ++i) { TimeZone *zone = TimeZone::createTimeZone(*ids->snext(status)); GregorianCalendar *cal = new GregorianCalendar(zone, status); failure(status, "new GregorianCalendar"); cal->clear(); cal->set(1900, 15, 5, 5, 8, 13); if (cal->get(UCAL_HOUR, status) != 5 || U_FAILURE(status)) { UnicodeString temp; logln(zone->getID(temp) + " " + //zone.useDaylightTime() + " " + cal->get(UCAL_DST_OFFSET,status) / (60*60*1000) + " " + zone->getRawOffset() / (60*60*1000) + ": HOUR = " + cal->get(UCAL_HOUR,status)); bad = TRUE; } delete cal; } if (bad) errln("TimeZone problems with GC"); // delete [] ids; // TODO: bad APIs delete ids; } /** * @bug 4035301 */ void CalendarRegressionTest::test4035301() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *c = new GregorianCalendar(98, 8, 7,status); GregorianCalendar *d = new GregorianCalendar(98, 8, 7,status); if (c->after(*d,status) || c->after(*c,status) || c->before(*d,status) || c->before(*c,status) || *c != *c || *c != *d) errln("Fail"); delete c; delete d; } /** * @bug 4040996 */ void CalendarRegressionTest::test4040996() { int32_t count = 0; StringEnumeration* ids = TimeZone::createEnumeration(-8 * 60 * 60 * 1000); UErrorCode status = U_ZERO_ERROR; count = ids->count(status); SimpleTimeZone *pdt = new SimpleTimeZone(-8 * 60 * 60 * 1000, *ids->snext(status)); pdt->setStartRule(UCAL_APRIL, 1, UCAL_SUNDAY, 2 * 60 * 60 * 1000, status); pdt->setEndRule(UCAL_OCTOBER, -1, UCAL_SUNDAY, 2 * 60 * 60 * 1000, status); Calendar *calendar = new GregorianCalendar(pdt, status); calendar->set(UCAL_MONTH,3); calendar->set(UCAL_DATE,18); calendar->set(UCAL_SECOND, 30); logln(UnicodeString("MONTH: ") + calendar->get(UCAL_MONTH, status)); logln(UnicodeString("DAY_OF_MONTH: ") + calendar->get(UCAL_DATE, status)); logln(UnicodeString("MINUTE: ") + calendar->get(UCAL_MINUTE, status)); logln(UnicodeString("SECOND: ") + calendar->get(UCAL_SECOND, status)); calendar->add(UCAL_SECOND,6, status); //This will print out todays date for MONTH and DAY_OF_MONTH //instead of the date it was set to. //This happens when adding MILLISECOND or MINUTE also logln(UnicodeString("MONTH: ") + calendar->get(UCAL_MONTH, status)); logln(UnicodeString("DAY_OF_MONTH: ") + calendar->get(UCAL_DATE, status)); logln(UnicodeString("MINUTE: ") + calendar->get(UCAL_MINUTE, status)); logln(UnicodeString("SECOND: ") + calendar->get(UCAL_SECOND, status)); if (calendar->get(UCAL_MONTH, status) != 3 || calendar->get(UCAL_DATE, status) != 18 || calendar->get(UCAL_SECOND, status) != 36) errln(UnicodeString("Fail: Calendar::add misbehaves")); delete calendar; delete ids; // delete ids; // TODO: BAD API } /** * @bug 4051765 */ void CalendarRegressionTest::test4051765() { UErrorCode status = U_ZERO_ERROR; Calendar *cal = Calendar::createInstance(status); cal->setLenient(FALSE); cal->set(UCAL_DAY_OF_WEEK, 0); //try { cal->getTime(status); if( ! U_FAILURE(status)) errln("Fail: DAY_OF_WEEK 0 should be disallowed"); /*} catch (IllegalArgumentException e) { return; }*/ delete cal; } /* User error - no bug here void CalendarRegressionTest::test4059524() { // Create calendar for April 10, 1997 GregorianCalendar calendar = new GregorianCalendar(status); // print out a bunch of interesting things logln("ERA: " + Calendar::get(Calendar::ERA)); logln("YEAR: " + Calendar::get(Calendar::YEAR)); logln("MONTH: " + Calendar::get(Calendar::MONTH)); logln("WEEK_OF_YEAR: " + Calendar::get(Calendar::WEEK_OF_YEAR)); logln("WEEK_OF_MONTH: " + Calendar::get(Calendar::WEEK_OF_MONTH)); logln("DATE: " + Calendar::get(Calendar::DATE)); logln("DAY_OF_MONTH: " + Calendar::get(Calendar::DAY_OF_MONTH)); logln("DAY_OF_YEAR: " + Calendar::get(Calendar::DAY_OF_YEAR)); logln("DAY_OF_WEEK: " + Calendar::get(Calendar::DAY_OF_WEEK)); logln("DAY_OF_WEEK_IN_MONTH: " + Calendar::get(Calendar::DAY_OF_WEEK_IN_MONTH)); logln("AM_PM: " + Calendar::get(Calendar::AM_PM)); logln("HOUR: " + Calendar::get(Calendar::HOUR)); logln("HOUR_OF_DAY: " + Calendar::get(Calendar::HOUR_OF_DAY)); logln("MINUTE: " + Calendar::get(Calendar::MINUTE)); logln("SECOND: " + Calendar::get(Calendar::SECOND)); logln("MILLISECOND: " + Calendar::get(Calendar::MILLISECOND)); logln("ZONE_OFFSET: " + (Calendar::get(Calendar::ZONE_OFFSET)/(60*60*1000))); logln("DST_OFFSET: " + (Calendar::get(Calendar::DST_OFFSET)/(60*60*1000))); calendar = new GregorianCalendar(1997,3,10); Calendar::getTime(); logln("April 10, 1997"); logln("ERA: " + Calendar::get(Calendar::ERA)); logln("YEAR: " + Calendar::get(Calendar::YEAR)); logln("MONTH: " + Calendar::get(Calendar::MONTH)); logln("WEEK_OF_YEAR: " + Calendar::get(Calendar::WEEK_OF_YEAR)); logln("WEEK_OF_MONTH: " + Calendar::get(Calendar::WEEK_OF_MONTH)); logln("DATE: " + Calendar::get(Calendar::DATE)); logln("DAY_OF_MONTH: " + Calendar::get(Calendar::DAY_OF_MONTH)); logln("DAY_OF_YEAR: " + Calendar::get(Calendar::DAY_OF_YEAR)); logln("DAY_OF_WEEK: " + Calendar::get(Calendar::DAY_OF_WEEK)); logln("DAY_OF_WEEK_IN_MONTH: " + Calendar::get(Calendar::DAY_OF_WEEK_IN_MONTH)); logln("AM_PM: " + Calendar::get(Calendar::AM_PM)); logln("HOUR: " + Calendar::get(Calendar::HOUR)); logln("HOUR_OF_DAY: " + Calendar::get(Calendar::HOUR_OF_DAY)); logln("MINUTE: " + Calendar::get(Calendar::MINUTE)); logln("SECOND: " + Calendar::get(Calendar::SECOND)); logln("MILLISECOND: " + Calendar::get(Calendar::MILLISECOND)); logln("ZONE_OFFSET: " + (Calendar::get(Calendar::ZONE_OFFSET)/(60*60*1000))); // in hours logln("DST_OFFSET: " + (Calendar::get(Calendar::DST_OFFSET)/(60*60*1000))); // in hours } */ /** * @bug 4059654 */ void CalendarRegressionTest::test4059654() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *gc = new GregorianCalendar(status); gc->set(1997, 3, 1, 15, 16, 17); // April 1, 1997 gc->set(UCAL_HOUR, 0); gc->set(UCAL_AM_PM, UCAL_AM); gc->set(UCAL_MINUTE, 0); gc->set(UCAL_SECOND, 0); gc->set(UCAL_MILLISECOND, 0); UDate cd = gc->getTime(status); GregorianCalendar *exp = new GregorianCalendar(1997, 3, 1, 0, 0, 0, status); if (cd != exp->getTime(status)) errln(UnicodeString("Fail: Calendar::set broken. Got ") + cd + " Want " + exp->getTime(status)); delete gc; delete exp; } /** * @bug 4061476 */ void CalendarRegressionTest::test4061476() { UErrorCode status = U_ZERO_ERROR; SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("ddMMMyy"), Locale::getUK(),status); Calendar *cal = Calendar::createInstance(TimeZone::createTimeZone("GMT"), Locale::getUK(),status); fmt->adoptCalendar(cal); // try { UDate date = fmt->parse("29MAY97", status); failure(status, "fmt->parse"); cal->setTime(date, status); failure(status, "cal->setTime"); // } //catch (Exception e) {;} cal->set(UCAL_HOUR_OF_DAY, 13); logln(UnicodeString("Hour: ")+cal->get(UCAL_HOUR_OF_DAY, status)); cal->add(UCAL_HOUR_OF_DAY, 6,status); logln(UnicodeString("Hour: ")+cal->get(UCAL_HOUR_OF_DAY, status)); if (cal->get(UCAL_HOUR_OF_DAY, status) != 19) errln(UnicodeString("Fail: Want 19 Got ") + cal->get(UCAL_HOUR_OF_DAY, status)); delete fmt; } /** * @bug 4070502 */ void CalendarRegressionTest::test4070502() { UErrorCode status = U_ZERO_ERROR; UDate d = getAssociatedDate(makeDate(1998,0,30), status); Calendar *cal = new GregorianCalendar(status); cal->setTime(d,status); if (cal->get(UCAL_DAY_OF_WEEK,status) == UCAL_SATURDAY || cal->get(UCAL_DAY_OF_WEEK,status) == UCAL_SUNDAY) errln(UnicodeString("Fail: Want weekday Got ") + d); delete cal; } /** * Get the associated date starting from a specified date * NOTE: the unnecessary "getTime()'s" below are a work-around for a * bug in jdk 1.1.3 (and probably earlier versions also) *

* @param date The date to start from */ UDate CalendarRegressionTest::getAssociatedDate(UDate d, UErrorCode& status) { GregorianCalendar *cal = new GregorianCalendar(status); cal->setTime(d,status); //cal.add(field, amount); //<-- PROBLEM SEEN WITH field = DATE,MONTH // cal.getTime(); // <--- REMOVE THIS TO SEE BUG for (;;) { int32_t wd = cal->get(UCAL_DAY_OF_WEEK, status); if (wd == UCAL_SATURDAY || wd == UCAL_SUNDAY) { cal->add(UCAL_DATE, 1, status); // cal.getTime(); } else break; } UDate dd = cal->getTime(status); delete cal; return dd; } /** * @bug 4071197 */ void CalendarRegressionTest::test4071197() { dowTest(FALSE); dowTest(TRUE); } void CalendarRegressionTest::dowTest(UBool lenient) { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *cal = new GregorianCalendar(status); cal->set(1997, UCAL_AUGUST, 12); // Wednesday // cal.getTime(); // Force update cal->setLenient(lenient); cal->set(1996, UCAL_DECEMBER, 1); // Set the date to be December 1, 1996 int32_t dow = cal->get(UCAL_DAY_OF_WEEK, status); int32_t min = cal->getMinimum(UCAL_DAY_OF_WEEK); int32_t max = cal->getMaximum(UCAL_DAY_OF_WEEK); //logln(cal.getTime().toString()); if (min != UCAL_SUNDAY || max != UCAL_SATURDAY) errln("FAIL: Min/max bad"); if (dow < min || dow > max) errln(UnicodeString("FAIL: Day of week ") + dow + " out of range"); if (dow != UCAL_SUNDAY) errln("FAIL: Day of week should be SUNDAY Got " + dow); delete cal; } /** * @bug 4071385 */ void CalendarRegressionTest::test4071385() { UErrorCode status = U_ZERO_ERROR; Calendar *cal = Calendar::createInstance(status); cal->setTime(makeDate(1998, UCAL_JUNE, 24),status); cal->set(UCAL_MONTH, UCAL_NOVEMBER); // change a field //logln(cal.getTime().toString()); if (cal->getTime(status) != makeDate(1998, UCAL_NOVEMBER, 24)) errln("Fail"); delete cal; } /** * @bug 4073929 */ void CalendarRegressionTest::test4073929() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *foo1 = new GregorianCalendar(1997, 8, 27,status); foo1->add(UCAL_DATE, + 1, status); int32_t testyear = foo1->get(UCAL_YEAR, status); int32_t testmonth = foo1->get(UCAL_MONTH, status); int32_t testday = foo1->get(UCAL_DATE, status); if (testyear != 1997 || testmonth != 8 || testday != 28) errln("Fail: Calendar not initialized"); delete foo1; } /** * @bug 4083167 */ void CalendarRegressionTest::test4083167() { UErrorCode status = U_ZERO_ERROR; TimeZone *saveZone = TimeZone::createDefault(); //try { TimeZone *newZone = TimeZone::createTimeZone("UTC"); TimeZone::setDefault(*newZone); UDate firstDate = Calendar::getNow(); Calendar *cal = new GregorianCalendar(status); cal->setTime(firstDate,status); int32_t hr = cal->get(UCAL_HOUR_OF_DAY, status); int32_t min = cal->get(UCAL_MINUTE, status); int32_t sec = cal->get(UCAL_SECOND, status); int32_t msec = cal->get(UCAL_MILLISECOND, status); double firstMillisInDay = hr * 3600000 + min * 60000 + sec * 1000 + msec; //logln("Current time: " + firstDate.toString()); for (int32_t validity=0; validity<30; validity++) { UDate lastDate = firstDate + validity*1000*24*60*60.0; cal->setTime(lastDate, status); hr = cal->get(UCAL_HOUR_OF_DAY, status); min = cal->get(UCAL_MINUTE, status); sec = cal->get(UCAL_SECOND, status); msec = cal->get(UCAL_MILLISECOND, status); double millisInDay = hr * 3600000.0 + min * 60000.0 + sec * 1000.0 + msec; if (firstMillisInDay != millisInDay) errln(UnicodeString("Day has shifted ") + lastDate); } //} //finally { TimeZone::setDefault(*saveZone); //} delete saveZone; delete newZone; delete cal; } /** * @bug 4086724 */ void CalendarRegressionTest::test4086724() { UErrorCode status = U_ZERO_ERROR; SimpleDateFormat *date; TimeZone *saveZone = TimeZone::createDefault(); Locale saveLocale = Locale::getDefault(); //try { Locale::setDefault(Locale::getUK(),status); TimeZone *newZone = TimeZone::createTimeZone("GMT"); TimeZone::setDefault(*newZone); date = new SimpleDateFormat(UnicodeString("dd MMM yyy (zzzz) 'is in week' ww"),status); Calendar *cal = Calendar::createInstance(status); cal->set(1997,UCAL_SEPTEMBER,30); UDate now = cal->getTime(status); UnicodeString temp; FieldPosition pos(FieldPosition::DONT_CARE); logln(date->format(now, temp, pos)); cal->set(1997,UCAL_JANUARY,1); now=cal->getTime(status); logln(date->format(now,temp, pos)); cal->set(1997,UCAL_JANUARY,8); now=cal->getTime(status); logln(date->format(now,temp, pos)); cal->set(1996,UCAL_DECEMBER,31); now=cal->getTime(status); logln(date->format(now,temp, pos)); //} //finally { Locale::setDefault(saveLocale,status); TimeZone::setDefault(*saveZone); //} logln("*** THE RESULTS OF THIS TEST MUST BE VERIFIED MANUALLY ***"); delete newZone; delete cal; delete date; delete saveZone; } /** * @bug 4092362 */ void CalendarRegressionTest::test4092362() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *cal1 = new GregorianCalendar(1997, 10, 11, 10, 20, 40,status); /*cal1.set( Calendar::YEAR, 1997 ); cal1.set( Calendar::MONTH, 10 ); cal1.set( Calendar::DATE, 11 ); cal1.set( Calendar::HOUR, 10 ); cal1.set( Calendar::MINUTE, 20 ); cal1.set( Calendar::SECOND, 40 ); */ logln( UnicodeString(" Cal1 = ") + cal1->getTime(status) ); logln( UnicodeString(" Cal1 time in ms = ") + cal1->get(UCAL_MILLISECOND,status) ); for( int32_t k = 0; k < 100 ; k++ ); GregorianCalendar *cal2 = new GregorianCalendar(1997, 10, 11, 10, 20, 40,status); /*cal2.set( Calendar::YEAR, 1997 ); cal2.set( Calendar::MONTH, 10 ); cal2.set( Calendar::DATE, 11 ); cal2.set( Calendar::HOUR, 10 ); cal2.set( Calendar::MINUTE, 20 ); cal2.set( Calendar::SECOND, 40 ); */ logln( UnicodeString(" Cal2 = ") + cal2->getTime(status) ); logln( UnicodeString(" Cal2 time in ms = ") + cal2->get(UCAL_MILLISECOND,status) ); if( *cal1 != *cal2 ) errln("Fail: Milliseconds randomized"); delete cal1; delete cal2; } /** * @bug 4095407 */ void CalendarRegressionTest::test4095407() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *a = new GregorianCalendar(1997,UCAL_NOVEMBER, 13,status); int32_t dow = a->get(UCAL_DAY_OF_WEEK, status); if (dow != UCAL_THURSDAY) errln("Fail: Want THURSDAY Got " + dow); delete a; } /** * @bug 4096231 */ void CalendarRegressionTest::test4096231() { UErrorCode status = U_ZERO_ERROR; TimeZone *GMT = TimeZone::createTimeZone("GMT"); TimeZone *PST = TimeZone::createTimeZone("PST"); int32_t sec = 0, min = 0, hr = 0, day = 1, month = 10, year = 1997; Calendar *cal1 = new GregorianCalendar(*PST,status); cal1->setTime(880698639000.0,status); // Issue 1: Changing the timezone doesn't change the // represented time. The old API, pre 1.2.2a requires // setTime to be called in order to update the time fields after the time // zone has been set. int32_t h1,h2; logln(UnicodeString("PST 1 is: ") + (h1=cal1->get(UCAL_HOUR_OF_DAY, status))); cal1->setTimeZone(*GMT); logln(UnicodeString("GMT 2 is: ") + (h2=cal1->get(UCAL_HOUR_OF_DAY, status))); if ((*GMT != *PST) && (h1 == h2)) errln("Fail: Hour same in different zones"); Calendar *cal2 = new GregorianCalendar(*GMT,status); Calendar *cal3 = new GregorianCalendar(*PST,status); cal2->set(cal1->get(UCAL_YEAR,status), cal1->get(UCAL_MONTH,status), cal1->get(UCAL_DATE,status), cal1->get(UCAL_HOUR_OF_DAY,status), cal1->get(UCAL_MINUTE,status), cal1->get(UCAL_SECOND,status)); double t1,t2,t3,t4; logln(UnicodeString("RGMT 1 is: ") + (t1=cal2->getTime(status))); cal3->set(year, month, day, hr, min, sec); logln(UnicodeString("RPST 1 is: ") + (t2=cal3->getTime(status))); cal3->setTimeZone(*GMT); logln(UnicodeString("RGMT 2 is: ") + (t3=cal3->getTime(status))); cal3->set(cal1->get(UCAL_YEAR,status), cal1->get(UCAL_MONTH,status), cal1->get(UCAL_DATE,status), cal1->get(UCAL_HOUR_OF_DAY,status), cal1->get(UCAL_MINUTE,status), cal1->get(UCAL_SECOND,status)); // Issue 2: Calendar continues to use the timezone in its // constructor for set() conversions, regardless // of calls to setTimeZone() logln(UnicodeString("RGMT 3 is: ") + (t4=cal3->getTime(status))); if (t1 == t2 || t1 != t4 || t2 != t3) errln("Fail: Calendar zone behavior faulty"); delete cal1; delete cal2; delete cal3; delete GMT; delete PST; } /** * @bug 4096539 */ void CalendarRegressionTest::test4096539() { UErrorCode status = U_ZERO_ERROR; int32_t y [] = {31,28,31,30,31,30,31,31,30,31,30,31}; for (int32_t x=0;x<12;x++) { GregorianCalendar *gc = new GregorianCalendar(1997,x,y[x], status); int32_t m1,m2; log(UnicodeString("") + (m1=gc->get(UCAL_MONTH,status)+1)+UnicodeString("/")+ gc->get(UCAL_DATE,status)+"/"+gc->get(UCAL_YEAR,status)+ " + 1mo = "); gc->add(UCAL_MONTH, 1,status); logln(UnicodeString("") + (m2=gc->get(UCAL_MONTH,status)+1)+UnicodeString("/")+ gc->get(UCAL_DATE,status)+"/"+gc->get(UCAL_YEAR,status) ); int32_t m = (m1 % 12) + 1; if (m2 != m) errln(UnicodeString("Fail: Want ") + m + " Got " + m2); delete gc; } } /** * @bug 4100311 */ void CalendarRegressionTest::test41003112() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *cal = (GregorianCalendar*)Calendar::createInstance(status); cal->set(UCAL_YEAR, 1997); cal->set(UCAL_DAY_OF_YEAR, 1); //UDate d = cal->getTime(status); // Should be Jan 1 //logln(d.toString()); if (cal->get(UCAL_DAY_OF_YEAR, status) != 1) errln("Fail: DAY_OF_YEAR not set"); delete cal; } /** * @bug 4103271 */ void CalendarRegressionTest::test4103271() { UErrorCode status = U_ZERO_ERROR; SimpleDateFormat sdf(status); int32_t numYears=40, startYear=1997, numDays=15; UnicodeString output, testDesc, str, str2; GregorianCalendar *testCal = (GregorianCalendar*)Calendar::createInstance(status); testCal->clear(); sdf.adoptCalendar(testCal); sdf.applyPattern("EEE dd MMM yyyy 'WOY'ww'-'YYYY 'DOY'DDD"); UBool fail = FALSE; for (int32_t firstDay=1; firstDay<=2; firstDay++) { for (int32_t minDays=1; minDays<=7; minDays++) { testCal->setMinimalDaysInFirstWeek((uint8_t)minDays); testCal->setFirstDayOfWeek((UCalendarDaysOfWeek)firstDay); testDesc = (UnicodeString("Test") + firstDay + minDays); logln(testDesc + " => 1st day of week=" + firstDay + ", minimum days in first week=" + minDays); for (int32_t j=startYear; j<=startYear+numYears; j++) { testCal->set(j,11,25); for(int32_t i=0; iadd(UCAL_DATE,1,status); UnicodeString calWOY; int32_t actWOY = testCal->get(UCAL_WEEK_OF_YEAR,status); if (actWOY < 1 || actWOY > 53) { UDate d = testCal->getTime(status); //calWOY = String.valueOf(actWOY); UnicodeString temp; FieldPosition pos(FieldPosition::DONT_CARE); output = testDesc + " - " + sdf.format(d,temp,pos) + "\t"; output = output + "\t" + actWOY; logln(output); fail = TRUE; } } } } } int32_t DATA [] = { 3, 52, 52, 52, 52, 52, 52, 52, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 4, 52, 52, 52, 52, 52, 52, 52, 53, 53, 53, 53, 53, 53, 53, 1, 1, 1, 1, 1, 1, 1, }; testCal->setFirstDayOfWeek(UCAL_SUNDAY); for (int32_t j=0; j<44; j+=22) { logln(UnicodeString("Minimal days in first week = ") + DATA[j] + " Week starts on Sunday"); testCal->setMinimalDaysInFirstWeek((uint8_t)DATA[j]); testCal->set(1997, UCAL_DECEMBER, 21); for (int32_t i=0; i<21; ++i) { int32_t woy = testCal->get(UCAL_WEEK_OF_YEAR,status); str.remove(); log(UnicodeString("") + sdf.format(testCal->getTime(status), str) + UnicodeString(" ") + woy); if (woy != DATA[j + 1 + i]) { log(" ERROR"); fail = TRUE; } logln(""); // Now compute the time from the fields, and make sure we // get the same answer back. This is a round-trip test. UDate save = testCal->getTime(status); testCal->clear(); testCal->set(UCAL_YEAR_WOY, DATA[j+1+i] < 25 ? 1998 : 1997); testCal->set(UCAL_WEEK_OF_YEAR, DATA[j+1+i]); testCal->set(UCAL_DAY_OF_WEEK, (i%7) + UCAL_SUNDAY); if (testCal->getTime(status) != save) { str.remove(); logln(UnicodeString(" Parse failed: ") + sdf.format(testCal->getTime(status), str)); fail= TRUE; } testCal->setTime(save,status); testCal->add(UCAL_DATE, 1,status); } } // Test field disambiguation with a few special hard-coded cases. // This shouldn't fail if the above cases aren't failing. int32_t DISAM_int [] = { // y y_woy woy dow 1997, 1998, 1, UCAL_SUNDAY, (1998), (1998), (2), (UCAL_SATURDAY), (1998), (1998), (53), (UCAL_THURSDAY), (1999), (1998), (53), (UCAL_FRIDAY) }; UDate DISAM_date [] = { makeDate(1997, UCAL_DECEMBER, 28), makeDate(1998, UCAL_JANUARY, 10), makeDate(1998, UCAL_DECEMBER, 31), makeDate(1999, UCAL_JANUARY, 1) }; testCal->setMinimalDaysInFirstWeek(3); testCal->setFirstDayOfWeek(UCAL_SUNDAY); int32_t i = 0; /* Enable this code to display various WOY values testCal->clear(); for (i=25; i<38; ++i) { testCal->set(1996, Calendar::DECEMBER, i); UDate got = testCal->getTime(status); str.remove(); logln(UnicodeString("") + sdf.format(got, str)); } for (i=25; i<38; ++i) { testCal->set(1997, Calendar::DECEMBER, i); UDate got = testCal->getTime(status); str.remove(); logln(UnicodeString("") + sdf.format(got, str)); } for (i=25; i<38; ++i) { testCal->set(1998, UCAL_DECEMBER, i); UDate got = testCal->getTime(status); str.remove(); logln(UnicodeString("") + sdf.format(got, str)); } */ for (i=0; i < 16; i += 4) { int32_t y = DISAM_int[i]; int32_t ywoy = DISAM_int[i+1]; int32_t woy = DISAM_int[i+2]; int32_t dow = DISAM_int[i+3]; UDate exp = DISAM_date[i/4]; testCal->clear(); testCal->set(UCAL_YEAR, y); testCal->set(UCAL_WEEK_OF_YEAR, woy); testCal->set(UCAL_DAY_OF_WEEK, dow); UDate got = testCal->getTime(status); str.remove(); str2.remove(); log(UnicodeString("Y") + y + "-W" + woy + "-DOW" + dow + " expect:" + sdf.format(exp, str) + " got:" + sdf.format(got, str2)); if (got != exp) { log(" FAIL"); fail = TRUE; } logln(""); testCal->clear(); testCal->set(UCAL_YEAR_WOY, ywoy); testCal->set(UCAL_WEEK_OF_YEAR, woy); testCal->set(UCAL_DAY_OF_WEEK, dow); got = testCal->getTime(status); str.remove(); str2.remove(); log(UnicodeString("YWOY") + ywoy + "-W" + woy + "-DOW" + dow + " expect:" + sdf.format(exp, str) + " got:" + sdf.format(got, str2)); if (got != exp) { log(" FAIL"); fail = TRUE; } logln(""); } // Now try adding and rolling UDate ADDROLL_date [] = { makeDate(1998, UCAL_DECEMBER, 25), makeDate(1999, UCAL_JANUARY, 1), makeDate(1997, UCAL_DECEMBER, 28), makeDate(1998, UCAL_JANUARY, 4), makeDate(1998, UCAL_DECEMBER, 27), makeDate(1997, UCAL_DECEMBER, 28), makeDate(1999, UCAL_JANUARY, 2), makeDate(1998, UCAL_JANUARY, 3), }; int32_t ADDROLL_int []= { (1), (1), (1), (1) }; UBool ADDROLL_bool [] = { TRUE,//ADD, TRUE, FALSE, FALSE }; testCal->setMinimalDaysInFirstWeek(3); testCal->setFirstDayOfWeek(UCAL_SUNDAY); for (i=0; i<8; i += 2) { int32_t amount = ADDROLL_int[i/2]; UDate before = ADDROLL_date[i]; UDate after = ADDROLL_date[i+1]; testCal->setTime(before,status); if (ADDROLL_bool[i/2]) testCal->add(UCAL_WEEK_OF_YEAR, amount,status); else testCal->roll(UCAL_WEEK_OF_YEAR, amount,status); UDate got = testCal->getTime(status); str.remove(); str2.remove(); log((ADDROLL_bool[i/2]? UnicodeString("add(WOY,"):UnicodeString("roll(WOY,")) + amount + ") " + sdf.format(before, str) + " => " + sdf.format(got, str2)); if (after != got) { str.remove(); logln(UnicodeString(" exp:") + sdf.format(after, str) + " FAIL"); fail = TRUE; } else logln(" ok"); testCal->setTime(after,status); if (ADDROLL_bool[i/2]) testCal->add(UCAL_WEEK_OF_YEAR, -amount,status); else testCal->roll(UCAL_WEEK_OF_YEAR, -amount,status); got = testCal->getTime(status); str.remove(); str2.remove(); log((ADDROLL_bool[i/2]?UnicodeString("add(WOY,"):UnicodeString("roll(WOY,")) + (-amount) + ") " + sdf.format(after, str) + " => " + sdf.format(got, str2)); if (before != got) { str.remove(); logln(UnicodeString(" exp:") + sdf.format(before, str) + " FAIL"); fail = TRUE; } else logln(" ok"); } if (fail) errln("Fail: Week of year misbehaving"); } /** * @bug 4106136 */ void CalendarRegressionTest::test4106136() { UErrorCode status = U_ZERO_ERROR; Locale saveLocale = Locale::getDefault(); //try { Locale locales [] = { Locale::getChinese(), Locale::getChina() }; for (int32_t i=0; i<2; ++i) { Locale::setDefault(locales[i], status); failure(status, "Locale::setDefault"); int32_t count1, count2, count3; Calendar::getAvailableLocales(count1); DateFormat::getAvailableLocales(count2); NumberFormat::getAvailableLocales(count3); int32_t n [] = { count1, count2, count3 }; for (int32_t j=0; j<3; ++j) { UnicodeString temp; if (n[j] == 0) errln(UnicodeString("Fail: No locales for ") + locales[i].getName()); } } //} //finally { Locale::setDefault(saveLocale,status); //} } /** * @bug 4108764 */ void CalendarRegressionTest::test4108764() { UErrorCode status = U_ZERO_ERROR; UDate d00 = makeDate(1997, UCAL_MARCH, 15, 12, 00, 00); UDate d01 = makeDate(1997, UCAL_MARCH, 15, 12, 00, 56); UDate d10 = makeDate(1997, UCAL_MARCH, 15, 12, 34, 00); UDate d11 = makeDate(1997, UCAL_MARCH, 15, 12, 34, 56); UDate epoch = makeDate(1970, UCAL_JANUARY, 1); Calendar *cal = Calendar::createInstance(status); cal->setTime(d11,status); cal->clear( UCAL_MINUTE ); logln(UnicodeString("") + cal->getTime(status)); if (cal->getTime(status) != d01) errln("Fail: clear(MINUTE) broken"); cal->set( UCAL_SECOND, 0 ); logln(UnicodeString("") + cal->getTime(status)); if (cal->getTime(status) != d00) errln("Fail: set(SECOND, 0) broken"); cal->setTime(d11,status); cal->set( UCAL_SECOND, 0 ); logln(UnicodeString("") + cal->getTime(status)); if (cal->getTime(status) != d10) errln("Fail: set(SECOND, 0) broken #2"); cal->clear( UCAL_MINUTE ); logln(UnicodeString("") + cal->getTime(status)); if (cal->getTime(status) != d00) errln("Fail: clear(MINUTE) broken #2"); cal->clear(); logln(UnicodeString("") + cal->getTime(status)); if (cal->getTime(status) != epoch) errln(UnicodeString("Fail: clear() broken Want ") + epoch); delete cal; } /** * @bug 4114578 */ void CalendarRegressionTest::test4114578() { UErrorCode status = U_ZERO_ERROR; int32_t ONE_HOUR = 60*60*1000; Calendar *cal = Calendar::createInstance(status); cal->adoptTimeZone(TimeZone::createTimeZone("PST")); UDate onset = makeDate(1998, UCAL_APRIL, 5, 1, 0) + ONE_HOUR; UDate cease = makeDate(1998, UCAL_OCTOBER, 25, 0, 0) + 2*ONE_HOUR; UBool fail = FALSE; const int32_t ADD = 1; const int32_t ROLL = 2; double DATA []= { // Start Action Amt Expected_change onset - ONE_HOUR, ADD, 1, ONE_HOUR, onset, ADD, -1, -ONE_HOUR, onset - ONE_HOUR, ROLL, 1, ONE_HOUR, onset, ROLL, -1, -ONE_HOUR, cease - ONE_HOUR, ADD, 1, ONE_HOUR, cease, ADD, -1, -ONE_HOUR, cease - ONE_HOUR, ROLL, 1, ONE_HOUR, cease, ROLL, -1, -ONE_HOUR, }; for (int32_t i=0; i<32; i+=4) { UDate date = DATA[i]; int32_t amt = (int32_t) DATA[i+2]; double expectedChange = DATA[i+3]; log(UnicodeString("") + date); cal->setTime(date,status); switch ((int32_t) DATA[i+1]) { case ADD: log(UnicodeString(" add (HOUR,") + (amt<0?"":"+")+amt + ")= "); cal->add(UCAL_HOUR, amt,status); break; case ROLL: log(UnicodeString(" roll(HOUR,") + (amt<0?"":"+")+amt + ")= "); cal->roll(UCAL_HOUR, amt,status); break; } log(UnicodeString("") + cal->getTime(status)); double change = cal->getTime(status) - date; if (change != expectedChange) { fail = TRUE; logln(" FAIL"); } else logln(" OK"); } if (fail) errln("Fail: roll/add misbehaves around DST onset/cease"); delete cal; } /** * @bug 4118384 * Make sure maximum for HOUR field is 11, not 12. */ void CalendarRegressionTest::test4118384() { UErrorCode status = U_ZERO_ERROR; Calendar *cal = Calendar::createInstance(status); if (cal->getMaximum(UCAL_HOUR) != 11 || cal->getLeastMaximum(UCAL_HOUR) != 11 || cal->getActualMaximum(UCAL_HOUR,status) != 11) errln("Fail: maximum of HOUR field should be 11"); delete cal; } /** * @bug 4125881 * Check isLeapYear for BC years. */ void CalendarRegressionTest::test4125881() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *cal = (GregorianCalendar*) Calendar::createInstance(status); DateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"),status); cal->clear(); for (int32_t y=-20; y<=10; ++y) { cal->set(UCAL_ERA, y < 1 ? GregorianCalendar::BC : GregorianCalendar::AD); cal->set(UCAL_YEAR, y < 1 ? 1 - y : y); UnicodeString temp; logln(UnicodeString("") + y + UnicodeString(" = ") + fmt->format(cal->getTime(status), temp) + " " + cal->isLeapYear(y)); if (cal->isLeapYear(y) != ((y+40)%4 == 0)) errln("Leap years broken"); } delete cal; delete fmt; } /** * @bug 4125892 * Prove that GregorianCalendar is proleptic (it used to cut off * at 45 BC, and not have leap years before then). */ void CalendarRegressionTest::test4125892() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *cal = (GregorianCalendar*) Calendar::createInstance(status); DateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"),status); cal->clear(); cal->set(UCAL_ERA, GregorianCalendar::BC); cal->set(UCAL_YEAR, 81); // 81 BC is a leap year (proleptically) cal->set(UCAL_MONTH, UCAL_FEBRUARY); cal->set(UCAL_DATE, 28); cal->add(UCAL_DATE, 1,status); if(U_FAILURE(status)) errln("add(DATE,1) failed"); if (cal->get(UCAL_DATE,status) != 29 || !cal->isLeapYear(-80)) // -80 == 81 BC errln("Calendar not proleptic"); delete cal; delete fmt; } /** * @bug 4141665 * GregorianCalendar::equals() ignores cutover date */ void CalendarRegressionTest::test4141665() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *cal = new GregorianCalendar(status); GregorianCalendar *cal2 = (GregorianCalendar*)cal->clone(); UDate cut = cal->getGregorianChange(); UDate cut2 = cut + 100*24*60*60*1000.0; // 100 days later if (*cal != *cal2) { errln("Cloned GregorianCalendars not equal"); } cal2->setGregorianChange(cut2,status); if ( *cal == *cal2) { errln("GregorianCalendar::equals() ignores cutover"); } delete cal; delete cal2; } /** * @bug 4142933 * Bug states that ArrayIndexOutOfBoundsException is thrown by GregorianCalendar::roll() * when IllegalArgumentException should be. */ void CalendarRegressionTest::test4142933() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *calendar = new GregorianCalendar(status); //try { calendar->roll((UCalendarDateFields)-1, TRUE, status); if(U_SUCCESS(status)) errln("Test failed, no exception thrown"); //} //catch (IllegalArgumentException e) { // OK: Do nothing // logln("Test passed"); //} //catch (Exception e) { //errln("Test failed. Unexpected exception is thrown: " + e); //e.printStackTrace(); //} delete calendar; } /** * @bug 4145158 * GregorianCalendar handling of Dates Long.MIN_VALUE and Long.MAX_VALUE is * confusing; unless the time zone has a raw offset of zero, one or the * other of these will wrap. We've modified the test given in the bug * report to therefore only check the behavior of a calendar with a zero raw * offset zone. */ void CalendarRegressionTest::test4145158() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *calendar = new GregorianCalendar(status); calendar->adoptTimeZone(TimeZone::createTimeZone("GMT")); calendar->setTime(makeDate(INT32_MIN),status); int32_t year1 = calendar->get(UCAL_YEAR,status); int32_t era1 = calendar->get(UCAL_ERA,status); calendar->setTime(makeDate(INT32_MAX),status); int32_t year2 = calendar->get(UCAL_YEAR,status); int32_t era2 = calendar->get(UCAL_ERA,status); if (year1 == year2 && era1 == era2) { errln("Fail: Long.MIN_VALUE or Long.MAX_VALUE wrapping around"); } delete calendar; } /** * @bug 4145983 * Maximum value for YEAR field wrong. */ // {sfb} this is not directly applicable in C++, since all // possible doubles are not representable by our Calendar. // In Java, all longs are representable. // We can determine limits programmatically // Using DBL_MAX is a bit of a hack, since for large doubles // Calendar gets squirrely and doesn't behave in any sort // of linear fashion (ie years jump around, up/down, etc) for a // small change in millis. void CalendarRegressionTest::test4145983() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *calendar = new GregorianCalendar(status); calendar->adoptTimeZone(TimeZone::createTimeZone("GMT")); UDate DATES [] = { LATEST_SUPPORTED_MILLIS, EARLIEST_SUPPORTED_MILLIS }; for (int32_t i=0; i<2; ++i) { calendar->setTime(DATES[i], status); int32_t year = calendar->get(UCAL_YEAR,status); int32_t maxYear = calendar->getMaximum(UCAL_YEAR); if (year > maxYear) { errln(UnicodeString("Failed for ")+DATES[i]+" ms: year=" + year + ", maxYear=" + maxYear); } } delete calendar; } /** * @bug 4147269 * This is a bug in the validation code of GregorianCalendar:: As reported, * the bug seems worse than it really is, due to a bug in the way the bug * report test was written. In reality the bug is restricted to the DAY_OF_YEAR * field. - liu 6/29/98 */ void CalendarRegressionTest::test4147269() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *calendar = new GregorianCalendar(status); calendar->setLenient(FALSE); UDate date = makeDate(1996, UCAL_JANUARY, 3); // Arbitrary date for (int32_t field = 0; field < UCAL_FIELD_COUNT; field++) { calendar->setTime(date,status); // Note: In the bug report, getActualMaximum() was called instead // of getMaximum() -- this was an error. The validation code doesn't // use getActualMaximum(), since that's too costly. int32_t max = calendar->getMaximum((UCalendarDateFields)field); int32_t value = max+1; calendar->set((UCalendarDateFields)field, value); //try { calendar->getTime(status); // Force time computation // We expect an exception to be thrown. If we fall through // to the next line, then we have a bug. if(U_SUCCESS(status)) errln(UnicodeString("Test failed with field ") + FIELD_NAME[field] + ", date before: " + date + ", date after: " + calendar->getTime(status) + ", value: " + value + " (max = " + max +")"); //} catch (IllegalArgumentException e) {} } delete calendar; } /** * @bug 4149677 * Reported bug is that a GregorianCalendar with a cutover of Date(Long.MAX_VALUE) * doesn't behave as a pure Julian calendar. * CANNOT REPRODUCE THIS BUG */ void CalendarRegressionTest::Test4149677() { UErrorCode status = U_ZERO_ERROR; TimeZone *zones [] = { TimeZone::createTimeZone("GMT"), TimeZone::createTimeZone("PST"), TimeZone::createTimeZone("EAT") }; if(U_FAILURE(status)) { errln("Couldn't create zones"); return; // could leak memory } for (int32_t i=0; i < 3; ++i) { GregorianCalendar *calendar = new GregorianCalendar(zones[i], status); if(U_FAILURE(status)) { errln("Couldnt' create calendar."); return; } // Make sure extreme values don't wrap around calendar->setTime(EARLIEST_SUPPORTED_MILLIS, status); if(U_FAILURE(status)) errln("setTime failed"); if (calendar->get(UCAL_ERA, status) != GregorianCalendar::BC || U_FAILURE(status)) { errln("Fail: Date(EARLIEST_SUPPORTED_MILLIS) has an AD year"); } calendar->setTime(LATEST_SUPPORTED_MILLIS, status); if(U_FAILURE(status)) errln("setTime failed"); if (calendar->get(UCAL_ERA, status) != GregorianCalendar::AD || U_FAILURE(status)) { errln("Fail: Date(LATEST_SUPPORTED_MILLIS) has a BC year"); } calendar->setGregorianChange(LATEST_SUPPORTED_MILLIS, status); if(U_FAILURE(status)) errln("setGregorianChange failed"); // to obtain a pure Julian calendar UBool is100Leap = calendar->isLeapYear(100); if (!is100Leap) { UnicodeString temp; errln("test failed with zone " + zones[i]->getID(temp)); errln(" cutover date is Date(Long.MAX_VALUE)"); errln(" isLeapYear(100) returns: " + is100Leap); } delete calendar; } // no need for cleanup- zones were adopted } /** * @bug 4162587 * Calendar and Date HOUR broken. If HOUR is out-of-range, Calendar * and Date classes will misbehave. */ void CalendarRegressionTest::Test4162587() { UErrorCode status = U_ZERO_ERROR; TimeZone *savedef = TimeZone::createDefault(); TimeZone *tz = TimeZone::createTimeZone("PST"); //TimeZone::adoptDefault(tz); TimeZone::setDefault(*tz); GregorianCalendar *cal = new GregorianCalendar(tz, status); if(U_FAILURE(status)) { errln("Couldn't create calendar"); return; } UDate d0, dPlus, dMinus; for(int32_t i=0; i<5; ++i) { if (i>0) logln("---"); cal->clear(); cal->set(1998, UCAL_APRIL, 5, i, 0); d0 = cal->getTime(status); if(U_FAILURE(status)) errln("Coudln't get time (1)"); //String s0 = d.toString(); logln(UnicodeString("0 ") + i + ": " + d0/*s0*/); cal->clear(); cal->set(1998, UCAL_APRIL, 4, i+24, 0); dPlus = cal->getTime(status); if(U_FAILURE(status)) errln("Coudln't get time (2)"); //String sPlus = d.toString(); logln(UnicodeString("+ ") + i + ": " + dPlus/*sPlus*/); cal->clear(); cal->set(1998, UCAL_APRIL, 6, i-24, 0); dMinus = cal->getTime(status); if(U_FAILURE(status)) errln("Coudln't get time (3)"); //String sMinus = d.toString(); logln(UnicodeString("- ") + i + ": " + dMinus/*sMinus*/); if (d0 != dPlus || d0 != dMinus) { errln("Fail: All three lines must match"); } } TimeZone::setDefault(*savedef); //delete tz; delete cal; delete savedef; } /** * @bug 4165343 * Adding 12 months behaves differently from adding 1 year */ void CalendarRegressionTest::Test4165343() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar *calendar = new GregorianCalendar(1996, UCAL_FEBRUARY, 29, status); if(U_FAILURE(status)) { errln("Couldn't create calendar"); return; } UDate start = calendar->getTime(status); if(U_FAILURE(status)) errln("Couldn't getTime (1)"); logln(UnicodeString("init date: ") + start); calendar->add(UCAL_MONTH, 12, status); if(U_FAILURE(status)) errln("Couldn't add(MONTH, 12)"); UDate date1 = calendar->getTime(status); if(U_FAILURE(status)) errln("Couldn't getTime (2)"); logln(UnicodeString("after adding 12 months: ") + date1); calendar->setTime(start, status); if(U_FAILURE(status)) errln("Couldn't setTime"); calendar->add(UCAL_YEAR, 1, status); if(U_FAILURE(status)) errln("Couldn't add(YEAR, 1)"); UDate date2 = calendar->getTime(status); if(U_FAILURE(status)) errln("Couldn't getTime (3)"); logln(UnicodeString("after adding one year : ") + date2); if (date1 == date2) { logln("Test passed"); } else { errln("Test failed"); } delete calendar; } /** * @bug 4166109 * GregorianCalendar.getActualMaximum() does not account for first day of week. */ void CalendarRegressionTest::Test4166109() { /* Test month: * * March 1998 * Su Mo Tu We Th Fr Sa * 1 2 3 4 5 6 7 * 8 9 10 11 12 13 14 * 15 16 17 18 19 20 21 * 22 23 24 25 26 27 28 * 29 30 31 */ UBool passed = TRUE; UErrorCode status = U_ZERO_ERROR; UCalendarDateFields field = UCAL_WEEK_OF_MONTH; GregorianCalendar *calendar = new GregorianCalendar(Locale::getUS(), status); if(U_FAILURE(status)) { errln("Couldn't create calendar"); return; } calendar->set(1998, UCAL_MARCH, 1); calendar->setMinimalDaysInFirstWeek(1); logln(UnicodeString("Date: ") + calendar->getTime(status)); int32_t firstInMonth = calendar->get(UCAL_DATE, status); if(U_FAILURE(status)) errln("get(D_O_M) failed"); for(int32_t firstInWeek = UCAL_SUNDAY; firstInWeek <= UCAL_SATURDAY; firstInWeek++) { calendar->setFirstDayOfWeek((UCalendarDaysOfWeek)firstInWeek); int32_t returned = calendar->getActualMaximum(field); int32_t expected = (31 + ((firstInMonth - firstInWeek + 7)% 7) + 6) / 7; logln(UnicodeString("First day of week = ") + firstInWeek + " getActualMaximum(WEEK_OF_MONTH) = " + returned + " expected = " + expected + ((returned == expected) ? " ok" : " FAIL")); if (returned != expected) { passed = FALSE; } } if (!passed) { errln("Test failed"); } delete calendar; } /** * @bug 4167060 * Calendar.getActualMaximum(YEAR) works wrong. */ void CalendarRegressionTest::Test4167060() { UErrorCode status = U_ZERO_ERROR; UCalendarDateFields field = UCAL_YEAR; DateFormat *format = new SimpleDateFormat(UnicodeString("EEE MMM dd HH:mm:ss zzz yyyy G"), Locale::getUS(), status); if(U_FAILURE(status)) { errln("Couldn't create SimpleDateFormat"); return; } GregorianCalendar *calendars [] = { new GregorianCalendar(100, UCAL_NOVEMBER, 1, status), new GregorianCalendar(-99 /*100BC*/, UCAL_JANUARY, 1, status), new GregorianCalendar(1996, UCAL_FEBRUARY, 29, status), }; if(U_FAILURE(status)) { errln("Couldn't create GregorianCalendars"); return; // could leak } UnicodeString id [] = { "Hybrid", "Gregorian", "Julian" }; for (int32_t k=0; k<3; ++k) { logln("--- " + id[k] + " ---"); for (int32_t j=0; j < 3; ++j) { GregorianCalendar *calendar = calendars[j]; if (k == 1) { calendar->setGregorianChange(EARLIEST_SUPPORTED_MILLIS, status); } else if (k == 2) { calendar->setGregorianChange(LATEST_SUPPORTED_MILLIS, status); } if(U_FAILURE(status)) errln("setGregorianChange() failed"); format->adoptCalendar((Calendar*)calendar->clone()); UDate dateBefore = calendar->getTime(status); if(U_FAILURE(status)) errln("getTime() failed"); int32_t maxYear = calendar->getActualMaximum(field); UnicodeString temp; logln(UnicodeString("maxYear: ") + maxYear + " for " + format->format(calendar->getTime(status), temp)); temp.remove(); logln("date before: " + format->format(dateBefore, temp)); int32_t years[] = {2000, maxYear-1, maxYear, maxYear+1}; for (int32_t i = 0; i < 4; i++) { UBool valid = years[i] <= maxYear; calendar->set(field, years[i]); UDate dateAfter = calendar->getTime(status); if(U_FAILURE(status)) errln("getTime() failed"); int32_t newYear = calendar->get(field, status); if(U_FAILURE(status)) errln(UnicodeString("get(") + (int32_t)field + ") failed"); calendar->setTime(dateBefore, status); // restore calendar for next use if(U_FAILURE(status)) errln("setTime() failed"); temp.remove(); logln(UnicodeString(" Year ") + years[i] + (valid? " ok " : " bad") + " => " + format->format(dateAfter, temp)); if (valid && newYear != years[i]) { errln(UnicodeString(" FAIL: ") + newYear + " should be valid; date, month and time shouldn't change"); } // {sfb} this next line is a hack, but it should work since if a // double has an exponent, adding 1 should not yield the same double else if (!valid && /*newYear == years[i]*/ dateAfter + 1.0 == dateAfter) { errln(UnicodeString(" FAIL: ") + newYear + " should be invalid"); } } } } delete format; delete calendars[0]; delete calendars[1]; delete calendars[2]; } /** * Week of year is wrong at the start and end of the year. */ void CalendarRegressionTest::Test4197699() { UErrorCode status = U_ZERO_ERROR; GregorianCalendar cal(status); cal.setFirstDayOfWeek(UCAL_MONDAY); cal.setMinimalDaysInFirstWeek(4); SimpleDateFormat fmt("E dd MMM yyyy 'DOY='D 'WOY='w", Locale::getUS(), status); fmt.setCalendar(cal); if (U_FAILURE(status)) { errln("Couldn't initialize test"); return; } int32_t DATA[] = { 2000, UCAL_JANUARY, 1, 52, 2001, UCAL_DECEMBER, 31, 1, }; int32_t DATA_length = (int32_t)(sizeof(DATA) / sizeof(DATA[0])); UnicodeString str; DateFormat& dfmt = *(DateFormat*)&fmt; for (int32_t i=0; ifields cal.set(1582, UCAL_OCTOBER, DOY_DATA[i]); int32_t woy = cal.get(UCAL_WEEK_OF_YEAR, status); int32_t doy = cal.get(UCAL_DAY_OF_YEAR, status); if (U_FAILURE(status)) { errln("Error: get() failed"); break; } if (woy != DOY_DATA[i+1] || doy != DOY_DATA[i+2]) { errln((UnicodeString)"Fail: expect woy=" + DOY_DATA[i+1] + ", doy=" + DOY_DATA[i+2] + " on " + fmt.format(cal.getTime(status), temp.remove())); status = U_ZERO_ERROR; } // Test fields->time for WOY cal.clear(); cal.set(UCAL_YEAR, 1582); cal.set(UCAL_WEEK_OF_YEAR, DOY_DATA[i+1]); cal.set(UCAL_DAY_OF_WEEK, DOY_DATA[i+3]); int32_t dom = cal.get(UCAL_DATE, status); if (U_FAILURE(status)) { errln("Error: get() failed"); break; } if (dom != DOY_DATA[i]) { errln((UnicodeString)"Fail: set woy=" + DOY_DATA[i+1] + " dow=" + DOY_DATA[i+3] + " => " + fmt.format(cal.getTime(status), temp.remove()) + ", expected 1582 Oct " + DOY_DATA[i]); status = U_ZERO_ERROR; } // Test fields->time for DOY cal.clear(); cal.set(UCAL_YEAR, 1582); cal.set(UCAL_DAY_OF_YEAR, DOY_DATA[i+2]); dom = cal.get(UCAL_DATE, status); if (U_FAILURE(status)) { errln("Error: get() failed"); break; } if (dom != DOY_DATA[i]) { errln((UnicodeString)"Fail: set doy=" + DOY_DATA[i+2] + " => " + fmt.format(cal.getTime(status), temp.remove()) + ", expected 1582 Oct " + DOY_DATA[i]); status = U_ZERO_ERROR; } } status = U_ZERO_ERROR; #define ADD_ROLL ADD|ROLL #define PLUS_MINUS PLUS|MINUS // Test cases J81_DATA DATA[] = { { UCAL_WEEK_OF_YEAR, ADD_ROLL, PLUS_MINUS, 1, -ONE_DAY, +6*ONE_DAY }, { UCAL_WEEK_OF_YEAR, ADD_ROLL, PLUS_MINUS, 1, -ONE_DAY, +6*ONE_DAY }, { UCAL_WEEK_OF_MONTH, ADD|ROLL, PLUS|MINUS, 1, -ONE_DAY, +6*ONE_DAY }, { UCAL_DATE, ADD|ROLL, PLUS|MINUS, 2, -ONE_DAY, +1*ONE_DAY }, { UCAL_DATE, ROLL, PLUS, -6, -ONE_DAY, +14*ONE_DAY }, { UCAL_DATE, ROLL, PLUS, -7, 0, +14*ONE_DAY }, { UCAL_DATE, ROLL, PLUS, -7, +ONE_DAY, +15*ONE_DAY }, { UCAL_DATE, ROLL, PLUS, +18, -ONE_DAY, -4*ONE_DAY }, { UCAL_DAY_OF_YEAR, ADD|ROLL, PLUS|MINUS, 2, -ONE_DAY, +1*ONE_DAY }, { UCAL_DAY_OF_WEEK, ADD|ROLL, PLUS|MINUS, 2, -ONE_DAY, +1*ONE_DAY }, { UCAL_DAY_OF_WEEK_IN_MONTH, ADD|ROLL, PLUS|MINUS, 1, -ONE_DAY, +6*ONE_DAY }, { UCAL_AM_PM, ADD, PLUS|MINUS, 4, -12*ONE_HOUR, +36*ONE_HOUR }, { UCAL_HOUR, ADD, PLUS|MINUS, 48, -12*ONE_HOUR, +36*ONE_HOUR }, { UCAL_HOUR_OF_DAY, ADD, PLUS|MINUS, 48, -12*ONE_HOUR, +36*ONE_HOUR }, { UCAL_MINUTE, ADD, PLUS|MINUS, 48*60, -12*ONE_HOUR, +36*ONE_HOUR }, { UCAL_SECOND, ADD, PLUS|MINUS, 48*60*60, -12*ONE_HOUR, +36*ONE_HOUR }, { UCAL_MILLISECOND, ADD, PLUS|MINUS, 48*ONE_HOUR, -12*ONE_HOUR, +36*ONE_HOUR }, // NOTE: These are not supported yet. See jitterbug 180. // Uncomment these lines when add/roll supported on these fields. // { Calendar::YEAR_WOY, ADD|ROLL, 1, -ONE_DAY, +6*ONE_DAY }, // { Calendar::DOW_LOCAL, ADD|ROLL, 2, -ONE_DAY, +1*ONE_DAY } }; int32_t DATA_length = (int32_t)(sizeof(DATA) / sizeof(DATA[0])); // Now run the tests for (i=0; i {" + fmt.format(result, temp2.remove()) + "}(" + result/ONE_DAY + ")"); } else { errln((UnicodeString)"FAIL: {" + fmt.format(date, temp.remove()) + "}(" + date/ONE_DAY + (action==ADD?") add ":") roll ") + amount + " " + FIELD_NAME[DATA[i].field] + " -> {" + fmt.format(result, temp2.remove()) + "}(" + result/ONE_DAY + "), expect {" + fmt.format(expected, temp3.remove()) + "}(" + expected/ONE_DAY + ")"); } } } } } /** * Test fieldDifference(). */ void CalendarRegressionTest::TestJ438(void) { UErrorCode ec = U_ZERO_ERROR; int32_t DATA[] = { 2000, UCAL_JANUARY, 20, 2010, UCAL_JUNE, 15, 2010, UCAL_JUNE, 15, 2000, UCAL_JANUARY, 20, 1964, UCAL_SEPTEMBER, 7, 1999, UCAL_JUNE, 4, 1999, UCAL_JUNE, 4, 1964, UCAL_SEPTEMBER, 7, }; int32_t DATA_length = (int32_t)(sizeof(DATA)/sizeof(DATA[0])); Calendar* pcal = Calendar::createInstance(Locale::getUS(), ec); Calendar& cal = *pcal; int32_t i; SimpleDateFormat fmt(UnicodeString("MMM dd yyyy",""), ec); fmt.setCalendar(cal); UnicodeString s, t, u; if (!failure(ec, "setup")) { for (i=0; iset(2004, UCAL_FEBRUARY, 29); UDate date2004 = cal->getTime(ec); cal->set(2000, UCAL_FEBRUARY, 29); UDate date2000 = cal->getTime(ec); if (U_FAILURE(ec)) { errln("FAIL: getTime()"); delete cal; return; } int32_t y = cal->fieldDifference(date2004, UCAL_YEAR, ec); int32_t d = cal->fieldDifference(date2004, UCAL_DAY_OF_YEAR, ec); if (U_FAILURE(ec)) { errln("FAIL: fieldDifference()"); delete cal; return; } if (d == 0) { logln((UnicodeString)"Ok: 2004/Feb/29 - 2000/Feb/29 = " + y + " years, " + d + " days"); } else { errln((UnicodeString)"FAIL: 2004/Feb/29 - 2000/Feb/29 = " + y + " years, " + d + " days"); } cal->setTime(date2004, ec); y = cal->fieldDifference(date2000, UCAL_YEAR, ec); d = cal->fieldDifference(date2000, UCAL_DAY_OF_YEAR, ec); if (U_FAILURE(ec)) { errln("FAIL: setTime() / fieldDifference()"); delete cal; return; } if (d == 0) { logln((UnicodeString)"Ok: 2000/Feb/29 - 2004/Feb/29 = " + y + " years, " + d + " days"); } else { errln((UnicodeString)"FAIL: 2000/Feb/29 - 2004/Feb/29 = " + y + " years, " + d + " days"); } // Test large difference cal->set(2001, UCAL_APRIL, 5); // 2452005 UDate ayl = cal->getTime(ec); cal->set(1964, UCAL_SEPTEMBER, 7); // 2438646 UDate asl = cal->getTime(ec); if (U_FAILURE(ec)) { errln("FAIL: getTime()"); delete cal; return; } d = cal->fieldDifference(ayl, UCAL_DATE, ec); cal->setTime(ayl, ec); int32_t d2 = cal->fieldDifference(asl, UCAL_DATE, ec); if (U_FAILURE(ec)) { errln("FAIL: setTime() / fieldDifference()"); delete cal; return; } if (d == -d2 && d == 13359) { logln((UnicodeString)"Ok: large field difference symmetrical " + d); } else { logln((UnicodeString)"FAIL: large field difference incorrect " + d + ", " + d2 + ", expect +/- 13359"); } delete cal; } /** * Test ms_MY "Malay (Malaysia)" locale. Bug 1543. */ void CalendarRegressionTest::TestMalaysianInstance() { Locale loc("ms", "MY"); // Malay (Malaysia) UErrorCode ec = U_ZERO_ERROR; Calendar* cal = Calendar::createInstance(loc, ec); if (U_FAILURE(ec)) { errln("FAIL: Can't construct calendar for ms_MY"); } delete cal; } /** * setFirstDayOfWeek and setMinimalDaysInFirstWeek may change the * field <=> time mapping, since they affect the interpretation of * the WEEK_OF_MONTH or WEEK_OF_YEAR fields. */ void CalendarRegressionTest::TestWeekShift() { UErrorCode ec = U_ZERO_ERROR; GregorianCalendar cal(TimeZone::createTimeZone("America/Los_Angeles"), Locale("en", "US"), ec); cal.setTime(UDate(997257600000.0), ec); // Wed Aug 08 01:00:00 PDT 2001 // In pass one, change the first day of week so that the weeks // shift in August 2001. In pass two, change the minimal days // in the first week so that the weeks shift in August 2001. // August 2001 // Su Mo Tu We Th Fr Sa // 1 2 3 4 // 5 6 7 8 9 10 11 // 12 13 14 15 16 17 18 // 19 20 21 22 23 24 25 // 26 27 28 29 30 31 for (int32_t pass=0; pass<2; ++pass) { if (pass==0) { cal.setFirstDayOfWeek(UCAL_WEDNESDAY); cal.setMinimalDaysInFirstWeek(4); } else { cal.setFirstDayOfWeek(UCAL_SUNDAY); cal.setMinimalDaysInFirstWeek(4); } cal.add(UCAL_DATE, 1, ec); // Force recalc cal.add(UCAL_DATE, -1, ec); UDate time1 = cal.getTime(ec); // Get time -- should not change // Now change a week parameter and then force a recalc. // The bug is that the recalc should not be necessary -- // calendar should do so automatically. if (pass==0) { cal.setFirstDayOfWeek(UCAL_THURSDAY); } else { cal.setMinimalDaysInFirstWeek(5); } int32_t woy1 = cal.get(UCAL_WEEK_OF_YEAR, ec); int32_t wom1 = cal.get(UCAL_WEEK_OF_MONTH, ec); cal.add(UCAL_DATE, 1, ec); // Force recalc cal.add(UCAL_DATE, -1, ec); int32_t woy2 = cal.get(UCAL_WEEK_OF_YEAR, ec); int32_t wom2 = cal.get(UCAL_WEEK_OF_MONTH, ec); UDate time2 = cal.getTime(ec); if (U_FAILURE(ec)) { errln("FAIL: internal test error"); return; } if (time1 != time2) { errln("FAIL: shifting week should not alter time"); } else { // logln(time1); } if (woy1 == woy2 && wom1 == wom2) { logln((UnicodeString)"Ok: WEEK_OF_YEAR: " + woy1 + ", WEEK_OF_MONTH: " + wom1); } else { errln((UnicodeString)"FAIL: WEEK_OF_YEAR: " + woy1 + " => " + woy2 + ", WEEK_OF_MONTH: " + wom1 + " => " + wom2 + " after week shift"); } } } /** * Make sure that when adding a day, we actually wind up in a * different day. The DST adjustments we use to keep the hour * constant across DST changes can backfire and change the day. */ void CalendarRegressionTest::TestTimeZoneTransitionAdd() { UErrorCode ec = U_ZERO_ERROR; Locale locale(Locale::getUS()); // could also be CHINA SimpleDateFormat dateFormat("MM/dd/yyyy HH:mm z", locale, ec); StringEnumeration *tz = TimeZone::createEnumeration(); if (tz == NULL) { errln("FAIL: TimeZone::createEnumeration"); return; } UnicodeString buf1, buf2; const UChar* id; while ((id = tz->unext(NULL, ec)) != NULL && U_SUCCESS(ec)) { if (U_FAILURE(ec)) { errln("FAIL: StringEnumeration::unext"); break; } TimeZone *t = TimeZone::createTimeZone(id); if (t == NULL) { errln("FAIL: TimeZone::createTimeZone"); break; } dateFormat.setTimeZone(*t); Calendar *cal = Calendar::createInstance(t, locale, ec); if (cal == NULL || U_FAILURE(ec)) { errln("FAIL: Calendar::createTimeZone"); delete cal; break; } cal->clear(); // Scan the year 2003, overlapping the edges of the year cal->set(UCAL_YEAR, 2002); cal->set(UCAL_MONTH, UCAL_DECEMBER); cal->set(UCAL_DATE, 25); for (int32_t i=0; i<365+10 && U_SUCCESS(ec); ++i) { UDate yesterday = cal->getTime(ec); int32_t yesterday_day = cal->get(UCAL_DATE, ec); cal->add(UCAL_DATE, 1, ec); if (yesterday_day == cal->get(UCAL_DATE, ec)) { errln(UnicodeString(id) + " " + dateFormat.format(yesterday, buf1) + " +1d= " + dateFormat.format(cal->getTime(ec), buf2)); buf1.truncate(0); buf2.truncate(0); } } delete cal; } if (U_FAILURE(ec)) { errln("FAIL: %s", u_errorName(ec)); } delete tz; } UDate CalendarRegressionTest::makeDate(int32_t y, int32_t m, int32_t d, int32_t hr, int32_t min, int32_t sec) { UDate result; UErrorCode status = U_ZERO_ERROR; Calendar *cal = Calendar::createInstance(status); cal->clear(); cal->set(UCAL_YEAR, y); if(m != 0) cal->set(UCAL_MONTH, m); if(d != 0) cal->set(UCAL_DATE, d); if(hr != 0) cal->set(UCAL_HOUR, hr); if(min != 0) cal->set(UCAL_MINUTE, min); if(sec != 0) cal->set(UCAL_SECOND, sec); result = cal->getTime(status); delete cal; return result; } #endif /* #if !UCONFIG_NO_FORMATTING */