int main(int argc, char **argv) {
Calendar *cal;
DateFormat *fmt;
DateFormat *defFmt;
Transliterator *greek_latin;
Transliterator *rbtUnaccent;
UErrorCode status = U_ZERO_ERROR;
Locale greece("el", "GR");
UnicodeString str, str2;
// Create a calendar in the Greek locale
cal = Calendar::createInstance(greece, status);
check(status, "Calendar::createInstance");
// Create a formatter
fmt = DateFormat::createDateInstance(DateFormat::kFull, greece);
fmt->setCalendar(*cal);
// Create a default formatter
defFmt = DateFormat::createDateInstance(DateFormat::kFull);
defFmt->setCalendar(*cal);
// Create a Greek-Latin Transliterator
greek_latin = Transliterator::createInstance("Greek-Latin");
if (greek_latin == 0) {
printf("ERROR: Transliterator::createInstance() failed\n");
exit(1);
}
// Create a custom Transliterator
rbtUnaccent = new RuleBasedTransliterator("RBTUnaccent",
UNACCENT_RULES,
UTRANS_FORWARD,
status);
check(status, "RuleBasedTransliterator::ct");
// Loop over various months
for (int32_t month = Calendar::JANUARY;
month <= Calendar::DECEMBER;
++month) {
// Set the calendar to a date
cal->clear();
cal->set(1999, month, 4);
// Format the date in default locale
str.remove();
defFmt->format(cal->getTime(status), str, status);
check(status, "DateFormat::format");
printf("Date: ");
uprintf(escape(str));
printf("\n");
// Format the date for Greece
str.remove();
fmt->format(cal->getTime(status), str, status);
check(status, "DateFormat::format");
printf("Greek formatted date: ");
uprintf(escape(str));
printf("\n");
// Transliterate result
greek_latin->transliterate(str);
printf("Transliterated via Greek-Latin: ");
uprintf(escape(str));
printf("\n");
// Transliterate result
str2 = str;
rbtUnaccent->transliterate(str);
printf("Transliterated via RBT unaccent: ");
uprintf(escape(str));
printf("\n\n");
}
// Clean up
delete fmt;
delete cal;
delete greek_latin;
delete rbtUnaccent;
printf("Exiting successfully\n");
return 0;
}
/**
* getDisplayName doesn't work with unusual savings/offsets.
*/
void TimeZoneRegressionTest::Test4176686() {
// Construct a zone that does not observe DST but
// that does have a DST savings (which should be ignored).
UErrorCode status = U_ZERO_ERROR;
int32_t offset = 90 * 60000; // 1:30
SimpleTimeZone* z1 = new SimpleTimeZone(offset, "_std_zone_");
z1->setDSTSavings(45 * 60000, status); // 0:45
// Construct a zone that observes DST for the first 6 months.
SimpleTimeZone* z2 = new SimpleTimeZone(offset, "_dst_zone_");
z2->setDSTSavings(45 * 60000, status); // 0:45
z2->setStartRule(UCAL_JANUARY, 1, 0, status);
z2->setEndRule(UCAL_JULY, 1, 0, status);
// Also check DateFormat
DateFormat* fmt1 = new SimpleDateFormat(UnicodeString("z"), status);
if (U_FAILURE(status)) {
dataerrln("Failure trying to construct: %s", u_errorName(status));
return;
}
fmt1->setTimeZone(*z1); // Format uses standard zone
DateFormat* fmt2 = new SimpleDateFormat(UnicodeString("z"), status);
if(!assertSuccess("trying to construct", status))return;
fmt2->setTimeZone(*z2); // Format uses DST zone
Calendar* tempcal = Calendar::createInstance(status);
tempcal->clear();
tempcal->set(1970, UCAL_FEBRUARY, 1);
UDate dst = tempcal->getTime(status); // Time in DST
tempcal->set(1970, UCAL_AUGUST, 1);
UDate std = tempcal->getTime(status); // Time in standard
// Description, Result, Expected Result
UnicodeString a,b,c,d,e,f,g,h,i,j,k,l;
UnicodeString DATA[] = {
"z1->getDisplayName(false, SHORT)/std zone",
z1->getDisplayName(FALSE, TimeZone::SHORT, a), "GMT+01:30",
"z1->getDisplayName(false, LONG)/std zone",
z1->getDisplayName(FALSE, TimeZone::LONG, b), "GMT+01:30",
"z1->getDisplayName(true, SHORT)/std zone",
z1->getDisplayName(TRUE, TimeZone::SHORT, c), "GMT+01:30",
"z1->getDisplayName(true, LONG)/std zone",
z1->getDisplayName(TRUE, TimeZone::LONG, d ), "GMT+01:30",
"z2->getDisplayName(false, SHORT)/dst zone",
z2->getDisplayName(FALSE, TimeZone::SHORT, e), "GMT+01:30",
"z2->getDisplayName(false, LONG)/dst zone",
z2->getDisplayName(FALSE, TimeZone::LONG, f ), "GMT+01:30",
"z2->getDisplayName(true, SHORT)/dst zone",
z2->getDisplayName(TRUE, TimeZone::SHORT, g), "GMT+02:15",
"z2->getDisplayName(true, LONG)/dst zone",
z2->getDisplayName(TRUE, TimeZone::LONG, h ), "GMT+02:15",
"DateFormat.format(std)/std zone", fmt1->format(std, i), "GMT+01:30",
"DateFormat.format(dst)/std zone", fmt1->format(dst, j), "GMT+01:30",
"DateFormat.format(std)/dst zone", fmt2->format(std, k), "GMT+01:30",
"DateFormat.format(dst)/dst zone", fmt2->format(dst, l), "GMT+02:15",
};
for (int32_t idx=0; idx<(int32_t)ARRAY_LENGTH(DATA); idx+=3) {
if (DATA[idx+1]!=(DATA[idx+2])) {
errln("FAIL: " + DATA[idx] + " -> " + DATA[idx+1] + ", exp " + DATA[idx+2]);
}
}
delete z1;
delete z2;
delete fmt1;
delete fmt2;
delete tempcal;
}
void DateFormatRegressionTest::Test1684(void)
{
// July 2001 August 2001 January 2002
// Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa Su Mo Tu We Th Fr Sa
// 1 2 3 4 5 6 7 1 2 3 4 1 2 3 4 5
// 8 9 10 11 12 13 14 5 6 7 8 9 10 11 6 7 8 9 10 11 12
// 15 16 17 18 19 20 21 12 13 14 15 16 17 18 13 14 15 16 17 18 19
// 22 23 24 25 26 27 28 19 20 21 22 23 24 25 20 21 22 23 24 25 26
// 29 30 31 26 27 28 29 30 31 27 28 29 30 31
Test1684Data *tests[] = {
new Test1684Data(2001, 8, 6, 2001,8,2,UCAL_MONDAY, "2001 08 02 Mon", NULL),
new Test1684Data(2001, 8, 7, 2001,8,2,UCAL_TUESDAY, "2001 08 02 Tue", NULL),
new Test1684Data(2001, 8, 5,/*12,*/ 2001,8,2,UCAL_SUNDAY, "2001 08 02 Sun", NULL),
new Test1684Data(2001, 8,6, /*7, 30,*/ 2001,7,6,UCAL_MONDAY, "2001 07 06 Mon", "2001 08 02 Mon"),
new Test1684Data(2001, 8,7, /*7, 31,*/ 2001,7,6,UCAL_TUESDAY, "2001 07 06 Tue", "2001 08 02 Tue"),
new Test1684Data(2001, 8, 5, 2001,7,6,UCAL_SUNDAY, "2001 07 06 Sun", "2001 08 02 Sun"),
new Test1684Data(2001, 7, 30, 2001,8,1,UCAL_MONDAY, "2001 08 01 Mon", "2001 07 05 Mon"),
new Test1684Data(2001, 7, 31, 2001,8,1,UCAL_TUESDAY, "2001 08 01 Tue", "2001 07 05 Tue"),
new Test1684Data(2001, 7,29, /*8, 5,*/ 2001,8,1,UCAL_SUNDAY, "2001 08 01 Sun", "2001 07 05 Sun"),
new Test1684Data(2001, 12, 31, 2001,12,6,UCAL_MONDAY, "2001 12 06 Mon", NULL),
new Test1684Data(2002, 1, 1, 2002,1,1,UCAL_TUESDAY, "2002 01 01 Tue", NULL),
new Test1684Data(2002, 1, 2, 2002,1,1,UCAL_WEDNESDAY, "2002 01 01 Wed", NULL),
new Test1684Data(2002, 1, 3, 2002,1,1,UCAL_THURSDAY, "2002 01 01 Thu", NULL),
new Test1684Data(2002, 1, 4, 2002,1,1,UCAL_FRIDAY, "2002 01 01 Fri", NULL),
new Test1684Data(2002, 1, 5, 2002,1,1,UCAL_SATURDAY, "2002 01 01 Sat", NULL),
new Test1684Data(2001,12,30, /*2002, 1, 6,*/ 2002,1,1,UCAL_SUNDAY, "2002 01 01 Sun", "2001 12 06 Sun")
};
#define kTest1684Count ((int32_t)(sizeof(tests)/sizeof(tests[0])))
int32_t pass = 0, error = 0, warning = 0;
int32_t i;
UErrorCode status = U_ZERO_ERROR;
UnicodeString pattern("yyyy MM WW EEE","");
Calendar *cal = new GregorianCalendar(status);
SimpleDateFormat *sdf = new SimpleDateFormat(pattern,status);
if (U_FAILURE(status)) {
dataerrln("Error constructing SimpleDateFormat");
for(i=0;i<kTest1684Count;i++) {
delete tests[i];
}
delete cal;
delete sdf;
return;
}
cal->setFirstDayOfWeek(UCAL_SUNDAY);
cal->setMinimalDaysInFirstWeek(1);
sdf->adoptCalendar(cal);
cal = sdf->getCalendar()->clone(); // sdf may have deleted calendar
if(!cal || !sdf || U_FAILURE(status)) {
errln(UnicodeString("Error setting up test: ") + u_errorName(status));
}
for (i = 0; i < kTest1684Count; ++i) {
Test1684Data &test = *(tests[i]);
logln(UnicodeString("#") + i + UnicodeString("\n-----\nTesting round trip of ") + test.year +
" " + (test.month + 1) +
" " + test.date +
" (written as) " + test.data);
cal->clear();
cal->set(test.year, test.month, test.date);
UDate ms = cal->getTime(status);
cal->clear();
cal->set(UCAL_YEAR, test.womyear);
cal->set(UCAL_MONTH, test.wommon);
cal->set(UCAL_WEEK_OF_MONTH, test.wom);
cal->set(UCAL_DAY_OF_WEEK, test.dow);
UDate ms2 = cal->getTime(status);
if (ms2 != ms) {
errln((UnicodeString)"\nError: GregorianUCAL_DOM gave " + ms +
"\n GregorianUCAL_WOM gave " + ms2);
error++;
} else {
pass++;
}
ms2 = sdf->parse(test.data, status);
if(U_FAILURE(status)) {
errln("parse exception: " + UnicodeString(u_errorName(status)));
}
if (ms2!=ms) {
errln((UnicodeString)"\nError: GregorianCalendar gave " + ms +
"\n SimpleDateFormat.parse gave " + ms2);
error++;
} else {
pass++;
}
UnicodeString result;
sdf->format(ms, result);
if (result != test.normalized) {
errln("\nWarning: format of '" + test.data + "' gave" +
"\n '" + result + "'" +
"\n expected '" + test.normalized + "'");
warning++;
} else {
pass++;
}
UDate ms3;
ms3 = sdf->parse(result, status);
if(U_FAILURE(status)) {
errln("parse exception 2: " + (UnicodeString)u_errorName(status));
}
if (ms3!=ms) {
error++;
errln((UnicodeString)"\nError: Re-parse of '" + result + "' gave time of " +
"\n " + ms3 +
"\n not " + ms);
} else {
pass++;
}
}
UnicodeString info
= UnicodeString("Passed: ") + pass + ", Warnings: " + warning + ", Errors: " + error;
if (error > 0) {
errln(info);
} else {
logln(info);
}
for(i=0;i<kTest1684Count;i++) {
delete tests[i];
}
delete cal;
delete sdf;
}
/**
* Test the behavior of SimpleTimeZone at the transition into and out of DST.
* Use a binary search to find boundaries.
*/
void
TimeZoneBoundaryTest::TestBoundaries()
{
UErrorCode status = U_ZERO_ERROR;
TimeZone* pst = TimeZone::createTimeZone("PST");
Calendar* tempcal = Calendar::createInstance(pst, status);
if(U_SUCCESS(status)){
verifyMapping(*tempcal, 1997, Calendar::APRIL, 3, 0, 238904.0);
verifyMapping(*tempcal, 1997, Calendar::APRIL, 4, 0, 238928.0);
verifyMapping(*tempcal, 1997, Calendar::APRIL, 5, 0, 238952.0);
verifyMapping(*tempcal, 1997, Calendar::APRIL, 5, 23, 238975.0);
verifyMapping(*tempcal, 1997, Calendar::APRIL, 6, 0, 238976.0);
verifyMapping(*tempcal, 1997, Calendar::APRIL, 6, 1, 238977.0);
verifyMapping(*tempcal, 1997, Calendar::APRIL, 6, 3, 238978.0);
}else{
dataerrln("Could not create calendar. Error: %s", u_errorName(status));
}
TimeZone* utc = TimeZone::createTimeZone("UTC");
Calendar* utccal = Calendar::createInstance(utc, status);
if(U_SUCCESS(status)){
verifyMapping(*utccal, 1997, Calendar::APRIL, 6, 0, 238968.0);
}else{
dataerrln("Could not create calendar. Error: %s", u_errorName(status));
}
TimeZone* save = TimeZone::createDefault();
TimeZone::setDefault(*pst);
if (tempcal != NULL) {
// DST changeover for PST is 4/6/1997 at 2 hours past midnight
// at 238978.0 epoch hours.
tempcal->clear();
tempcal->set(1997, Calendar::APRIL, 6);
UDate d = tempcal->getTime(status);
// i is minutes past midnight standard time
for (int i=-120; i<=180; i+=60)
{
UBool inDST = (i >= 120);
tempcal->setTime(d + i*60*1000, status);
verifyDST(tempcal->getTime(status),pst, TRUE, inDST, -8*ONE_HOUR,inDST ? -7*ONE_HOUR : -8*ONE_HOUR);
}
}
TimeZone::setDefault(*save);
delete save;
delete utccal;
delete tempcal;
#if 1
{
logln("--- Test a ---");
UDate d = date(97, UCAL_APRIL, 6);
TimeZone *z = TimeZone::createTimeZone("PST");
for (int32_t i = 60; i <= 180; i += 15) {
UBool inDST = (i >= 120);
UDate e = d + i * 60 * 1000;
verifyDST(e, z, TRUE, inDST, - 8 * ONE_HOUR, inDST ? - 7 * ONE_HOUR: - 8 * ONE_HOUR);
}
delete z;
}
#endif
#if 1
{
logln("--- Test b ---");
TimeZone *tz;
TimeZone::setDefault(*(tz = TimeZone::createTimeZone("PST")));
delete tz;
logln("========================================");
findDaylightBoundaryUsingDate(date(97, 0, 1), "PST", PST_1997_BEG);
logln("========================================");
findDaylightBoundaryUsingDate(date(97, 6, 1), "PDT", PST_1997_END);
}
#endif
#if 1
{
logln("--- Test c ---");
logln("========================================");
TimeZone* z = TimeZone::createTimeZone("Australia/Adelaide");
findDaylightBoundaryUsingTimeZone(date(97, 0, 1), TRUE, 859653000000.0, z);
logln("========================================");
findDaylightBoundaryUsingTimeZone(date(97, 6, 1), FALSE, 877797000000.0, z);
delete z;
}
#endif
#if 1
{
logln("--- Test d ---");
logln("========================================");
findDaylightBoundaryUsingTimeZone(date(97, 0, 1), FALSE, PST_1997_BEG);
logln("========================================");
findDaylightBoundaryUsingTimeZone(date(97, 6, 1), TRUE, PST_1997_END);
}
#endif
#if 0
{
logln("--- Test e ---");
TimeZone *z = TimeZone::createDefault();
logln(UnicodeString("") + z->getOffset(1, 97, 3, 4, 6, 0) + " " + date(97, 3, 4));
logln(UnicodeString("") + z->getOffset(1, 97, 3, 5, 7, 0) + " " + date(97, 3, 5));
logln(UnicodeString("") + z->getOffset(1, 97, 3, 6, 1, 0) + " " + date(97, 3, 6));
logln(UnicodeString("") + z->getOffset(1, 97, 3, 7, 2, 0) + " " + date(97, 3, 7));
delete z;
}
#endif
}
void
TimeZoneOffsetLocalTest::TestGetOffsetAroundTransition() {
const int32_t NUM_DATES = 10;
const int32_t NUM_TIMEZONES = 3;
const int32_t HOUR = 60*60*1000;
const int32_t MINUTE = 60*1000;
const int32_t DATES[NUM_DATES][6] = {
{2006, UCAL_APRIL, 2, 1, 30, 1*HOUR+30*MINUTE},
{2006, UCAL_APRIL, 2, 2, 00, 2*HOUR},
{2006, UCAL_APRIL, 2, 2, 30, 2*HOUR+30*MINUTE},
{2006, UCAL_APRIL, 2, 3, 00, 3*HOUR},
{2006, UCAL_APRIL, 2, 3, 30, 3*HOUR+30*MINUTE},
{2006, UCAL_OCTOBER, 29, 0, 30, 0*HOUR+30*MINUTE},
{2006, UCAL_OCTOBER, 29, 1, 00, 1*HOUR},
{2006, UCAL_OCTOBER, 29, 1, 30, 1*HOUR+30*MINUTE},
{2006, UCAL_OCTOBER, 29, 2, 00, 2*HOUR},
{2006, UCAL_OCTOBER, 29, 2, 30, 2*HOUR+30*MINUTE},
};
// Expected offsets by int32_t getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
// uint8_t dayOfWeek, int32_t millis, UErrorCode& status)
const int32_t OFFSETS1[NUM_DATES] = {
// April 2, 2006
-8*HOUR,
-7*HOUR,
-7*HOUR,
-7*HOUR,
-7*HOUR,
// October 29, 2006
-7*HOUR,
-8*HOUR,
-8*HOUR,
-8*HOUR,
-8*HOUR,
};
// Expected offsets by void getOffset(UDate date, UBool local, int32_t& rawOffset,
// int32_t& dstOffset, UErrorCode& ec) with local=TRUE
// or void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
// int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) with
// nonExistingTimeOpt=kStandard/duplicatedTimeOpt=kStandard
const int32_t OFFSETS2[NUM_DATES][2] = {
// April 2, 2006
{-8*HOUR, 0},
{-8*HOUR, 0},
{-8*HOUR, 0},
{-8*HOUR, 1*HOUR},
{-8*HOUR, 1*HOUR},
// Oct 29, 2006
{-8*HOUR, 1*HOUR},
{-8*HOUR, 0},
{-8*HOUR, 0},
{-8*HOUR, 0},
{-8*HOUR, 0},
};
// Expected offsets by void getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt,
// int32_t duplicatedTimeOpt, int32_t& rawOffset, int32_t& dstOffset, UErrorCode& status) with
// nonExistingTimeOpt=kDaylight/duplicatedTimeOpt=kDaylight
const int32_t OFFSETS3[][2] = {
// April 2, 2006
{-8*HOUR, 0},
{-8*HOUR, 1*HOUR},
{-8*HOUR, 1*HOUR},
{-8*HOUR, 1*HOUR},
{-8*HOUR, 1*HOUR},
// October 29, 2006
{-8*HOUR, 1*HOUR},
{-8*HOUR, 1*HOUR},
{-8*HOUR, 1*HOUR},
{-8*HOUR, 0},
{-8*HOUR, 0},
};
UErrorCode status = U_ZERO_ERROR;
int32_t rawOffset, dstOffset;
TimeZone* utc = TimeZone::createTimeZone("UTC");
Calendar* cal = Calendar::createInstance(*utc, status);
if (U_FAILURE(status)) {
errln("Calendar::createInstance failed");
return;
}
cal->clear();
// Set up TimeZone objects - OlsonTimeZone, SimpleTimeZone and RuleBasedTimeZone
BasicTimeZone *TESTZONES[NUM_TIMEZONES];
TESTZONES[0] = (BasicTimeZone*)TimeZone::createTimeZone("America/Los_Angeles");
TESTZONES[1] = new SimpleTimeZone(-8*HOUR, "Simple Pacific Time",
UCAL_APRIL, 1, UCAL_SUNDAY, 2*HOUR,
UCAL_OCTOBER, -1, UCAL_SUNDAY, 2*HOUR, status);
if (U_FAILURE(status)) {
errln("SimpleTimeZone constructor failed");
return;
}
InitialTimeZoneRule *ir = new InitialTimeZoneRule(
"Pacific Standard Time", // Initial time Name
-8*HOUR, // Raw offset
0*HOUR); // DST saving amount
RuleBasedTimeZone *rbPT = new RuleBasedTimeZone("Rule based Pacific Time", ir);
DateTimeRule *dtr;
AnnualTimeZoneRule *atzr;
const int32_t STARTYEAR = 2000;
dtr = new DateTimeRule(UCAL_APRIL, 1, UCAL_SUNDAY,
2*HOUR, DateTimeRule::WALL_TIME); // 1st Sunday in April, at 2AM wall time
atzr = new AnnualTimeZoneRule("Pacific Daylight Time",
-8*HOUR /* rawOffset */, 1*HOUR /* dstSavings */, dtr,
STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
rbPT->addTransitionRule(atzr, status);
if (U_FAILURE(status)) {
errln("Could not add DST start rule to the RuleBasedTimeZone rbPT");
return;
}
dtr = new DateTimeRule(UCAL_OCTOBER, -1, UCAL_SUNDAY,
2*HOUR, DateTimeRule::WALL_TIME); // last Sunday in October, at 2AM wall time
atzr = new AnnualTimeZoneRule("Pacific Standard Time",
-8*HOUR /* rawOffset */, 0 /* dstSavings */, dtr,
STARTYEAR, AnnualTimeZoneRule::MAX_YEAR);
rbPT->addTransitionRule(atzr, status);
if (U_FAILURE(status)) {
errln("Could not add STD start rule to the RuleBasedTimeZone rbPT");
return;
}
rbPT->complete(status);
if (U_FAILURE(status)) {
errln("complete() failed for RuleBasedTimeZone rbPT");
return;
}
TESTZONES[2] = rbPT;
// Calculate millis
UDate MILLIS[NUM_DATES];
for (int32_t i = 0; i < NUM_DATES; i++) {
cal->clear();
cal->set(DATES[i][0], DATES[i][1], DATES[i][2], DATES[i][3], DATES[i][4]);
MILLIS[i] = cal->getTime(status);
if (U_FAILURE(status)) {
errln("cal->getTime failed");
return;
}
}
SimpleDateFormat df(UnicodeString("yyyy-MM-dd HH:mm:ss"), status);
if (U_FAILURE(status)) {
errcheckln(status, "Failed to initialize a SimpleDateFormat - %s", u_errorName(status));
}
df.setTimeZone(*utc);
UnicodeString dateStr;
// Test getOffset(uint8_t era, int32_t year, int32_t month, int32_t day,
// uint8_t dayOfWeek, int32_t millis, UErrorCode& status)
for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
for (int32_t d = 0; d < NUM_DATES; d++) {
status = U_ZERO_ERROR;
int32_t offset = TESTZONES[i]->getOffset(GregorianCalendar::AD, DATES[d][0], DATES[d][1], DATES[d][2],
UCAL_SUNDAY, DATES[d][5], status);
if (U_FAILURE(status)) {
errln((UnicodeString)"getOffset(era,year,month,day,dayOfWeek,millis,status) failed for TESTZONES[" + i + "]");
} else if (offset != OFFSETS1[d]) {
dateStr.remove();
df.format(MILLIS[d], dateStr);
dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
+ dateStr + "(standard) - Got: " + offset + " Expected: " + OFFSETS1[d]);
}
}
}
// Test getOffset(UDate date, UBool local, int32_t& rawOffset,
// int32_t& dstOffset, UErrorCode& ec) with local = TRUE
for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
for (int32_t m = 0; m < NUM_DATES; m++) {
status = U_ZERO_ERROR;
TESTZONES[i]->getOffset(MILLIS[m], TRUE, rawOffset, dstOffset, status);
if (U_FAILURE(status)) {
errln((UnicodeString)"getOffset(date,local,rawOfset,dstOffset,ec) failed for TESTZONES[" + i + "]");
} else if (rawOffset != OFFSETS2[m][0] || dstOffset != OFFSETS2[m][1]) {
dateStr.remove();
df.format(MILLIS[m], dateStr);
dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
+ dateStr + "(wall) - Got: "
+ rawOffset + "/" + dstOffset
+ " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);
}
}
}
// Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
// int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
// with nonExistingTimeOpt=kStandard/duplicatedTimeOpt=kStandard
for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
for (int m = 0; m < NUM_DATES; m++) {
status = U_ZERO_ERROR;
TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kStandard, BasicTimeZone::kStandard,
rawOffset, dstOffset, status);
if (U_FAILURE(status)) {
errln((UnicodeString)"getOffsetFromLocal with kStandard/kStandard failed for TESTZONES[" + i + "]");
} else if (rawOffset != OFFSETS2[m][0] || dstOffset != OFFSETS2[m][1]) {
dateStr.remove();
df.format(MILLIS[m], dateStr);
dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
+ dateStr + "(wall/kStandard/kStandard) - Got: "
+ rawOffset + "/" + dstOffset
+ " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);
}
}
}
// Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
// int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
// with nonExistingTimeOpt=kDaylight/duplicatedTimeOpt=kDaylight
for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
for (int m = 0; m < NUM_DATES; m++) {
status = U_ZERO_ERROR;
TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kDaylight, BasicTimeZone::kDaylight,
rawOffset, dstOffset, status);
if (U_FAILURE(status)) {
errln((UnicodeString)"getOffsetFromLocal with kDaylight/kDaylight failed for TESTZONES[" + i + "]");
} else if (rawOffset != OFFSETS3[m][0] || dstOffset != OFFSETS3[m][1]) {
dateStr.remove();
df.format(MILLIS[m], dateStr);
dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
+ dateStr + "(wall/kDaylight/kDaylight) - Got: "
+ rawOffset + "/" + dstOffset
+ " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]);
}
}
}
// Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
// int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
// with nonExistingTimeOpt=kFormer/duplicatedTimeOpt=kLatter
for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
for (int m = 0; m < NUM_DATES; m++) {
status = U_ZERO_ERROR;
TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kFormer, BasicTimeZone::kLatter,
rawOffset, dstOffset, status);
if (U_FAILURE(status)) {
errln((UnicodeString)"getOffsetFromLocal with kFormer/kLatter failed for TESTZONES[" + i + "]");
} else if (rawOffset != OFFSETS2[m][0] || dstOffset != OFFSETS2[m][1]) {
dateStr.remove();
df.format(MILLIS[m], dateStr);
dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
+ dateStr + "(wall/kFormer/kLatter) - Got: "
+ rawOffset + "/" + dstOffset
+ " Expected: " + OFFSETS2[m][0] + "/" + OFFSETS2[m][1]);
}
}
}
// Test getOffsetFromLocal(UDate date, int32_t nonExistingTimeOpt, int32_t duplicatedTimeOpt,
// int32_t& rawOffset, int32_t& dstOffset, UErroCode& status)
// with nonExistingTimeOpt=kLatter/duplicatedTimeOpt=kFormer
for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
for (int m = 0; m < NUM_DATES; m++) {
status = U_ZERO_ERROR;
TESTZONES[i]->getOffsetFromLocal(MILLIS[m], BasicTimeZone::kLatter, BasicTimeZone::kFormer,
rawOffset, dstOffset, status);
if (U_FAILURE(status)) {
errln((UnicodeString)"getOffsetFromLocal with kLatter/kFormer failed for TESTZONES[" + i + "]");
} else if (rawOffset != OFFSETS3[m][0] || dstOffset != OFFSETS3[m][1]) {
dateStr.remove();
df.format(MILLIS[m], dateStr);
dataerrln((UnicodeString)"Bad offset returned by TESTZONES[" + i + "] at "
+ dateStr + "(wall/kLatter/kFormer) - Got: "
+ rawOffset + "/" + dstOffset
+ " Expected: " + OFFSETS3[m][0] + "/" + OFFSETS3[m][1]);
}
}
}
for (int32_t i = 0; i < NUM_TIMEZONES; i++) {
delete TESTZONES[i];
}
delete utc;
delete cal;
}
int main(int argc, char **argv) {
Calendar *cal;
TimeZone *zone;
DateFormat *fmt;
UErrorCode status = U_ZERO_ERROR;
UnicodeString str;
UDate date;
// The languages in which we will display the date
static char* LANGUAGE[] = {
"en", "de", "fr"
};
static const int32_t N_LANGUAGE = sizeof(LANGUAGE)/sizeof(LANGUAGE[0]);
// The time zones in which we will display the time
static char* TIMEZONE[] = {
"America/Los_Angeles",
"America/New_York",
"Europe/Paris",
"Europe/Berlin"
};
static const int32_t N_TIMEZONE = sizeof(TIMEZONE)/sizeof(TIMEZONE[0]);
// Create a calendar
cal = Calendar::createInstance(status);
check(status, "Calendar::createInstance");
zone = createZone("GMT"); // Create a GMT zone
cal->adoptTimeZone(zone);
cal->clear();
cal->set(1999, Calendar::JUNE, 4);
date = cal->getTime(status);
check(status, "Calendar::getTime");
for (int32_t i=0; i<N_LANGUAGE; ++i) {
Locale loc(LANGUAGE[i]);
// Create a formatter for DATE and TIME
fmt = DateFormat::createDateTimeInstance(
DateFormat::kFull, DateFormat::kFull, loc);
for (int32_t j=0; j<N_TIMEZONE; ++j) {
cal->adoptTimeZone(createZone(TIMEZONE[j]));
fmt->setCalendar(*cal);
// Format the date
str.remove();
fmt->format(date, str, status);
// Display the formatted date string
printf("Date (%s, %s): ", LANGUAGE[i], TIMEZONE[j]);
uprintf(escape(str));
printf("\n\n");
}
delete fmt;
}
printf("Exiting successfully\n");
return 0;
}
void DataDrivenFormatTest::testConvertDate(TestData *testData,
const DataMap * /* settings */, UBool fmt) {
UnicodeString kPATTERN("PATTERN="); // TODO: static
UnicodeString kMILLIS("MILLIS="); // TODO: static
UnicodeString kRELATIVE_MILLIS("RELATIVE_MILLIS="); // TODO: static
UnicodeString kRELATIVE_ADD("RELATIVE_ADD:"); // TODO: static
UErrorCode status = U_ZERO_ERROR;
SimpleDateFormat basicFmt(UnicodeString("EEE MMM dd yyyy / YYYY'-W'ww-ee"),
status);
if (U_FAILURE(status)) {
dataerrln("FAIL: Couldn't create basic SimpleDateFormat: %s",
u_errorName(status));
return;
}
const DataMap *currentCase= NULL;
// Start the processing
int n = 0;
while (testData->nextCase(currentCase, status)) {
char calLoc[256] = "";
DateTimeStyleSet styleSet;
UnicodeString pattern;
UBool usePattern = FALSE;
(void)usePattern; // Suppress unused warning.
CalendarFieldsSet fromSet;
UDate fromDate = 0;
UBool useDate = FALSE;
UDate now = Calendar::getNow();
++n;
char theCase[200];
sprintf(theCase, "case %d:", n);
UnicodeString caseString(theCase, "");
// load params
UnicodeString locale = currentCase->getString("locale", status);
if (U_FAILURE(status)) {
errln("case %d: No 'locale' line.", n);
continue;
}
UnicodeString zone = currentCase->getString("zone", status);
if (U_FAILURE(status)) {
errln("case %d: No 'zone' line.", n);
continue;
}
UnicodeString spec = currentCase->getString("spec", status);
if(U_FAILURE(status)) {
errln("case %d: No 'spec' line.", n);
continue;
}
UnicodeString date = currentCase->getString("date", status);
if(U_FAILURE(status)) {
errln("case %d: No 'date' line.", n);
continue;
}
UnicodeString expectStr= currentCase->getString("str", status);
if(U_FAILURE(status)) {
errln("case %d: No 'str' line.", n);
continue;
}
DateFormat *format = NULL;
// Process: 'locale'
locale.extract(0, locale.length(), calLoc, (const char*)0); // default codepage. Invariant codepage doesn't have '@'!
Locale loc(calLoc);
if(spec.startsWith(kPATTERN)) {
pattern = UnicodeString(spec,kPATTERN.length());
usePattern = TRUE;
format = new SimpleDateFormat(pattern, loc, status);
if(U_FAILURE(status)) {
errln("case %d: could not create SimpleDateFormat from pattern: %s", n, u_errorName(status));
continue;
}
} else {
if(styleSet.parseFrom(spec, status)<0 || U_FAILURE(status)) {
errln("case %d: could not parse spec as style fields: %s", n, u_errorName(status));
continue;
}
format = DateFormat::createDateTimeInstance((DateFormat::EStyle)styleSet.getDateStyle(), (DateFormat::EStyle)styleSet.getTimeStyle(), loc);
if(format == NULL ) {
errln("case %d: could not create SimpleDateFormat from styles.", n);
continue;
}
}
Calendar *cal = Calendar::createInstance(loc, status);
if(U_FAILURE(status)) {
errln("case %d: could not create calendar from %s", n, calLoc);
}
if (zone.length() > 0) {
TimeZone * tz = TimeZone::createTimeZone(zone);
cal->setTimeZone(*tz);
format->setTimeZone(*tz);
delete tz;
}
// parse 'date'
if(date.startsWith(kMILLIS)) {
UnicodeString millis = UnicodeString(date, kMILLIS.length());
useDate = TRUE;
fromDate = udbg_stod(millis);
} else if(date.startsWith(kRELATIVE_MILLIS)) {
UnicodeString millis = UnicodeString(date, kRELATIVE_MILLIS.length());
useDate = TRUE;
fromDate = udbg_stod(millis) + now;
} else if(date.startsWith(kRELATIVE_ADD)) {
UnicodeString add = UnicodeString(date, kRELATIVE_ADD.length()); // "add" is a string indicating which fields to add
if(fromSet.parseFrom(add, status)<0 || U_FAILURE(status)) {
errln("case %d: could not parse date as RELATIVE_ADD calendar fields: %s", n, u_errorName(status));
continue;
}
useDate=TRUE;
cal->clear();
cal->setTime(now, status);
for (int q=0; q<UCAL_FIELD_COUNT; q++) {
if (fromSet.isSet((UCalendarDateFields)q)) {
//int32_t oldv = cal->get((UCalendarDateFields)q, status);
if (q == UCAL_DATE) {
cal->add((UCalendarDateFields)q,
fromSet.get((UCalendarDateFields)q), status);
} else {
cal->set((UCalendarDateFields)q,
fromSet.get((UCalendarDateFields)q));
}
//int32_t newv = cal->get((UCalendarDateFields)q, status);
}
}
fromDate = cal->getTime(status);
if(U_FAILURE(status)) {
errln("case %d: could not apply date as RELATIVE_ADD calendar fields: %s", n, u_errorName(status));
continue;
}
} else if(fromSet.parseFrom(date, status)<0 || U_FAILURE(status)) {
errln("case %d: could not parse date as calendar fields: %s", n, u_errorName(status));
continue;
}
// now, do it.
if (fmt) {
FieldPosition pos;
// logln((UnicodeString)"#"+n+" "+locale+"/"+from+" >>> "+toCalLoc+"/"
// +to);
cal->clear();
UnicodeString output;
output.remove();
if(useDate) {
// cal->setTime(fromDate, status);
// if(U_FAILURE(status)) {
// errln("case %d: could not set time on calendar: %s", n, u_errorName(status));
// continue;
// }
format->format(fromDate, output, pos, status);
} else {
fromSet.setOnCalendar(cal, status);
if(U_FAILURE(status)) {
errln("case %d: could not set fields on calendar: %s", n, u_errorName(status));
continue;
}
format->format(*cal, output, pos);
}
// check erro result from 'format'
if(U_FAILURE(status)) {
errln("case %d: could not format(): %s", n, u_errorName(status)); // TODO: use 'pos'
}
// if(pos.getBeginIndex()==0 && pos.getEndIndex()==0) { // TODO: more precise error?
// errln("WARNING: case %d: format's pos returned (0,0) - error ??", n);
// }
if(output == expectStr) {
logln(caseString+": format: SUCCESS! "+UnicodeString("expect=output=")+output);
} else {
UnicodeString result;
UnicodeString result2;
errln(caseString+": format: output!=expectStr, got " + *udbg_escape(output, &result) + " expected " + *udbg_escape(expectStr, &result2));
}
} else {
cal->clear();
ParsePosition pos;
format->parse(expectStr,*cal,pos);
if(useDate) {
UDate gotDate = cal->getTime(status);
if(U_FAILURE(status)) {
errln(caseString+": parse: could not get time on calendar: "+UnicodeString(u_errorName(status)));
continue;
}
if(gotDate == fromDate) {
logln(caseString+": parse: SUCCESS! "+UnicodeString("gotDate=parseDate=")+expectStr);
} else {
UnicodeString expectDateStr, gotDateStr;
basicFmt.format(fromDate,expectDateStr);
basicFmt.format(gotDate,gotDateStr);
errln(caseString+": parse: FAIL. parsed '"+expectStr+"' and got "+gotDateStr+", expected " + expectDateStr);
}
} else {
// Calendar *cal2 = cal->clone();
// cal2->clear();
// fromSet.setOnCalendar(cal2, status);
if(U_FAILURE(status)) {
errln("case %d: parse: could not set fields on calendar: %s", n, u_errorName(status));
continue;
}
CalendarFieldsSet diffSet;
// diffSet.clear();
if (!fromSet.matches(cal, diffSet, status)) {
UnicodeString diffs = diffSet.diffFrom(fromSet, status);
errln((UnicodeString)"FAIL: "+caseString
+", Differences: '"+ diffs
+"', status: "+ u_errorName(status));
} else if (U_FAILURE(status)) {
errln("FAIL: "+caseString+" parse SET SOURCE calendar Failed to match: "
+u_errorName(status));
} else {
logln("PASS: "******" parse.");
}
}
}
delete cal;
delete format;
}
// delete basicFmt;
}
void IntlCalendarTest::quasiGregorianTest(Calendar& cal, const Locale& gcl, const int32_t *data) {
UErrorCode status = U_ZERO_ERROR;
// As of JDK 1.4.1_01, using the Sun JDK GregorianCalendar as
// a reference throws us off by one hour. This is most likely
// due to the JDK 1.4 incorporation of historical time zones.
//java.util.Calendar grego = java.util.Calendar.getInstance();
Calendar *grego = Calendar::createInstance(gcl, status);
if (U_FAILURE(status)) {
dataerrln("Error calling Calendar::createInstance");
return;
}
int32_t tz1 = cal.get(UCAL_ZONE_OFFSET,status);
int32_t tz2 = grego -> get (UCAL_ZONE_OFFSET, status);
if(tz1 != tz2) {
errln((UnicodeString)"cal's tz " + tz1 + " != grego's tz " + tz2);
}
for (int32_t i=0; data[i]!=-1; ) {
int32_t era = data[i++];
int32_t year = data[i++];
int32_t gregorianYear = data[i++];
int32_t month = data[i++];
int32_t dayOfMonth = data[i++];
grego->clear();
grego->set(gregorianYear, month, dayOfMonth);
UDate D = grego->getTime(status);
cal.clear();
cal.set(UCAL_ERA, era);
cal.set(year, month, dayOfMonth);
UDate d = cal.getTime(status);
#ifdef U_DEBUG_DUMPCALS
logln((UnicodeString)"cal : " + CalendarTest::calToStr(cal));
logln((UnicodeString)"grego: " + CalendarTest::calToStr(*grego));
#endif
if (d == D) {
logln(UnicodeString("OK: ") + era + ":" + year + "/" + (month+1) + "/" + dayOfMonth +
" => " + d + " (" + UnicodeString(cal.getType()) + ")");
} else {
errln(UnicodeString("Fail: (fields to millis)") + era + ":" + year + "/" + (month+1) + "/" + dayOfMonth +
" => " + d + ", expected " + D + " (" + UnicodeString(cal.getType()) + "Off by: " + (d-D));
}
// Now, set the gregorian millis on the other calendar
cal.clear();
cal.setTime(D, status);
int e = cal.get(UCAL_ERA, status);
int y = cal.get(UCAL_YEAR, status);
#ifdef U_DEBUG_DUMPCALS
logln((UnicodeString)"cal : " + CalendarTest::calToStr(cal));
logln((UnicodeString)"grego: " + CalendarTest::calToStr(*grego));
#endif
if (y == year && e == era) {
logln((UnicodeString)"OK: " + D + " => " + cal.get(UCAL_ERA, status) + ":" +
cal.get(UCAL_YEAR, status) + "/" +
(cal.get(UCAL_MONTH, status)+1) + "/" + cal.get(UCAL_DATE, status) + " (" + UnicodeString(cal.getType()) + ")");
} else {
errln((UnicodeString)"Fail: (millis to fields)" + D + " => " + cal.get(UCAL_ERA, status) + ":" +
cal.get(UCAL_YEAR, status) + "/" +
(cal.get(UCAL_MONTH, status)+1) + "/" + cal.get(UCAL_DATE, status) +
", expected " + era + ":" + year + "/" + (month+1) + "/" +
dayOfMonth + " (" + UnicodeString(cal.getType()));
}
}
delete grego;
CHECK(status, "err during quasiGregorianTest()");
}