#include "unicode/utypes.h"
#if !UCONFIG_NO_FORMATTING
#include "caltest.h"
#include "unicode/gregocal.h"
#include "unicode/smpdtfmt.h"
#include "unicode/simpletz.h"
static UnicodeString fieldName(UCalendarDateFields f);
static UnicodeString calToStr(const Calendar & cal)
{
UnicodeString out;
UErrorCode status = U_ZERO_ERROR;
int i;
for(i = 0;i<UCAL_FIELD_COUNT;i++) {
out += (UnicodeString("+") + fieldName((UCalendarDateFields)i) + "=" + cal.get((UCalendarDateFields)i, status) + UnicodeString(", "));
}
return out;
}
void CalendarTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* )
{
if (exec) logln("TestSuite TestCalendar");
switch (index) {
case 0:
name = "TestDOW943";
if (exec) {
logln("TestDOW943---"); logln("");
TestDOW943();
}
break;
case 1:
name = "TestClonesUnique908";
if (exec) {
logln("TestClonesUnique908---"); logln("");
TestClonesUnique908();
}
break;
case 2:
name = "TestGregorianChange768";
if (exec) {
logln("TestGregorianChange768---"); logln("");
TestGregorianChange768();
}
break;
case 3:
name = "TestDisambiguation765";
if (exec) {
logln("TestDisambiguation765---"); logln("");
TestDisambiguation765();
}
break;
case 4:
name = "TestGMTvsLocal4064654";
if (exec) {
logln("TestGMTvsLocal4064654---"); logln("");
TestGMTvsLocal4064654();
}
break;
case 5:
name = "TestAddSetOrder621";
if (exec) {
logln("TestAddSetOrder621---"); logln("");
TestAddSetOrder621();
}
break;
case 6:
name = "TestAdd520";
if (exec) {
logln("TestAdd520---"); logln("");
TestAdd520();
}
break;
case 7:
name = "TestFieldSet4781";
if (exec) {
logln("TestFieldSet4781---"); logln("");
TestFieldSet4781();
}
break;
case 8:
name = "TestSerialize337";
if (exec) {
logln("TestSerialize337---"); logln("");
}
break;
case 9:
name = "TestSecondsZero121";
if (exec) {
logln("TestSecondsZero121---"); logln("");
TestSecondsZero121();
}
break;
case 10:
name = "TestAddSetGet0610";
if (exec) {
logln("TestAddSetGet0610---"); logln("");
TestAddSetGet0610();
}
break;
case 11:
name = "TestFields060";
if (exec) {
logln("TestFields060---"); logln("");
TestFields060();
}
break;
case 12:
name = "TestEpochStartFields";
if (exec) {
logln("TestEpochStartFields---"); logln("");
TestEpochStartFields();
}
break;
case 13:
name = "TestDOWProgression";
if (exec) {
logln("TestDOWProgression---"); logln("");
TestDOWProgression();
}
break;
case 14:
name = "TestGenericAPI";
if (exec) {
logln("TestGenericAPI---"); logln("");
TestGenericAPI();
}
break;
case 15:
name = "TestAddRollExtensive";
if (exec) {
logln("TestAddRollExtensive---"); logln("");
TestAddRollExtensive();
}
break;
case 16:
name = "TestDOW_LOCALandYEAR_WOY";
if (exec) {
logln("TestDOW_LOCALandYEAR_WOY---"); logln("");
TestDOW_LOCALandYEAR_WOY();
}
break;
case 17:
name = "TestWOY";
if (exec) {
logln("TestWOY---"); logln("");
TestWOY();
}
break;
case 18:
name = "TestRog";
if (exec) {
logln("TestRog---"); logln("");
TestRog();
}
break;
default: name = ""; break;
}
}
static UnicodeString fieldName(UCalendarDateFields f) {
switch (f) {
case UCAL_ERA: return "ERA";
case UCAL_YEAR: return "YEAR";
case UCAL_MONTH: return "MONTH";
case UCAL_WEEK_OF_YEAR: return "WEEK_OF_YEAR";
case UCAL_WEEK_OF_MONTH: return "WEEK_OF_MONTH";
case UCAL_DATE: return "DAY_OF_MONTH"; case UCAL_DAY_OF_YEAR: return "DAY_OF_YEAR";
case UCAL_DAY_OF_WEEK: return "DAY_OF_WEEK";
case UCAL_DAY_OF_WEEK_IN_MONTH: return "DAY_OF_WEEK_IN_MONTH";
case UCAL_AM_PM: return "AM_PM";
case UCAL_HOUR: return "HOUR";
case UCAL_HOUR_OF_DAY: return "HOUR_OF_DAY";
case UCAL_MINUTE: return "MINUTE";
case UCAL_SECOND: return "SECOND";
case UCAL_MILLISECOND: return "MILLISECOND";
case UCAL_ZONE_OFFSET: return "ZONE_OFFSET";
case UCAL_DST_OFFSET: return "DST_OFFSET";
case UCAL_YEAR_WOY: return "YEAR_WOY";
case UCAL_DOW_LOCAL: return "DOW_LOCAL";
case UCAL_FIELD_COUNT: return "FIELD_COUNT";
default:
return UnicodeString("") + ((int32_t)f);
}
}
void
CalendarTest::TestGenericAPI()
{
UErrorCode status = U_ZERO_ERROR;
UDate d;
UnicodeString str;
UDate when = date(90, UCAL_APRIL, 15);
UnicodeString tzid("TestZone");
int32_t tzoffset = 123400;
SimpleTimeZone *zone = new SimpleTimeZone(tzoffset, tzid);
Calendar *cal = Calendar::createInstance(zone->clone(), status);
if (failure(status, "Calendar::createInstance")) return;
if (*zone != cal->getTimeZone()) errln("FAIL: Calendar::getTimeZone failed");
Calendar *cal2 = Calendar::createInstance(cal->getTimeZone(), status);
if (failure(status, "Calendar::createInstance")) return;
cal->setTime(when, status);
cal2->setTime(when, status);
if (failure(status, "Calendar::setTime")) return;
if (!(*cal == *cal2)) errln("FAIL: Calendar::operator== failed");
if ((*cal != *cal2)) errln("FAIL: Calendar::operator!= failed");
if (!cal->equals(*cal2, status) ||
cal->before(*cal2, status) ||
cal->after(*cal2, status) ||
U_FAILURE(status)) errln("FAIL: equals/before/after failed");
cal2->setTime(when + 1000, status);
if (failure(status, "Calendar::setTime")) return;
if (cal->equals(*cal2, status) ||
cal2->before(*cal, status) ||
cal->after(*cal2, status) ||
U_FAILURE(status)) errln("FAIL: equals/before/after failed");
cal->roll(UCAL_SECOND, (UBool) TRUE, status);
if (failure(status, "Calendar::roll")) return;
if (!cal->equals(*cal2, status) ||
cal->before(*cal2, status) ||
cal->after(*cal2, status) ||
U_FAILURE(status)) errln("FAIL: equals/before/after failed");
cal->roll(UCAL_MONTH, (int32_t)(1 + UCAL_DECEMBER - cal->get(UCAL_MONTH, status)), status);
if (failure(status, "Calendar::roll")) return;
if (cal->equals(*cal2, status) ||
cal2->before(*cal, status) ||
cal->after(*cal2, status) ||
U_FAILURE(status)) errln("FAIL: equals/before/after failed");
TimeZone *z = cal->orphanTimeZone();
if (z->getID(str) != tzid ||
z->getRawOffset() != tzoffset)
errln("FAIL: orphanTimeZone failed");
int32_t i;
for (i=0; i<2; ++i)
{
UBool lenient = ( i > 0 );
cal->setLenient(lenient);
if (lenient != cal->isLenient()) errln("FAIL: setLenient/isLenient failed");
}
for (i=UCAL_SUNDAY; i<=UCAL_SATURDAY; ++i)
{
cal->setFirstDayOfWeek((UCalendarDaysOfWeek)i);
if (cal->getFirstDayOfWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
UErrorCode aStatus = U_ZERO_ERROR;
if (cal->getFirstDayOfWeek(aStatus) != i || U_FAILURE(aStatus)) errln("FAIL: getFirstDayOfWeek(status) failed");
}
for (i=1; i<=7; ++i)
{
cal->setMinimalDaysInFirstWeek((uint8_t)i);
if (cal->getMinimalDaysInFirstWeek() != i) errln("FAIL: set/getFirstDayOfWeek failed");
}
for (i=0; i<UCAL_FIELD_COUNT; ++i)
{
if (cal->getMinimum((UCalendarDateFields)i) != cal->getGreatestMinimum((UCalendarDateFields)i))
errln("FAIL: getMinimum doesn't match getGreatestMinimum for field " + i);
if (cal->getLeastMaximum((UCalendarDateFields)i) > cal->getMaximum((UCalendarDateFields)i))
errln("FAIL: getLeastMaximum larger than getMaximum for field " + i);
if (cal->getMinimum((UCalendarDateFields)i) >= cal->getMaximum((UCalendarDateFields)i))
errln("FAIL: getMinimum not less than getMaximum for field " + i);
}
cal->adoptTimeZone(TimeZone::createDefault());
cal->clear();
cal->set(1984, 5, 24);
if (cal->getTime(status) != date(84, 5, 24) || U_FAILURE(status))
errln("FAIL: Calendar::set(3 args) failed");
cal->clear();
cal->set(1985, 3, 2, 11, 49);
if (cal->getTime(status) != date(85, 3, 2, 11, 49) || U_FAILURE(status))
errln("FAIL: Calendar::set(5 args) failed");
cal->clear();
cal->set(1995, 9, 12, 1, 39, 55);
if (cal->getTime(status) != date(95, 9, 12, 1, 39, 55) || U_FAILURE(status))
errln("FAIL: Calendar::set(6 args) failed");
cal->getTime(status);
if (failure(status, "Calendar::getTime")) return;
for (i=0; i<UCAL_FIELD_COUNT; ++i)
{
switch(i) {
case UCAL_YEAR: case UCAL_MONTH: case UCAL_DATE:
case UCAL_HOUR_OF_DAY: case UCAL_MINUTE: case UCAL_SECOND:
if (!cal->isSet((UCalendarDateFields)i)) errln("FAIL: Calendar::isSet failed");
break;
default:
if (cal->isSet((UCalendarDateFields)i)) errln("FAIL: Calendar::isSet failed");
}
cal->clear((UCalendarDateFields)i);
if (cal->isSet((UCalendarDateFields)i)) errln("FAIL: Calendar::clear/isSet failed");
}
delete cal;
delete cal2;
int32_t count;
const Locale* loc = Calendar::getAvailableLocales(count);
if (count < 1 || loc == 0)
{
errln("FAIL: getAvailableLocales failed");
}
else
{
for (i=0; i<count; ++i)
{
cal = Calendar::createInstance(loc[i], status);
if (failure(status, "Calendar::createInstance")) return;
delete cal;
}
}
cal = Calendar::createInstance(TimeZone::createDefault(), Locale::getEnglish(), status);
if (failure(status, "Calendar::createInstance")) return;
delete cal;
cal = Calendar::createInstance(*zone, Locale::getEnglish(), status);
if (failure(status, "Calendar::createInstance")) return;
delete cal;
GregorianCalendar *gc = new GregorianCalendar(*zone, status);
if (failure(status, "new GregorianCalendar")) return;
delete gc;
gc = new GregorianCalendar(Locale::getEnglish(), status);
if (failure(status, "new GregorianCalendar")) return;
delete gc;
gc = new GregorianCalendar(Locale::getEnglish(), status);
delete gc;
gc = new GregorianCalendar(*zone, Locale::getEnglish(), status);
if (failure(status, "new GregorianCalendar")) return;
delete gc;
gc = new GregorianCalendar(zone, status);
if (failure(status, "new GregorianCalendar")) return;
delete gc;
gc = new GregorianCalendar(1998, 10, 14, 21, 43, status);
if (gc->getTime(status) != (d =date(98, 10, 14, 21, 43) )|| U_FAILURE(status))
errln("FAIL: new GregorianCalendar(ymdhm) failed with " + UnicodeString(u_errorName(status)) + ", cal=" + gc->getTime(status) + UnicodeString(calToStr(*gc)) + ", d=" + d);
else
logln(UnicodeString("GOOD: cal=") +gc->getTime(status) + UnicodeString(calToStr(*gc)) + ", d=" + d);
delete gc;
gc = new GregorianCalendar(1998, 10, 14, 21, 43, 55, status);
if (gc->getTime(status) != (d=date(98, 10, 14, 21, 43, 55)) || U_FAILURE(status))
errln("FAIL: new GregorianCalendar(ymdhms) failed with " + UnicodeString(u_errorName(status)));
GregorianCalendar gc2(Locale::getEnglish(), status);
if (failure(status, "new GregorianCalendar")) return;
gc2 = *gc;
if (gc2 != *gc || !(gc2 == *gc)) errln("FAIL: GregorianCalendar assignment/operator==/operator!= failed");
delete gc;
delete z;
}
void
CalendarTest::TestRog()
{
UErrorCode status = U_ZERO_ERROR;
GregorianCalendar* gc = new GregorianCalendar(status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
int32_t year = 1997, month = UCAL_APRIL, date = 1;
gc->set(year, month, date);
gc->set(UCAL_HOUR_OF_DAY, 23);
gc->set(UCAL_MINUTE, 0);
gc->set(UCAL_SECOND, 0);
gc->set(UCAL_MILLISECOND, 0);
for (int32_t i = 0; i < 9; i++, gc->add(UCAL_DATE, 1, status)) {
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
if (gc->get(UCAL_YEAR, status) != year ||
gc->get(UCAL_MONTH, status) != month ||
gc->get(UCAL_DATE, status) != (date + i)) errln("FAIL: Date wrong");
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
}
delete gc;
}
void
CalendarTest::TestDOW943()
{
dowTest(FALSE);
dowTest(TRUE);
}
void CalendarTest::dowTest(UBool lenient)
{
UErrorCode status = U_ZERO_ERROR;
GregorianCalendar* cal = new GregorianCalendar(status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
cal->set(1997, UCAL_AUGUST, 12);
cal->getTime(status);
if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
cal->setLenient(lenient);
cal->set(1996, UCAL_DECEMBER, 1);
int32_t dow = cal->get(UCAL_DAY_OF_WEEK, status);
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
int32_t min = cal->getMinimum(UCAL_DAY_OF_WEEK);
int32_t max = cal->getMaximum(UCAL_DAY_OF_WEEK);
if (dow < min ||
dow > max) errln(UnicodeString("FAIL: Day of week ") + (int32_t)dow + " out of range");
if (dow != UCAL_SUNDAY) errln("FAIL: Day of week should be SUNDAY");
if (min != UCAL_SUNDAY ||
max != UCAL_SATURDAY) errln("FAIL: Min/max bad");
delete cal;
}
void
CalendarTest::TestClonesUnique908()
{
UErrorCode status = U_ZERO_ERROR;
Calendar *c = Calendar::createInstance(status);
if (U_FAILURE(status)) { errln("Calendar::createInstance failed"); return; }
Calendar *d = (Calendar*) c->clone();
c->set(UCAL_MILLISECOND, 123);
d->set(UCAL_MILLISECOND, 456);
if (c->get(UCAL_MILLISECOND, status) != 123 ||
d->get(UCAL_MILLISECOND, status) != 456) {
errln("FAIL: Clones share fields");
}
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
delete c;
delete d;
}
void
CalendarTest::TestGregorianChange768()
{
UBool b;
UErrorCode status = U_ZERO_ERROR;
UnicodeString str;
GregorianCalendar* c = new GregorianCalendar(status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
logln(UnicodeString("With cutoff ") + dateToString(c->getGregorianChange(), str));
b = c->isLeapYear(1800);
logln(UnicodeString(" isLeapYear(1800) = ") + (b ? "true" : "false"));
logln(UnicodeString(" (should be FALSE)"));
if (b) errln("FAIL");
c->setGregorianChange(date(0, 0, 1), status);
if (U_FAILURE(status)) { errln("GregorianCalendar::setGregorianChange failed"); return; }
logln(UnicodeString("With cutoff ") + dateToString(c->getGregorianChange(), str));
b = c->isLeapYear(1800);
logln(UnicodeString(" isLeapYear(1800) = ") + (b ? "true" : "false"));
logln(UnicodeString(" (should be TRUE)"));
if (!b) errln("FAIL");
delete c;
}
void
CalendarTest::TestDisambiguation765()
{
UErrorCode status = U_ZERO_ERROR;
Calendar *c = Calendar::createInstance(status);
if (U_FAILURE(status)) { errln("Calendar::createInstance failed"); return; }
c->setLenient(FALSE);
c->clear();
c->set(UCAL_YEAR, 1997);
c->set(UCAL_MONTH, UCAL_JUNE);
c->set(UCAL_DATE, 3);
verify765("1997 third day of June = ", c, 1997, UCAL_JUNE, 3);
c->clear();
c->set(UCAL_YEAR, 1997);
c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
c->set(UCAL_MONTH, UCAL_JUNE);
c->set(UCAL_DAY_OF_WEEK_IN_MONTH, 1);
verify765("1997 first Tuesday in June = ", c, 1997, UCAL_JUNE, 3);
c->clear();
c->set(UCAL_YEAR, 1997);
c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
c->set(UCAL_MONTH, UCAL_JUNE);
c->set(UCAL_DAY_OF_WEEK_IN_MONTH, - 1);
verify765("1997 last Tuesday in June = ", c, 1997, UCAL_JUNE, 24);
status = U_ZERO_ERROR;
c->clear();
c->set(UCAL_YEAR, 1997);
c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
c->set(UCAL_MONTH, UCAL_JUNE);
c->set(UCAL_DAY_OF_WEEK_IN_MONTH, 0);
c->getTime(status);
verify765("1997 zero-th Tuesday in June = ", status);
c->clear();
c->set(UCAL_YEAR, 1997);
c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
c->set(UCAL_MONTH, UCAL_JUNE);
c->set(UCAL_WEEK_OF_MONTH, 1);
verify765("1997 Tuesday in week 1 of June = ", c, 1997, UCAL_JUNE, 3);
c->clear();
c->set(UCAL_YEAR, 1997);
c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
c->set(UCAL_MONTH, UCAL_JUNE);
c->set(UCAL_WEEK_OF_MONTH, 5);
verify765("1997 Tuesday in week 5 of June = ", c, 1997, UCAL_JULY, 1);
status = U_ZERO_ERROR;
c->clear();
c->set(UCAL_YEAR, 1997);
c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
c->set(UCAL_MONTH, UCAL_JUNE);
c->set(UCAL_WEEK_OF_MONTH, 0);
verify765("1997 Tuesday in week 0 of June = ", c, 1997, UCAL_MAY, 27);
c->clear();
c->set(UCAL_YEAR_WOY, 1997); c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
c->set(UCAL_WEEK_OF_YEAR, 1);
verify765("1997 Tuesday in week 1 of yearWOY = ", c, 1996, UCAL_DECEMBER, 31);
c->clear(); c->set(UCAL_YEAR, 1997);
c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
c->set(UCAL_WEEK_OF_YEAR, 1);
verify765("1997 Tuesday in week 1 of year = ", c, 1997, UCAL_DECEMBER, 30);
c->clear();
c->set(UCAL_YEAR, 1997);
c->set(UCAL_DAY_OF_WEEK, UCAL_TUESDAY);
c->set(UCAL_WEEK_OF_YEAR, 10);
verify765("1997 Tuesday in week 10 of year = ", c, 1997, UCAL_MARCH, 4);
delete c;
}
void
CalendarTest::verify765(const UnicodeString& msg, Calendar* c, int32_t year, int32_t month, int32_t day)
{
UnicodeString str;
UErrorCode status = U_ZERO_ERROR;
if (c->get(UCAL_YEAR, status) == year &&
c->get(UCAL_MONTH, status) == month &&
c->get(UCAL_DATE, status) == day) {
if (U_FAILURE(status)) { errln("FAIL: Calendar::get failed"); return; }
logln("PASS: " + msg + dateToString(c->getTime(status), str));
if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
}
else {
errln("FAIL: " + msg + dateToString(c->getTime(status), str) + "; expected " + (int32_t)year + "/" + (int32_t)(month + 1) + "/" + (int32_t)day);
if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
}
}
void
CalendarTest::verify765(const UnicodeString& msg, UErrorCode status)
{
if (status != U_ILLEGAL_ARGUMENT_ERROR) errln("FAIL: No IllegalArgumentException for " + msg);
else logln("PASS: " + msg + "IllegalArgument as expected");
}
void
CalendarTest::TestGMTvsLocal4064654()
{
test4064654(1997, 1, 1, 12, 0, 0);
test4064654(1997, 4, 16, 18, 30, 0);
}
void
CalendarTest::test4064654(int32_t yr, int32_t mo, int32_t dt, int32_t hr, int32_t mn, int32_t sc)
{
UDate date;
UErrorCode status = U_ZERO_ERROR;
UnicodeString str;
Calendar *gmtcal = Calendar::createInstance(status);
if (U_FAILURE(status)) { errln("Calendar::createInstance failed"); return; }
gmtcal->adoptTimeZone(TimeZone::createTimeZone("Africa/Casablanca"));
gmtcal->set(yr, mo - 1, dt, hr, mn, sc);
gmtcal->set(UCAL_MILLISECOND, 0);
date = gmtcal->getTime(status);
if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
logln("date = " + dateToString(date, str));
Calendar *cal = Calendar::createInstance(status);
if (U_FAILURE(status)) { errln("Calendar::createInstance failed"); return; }
cal->setTime(date, status);
if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
int32_t offset = cal->getTimeZone().getOffset((uint8_t)cal->get(UCAL_ERA, status),
cal->get(UCAL_YEAR, status),
cal->get(UCAL_MONTH, status),
cal->get(UCAL_DATE, status),
(uint8_t)cal->get(UCAL_DAY_OF_WEEK, status),
cal->get(UCAL_MILLISECOND, status), status);
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
logln("offset for " + dateToString(date, str) + "= " + (offset / 1000 / 60 / 60.0) + "hr");
int32_t utc = ((cal->get(UCAL_HOUR_OF_DAY, status) * 60 +
cal->get(UCAL_MINUTE, status)) * 60 +
cal->get(UCAL_SECOND, status)) * 1000 +
cal->get(UCAL_MILLISECOND, status) - offset;
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
int32_t expected = ((hr * 60 + mn) * 60 + sc) * 1000;
if (utc != expected) errln(UnicodeString("FAIL: Discrepancy of ") + (utc - expected) +
" millis = " + ((utc - expected) / 1000 / 60 / 60.0) + " hr");
delete gmtcal;
delete cal;
}
void
CalendarTest::TestAddSetOrder621()
{
UDate d = date(97, 4, 14, 13, 23, 45);
UErrorCode status = U_ZERO_ERROR;
Calendar *cal = Calendar::createInstance(status);
if (U_FAILURE(status)) {
errln("Calendar::createInstance failed");
delete cal;
return;
}
cal->setTime(d, status);
if (U_FAILURE(status)) {
errln("Calendar::setTime failed");
delete cal;
return;
}
cal->add(UCAL_DATE, - 5, status);
if (U_FAILURE(status)) {
errln("Calendar::add failed");
delete cal;
return;
}
cal->set(UCAL_HOUR_OF_DAY, 0);
cal->set(UCAL_MINUTE, 0);
cal->set(UCAL_SECOND, 0);
UnicodeString s;
dateToString(cal->getTime(status), s);
if (U_FAILURE(status)) {
errln("Calendar::getTime failed");
delete cal;
return;
}
delete cal;
cal = Calendar::createInstance(status);
if (U_FAILURE(status)) {
errln("Calendar::createInstance failed");
delete cal;
return;
}
cal->setTime(d, status);
if (U_FAILURE(status)) {
errln("Calendar::setTime failed");
delete cal;
return;
}
cal->set(UCAL_HOUR_OF_DAY, 0);
cal->set(UCAL_MINUTE, 0);
cal->set(UCAL_SECOND, 0);
cal->add(UCAL_DATE, - 5, status);
if (U_FAILURE(status)) {
errln("Calendar::add failed");
delete cal;
return;
}
UnicodeString s2;
dateToString(cal->getTime(status), s2);
if (U_FAILURE(status)) {
errln("Calendar::getTime failed");
delete cal;
return;
}
if (s == s2)
logln("Pass: " + s + " == " + s2);
else
errln("FAIL: " + s + " != " + s2);
delete cal;
}
void
CalendarTest::TestAdd520()
{
int32_t y = 1997, m = UCAL_FEBRUARY, d = 1;
UErrorCode status = U_ZERO_ERROR;
GregorianCalendar *temp = new GregorianCalendar(y, m, d, status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
check520(temp, y, m, d);
temp->add(UCAL_YEAR, 1, status);
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
y++;
check520(temp, y, m, d);
temp->add(UCAL_MONTH, 1, status);
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
m++;
check520(temp, y, m, d);
temp->add(UCAL_DATE, 1, status);
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
d++;
check520(temp, y, m, d);
temp->add(UCAL_DATE, 2, status);
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
d += 2;
check520(temp, y, m, d);
temp->add(UCAL_DATE, 28, status);
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
d = 1;++m;
check520(temp, y, m, d);
delete temp;
}
void
CalendarTest::TestAddRollExtensive()
{
int32_t maxlimit = 40;
int32_t y = 1997, m = UCAL_FEBRUARY, d = 1, hr = 1, min = 1, sec = 0, ms = 0;
UErrorCode status = U_ZERO_ERROR;
GregorianCalendar *temp = new GregorianCalendar(y, m, d, status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
temp->set(UCAL_HOUR, hr);
temp->set(UCAL_MINUTE, min);
temp->set(UCAL_SECOND, sec);
temp->set(UCAL_MILLISECOND, ms);
UCalendarDateFields e;
logln("Testing GregorianCalendar add...");
e = UCAL_YEAR;
while (e < UCAL_FIELD_COUNT) {
int32_t i;
int32_t limit = maxlimit;
status = U_ZERO_ERROR;
for (i = 0; i < limit; i++) {
temp->add(e, 1, status);
if (U_FAILURE(status)) { limit = i; status = U_ZERO_ERROR; }
}
for (i = 0; i < limit; i++) {
temp->add(e, -1, status);
if (U_FAILURE(status)) { errln("GregorianCalendar::add -1 failed"); return; }
}
check520(temp, y, m, d, hr, min, sec, ms, e);
e = (UCalendarDateFields) ((int32_t) e + 1);
}
logln("Testing GregorianCalendar roll...");
e = UCAL_YEAR;
while (e < UCAL_FIELD_COUNT) {
int32_t i;
int32_t limit = maxlimit;
status = U_ZERO_ERROR;
for (i = 0; i < limit; i++) {
temp->roll(e, 1, status);
if (U_FAILURE(status)) { limit = i; status = U_ZERO_ERROR; }
}
for (i = 0; i < limit; i++) {
temp->roll(e, -1, status);
if (U_FAILURE(status)) { errln("GregorianCalendar::roll -1 failed"); return; }
}
check520(temp, y, m, d, hr, min, sec, ms, e);
e = (UCalendarDateFields) ((int32_t) e + 1);
}
delete temp;
}
void
CalendarTest::check520(Calendar* c,
int32_t y, int32_t m, int32_t d,
int32_t hr, int32_t min, int32_t sec,
int32_t ms, UCalendarDateFields field)
{
UErrorCode status = U_ZERO_ERROR;
if (c->get(UCAL_YEAR, status) != y ||
c->get(UCAL_MONTH, status) != m ||
c->get(UCAL_DATE, status) != d ||
c->get(UCAL_HOUR, status) != hr ||
c->get(UCAL_MINUTE, status) != min ||
c->get(UCAL_SECOND, status) != sec ||
c->get(UCAL_MILLISECOND, status) != ms) {
errln(UnicodeString("U_FAILURE for field ") + (int32_t)field +
": Expected y/m/d h:m:s:ms of " +
y + "/" + (m + 1) + "/" + d + " " +
hr + ":" + min + ":" + sec + ":" + ms +
"; got " + c->get(UCAL_YEAR, status) +
"/" + (c->get(UCAL_MONTH, status) + 1) +
"/" + c->get(UCAL_DATE, status) +
" " + c->get(UCAL_HOUR, status) + ":" +
c->get(UCAL_MINUTE, status) + ":" +
c->get(UCAL_SECOND, status) + ":" +
c->get(UCAL_MILLISECOND, status)
);
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
}
else
logln(UnicodeString("Confirmed: ") + y + "/" +
(m + 1) + "/" + d + " " +
hr + ":" + min + ":" + sec + ":" + ms);
}
void
CalendarTest::check520(Calendar* c,
int32_t y, int32_t m, int32_t d)
{
UErrorCode status = U_ZERO_ERROR;
if (c->get(UCAL_YEAR, status) != y ||
c->get(UCAL_MONTH, status) != m ||
c->get(UCAL_DATE, status) != d) {
errln(UnicodeString("FAILURE: Expected y/m/d of ") +
y + "/" + (m + 1) + "/" + d + " " +
"; got " + c->get(UCAL_YEAR, status) +
"/" + (c->get(UCAL_MONTH, status) + 1) +
"/" + c->get(UCAL_DATE, status)
);
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
}
else
logln(UnicodeString("Confirmed: ") + y + "/" +
(m + 1) + "/" + d);
}
void
CalendarTest::TestFieldSet4781()
{
UErrorCode status = U_ZERO_ERROR;
GregorianCalendar *g = new GregorianCalendar(status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
GregorianCalendar *g2 = new GregorianCalendar(status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
g2->set(UCAL_HOUR, 12, status);
g2->set(UCAL_MINUTE, 0, status);
g2->set(UCAL_SECOND, 0, status);
if (U_FAILURE(status)) { errln("Calendar::set failed"); return; }
if (*g == *g2) logln("Same");
else logln("Different");
delete g;
delete g2;
}
void
CalendarTest::TestSecondsZero121()
{
UErrorCode status = U_ZERO_ERROR;
Calendar *cal = new GregorianCalendar(status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
cal->setTime(Calendar::getNow(), status);
if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
cal->set(UCAL_SECOND, 0);
if (U_FAILURE(status)) { errln("Calendar::set failed"); return; }
UDate d = cal->getTime(status);
if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
UnicodeString s;
dateToString(d, s);
if (s.indexOf(":00 ") < 0) errln("Expected to see :00 in " + s);
delete cal;
}
void
CalendarTest::TestAddSetGet0610()
{
UnicodeString EXPECTED_0610("1993/0/5", "");
UErrorCode status = U_ZERO_ERROR;
{
Calendar *calendar = new GregorianCalendar(status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
calendar->set(1993, UCAL_JANUARY, 4);
logln("1A) " + value(calendar));
calendar->add(UCAL_DATE, 1, status);
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
UnicodeString v = value(calendar);
logln("1B) " + v);
logln("--) 1993/0/5");
if (!(v == EXPECTED_0610)) errln("Expected " + EXPECTED_0610 + "; saw " + v);
delete calendar;
}
{
Calendar *calendar = new GregorianCalendar(1993, UCAL_JANUARY, 4, status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
logln("2A) " + value(calendar));
calendar->add(UCAL_DATE, 1, status);
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
UnicodeString v = value(calendar);
logln("2B) " + v);
logln("--) 1993/0/5");
if (!(v == EXPECTED_0610)) errln("Expected " + EXPECTED_0610 + "; saw " + v);
delete calendar;
}
{
Calendar *calendar = new GregorianCalendar(1993, UCAL_JANUARY, 4, status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
logln("3A) " + value(calendar));
calendar->getTime(status);
if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
calendar->add(UCAL_DATE, 1, status);
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
UnicodeString v = value(calendar);
logln("3B) " + v);
logln("--) 1993/0/5");
if (!(v == EXPECTED_0610)) errln("Expected " + EXPECTED_0610 + "; saw " + v);
delete calendar;
}
}
UnicodeString
CalendarTest::value(Calendar* calendar)
{
UErrorCode status = U_ZERO_ERROR;
return UnicodeString("") + (int32_t)calendar->get(UCAL_YEAR, status) +
"/" + (int32_t)calendar->get(UCAL_MONTH, status) +
"/" + (int32_t)calendar->get(UCAL_DATE, status) +
(U_FAILURE(status) ? " FAIL: Calendar::get failed" : "");
}
void
CalendarTest::TestFields060()
{
UErrorCode status = U_ZERO_ERROR;
int32_t year = 1997;
int32_t month = UCAL_OCTOBER;
int32_t dDate = 22;
GregorianCalendar *calendar = 0;
calendar = new GregorianCalendar(year, month, dDate, status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
for (int32_t i = 0; i < EXPECTED_FIELDS_length;) {
UCalendarDateFields field = (UCalendarDateFields)EXPECTED_FIELDS[i++];
int32_t expected = EXPECTED_FIELDS[i++];
if (calendar->get(field, status) != expected) {
errln(UnicodeString("Expected field ") + (int32_t)field + " to have value " + (int32_t)expected +
"; received " + (int32_t)calendar->get(field, status) + " instead");
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
}
}
delete calendar;
}
int32_t CalendarTest::EXPECTED_FIELDS[] = {
UCAL_YEAR, 1997,
UCAL_MONTH, UCAL_OCTOBER,
UCAL_DATE, 22,
UCAL_DAY_OF_WEEK, UCAL_WEDNESDAY,
UCAL_DAY_OF_WEEK_IN_MONTH, 4,
UCAL_DAY_OF_YEAR, 295
};
const int32_t CalendarTest::EXPECTED_FIELDS_length = (int32_t)(sizeof(CalendarTest::EXPECTED_FIELDS) /
sizeof(CalendarTest::EXPECTED_FIELDS[0]));
void
CalendarTest::TestEpochStartFields()
{
UErrorCode status = U_ZERO_ERROR;
TimeZone *z = TimeZone::createDefault();
Calendar *c = Calendar::createInstance(status);
if (U_FAILURE(status)) { errln("Calendar::createInstance failed"); return; }
UDate d = - z->getRawOffset();
GregorianCalendar *gc = new GregorianCalendar(status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
gc->setTimeZone(*z);
gc->setTime(d, status);
if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
UBool idt = gc->inDaylightTime(status);
if (U_FAILURE(status)) { errln("GregorianCalendar::inDaylightTime failed"); return; }
if (idt) {
UnicodeString str;
logln("Warning: Skipping test because " + dateToString(d, str) + " is in DST.");
}
else {
c->setTime(d, status);
if (U_FAILURE(status)) { errln("Calendar::setTime failed"); return; }
for (int32_t i = 0; i < UCAL_ZONE_OFFSET;++i) {
if (c->get((UCalendarDateFields)i, status) != EPOCH_FIELDS[i])
errln(UnicodeString("Expected field ") + i + " to have value " + EPOCH_FIELDS[i] +
"; saw " + c->get((UCalendarDateFields)i, status) + " instead");
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
}
if (c->get(UCAL_ZONE_OFFSET, status) != z->getRawOffset())
{
errln(UnicodeString("Expected field ZONE_OFFSET to have value ") + z->getRawOffset() +
"; saw " + c->get(UCAL_ZONE_OFFSET, status) + " instead");
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
}
if (c->get(UCAL_DST_OFFSET, status) != 0)
{
errln(UnicodeString("Expected field DST_OFFSET to have value 0") +
"; saw " + c->get(UCAL_DST_OFFSET, status) + " instead");
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
}
}
delete c;
delete z;
delete gc;
}
int32_t CalendarTest::EPOCH_FIELDS[] = {
1, 1970, 0, 1, 1, 1, 1, 5, 1, 0, 0, 0, 0, 0, 0, - 28800000, 0
};
void
CalendarTest::TestDOWProgression()
{
UErrorCode status = U_ZERO_ERROR;
Calendar *cal = new GregorianCalendar(1972, UCAL_OCTOBER, 26, status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
marchByDelta(cal, 24);
delete cal;
}
void
CalendarTest::TestDOW_LOCALandYEAR_WOY()
{
UErrorCode status = U_ZERO_ERROR;
int32_t times = 20;
Calendar *cal=Calendar::createInstance(Locale::getGermany(), status);
if (U_FAILURE(status)) { errln("Couldn't create GregorianCalendar"); return; }
SimpleDateFormat *sdf=new SimpleDateFormat(UnicodeString("YYYY'-W'ww-ee"), Locale::getGermany(), status);
if (U_FAILURE(status)) { errln("Couldn't create SimpleDateFormat"); return; }
sdf->applyLocalizedPattern(UnicodeString("JJJJ'-W'ww-ee"), status);
if (U_FAILURE(status)) { errln("Couldn't apply localized pattern"); return; }
cal->clear();
cal->set(1997, UCAL_DECEMBER, 25);
doYEAR_WOYLoop(cal, sdf, times, status);
yearAddTest(*cal, status); loop_addroll(cal, times, UCAL_DOW_LOCAL, UCAL_DAY_OF_WEEK, status);
if (U_FAILURE(status)) { errln("Error in parse/calculate test for 1997"); return; }
cal->clear();
cal->set(1998, UCAL_DECEMBER, 25);
doYEAR_WOYLoop(cal, sdf, times, status);
yearAddTest(*cal, status); loop_addroll(cal, times, UCAL_DOW_LOCAL, UCAL_DAY_OF_WEEK, status);
if (U_FAILURE(status)) { errln("Error in parse/calculate test for 1998"); return; }
cal->clear();
cal->set(1582, UCAL_OCTOBER, 1);
doYEAR_WOYLoop(cal, sdf, times, status);
yearAddTest(*cal, status); loop_addroll(cal, times, UCAL_DOW_LOCAL, UCAL_DAY_OF_WEEK, status);
if (U_FAILURE(status)) { errln("Error in parse/calculate test for 1582"); return; }
delete sdf;
delete cal;
return;
}
void CalendarTest::yearAddTest(Calendar& cal, UErrorCode& status) {
int32_t y = cal.get(UCAL_YEAR, status);
int32_t mon = cal.get(UCAL_MONTH, status);
int32_t day = cal.get(UCAL_DATE, status);
int32_t ywy = cal.get(UCAL_YEAR_WOY, status);
int32_t woy = cal.get(UCAL_WEEK_OF_YEAR, status);
int32_t dow = cal.get(UCAL_DOW_LOCAL, status);
UDate t = cal.getTime(status);
UnicodeString str, str2;
SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy / YYYY'-W'ww-ee"), status);
fmt.setCalendar(cal);
fmt.format(t, str.remove());
str += ".add(YEAR, 1) =>";
cal.add(UCAL_YEAR, 1, status);
int32_t y2 = cal.get(UCAL_YEAR, status);
int32_t mon2 = cal.get(UCAL_MONTH, status);
int32_t day2 = cal.get(UCAL_DATE, status);
fmt.format(cal.getTime(status), str);
if (y2 != (y+1) || mon2 != mon || day2 != day) {
str += (UnicodeString)", expected year " +
(y+1) + ", month " + (mon+1) + ", day " + day;
errln((UnicodeString)"FAIL: " + str);
} else {
logln(str);
}
fmt.format(t, str.remove());
str += ".add(YEAR_WOY, 1)=>";
cal.setTime(t, status);
cal.add(UCAL_YEAR_WOY, 1, status);
int32_t ywy2 = cal.get(UCAL_YEAR_WOY, status);
int32_t woy2 = cal.get(UCAL_WEEK_OF_YEAR, status);
int32_t dow2 = cal.get(UCAL_DOW_LOCAL, status);
fmt.format(cal.getTime(status), str);
if (ywy2 != (ywy+1) || woy2 != woy || dow2 != dow) {
str += (UnicodeString)", expected yearWOY " +
(ywy+1) + ", woy " + woy + ", dowLocal " + dow;
errln((UnicodeString)"FAIL: " + str);
} else {
logln(str);
}
}
void CalendarTest::loop_addroll(Calendar *cal, int times, UCalendarDateFields field, UCalendarDateFields field2, UErrorCode& errorCode) {
Calendar *calclone;
SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy / YYYY'-W'ww-ee"), errorCode);
fmt.setCalendar(*cal);
int i;
for(i = 0; i<times; i++) {
calclone = cal->clone();
UDate start = cal->getTime(errorCode);
cal->add(field,1,errorCode);
if (U_FAILURE(errorCode)) { errln("Error in add"); delete calclone; return; }
calclone->add(field2,1,errorCode);
if (U_FAILURE(errorCode)) { errln("Error in add"); delete calclone; return; }
if(cal->getTime(errorCode) != calclone->getTime(errorCode)) {
UnicodeString str("FAIL: Results of add differ. "), str2;
str += fmt.format(start, str2) + " ";
str += UnicodeString("Add(") + fieldName(field) + ", 1) -> " +
fmt.format(cal->getTime(errorCode), str2.remove()) + "; ";
str += UnicodeString("Add(") + fieldName(field2) + ", 1) -> " +
fmt.format(calclone->getTime(errorCode), str2.remove());
errln(str);
delete calclone;
return;
}
delete calclone;
}
for(i = 0; i<times; i++) {
calclone = cal->clone();
cal->roll(field,(int32_t)1,errorCode);
if (U_FAILURE(errorCode)) { errln("Error in roll"); delete calclone; return; }
calclone->roll(field2,(int32_t)1,errorCode);
if (U_FAILURE(errorCode)) { errln("Error in roll"); delete calclone; return; }
if(cal->getTime(errorCode) != calclone->getTime(errorCode)) {
delete calclone;
errln("Results of roll differ!");
return;
}
delete calclone;
}
}
void
CalendarTest::doYEAR_WOYLoop(Calendar *cal, SimpleDateFormat *sdf,
int32_t times, UErrorCode& errorCode) {
UnicodeString us;
UDate tst, original;
Calendar *tstres = new GregorianCalendar(Locale::getGermany(), errorCode);
for(int i=0; i<times; ++i) {
sdf->format(Formattable(cal->getTime(errorCode),Formattable::kIsDate), us, errorCode);
if (U_FAILURE(errorCode)) { errln("Format error"); return; }
tst=sdf->parse(us,errorCode);
if (U_FAILURE(errorCode)) { errln("Parse error"); return; }
tstres->clear();
tstres->setTime(tst, errorCode);
if (U_FAILURE(errorCode)) { errln("Set time error"); return; }
original = cal->getTime(errorCode);
us.remove();
sdf->format(Formattable(tst,Formattable::kIsDate), us, errorCode);
if (U_FAILURE(errorCode)) { errln("Get time error"); return; }
if(original!=tst) {
us.remove();
sdf->format(Formattable(original, Formattable::kIsDate), us, errorCode);
errln("Parsed time doesn't match with regular");
logln("expected "+us);
us.remove();
sdf->format(Formattable(tst, Formattable::kIsDate), us, errorCode);
logln("got "+us);
}
tstres->clear();
tstres->set(UCAL_YEAR_WOY, cal->get(UCAL_YEAR_WOY, errorCode));
tstres->set(UCAL_WEEK_OF_YEAR, cal->get(UCAL_WEEK_OF_YEAR, errorCode));
tstres->set(UCAL_DOW_LOCAL, cal->get(UCAL_DOW_LOCAL, errorCode));
if(cal->get(UCAL_YEAR, errorCode) != tstres->get(UCAL_YEAR, errorCode)) {
errln("Different Year!");
logln((UnicodeString)"Expected "+cal->get(UCAL_YEAR, errorCode));
logln((UnicodeString)"Got "+tstres->get(UCAL_YEAR, errorCode));
return;
}
if(cal->get(UCAL_DAY_OF_YEAR, errorCode) != tstres->get(UCAL_DAY_OF_YEAR, errorCode)) {
errln("Different Day Of Year!");
logln((UnicodeString)"Expected "+cal->get(UCAL_DAY_OF_YEAR, errorCode));
logln((UnicodeString)"Got "+tstres->get(UCAL_DAY_OF_YEAR, errorCode));
return;
}
cal->add(UCAL_DATE, 1, errorCode);
if (U_FAILURE(errorCode)) { errln("Add error"); return; }
us.remove();
}
delete (tstres);
}
void
CalendarTest::marchByDelta(Calendar* cal, int32_t delta)
{
UErrorCode status = U_ZERO_ERROR;
Calendar *cur = (Calendar*) cal->clone();
int32_t initialDOW = cur->get(UCAL_DAY_OF_WEEK, status);
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
int32_t DOW, newDOW = initialDOW;
do {
UnicodeString str;
DOW = newDOW;
logln(UnicodeString("DOW = ") + DOW + " " + dateToString(cur->getTime(status), str));
if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
cur->add(UCAL_DAY_OF_WEEK, delta, status);
if (U_FAILURE(status)) { errln("Calendar::add failed"); return; }
newDOW = cur->get(UCAL_DAY_OF_WEEK, status);
if (U_FAILURE(status)) { errln("Calendar::get failed"); return; }
int32_t expectedDOW = 1 + (DOW + delta - 1) % 7;
if (newDOW != expectedDOW) {
errln(UnicodeString("Day of week should be ") + expectedDOW + " instead of " + newDOW +
" on " + dateToString(cur->getTime(status), str));
if (U_FAILURE(status)) { errln("Calendar::getTime failed"); return; }
return;
}
}
while (newDOW != initialDOW);
delete cur;
}
#define CHECK(status, msg) \
if (U_FAILURE(status)) { \
errln(msg); \
return; \
}
void CalendarTest::TestWOY(void) {
UnicodeString str;
UErrorCode status = U_ZERO_ERROR;
int32_t i;
GregorianCalendar cal(status);
SimpleDateFormat fmt(UnicodeString("EEE MMM dd yyyy', WOY' w"), status);
CHECK(status, "Fail: Cannot construct calendar/format");
UCalendarDaysOfWeek fdw = (UCalendarDaysOfWeek) 0;
for (int8_t pass=1; pass<=2; ++pass) {
switch (pass) {
case 1:
fdw = UCAL_MONDAY;
cal.setFirstDayOfWeek(fdw);
cal.setMinimalDaysInFirstWeek(4);
fmt.setCalendar(cal);
break;
case 2:
fdw = UCAL_MONDAY;
cal.setFirstDayOfWeek(fdw);
cal.setMinimalDaysInFirstWeek(2);
fmt.setCalendar(cal);
break;
}
for (i=0; i<16; ++i) {
UDate t, t2;
int32_t t_y, t_woy, t_dow;
cal.clear();
cal.set(1999, UCAL_DECEMBER, 26 + i);
fmt.format(t = cal.getTime(status), str.remove());
CHECK(status, "Fail: getTime failed");
logln(str);
int32_t dow = cal.get(UCAL_DAY_OF_WEEK, status);
int32_t woy = cal.get(UCAL_WEEK_OF_YEAR, status);
int32_t year = cal.get(UCAL_YEAR, status);
int32_t mon = cal.get(UCAL_MONTH, status);
CHECK(status, "Fail: get failed");
int32_t dowLocal = dow - fdw;
if (dowLocal < 0) dowLocal += 7;
dowLocal++;
int32_t yearWoy = year;
if (mon == UCAL_JANUARY) {
if (woy >= 52) --yearWoy;
} else {
if (woy == 1) ++yearWoy;
}
cal.clear();
cal.set(UCAL_YEAR, year);
cal.set(UCAL_WEEK_OF_YEAR, woy);
cal.set(UCAL_DAY_OF_WEEK, dow);
t_y = cal.get(UCAL_YEAR, status);
t_woy = cal.get(UCAL_WEEK_OF_YEAR, status);
t_dow = cal.get(UCAL_DAY_OF_WEEK, status);
CHECK(status, "Fail: get failed");
if (t_y != year || t_woy != woy || t_dow != dow) {
str = "Fail: y/woy/dow fields->time => ";
fmt.format(cal.getTime(status), str);
errln(str);
}
cal.clear();
cal.set(UCAL_YEAR, year);
cal.set(UCAL_WEEK_OF_YEAR, woy);
cal.set(UCAL_DOW_LOCAL, dowLocal);
t_y = cal.get(UCAL_YEAR, status);
t_woy = cal.get(UCAL_WEEK_OF_YEAR, status);
t_dow = cal.get(UCAL_DOW_LOCAL, status);
CHECK(status, "Fail: get failed");
if (t_y != year || t_woy != woy || t_dow != dowLocal) {
str = "Fail: y/woy/dow_local fields->time => ";
fmt.format(cal.getTime(status), str);
errln(str);
}
cal.clear();
cal.set(UCAL_YEAR_WOY, yearWoy);
cal.set(UCAL_WEEK_OF_YEAR, woy);
cal.set(UCAL_DAY_OF_WEEK, dow);
t2 = cal.getTime(status);
CHECK(status, "Fail: getTime failed");
if (t != t2) {
str = "Fail: y_woy/woy/dow fields->time => ";
fmt.format(t2, str);
errln(str);
}
cal.clear();
cal.set(UCAL_YEAR_WOY, yearWoy);
cal.set(UCAL_WEEK_OF_YEAR, woy);
cal.set(UCAL_DOW_LOCAL, dowLocal);
t2 = cal.getTime(status);
CHECK(status, "Fail: getTime failed");
if (t != t2) {
str = "Fail: y_woy/woy/dow_local fields->time => ";
fmt.format(t2, str);
errln(str);
}
int32_t wrongDow = dow - 3;
if (wrongDow < 1) wrongDow += 7;
cal.setTime(t, status);
cal.set(UCAL_DAY_OF_WEEK, wrongDow);
cal.set(UCAL_DOW_LOCAL, dowLocal);
t2 = cal.getTime(status);
CHECK(status, "Fail: set/getTime failed");
if (t != t2) {
str = "Fail: DOW_LOCAL fields->time => ";
fmt.format(t2, str);
errln(str);
}
int32_t wrongDowLocal = dowLocal - 3;
if (wrongDowLocal < 1) wrongDowLocal += 7;
cal.setTime(t, status);
cal.set(UCAL_DOW_LOCAL, wrongDowLocal);
cal.set(UCAL_DAY_OF_WEEK, dow);
t2 = cal.getTime(status);
CHECK(status, "Fail: set/getTime failed");
if (t != t2) {
str = "Fail: DOW fields->time => ";
fmt.format(t2, str);
errln(str);
}
cal.setTime(t, status);
cal.set(UCAL_YEAR, year - 2);
cal.set(UCAL_YEAR_WOY, yearWoy);
t2 = cal.getTime(status);
CHECK(status, "Fail: set/getTime failed");
if (t != t2) {
str = "Fail: YEAR_WOY fields->time => ";
fmt.format(t2, str);
errln(str);
}
cal.setTime(t, status);
cal.set(UCAL_YEAR_WOY, yearWoy - 2);
cal.set(UCAL_YEAR, year);
t2 = cal.getTime(status);
CHECK(status, "Fail: set/getTime failed");
if (t != t2) {
str = "Fail: YEAR fields->time => ";
fmt.format(t2, str);
errln(str);
}
}
}
for (i=27; i<=33; ++i) {
int32_t amount;
for (amount=-7; amount<=7; ++amount) {
str = "roll(";
cal.set(1999, UCAL_DECEMBER, i);
UDate t, t2;
fmt.format(cal.getTime(status), str);
CHECK(status, "Fail: getTime failed");
str += UnicodeString(", ") + amount + ") = ";
cal.roll(UCAL_DOW_LOCAL, amount, status);
CHECK(status, "Fail: roll failed");
t = cal.getTime(status);
int32_t newDom = i + amount;
while (newDom < 27) newDom += 7;
while (newDom > 33) newDom -= 7;
cal.set(1999, UCAL_DECEMBER, newDom);
t2 = cal.getTime(status);
CHECK(status, "Fail: getTime failed");
fmt.format(t, str);
if (t != t2) {
str.append(", exp ");
fmt.format(t2, str);
errln(str);
} else {
logln(str);
}
}
}
}
#undef CHECK
#endif