2113 lines
72 KiB
C++
2113 lines
72 KiB
C++
/********************************************************************
|
|
* 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 <float.h>
|
|
|
|
// *****************************************************************************
|
|
// 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);
|
|
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(Calendar::YEAR, 1997);
|
|
cal->set(Calendar::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, Calendar::JANUARY, 1, h, 34);
|
|
//System.out.print(d);
|
|
logln(UnicodeString("HOUR=") + cal->get(Calendar::HOUR, status)); //prints 0
|
|
failure(status, "cal->get");
|
|
logln(UnicodeString("HOUR_OF_DAY=") + cal->get(Calendar::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(GregorianCalendar::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(GregorianCalendar::MONTH, status)) ;
|
|
failure(status, "cal->get");
|
|
int32_t date = cal->get(GregorianCalendar::DATE, status) + 1 ;
|
|
failure(status, "cal->get");
|
|
log(UnicodeString("/") + date) ;
|
|
logln(UnicodeString("/") + cal->get(GregorianCalendar::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; i<ids->count(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(Calendar::HOUR, status) != 5 || U_FAILURE(status)) {
|
|
UnicodeString temp;
|
|
logln(zone->getID(temp) + " " +
|
|
//zone.useDaylightTime() + " " +
|
|
cal->get(Calendar::DST_OFFSET,status) / (60*60*1000) + " " +
|
|
zone->getRawOffset() / (60*60*1000) +
|
|
": HOUR = " + cal->get(Calendar::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(Calendar::APRIL, 1, Calendar::SUNDAY, 2 * 60 * 60 * 1000, status);
|
|
pdt->setEndRule(Calendar::OCTOBER, -1, Calendar::SUNDAY, 2 * 60 * 60 * 1000, status);
|
|
Calendar *calendar = new GregorianCalendar(pdt, status);
|
|
|
|
calendar->set(Calendar::MONTH,3);
|
|
calendar->set(Calendar::DAY_OF_MONTH,18);
|
|
calendar->set(Calendar::SECOND, 30);
|
|
|
|
logln(UnicodeString("MONTH: ") + calendar->get(Calendar::MONTH, status));
|
|
logln(UnicodeString("DAY_OF_MONTH: ") +
|
|
calendar->get(Calendar::DAY_OF_MONTH, status));
|
|
logln(UnicodeString("MINUTE: ") + calendar->get(Calendar::MINUTE, status));
|
|
logln(UnicodeString("SECOND: ") + calendar->get(Calendar::SECOND, status));
|
|
|
|
calendar->add(Calendar::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(Calendar::MONTH, status));
|
|
logln(UnicodeString("DAY_OF_MONTH: ") +
|
|
calendar->get(Calendar::DAY_OF_MONTH, status));
|
|
logln(UnicodeString("MINUTE: ") + calendar->get(Calendar::MINUTE, status));
|
|
logln(UnicodeString("SECOND: ") + calendar->get(Calendar::SECOND, status));
|
|
if (calendar->get(Calendar::MONTH, status) != 3 ||
|
|
calendar->get(Calendar::DAY_OF_MONTH, status) != 18 ||
|
|
calendar->get(Calendar::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(Calendar::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(Calendar::HOUR, 0);
|
|
gc->set(Calendar::AM_PM, Calendar::AM);
|
|
gc->set(Calendar::MINUTE, 0);
|
|
gc->set(Calendar::SECOND, 0);
|
|
gc->set(Calendar::MILLISECOND, 0);
|
|
|
|
UDate cd = gc->getTime(status);
|
|
GregorianCalendar *exp = new GregorianCalendar(97, 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(Calendar::HOUR_OF_DAY, 13);
|
|
logln(UnicodeString("Hour: ")+cal->get(Calendar::HOUR_OF_DAY, status));
|
|
cal->add(Calendar::HOUR_OF_DAY, 6,status);
|
|
logln(UnicodeString("Hour: ")+cal->get(Calendar::HOUR_OF_DAY, status));
|
|
if (cal->get(Calendar::HOUR_OF_DAY, status) != 19)
|
|
errln(UnicodeString("Fail: Want 19 Got ") + cal->get(Calendar::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(Calendar::DAY_OF_WEEK,status) == Calendar::SATURDAY ||
|
|
cal->get(Calendar::DAY_OF_WEEK,status) == Calendar::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)
|
|
* <p>
|
|
* @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(Calendar::DAY_OF_WEEK, status);
|
|
if (wd == Calendar::SATURDAY || wd == Calendar::SUNDAY) {
|
|
cal->add(Calendar::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, Calendar::AUGUST, 12); // Wednesday
|
|
// cal.getTime(); // Force update
|
|
cal->setLenient(lenient);
|
|
cal->set(1996, Calendar::DECEMBER, 1); // Set the date to be December 1, 1996
|
|
int32_t dow = cal->get(Calendar::DAY_OF_WEEK, status);
|
|
int32_t min = cal->getMinimum(Calendar::DAY_OF_WEEK);
|
|
int32_t max = cal->getMaximum(Calendar::DAY_OF_WEEK);
|
|
//logln(cal.getTime().toString());
|
|
if (min != Calendar::SUNDAY || max != Calendar::SATURDAY)
|
|
errln("FAIL: Min/max bad");
|
|
if (dow < min || dow > max)
|
|
errln(UnicodeString("FAIL: Day of week ") + dow + " out of range");
|
|
if (dow != Calendar::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, Calendar::JUNE, 24),status);
|
|
cal->set(Calendar::MONTH, Calendar::NOVEMBER); // change a field
|
|
//logln(cal.getTime().toString());
|
|
if (cal->getTime(status) != makeDate(1998, Calendar::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(Calendar::DAY_OF_MONTH, + 1, status);
|
|
int32_t testyear = foo1->get(Calendar::YEAR, status);
|
|
int32_t testmonth = foo1->get(Calendar::MONTH, status);
|
|
int32_t testday = foo1->get(Calendar::DAY_OF_MONTH, 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(Calendar::HOUR_OF_DAY, status);
|
|
int32_t min = cal->get(Calendar::MINUTE, status);
|
|
int32_t sec = cal->get(Calendar::SECOND, status);
|
|
int32_t msec = cal->get(Calendar::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(Calendar::HOUR_OF_DAY, status);
|
|
min = cal->get(Calendar::MINUTE, status);
|
|
sec = cal->get(Calendar::SECOND, status);
|
|
msec = cal->get(Calendar::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,Calendar::SEPTEMBER,30);
|
|
UDate now = cal->getTime(status);
|
|
UnicodeString temp;
|
|
FieldPosition pos(FieldPosition::DONT_CARE);
|
|
logln(date->format(now, temp, pos));
|
|
cal->set(1997,Calendar::JANUARY,1);
|
|
now=cal->getTime(status);
|
|
logln(date->format(now,temp, pos));
|
|
cal->set(1997,Calendar::JANUARY,8);
|
|
now=cal->getTime(status);
|
|
logln(date->format(now,temp, pos));
|
|
cal->set(1996,Calendar::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(Calendar::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(Calendar::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,Calendar::NOVEMBER, 13,status);
|
|
int32_t dow = a->get(Calendar::DAY_OF_WEEK, status);
|
|
if (dow != Calendar::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(Calendar::HOUR_OF_DAY, status)));
|
|
cal1->setTimeZone(*GMT);
|
|
logln(UnicodeString("GMT 2 is: ") + (h2=cal1->get(Calendar::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(Calendar::YEAR,status),
|
|
cal1->get(Calendar::MONTH,status),
|
|
cal1->get(Calendar::DAY_OF_MONTH,status),
|
|
cal1->get(Calendar::HOUR_OF_DAY,status),
|
|
cal1->get(Calendar::MINUTE,status),
|
|
cal1->get(Calendar::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(Calendar::YEAR,status),
|
|
cal1->get(Calendar::MONTH,status),
|
|
cal1->get(Calendar::DAY_OF_MONTH,status),
|
|
cal1->get(Calendar::HOUR_OF_DAY,status),
|
|
cal1->get(Calendar::MINUTE,status),
|
|
cal1->get(Calendar::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(Calendar::MONTH,status)+1)+UnicodeString("/")+
|
|
gc->get(Calendar::DATE,status)+"/"+gc->get(Calendar::YEAR,status)+
|
|
" + 1mo = ");
|
|
|
|
gc->add(Calendar::MONTH, 1,status);
|
|
logln(UnicodeString("") + (m2=gc->get(Calendar::MONTH,status)+1)+UnicodeString("/")+
|
|
gc->get(Calendar::DATE,status)+"/"+gc->get(Calendar::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(Calendar::YEAR, 1997);
|
|
cal->set(Calendar::DAY_OF_YEAR, 1);
|
|
//UDate d = cal->getTime(status); // Should be Jan 1
|
|
//logln(d.toString());
|
|
if (cal->get(Calendar::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((Calendar::EDaysOfWeek)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; i<numDays; i++) {
|
|
testCal->add(Calendar::DATE,1,status);
|
|
UnicodeString calWOY;
|
|
int32_t actWOY = testCal->get(Calendar::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(Calendar::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, Calendar::DECEMBER, 21);
|
|
for (int32_t i=0; i<21; ++i) {
|
|
int32_t woy = testCal->get(Calendar::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(Calendar::YEAR_WOY, DATA[j+1+i] < 25 ? 1998 : 1997);
|
|
testCal->set(Calendar::WEEK_OF_YEAR, DATA[j+1+i]);
|
|
testCal->set(Calendar::DAY_OF_WEEK, (i%7) + Calendar::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(Calendar::DAY_OF_MONTH, 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, Calendar::SUNDAY,
|
|
(1998), (1998), (2), (Calendar::SATURDAY),
|
|
(1998), (1998), (53), (Calendar::THURSDAY),
|
|
(1999), (1998), (53), (Calendar::FRIDAY)
|
|
};
|
|
|
|
UDate DISAM_date [] = {
|
|
makeDate(1997, Calendar::DECEMBER, 28),
|
|
makeDate(1998, Calendar::JANUARY, 10),
|
|
makeDate(1998, Calendar::DECEMBER, 31),
|
|
makeDate(1999, Calendar::JANUARY, 1)
|
|
};
|
|
|
|
testCal->setMinimalDaysInFirstWeek(3);
|
|
testCal->setFirstDayOfWeek(Calendar::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, Calendar::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(Calendar::YEAR, y);
|
|
testCal->set(Calendar::WEEK_OF_YEAR, woy);
|
|
testCal->set(Calendar::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(Calendar::YEAR_WOY, ywoy);
|
|
testCal->set(Calendar::WEEK_OF_YEAR, woy);
|
|
testCal->set(Calendar::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, Calendar::DECEMBER, 25), makeDate(1999, Calendar::JANUARY, 1),
|
|
makeDate(1997, Calendar::DECEMBER, 28), makeDate(1998, Calendar::JANUARY, 4),
|
|
makeDate(1998, Calendar::DECEMBER, 27), makeDate(1997, Calendar::DECEMBER, 28),
|
|
makeDate(1999, Calendar::JANUARY, 2), makeDate(1998, Calendar::JANUARY, 3),
|
|
};
|
|
|
|
int32_t ADDROLL_int []= {
|
|
(1),
|
|
(1),
|
|
(1),
|
|
(1)
|
|
};
|
|
|
|
|
|
UBool ADDROLL_bool [] = {
|
|
TRUE,//ADD,
|
|
TRUE,
|
|
FALSE,
|
|
FALSE
|
|
};
|
|
|
|
testCal->setMinimalDaysInFirstWeek(3);
|
|
testCal->setFirstDayOfWeek(Calendar::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(Calendar::WEEK_OF_YEAR, amount,status);
|
|
else
|
|
testCal->roll(Calendar::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(Calendar::WEEK_OF_YEAR, -amount,status);
|
|
else
|
|
testCal->roll(Calendar::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, Calendar::MARCH, 15, 12, 00, 00);
|
|
UDate d01 = makeDate(1997, Calendar::MARCH, 15, 12, 00, 56);
|
|
UDate d10 = makeDate(1997, Calendar::MARCH, 15, 12, 34, 00);
|
|
UDate d11 = makeDate(1997, Calendar::MARCH, 15, 12, 34, 56);
|
|
UDate epoch = makeDate(1970, Calendar::JANUARY, 1);
|
|
|
|
Calendar *cal = Calendar::createInstance(status);
|
|
cal->setTime(d11,status);
|
|
|
|
cal->clear( Calendar::MINUTE );
|
|
logln(UnicodeString("") + cal->getTime(status));
|
|
if (cal->getTime(status) != d01)
|
|
errln("Fail: clear(MINUTE) broken");
|
|
|
|
cal->set( Calendar::SECOND, 0 );
|
|
logln(UnicodeString("") + cal->getTime(status));
|
|
if (cal->getTime(status) != d00)
|
|
errln("Fail: set(SECOND, 0) broken");
|
|
|
|
cal->setTime(d11,status);
|
|
cal->set( Calendar::SECOND, 0 );
|
|
logln(UnicodeString("") + cal->getTime(status));
|
|
if (cal->getTime(status) != d10)
|
|
errln("Fail: set(SECOND, 0) broken #2");
|
|
|
|
cal->clear( Calendar::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, Calendar::APRIL, 5, 1, 0) + ONE_HOUR;
|
|
UDate cease = makeDate(1998, Calendar::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(Calendar::HOUR, amt,status);
|
|
break;
|
|
case ROLL:
|
|
log(UnicodeString(" roll(HOUR,") + (amt<0?"":"+")+amt + ")= ");
|
|
cal->roll(Calendar::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(Calendar::HOUR) != 11 ||
|
|
cal->getLeastMaximum(Calendar::HOUR) != 11 ||
|
|
cal->getActualMaximum(Calendar::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(Calendar::ERA, y < 1 ? GregorianCalendar::BC : GregorianCalendar::AD);
|
|
cal->set(Calendar::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(Calendar::ERA, GregorianCalendar::BC);
|
|
cal->set(Calendar::YEAR, 81); // 81 BC is a leap year (proleptically)
|
|
cal->set(Calendar::MONTH, Calendar::FEBRUARY);
|
|
cal->set(Calendar::DATE, 28);
|
|
cal->add(Calendar::DATE, 1,status);
|
|
if(U_FAILURE(status))
|
|
errln("add(DATE,1) failed");
|
|
if (cal->get(Calendar::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((Calendar::EDateFields)-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(Calendar::YEAR,status);
|
|
int32_t era1 = calendar->get(Calendar::ERA,status);
|
|
|
|
calendar->setTime(makeDate(INT32_MAX),status);
|
|
int32_t year2 = calendar->get(Calendar::YEAR,status);
|
|
int32_t era2 = calendar->get(Calendar::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(Calendar::YEAR,status);
|
|
int32_t maxYear = calendar->getMaximum(Calendar::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, Calendar::JANUARY, 3); // Arbitrary date
|
|
for (int32_t field = 0; field < Calendar::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((Calendar::EDateFields)field);
|
|
int32_t value = max+1;
|
|
calendar->set((Calendar::EDateFields)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(Calendar::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(Calendar::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, Calendar::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, Calendar::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, Calendar::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, Calendar::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(Calendar::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(Calendar::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;
|
|
Calendar::EDateFields field = Calendar::WEEK_OF_MONTH;
|
|
|
|
GregorianCalendar *calendar = new GregorianCalendar(Locale::getUS(), status);
|
|
if(U_FAILURE(status)) {
|
|
errln("Couldn't create calendar");
|
|
return;
|
|
}
|
|
calendar->set(1998, Calendar::MARCH, 1);
|
|
calendar->setMinimalDaysInFirstWeek(1);
|
|
logln(UnicodeString("Date: ") + calendar->getTime(status));
|
|
|
|
int32_t firstInMonth = calendar->get(Calendar::DAY_OF_MONTH, status);
|
|
if(U_FAILURE(status))
|
|
errln("get(D_O_M) failed");
|
|
|
|
for(int32_t firstInWeek = Calendar::SUNDAY; firstInWeek <= Calendar::SATURDAY; firstInWeek++) {
|
|
calendar->setFirstDayOfWeek((Calendar::EDaysOfWeek)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;
|
|
Calendar::EDateFields field = Calendar::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, Calendar::NOVEMBER, 1, status),
|
|
new GregorianCalendar(-99 /*100BC*/, Calendar::JANUARY, 1, status),
|
|
new GregorianCalendar(1996, Calendar::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(Calendar::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, Calendar::JANUARY, 1, 52,
|
|
2001, Calendar::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; i<DATA_length; ) {
|
|
cal.clear();
|
|
cal.set(DATA[i], DATA[i+1], DATA[i+2]);
|
|
i += 3;
|
|
int32_t expWOY = DATA[i++];
|
|
int32_t actWOY = cal.get(Calendar::WEEK_OF_YEAR, status);
|
|
if (expWOY == actWOY) {
|
|
logln(UnicodeString("Ok: ") + dfmt.format(cal.getTime(status), str.remove()));
|
|
} else {
|
|
errln(UnicodeString("FAIL: ") + dfmt.format(cal.getTime(status), str.remove())
|
|
+ ", expected WOY=" + expWOY);
|
|
cal.add(Calendar::DATE, -8, status);
|
|
for (int j=0; j<14; ++j) {
|
|
cal.add(Calendar::DATE, 1, status);
|
|
logln(dfmt.format(cal.getTime(status), str.remove()));
|
|
}
|
|
}
|
|
if (U_FAILURE(status)) {
|
|
errln("FAIL: Unexpected error from Calendar");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
enum Action { ADD=1, ROLL=2 };
|
|
enum Sign { PLUS=1, MINUS=2 };
|
|
|
|
#define ONE_HOUR (60*60*1000)
|
|
#define ONE_DAY (24*ONE_HOUR)
|
|
|
|
typedef struct {
|
|
Calendar::EDateFields field;
|
|
int8_t actionMask; // ADD or ROLL or both
|
|
int8_t signMask; // PLUS or MINUS or both
|
|
int32_t amount;
|
|
int32_t before; // ms before cutover
|
|
int32_t after; // ms after cutover
|
|
} J81_DATA;
|
|
|
|
/**
|
|
* Rolling and adding across the Gregorian cutover should work as expected.
|
|
* Jitterbug 81.
|
|
*/
|
|
void CalendarRegressionTest::TestJ81() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UnicodeString temp, temp2, temp3;
|
|
int32_t i;
|
|
GregorianCalendar cal(TimeZone::createTimeZone("GMT"), status);
|
|
SimpleDateFormat fmt("HH:mm 'w'w 'd'D E d MMM yyyy", Locale::getUS(), status);
|
|
if (U_FAILURE(status)) {
|
|
errln("Error: Cannot create calendar or format");
|
|
return;
|
|
}
|
|
fmt.setCalendar(cal);
|
|
// Get the Gregorian cutover
|
|
UDate cutover = cal.getGregorianChange();
|
|
logln(UnicodeString("Cutover: {") +
|
|
fmt.format(cutover, temp) + "}(" + cutover/ONE_DAY + ")");
|
|
|
|
// Check woy and doy handling. Reference data:
|
|
/* w40 d274 Mon 1 Oct 1582
|
|
w40 d275 Tue 2 Oct 1582
|
|
w40 d276 Wed 3 Oct 1582
|
|
w40 d277 Thu 4 Oct 1582
|
|
w40 d278 Fri 15 Oct 1582
|
|
w40 d279 Sat 16 Oct 1582
|
|
w41 d280 Sun 17 Oct 1582
|
|
w41 d281 Mon 18 Oct 1582
|
|
w41 d282 Tue 19 Oct 1582
|
|
w41 d283 Wed 20 Oct 1582
|
|
w41 d284 Thu 21 Oct 1582
|
|
w41 d285 Fri 22 Oct 1582
|
|
w41 d286 Sat 23 Oct 1582
|
|
w42 d287 Sun 24 Oct 1582
|
|
w42 d288 Mon 25 Oct 1582
|
|
w42 d289 Tue 26 Oct 1582
|
|
w42 d290 Wed 27 Oct 1582
|
|
w42 d291 Thu 28 Oct 1582
|
|
w42 d292 Fri 29 Oct 1582
|
|
w42 d293 Sat 30 Oct 1582
|
|
w43 d294 Sun 31 Oct 1582
|
|
w43 d295 Mon 1 Nov 1582 */
|
|
int32_t DOY_DATA[] = {
|
|
// dom, woy, doy
|
|
1, 40, 274, Calendar::MONDAY,
|
|
4, 40, 277, Calendar::THURSDAY,
|
|
15, 40, 278, Calendar::FRIDAY,
|
|
17, 41, 280, Calendar::SUNDAY,
|
|
24, 42, 287, Calendar::SUNDAY,
|
|
25, 42, 288, Calendar::MONDAY,
|
|
26, 42, 289, Calendar::TUESDAY,
|
|
27, 42, 290, Calendar::WEDNESDAY,
|
|
28, 42, 291, Calendar::THURSDAY,
|
|
29, 42, 292, Calendar::FRIDAY,
|
|
30, 42, 293, Calendar::SATURDAY,
|
|
31, 43, 294, Calendar::SUNDAY
|
|
};
|
|
int32_t DOY_DATA_length = (int32_t)(sizeof(DOY_DATA) / sizeof(DOY_DATA[0]));
|
|
for (i=0; i<DOY_DATA_length; i+=4) {
|
|
// Test time->fields
|
|
cal.set(1582, Calendar::OCTOBER, DOY_DATA[i]);
|
|
int32_t woy = cal.get(Calendar::WEEK_OF_YEAR, status);
|
|
int32_t doy = cal.get(Calendar::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(Calendar::YEAR, 1582);
|
|
cal.set(Calendar::WEEK_OF_YEAR, DOY_DATA[i+1]);
|
|
cal.set(Calendar::DAY_OF_WEEK, DOY_DATA[i+3]);
|
|
int32_t dom = cal.get(Calendar::DAY_OF_MONTH, 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(Calendar::YEAR, 1582);
|
|
cal.set(Calendar::DAY_OF_YEAR, DOY_DATA[i+2]);
|
|
dom = cal.get(Calendar::DAY_OF_MONTH, 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[] = {
|
|
{ Calendar::WEEK_OF_YEAR, ADD_ROLL, PLUS_MINUS, 1, -ONE_DAY, +6*ONE_DAY },
|
|
{ Calendar::WEEK_OF_YEAR, ADD_ROLL, PLUS_MINUS, 1, -ONE_DAY, +6*ONE_DAY },
|
|
{ Calendar::WEEK_OF_MONTH, ADD|ROLL, PLUS|MINUS, 1, -ONE_DAY, +6*ONE_DAY },
|
|
{ Calendar::DAY_OF_MONTH, ADD|ROLL, PLUS|MINUS, 2, -ONE_DAY, +1*ONE_DAY },
|
|
{ Calendar::DAY_OF_MONTH, ROLL, PLUS, -6, -ONE_DAY, +14*ONE_DAY },
|
|
{ Calendar::DAY_OF_MONTH, ROLL, PLUS, -7, 0, +14*ONE_DAY },
|
|
{ Calendar::DAY_OF_MONTH, ROLL, PLUS, -7, +ONE_DAY, +15*ONE_DAY },
|
|
{ Calendar::DAY_OF_MONTH, ROLL, PLUS, +18, -ONE_DAY, -4*ONE_DAY },
|
|
{ Calendar::DAY_OF_YEAR, ADD|ROLL, PLUS|MINUS, 2, -ONE_DAY, +1*ONE_DAY },
|
|
{ Calendar::DAY_OF_WEEK, ADD|ROLL, PLUS|MINUS, 2, -ONE_DAY, +1*ONE_DAY },
|
|
{ Calendar::DAY_OF_WEEK_IN_MONTH, ADD|ROLL, PLUS|MINUS, 1, -ONE_DAY, +6*ONE_DAY },
|
|
{ Calendar::AM_PM, ADD, PLUS|MINUS, 4, -12*ONE_HOUR, +36*ONE_HOUR },
|
|
{ Calendar::HOUR, ADD, PLUS|MINUS, 48, -12*ONE_HOUR, +36*ONE_HOUR },
|
|
{ Calendar::HOUR_OF_DAY, ADD, PLUS|MINUS, 48, -12*ONE_HOUR, +36*ONE_HOUR },
|
|
{ Calendar::MINUTE, ADD, PLUS|MINUS, 48*60, -12*ONE_HOUR, +36*ONE_HOUR },
|
|
{ Calendar::SECOND, ADD, PLUS|MINUS, 48*60*60, -12*ONE_HOUR, +36*ONE_HOUR },
|
|
{ Calendar::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<DATA_length; ++i) {
|
|
for (Action action=ADD; action<=ROLL; action=(Action)(action+1)) {
|
|
if (!(DATA[i].actionMask & action)) {
|
|
continue;
|
|
}
|
|
for (Sign sign=PLUS; sign<=MINUS; sign=(Sign)(sign+1)) {
|
|
if (!(DATA[i].signMask & sign)) {
|
|
continue;
|
|
}
|
|
status = U_ZERO_ERROR;
|
|
int32_t amount = DATA[i].amount * (sign==MINUS?-1:1);
|
|
UDate date = cutover +
|
|
(sign==PLUS ? DATA[i].before : DATA[i].after);
|
|
UDate expected = cutover +
|
|
(sign==PLUS ? DATA[i].after : DATA[i].before);
|
|
cal.setTime(date, status);
|
|
if (U_FAILURE(status)) {
|
|
errln((UnicodeString)"FAIL: setTime returned error code " + u_errorName(status));
|
|
continue;
|
|
}
|
|
if (action == ADD) {
|
|
cal.add(DATA[i].field, amount, status);
|
|
} else {
|
|
cal.roll(DATA[i].field, amount, status);
|
|
}
|
|
if (U_FAILURE(status)) {
|
|
errln((UnicodeString)"FAIL: " +
|
|
(action==ADD?"add ":"roll ") + FIELD_NAME[DATA[i].field] +
|
|
" returned error code " + u_errorName(status));
|
|
continue;
|
|
}
|
|
UDate result = cal.getTime(status);
|
|
if (U_FAILURE(status)) {
|
|
errln((UnicodeString)"FAIL: getTime returned error code " + u_errorName(status));
|
|
continue;
|
|
}
|
|
if (result == expected) {
|
|
logln((UnicodeString)"Ok: {" +
|
|
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 + ")");
|
|
} 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, Calendar::JANUARY, 20, 2010, Calendar::JUNE, 15,
|
|
2010, Calendar::JUNE, 15, 2000, Calendar::JANUARY, 20,
|
|
1964, Calendar::SEPTEMBER, 7, 1999, Calendar::JUNE, 4,
|
|
1999, Calendar::JUNE, 4, 1964, Calendar::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; i<DATA_length; i+=6) {
|
|
int32_t y1 = DATA[i];
|
|
int32_t m1 = DATA[i+1];
|
|
int32_t d1 = DATA[i+2];
|
|
int32_t y2 = DATA[i+3];
|
|
int32_t m2 = DATA[i+4];
|
|
int32_t d2 = DATA[i+5];
|
|
|
|
cal.clear();
|
|
cal.set(y1, m1, d1);
|
|
UDate date1 = cal.getTime(ec);
|
|
if (failure(ec, "getTime"))
|
|
break;
|
|
cal.set(y2, m2, d2);
|
|
UDate date2 = cal.getTime(ec);
|
|
if (failure(ec, "getTime"))
|
|
break;
|
|
|
|
cal.setTime(date1, ec);
|
|
if (failure(ec, "setTime"))
|
|
break;
|
|
int32_t dy = cal.fieldDifference(date2, Calendar::YEAR, ec);
|
|
int32_t dm = cal.fieldDifference(date2, Calendar::MONTH, ec);
|
|
int32_t dd = cal.fieldDifference(date2, Calendar::DATE, ec);
|
|
if (failure(ec, "fieldDifference"))
|
|
break;
|
|
|
|
logln(UnicodeString("") +
|
|
fmt.format(date2, s.remove()) + " - " +
|
|
fmt.format(date1, t.remove()) + " = " +
|
|
dy + "y " + dm + "m " + dd + "d");
|
|
|
|
cal.setTime(date1, ec);
|
|
if (failure(ec, "setTime"))
|
|
break;
|
|
cal.add(Calendar::YEAR, dy, ec);
|
|
cal.add(Calendar::MONTH, dm, ec);
|
|
cal.add(Calendar::DATE, dd, ec);
|
|
if (failure(ec, "add"))
|
|
break;
|
|
UDate date22 = cal.getTime(ec);
|
|
if (failure(ec, "getTime"))
|
|
break;
|
|
if (date2 != date22) {
|
|
errln(UnicodeString("FAIL: ") +
|
|
fmt.format(date1, s.remove()) + " + " +
|
|
dy + "y " + dm + "m " + dd + "d = " +
|
|
fmt.format(date22, t.remove()) + ", exp " +
|
|
fmt.format(date2, u.remove()));
|
|
} else {
|
|
logln(UnicodeString("Ok: ") +
|
|
fmt.format(date1, s.remove()) + " + " +
|
|
dy + "y " + dm + "m " + dd + "d = " +
|
|
fmt.format(date22, t.remove()));
|
|
}
|
|
}
|
|
}
|
|
delete pcal;
|
|
}
|
|
|
|
/**
|
|
* Test behavior of fieldDifference around leap years. Also test a large
|
|
* field difference to check binary search.
|
|
*/
|
|
void CalendarRegressionTest::TestLeapFieldDifference() {
|
|
UErrorCode ec = U_ZERO_ERROR;
|
|
Calendar* cal = Calendar::createInstance(ec);
|
|
if (cal == NULL || U_FAILURE(ec)) {
|
|
errln("FAIL: Calendar::createInstance()");
|
|
delete cal;
|
|
return;
|
|
}
|
|
cal->set(2004, Calendar::FEBRUARY, 29);
|
|
UDate date2004 = cal->getTime(ec);
|
|
cal->set(2000, Calendar::FEBRUARY, 29);
|
|
UDate date2000 = cal->getTime(ec);
|
|
if (U_FAILURE(ec)) {
|
|
errln("FAIL: getTime()");
|
|
delete cal;
|
|
return;
|
|
}
|
|
int32_t y = cal->fieldDifference(date2004, Calendar::YEAR, ec);
|
|
int32_t d = cal->fieldDifference(date2004, Calendar::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, Calendar::YEAR, ec);
|
|
d = cal->fieldDifference(date2000, Calendar::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, Calendar::APRIL, 5); // 2452005
|
|
UDate ayl = cal->getTime(ec);
|
|
cal->set(1964, Calendar::SEPTEMBER, 7); // 2438646
|
|
UDate asl = cal->getTime(ec);
|
|
if (U_FAILURE(ec)) {
|
|
errln("FAIL: getTime()");
|
|
delete cal;
|
|
return;
|
|
}
|
|
d = cal->fieldDifference(ayl, Calendar::DAY_OF_MONTH, ec);
|
|
cal->setTime(ayl, ec);
|
|
int32_t d2 = cal->fieldDifference(asl, Calendar::DAY_OF_MONTH, 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;
|
|
}
|
|
|
|
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(Calendar::YEAR, y);
|
|
|
|
if(m != 0) cal->set(Calendar::MONTH, m);
|
|
if(d != 0) cal->set(Calendar::DATE, d);
|
|
if(hr != 0) cal->set(Calendar::HOUR, hr);
|
|
if(min != 0) cal->set(Calendar::MINUTE, min);
|
|
if(sec != 0) cal->set(Calendar::SECOND, sec);
|
|
|
|
result = cal->getTime(status);
|
|
|
|
delete cal;
|
|
|
|
return result;
|
|
}
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|