static void replaceFieldTypesExample() {
// Use repalceFieldTypes API to replace zone 'zzzz' with 'vvvv'
u_printf("========================================================================\n");
u_printf(" replaceFieldTypeExample()\n");
u_printf("\n");
u_printf(" Use replaceFieldTypes API to replace zone 'zzzz' with 'vvvv'\n");
u_printf("========================================================================\n");
//! [replaceFieldTypesExample]
UFILE *out = u_finit(stdout, NULL, "UTF-8");
UErrorCode status =U_ZERO_ERROR;
UnicodeString pattern,dateReturned;
Locale locale =Locale::getFrance();
Calendar *cal = Calendar::createInstance(status);
cal->set (1999,9,13,23,58,59);
UDate date = cal->getTime(status);
TimeZone *zone = TimeZone::createTimeZone(UnicodeString("Europe/Paris"));
DateTimePatternGenerator *dtfg = DateTimePatternGenerator::createInstance(locale,status);
SimpleDateFormat *sdf = new SimpleDateFormat("EEEE d MMMM y HH:mm:ss zzzz",locale,status);
sdf->setTimeZone(*zone);
pattern = sdf->toPattern(pattern);
u_fprintf(out, "%S\n", UnicodeString("Pattern before replacement:").getTerminatedBuffer());
u_fprintf(out, "%S\n", pattern.getTerminatedBuffer());
dateReturned.remove();
dateReturned = sdf->format(date, dateReturned, status);
u_fprintf(out, "%S\n", UnicodeString("Date/Time format in fr_FR:").getTerminatedBuffer());
u_fprintf(out, "%S\n", dateReturned.getTerminatedBuffer());
// Replace zone "zzzz" in the pattern with "vvvv"
UnicodeString newPattern = dtfg->replaceFieldTypes(pattern, "vvvv", status);
// Apply the new pattern
sdf->applyPattern(newPattern);
dateReturned.remove();
dateReturned = sdf->format(date, dateReturned, status);
u_fprintf(out, "%S\n", UnicodeString("Pattern after replacement:").getTerminatedBuffer());
u_fprintf(out, "%S\n", newPattern.getTerminatedBuffer());
u_fprintf(out, "%S\n", UnicodeString("Date/Time format in fr_FR:").getTerminatedBuffer());
u_fprintf(out, "%S\n", dateReturned.getTerminatedBuffer());
delete sdf;
delete dtfg;
delete zone;
delete cal;
u_fclose(out);
//! [replaceFieldTypesExample]
/* output of the sample code:
*************************************************************************************************
Pattern before replacement:
EEEE d MMMM y HH:mm:ss zzzz
Date/Time format in fr_FR:
jeudi 14 octobre 1999 05:58:59 heure avancée d’Europe centrale
Pattern after replacement:
EEEE d MMMM y HH:mm:ss vvvv
Date/Time format in fr_FR:
jeudi 14 octobre 1999 05:58:59 heure de l’Europe centrale
*************************************************************************************************/
}
/**
* @bug 4029195
*/
void DateFormatRegressionTest::Test4029195(void)
{
UErrorCode status = U_ZERO_ERROR;
UDate today = Calendar::getNow();
logln((UnicodeString) "today: " + today);
SimpleDateFormat *sdf = (SimpleDateFormat*) DateFormat::createDateInstance();
if (failure(status, "SimpleDateFormat::createDateInstance")) {
return;
}
UnicodeString pat;
if(sdf == NULL){
dataerrln("Error calling DateFormat::createDateTimeInstance");
return;
}
pat = sdf->toPattern(pat);
logln("pattern: " + pat);
UnicodeString fmtd;
FieldPosition pos(FieldPosition::DONT_CARE);
fmtd = sdf->format(today, fmtd, pos);
logln("today: " + fmtd);
sdf->applyPattern("G yyyy DDD");
UnicodeString todayS;
todayS = sdf->format(today, todayS, pos);
logln("today: " + todayS);
//try {
today = sdf->parse(todayS, status);
failure(status, "sdf->parse");
logln((UnicodeString)"today date: " + today);
/*} catch(Exception e) {
logln("Error reparsing date: " + e.getMessage());
}*/
//try {
UnicodeString rt;
rt = sdf->format(sdf->parse(todayS, status), rt, pos);
failure(status, "sdf->parse");
logln("round trip: " + rt);
if(rt != todayS)
errln("Fail: Want " + todayS + " Got " + rt);
/*}
catch (ParseException e) {
errln("Fail: " + e);
e.printStackTrace();
}*/
delete sdf;
}
void DateFormatRegressionTest::Test5554(void)
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString pattern("Z","");
UnicodeString newfoundland("Canada/Newfoundland", "");
TimeZone *zone = TimeZone::createTimeZone(newfoundland);
Calendar *cal = new GregorianCalendar(zone, status);
SimpleDateFormat *sdf = new SimpleDateFormat(pattern,status);
if (U_FAILURE(status)) {
dataerrln("Error constructing SimpleDateFormat");
delete cal;
delete sdf;
return;
}
cal->set(2007, 1, 14);
UDate date = cal->getTime(status);
if (U_FAILURE(status)) {
errln("Error getting time to format");
return;
};
sdf->adoptCalendar(cal);
UnicodeString result;
UnicodeString correct("-0330", "");
sdf->format(date, result);
if (result != correct) {
errln("\nError: Newfoundland Z of Jan 14, 2007 gave '" + result + "', expected '" + correct + "'");
}
delete sdf;
}
std::string L10n::FormatMillisecondsIntoDateString(const UDate& milliseconds, const std::string& formatString) const
{
UErrorCode status = U_ZERO_ERROR;
UnicodeString dateString;
std::string resultString;
UnicodeString unicodeFormat = UnicodeString::fromUTF8(formatString.c_str());
SimpleDateFormat* dateFormat = new SimpleDateFormat(unicodeFormat, status);
if (U_FAILURE(status))
LOGERROR("Error creating SimpleDateFormat: %s", u_errorName(status));
const TimeZone* timeZone = TimeZone::getGMT();
status = U_ZERO_ERROR;
Calendar* calendar = Calendar::createInstance(*timeZone, currentLocale, status);
if (U_FAILURE(status))
LOGERROR("Error creating calendar: %s", u_errorName(status));
dateFormat->adoptCalendar(calendar);
dateFormat->format(milliseconds, dateString);
delete dateFormat;
dateString.toUTF8String(resultString);
return resultString;
}
void IntlCalendarTest::TestPersianFormat() {
UErrorCode status = U_ZERO_ERROR;
SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"), Locale(" en_US@calendar=persian"), status);
CHECK(status, "creating date format instance");
SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
CHECK(status, "creating gregorian date format instance");
UnicodeString gregorianDate("January 18, 2007 AD");
UDate aDate = fmt2->parse(gregorianDate, status);
if(!fmt) {
errln("Coudln't create en_US instance");
} else {
UnicodeString str;
fmt->format(aDate, str);
logln(UnicodeString() + "as Persian Calendar: " + escape(str));
UnicodeString expected("Dey 28, 1385 AP");
if(str != expected) {
errln("Expected " + escape(expected) + " but got " + escape(str));
}
UDate otherDate = fmt->parse(expected, status);
if(otherDate != aDate) {
UnicodeString str3;
fmt->format(otherDate, str3);
errln("Parse incorrect of " + escape(expected) + " - wanted " + aDate + " but got " + otherDate + ", " + escape(str3));
} else {
logln("Parsed OK: " + expected);
}
// Two digit year parsing problem #4732
fmt->applyPattern("yy-MM-dd");
str.remove();
fmt->format(aDate, str);
expected.setTo("85-10-28");
if(str != expected) {
errln("Expected " + escape(expected) + " but got " + escape(str));
}
otherDate = fmt->parse(expected, status);
if (otherDate != aDate) {
errln("Parse incorrect of " + escape(expected) + " - wanted " + aDate + " but got " + otherDate);
} else {
logln("Parsed OK: " + expected);
}
delete fmt;
}
delete fmt2;
CHECK(status, "Error occured testing Persian Calendar in English ");
}
static void getBestPatternExample() {
u_printf("========================================================================\n");
u_printf(" getBestPatternExample()\n");
u_printf("\n");
u_printf(" Use DateTimePatternGenerator to create customized date/time pattern:\n");
u_printf(" yQQQQ,yMMMM, MMMMd, hhmm, jjmm per locale\n");
u_printf("========================================================================\n");
//! [getBestPatternExample]
UnicodeString skeletons [] = {
UnicodeString("yQQQQ"), // year + full name of quarter, i.e., 4th quarter 1999
UnicodeString("yMMMM"), // year + full name of month, i.e., October 1999
UnicodeString("MMMMd"), // full name of month + day of the month, i.e., October 25
UnicodeString("hhmm"), // 12-hour-cycle format, i.e., 1:32 PM
UnicodeString("jjmm"), // preferred hour format for the given locale, i.e., 24-hour-cycle format for fr_FR
0,
};
Locale locales[] = {
Locale ("en_US"),
Locale ("fr_FR"),
Locale ("zh_CN"),
};
const char* filename = "sample.txt";
/* open a UTF-8 file for writing */
UFILE* f = u_fopen(filename, "w", NULL,"UTF-8");
UnicodeString dateReturned;
UErrorCode status =U_ZERO_ERROR;
Calendar *cal = Calendar::createInstance(status);
cal->set (1999,9,13,23,58,59);
UDate date = cal->getTime(status);
u_fprintf(f, "%-20S%-20S%-20S%-20S\n", UnicodeString("Skeleton").getTerminatedBuffer(),UnicodeString("en_US").getTerminatedBuffer(),UnicodeString("fr_FR").getTerminatedBuffer(),UnicodeString("zh_CN").getTerminatedBuffer());
for (int i=0;skeletons[i]!=NULL;i++) {
u_fprintf(f, "%-20S",skeletons[i].getTerminatedBuffer());
for (int j=0;j<sizeof(locales)/sizeof(locales[0]);j++) {
// create a DateTimePatternGenerator instance for given locale
DateTimePatternGenerator *dtfg= DateTimePatternGenerator::createInstance(locales[j],status);
// use getBestPattern method to get the best pattern for the given skeleton
UnicodeString pattern = dtfg->getBestPattern(skeletons[i],status);
// Constructs a SimpleDateFormat with the best pattern generated above and the given locale
SimpleDateFormat *sdf = new SimpleDateFormat(pattern,locales[j],status);
dateReturned.remove();
// Get the format of the given date
sdf->format(date,dateReturned,status);
/* write Unicode string to file */
u_fprintf(f, "%-20S", dateReturned.getTerminatedBuffer());
delete dtfg;
delete sdf;
}
u_fprintf(f,"\n");
}
/* close the file resource */
u_fclose(f);
delete cal;
//! [getBestPatternExample]
}
/**
* @bug 4151631
* SimpleDateFormat incorrect handling of 2 single quotes in format()
*/
void DateFormatRegressionTest::Test4151631(void)
{
UnicodeString pattern = "'TO_DATE('''dd'-'MM'-'yyyy HH:mm:ss''' , ''DD-MM-YYYY HH:MI:SS'')'";
logln("pattern=" + pattern);
UErrorCode status = U_ZERO_ERROR;
SimpleDateFormat *format = new SimpleDateFormat(pattern, Locale::getUS(), status);
if (failure(status, "new SimpleDateFormat", TRUE)) return;
UnicodeString result;
FieldPosition pos(FieldPosition::DONT_CARE);
result = format->format(date(1998-1900, UCAL_JUNE, 30, 13, 30, 0), result, pos);
if (result != "TO_DATE('30-06-1998 13:30:00' , 'DD-MM-YYYY HH:MI:SS')") {
errln("Fail: result=" + result);
}
else {
logln("Pass: result=" + result);
}
delete format;
}
/**
* @bug 4101483
*/
void DateFormatRegressionTest::Test4101483(void)
{
UErrorCode status = U_ZERO_ERROR;
SimpleDateFormat *sdf = new SimpleDateFormat(UnicodeString("z"), Locale::getUS(), status);
if (failure(status, "new SimpleDateFormat", TRUE)) return;
FieldPosition fp(UDAT_TIMEZONE_FIELD);
//Date d = date(9234567890L);
UDate d = 9234567890.0;
//StringBuffer buf = new StringBuffer("");
UnicodeString buf;
sdf->format(d, buf, fp);
//logln(sdf.format(d, buf, fp).toString());
logln(dateToString(d) + " => " + buf);
logln("beginIndex = " + fp.getBeginIndex());
logln("endIndex = " + fp.getEndIndex());
if (fp.getBeginIndex() == fp.getEndIndex())
errln("Fail: Empty field");
delete sdf;
}
static void addPatternExample() {
u_printf("========================================================================\n");
u_printf(" addPatternExample()\n");
u_printf("\n");
u_printf(" Use addPattern API to add new '. von' to existing pattern\n");
u_printf("========================================================================\n");
//! [addPatternExample]
UErrorCode status =U_ZERO_ERROR;
UnicodeString conflictingPattern,dateReturned, pattern;
Locale locale=Locale::getFrance();
Calendar *cal = Calendar::createInstance(status);
cal->set (1999,9,13,23,58,59);
UDate date = cal->getTime(status);
// Create an DateTimePatternGenerator instance for the given locale
DateTimePatternGenerator *dtfg= DateTimePatternGenerator::createInstance(locale,status);
SimpleDateFormat *sdf = new SimpleDateFormat(dtfg->getBestPattern("MMMMddHmm",status),locale,status);
// Add '. von' to the existing pattern
dtfg->addPattern("dd'. von' MMMM", true, conflictingPattern,status);
// Apply the new pattern
sdf->applyPattern(dtfg->getBestPattern("MMMMddHmm",status));
dateReturned = sdf->format(date, dateReturned, status);
pattern =sdf->toPattern(pattern);
u_printf("%s\n", "New Pattern for FRENCH: ");
u_printf("%S\n", pattern.getTerminatedBuffer());
u_printf("%s\n", "Date Time in new Pattern: ");
u_printf("%S\n", dateReturned.getTerminatedBuffer());
delete dtfg;
delete sdf;
delete cal;
//! [addPatternExample]
/* output of the sample code:
************************************************************************************************
New Pattern for FRENCH: dd. 'von' MMMM HH:mm
Date Time in new Pattern: 13. von octobre 23:58
*************************************************************************************************/
}
/**
* @bug 4103340
* @bug 4138203
* This bug really only works in Locale.US, since that's what the locale
* used for Date.toString() is. Bug 4138203 reports that it fails on Korean
* NT; it would actually have failed on any non-US locale. Now it should
* work on all locales.
*/
void DateFormatRegressionTest::Test4103340(void)
{
UErrorCode status = U_ZERO_ERROR;
// choose a date that is the FIRST of some month
// and some arbitrary time
UDate d = date(97, 3, 1, 1, 1, 1);
SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("MMMM"), Locale::getUS(), status);
if (failure(status, "new SimpleDateFormat", TRUE)) return;
UnicodeString s;
s = dateToString(d, s);
UnicodeString s2;
FieldPosition pos(FieldPosition::DONT_CARE);
s2 = df->format(d, s2, pos);
logln("Date=" + s);
logln("DF=" + s2);
UnicodeString substr;
s2.extract(0,2, substr);
if (s.indexOf(substr) == -1)
errln("Months should match");
delete df;
}
void IntlCalendarTest::TestJapaneseFormat() {
Calendar *cal;
UErrorCode status = U_ZERO_ERROR;
cal = Calendar::createInstance("ja_JP_TRADITIONAL", status);
CHECK(status, UnicodeString("Creating ja_JP_TRADITIONAL calendar"));
Calendar *cal2 = cal->clone();
delete cal;
cal = NULL;
// Test simple parse/format with adopt
UDate aDate = 999932400000.0;
SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yy G"), Locale("en_US@calendar=japanese"), status);
SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
CHECK(status, "creating date format instance");
if(!fmt) {
errln("Coudln't create en_US instance");
} else {
UnicodeString str;
fmt2->format(aDate, str);
logln(UnicodeString() + "Test Date: " + str);
str.remove();
fmt->format(aDate, str);
logln(UnicodeString() + "as Japanese Calendar: " + str);
UnicodeString expected("September 8, 13 Heisei");
if(str != expected) {
errln("Expected " + expected + " but got " + str);
}
UDate otherDate = fmt->parse(expected, status);
if(otherDate != aDate) {
UnicodeString str3;
ParsePosition pp;
fmt->parse(expected, *cal2, pp);
fmt->format(otherDate, str3);
errln("Parse incorrect of " + expected + " - wanted " + aDate + " but got " + " = " + otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*cal2) );
} else {
logln("Parsed OK: " + expected);
}
delete fmt;
}
// Test parse with incomplete information
fmt = new SimpleDateFormat(UnicodeString("G y"), Locale("en_US@calendar=japanese"), status);
aDate = -3197117222000.0;
CHECK(status, "creating date format instance");
if(!fmt) {
errln("Coudln't create en_US instance");
} else {
UnicodeString str;
fmt2->format(aDate, str);
logln(UnicodeString() + "Test Date: " + str);
str.remove();
fmt->format(aDate, str);
logln(UnicodeString() + "as Japanese Calendar: " + str);
UnicodeString expected("Meiji 1");
if(str != expected) {
errln("Expected " + expected + " but got " + str);
}
UDate otherDate = fmt->parse(expected, status);
if(otherDate != aDate) {
UnicodeString str3;
ParsePosition pp;
fmt->parse(expected, *cal2, pp);
fmt->format(otherDate, str3);
errln("Parse incorrect of " + expected + " - wanted " + aDate + " but got " + " = " +
otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*cal2) );
} else {
logln("Parsed OK: " + expected);
}
delete fmt;
}
delete cal2;
delete fmt2;
CHECK(status, "Error occured");
// Now, try in Japanese
{
UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u67088\\u65e5\\u571f\\u66dc\\u65e5");
UDate expectDate = 999932400000.0; // Testing a recent date
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{
UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u67088\\u65e5\\u571f\\u66dc\\u65e5");
UDate expectDate = 999932400000.0; // Testing a recent date
Locale loc("ja_JP_TRADITIONAL"); // legacy
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{
UnicodeString expect = CharsToUnicodeString("\\u5b89\\u6c385\\u5e747\\u67084\\u65e5\\u6728\\u66dc\\u65e5");
UDate expectDate = -6106032422000.0; // 1776-07-04T00:00:00Z-075258
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{ // Jitterbug 1869 - this is an ambiguous era. (Showa 64 = Jan 6 1989, but Showa could be 2 other eras) )
UnicodeString expect = CharsToUnicodeString("\\u662d\\u548c64\\u5e741\\u67086\\u65e5\\u91d1\\u66dc\\u65e5");
UDate expectDate = 600076800000.0;
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{ // This Feb 29th falls on a leap year by gregorian year, but not by Japanese year.
UnicodeString expect = CharsToUnicodeString("\\u5EB7\\u6B632\\u5e742\\u670829\\u65e5\\u65e5\\u66dc\\u65e5");
UDate expectDate = -16214400422000.0; // 1456-03-09T00:00Z-075258
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
}
/**
* Today, the 9th day of April, is your birthday.
* So I created a page to celebrate this extraordinary day.
*/
Girl u = new Girl( "Ziqian Wang" );
// You are always elegant and beautiful
u.attr = "Grace";
// Apr. 9th, when the bell rang, your age increased
Date currentTime = new Date();
SimpleDateFormat formatter = new SimpleDateFormat( "yyyy-mm-dd hh:mm:ss" );
String dateString = formatter.format( currentTime );
if( dateString.equals( "2016-04-09 00:00:00" ) ){
u.age ++;
}
// Our blessing will be with you simultaneously.
new Thread (){
@Override
// Forever and ever. I wish
while(true){
// luckiness,
u.fortune ++;
// happiness,
u.happiness ++;
// and everything you wish can be achieved.
}.start()
// The last thing I wanna say, boring and ordinary, is:
System.out.println("Happy Birthday !");
}
void
DateFormatMiscTests::test4099975()
{
/**
* Test Constructor SimpleDateFormat::SimpleDateFormat (const UnicodeString & pattern,
* const DateFormatSymbols & formatData, UErrorCode & status )
* The DateFormatSymbols object is NOT adopted; Modifying the original DateFormatSymbols
* should not change the SimpleDateFormat's behavior.
*/
UDate d = Calendar::getNow();
{
UErrorCode status = U_ZERO_ERROR;
DateFormatSymbols* symbols = new DateFormatSymbols(Locale::getUS(), status);
if(failure(status, "new DateFormatSymbols")) return;
SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("E hh:mm"), *symbols, status);
if(failure(status, "new SimpleDateFormat")) return;
UnicodeString format0;
format0 = df->format(d, format0);
UnicodeString localizedPattern0;
localizedPattern0 = df->toLocalizedPattern(localizedPattern0, status);
failure(status, "df->toLocalizedPattern");
symbols->setLocalPatternChars(UnicodeString("abcdefghijklmonpqr")); // change value of field
UnicodeString format1;
format1 = df->format(d, format1);
if (format0 != format1) {
errln(UnicodeString("Formats are different. format0: ") + format0
+ UnicodeString("; format1: ") + format1);
}
UnicodeString localizedPattern1;
localizedPattern1 = df->toLocalizedPattern(localizedPattern1, status);
failure(status, "df->toLocalizedPattern");
if (localizedPattern0 != localizedPattern1) {
errln(UnicodeString("Pattern has been changed. localizedPattern0: ") + localizedPattern0
+ UnicodeString("; localizedPattern1: ") + localizedPattern1);
}
delete symbols;
delete df;
}
/*
* Test void SimpleDateFormat::setDateFormatSymbols ( const DateFormatSymbols & newFormatSymbols )
* Modifying the original DateFormatSymbols should not change the SimpleDateFormat's behavior.
*/
{
UErrorCode status = U_ZERO_ERROR;
DateFormatSymbols* symbols = new DateFormatSymbols(Locale::getUS(), status);
if(failure(status, "new DateFormatSymbols")) return;
SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("E hh:mm"), status);
if(failure(status, "new SimpleDateFormat")) return;
df->setDateFormatSymbols(*symbols);
UnicodeString format0;
format0 = df->format(d, format0);
UnicodeString localizedPattern0;
localizedPattern0 = df->toLocalizedPattern(localizedPattern0, status);
failure(status, "df->toLocalizedPattern");
symbols->setLocalPatternChars(UnicodeString("abcdefghijklmonpqr")); // change value of field
UnicodeString format1;
format1 = df->format(d, format1);
if (format0 != format1) {
errln(UnicodeString("Formats are different. format0: ") + format0
+ UnicodeString("; format1: ") + format1);
}
UnicodeString localizedPattern1;
localizedPattern1 = df->toLocalizedPattern(localizedPattern1, status);
failure(status, "df->toLocalizedPattern");
if (localizedPattern0 != localizedPattern1) {
errln(UnicodeString("Pattern has been changed. localizedPattern0: ") + localizedPattern0
+ UnicodeString("; localizedPattern1: ") + localizedPattern1);
}
delete symbols;
delete df;
}
//Test the pointer version of the constructor (and the adoptDateFormatSymbols method)
{
UErrorCode status = U_ZERO_ERROR;
DateFormatSymbols* symbols = new DateFormatSymbols(Locale::getUS(), status);
if(failure(status, "new DateFormatSymbols")) return;
SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("E hh:mm"), symbols, status);
if(failure(status, "new SimpleDateFormat")) return;
UnicodeString format0;
format0 = df->format(d, format0);
UnicodeString localizedPattern0;
localizedPattern0 = df->toLocalizedPattern(localizedPattern0, status);
failure(status, "df->toLocalizedPattern");
symbols->setLocalPatternChars(UnicodeString("abcdefghijklmonpqr")); // change value of field
UnicodeString format1;
format1 = df->format(d, format1);
if (format0 != format1) {
errln(UnicodeString("Formats are different. format0: ") + format0
+ UnicodeString("; format1: ") + format1);
}
UnicodeString localizedPattern1;
localizedPattern1 = df->toLocalizedPattern(localizedPattern1, status);
failure(status, "df->toLocalizedPattern");
if (localizedPattern0 == localizedPattern1) {
errln(UnicodeString("Pattern should have been changed. localizedPattern0: ") + localizedPattern0
+ UnicodeString("; localizedPattern1: ") + localizedPattern1);
}
//delete symbols; the caller is no longer responsible for deleting the symbols
delete df;
}
//
{
UErrorCode status = U_ZERO_ERROR;
DateFormatSymbols* symbols = new DateFormatSymbols(Locale::getUS(), status);
failure(status, "new DateFormatSymbols");
SimpleDateFormat *df = new SimpleDateFormat(UnicodeString("E hh:mm"), status);
if(failure(status, "new SimpleDateFormat")) return;
df-> adoptDateFormatSymbols(symbols);
UnicodeString format0;
format0 = df->format(d, format0);
UnicodeString localizedPattern0;
localizedPattern0 = df->toLocalizedPattern(localizedPattern0, status);
failure(status, "df->toLocalizedPattern");
symbols->setLocalPatternChars(UnicodeString("abcdefghijklmonpqr")); // change value of field
UnicodeString format1;
format1 = df->format(d, format1);
if (format0 != format1) {
errln(UnicodeString("Formats are different. format0: ") + format0
+ UnicodeString("; format1: ") + format1);
}
UnicodeString localizedPattern1;
localizedPattern1 = df->toLocalizedPattern(localizedPattern1, status);
failure(status, "df->toLocalizedPattern");
if (localizedPattern0 == localizedPattern1) {
errln(UnicodeString("Pattern should have been changed. localizedPattern0: ") + localizedPattern0
+ UnicodeString("; localizedPattern1: ") + localizedPattern1);
}
//delete symbols; the caller is no longer responsible for deleting the symbols
delete df;
}
}
void IntlCalendarTest::TestBuddhistFormat() {
UErrorCode status = U_ZERO_ERROR;
// Test simple parse/format with adopt
// First, a contrived english test..
UDate aDate = 999932400000.0;
SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=buddhist"), status);
CHECK(status, "creating date format instance");
SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
CHECK(status, "creating gregorian date format instance");
if(!fmt) {
errln("Coudln't create en_US instance");
} else {
UnicodeString str;
fmt2->format(aDate, str);
logln(UnicodeString() + "Test Date: " + str);
str.remove();
fmt->format(aDate, str);
logln(UnicodeString() + "as Buddhist Calendar: " + escape(str));
UnicodeString expected("September 8, 2544 BE");
if(str != expected) {
errln("Expected " + escape(expected) + " but got " + escape(str));
}
UDate otherDate = fmt->parse(expected, status);
if(otherDate != aDate) {
UnicodeString str3;
fmt->format(otherDate, str3);
errln("Parse incorrect of " + escape(expected) + " - wanted " + aDate + " but got " + otherDate + ", " + escape(str3));
} else {
logln("Parsed OK: " + expected);
}
delete fmt;
}
delete fmt2;
CHECK(status, "Error occured testing Buddhist Calendar in English ");
status = U_ZERO_ERROR;
// Now, try in Thai
{
UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
" 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e1e.\\u0e28. 2544");
UDate expectDate = 999932400000.0;
Locale loc("th_TH_TRADITIONAL"); // legacy
simpleTest(loc, expect, expectDate, status);
}
status = U_ZERO_ERROR;
{
UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
" 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e1e.\\u0e28. 2544");
UDate expectDate = 999932400000.0;
Locale loc("th_TH@calendar=buddhist");
simpleTest(loc, expect, expectDate, status);
}
status = U_ZERO_ERROR;
{
UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
" 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e04.\\u0e28. 2001");
UDate expectDate = 999932400000.0;
Locale loc("th_TH@calendar=gregorian");
simpleTest(loc, expect, expectDate, status);
}
status = U_ZERO_ERROR;
{
UnicodeString expect = CharsToUnicodeString("\\u0E27\\u0E31\\u0E19\\u0E40\\u0E2A\\u0E32\\u0E23\\u0E4C\\u0E17\\u0E35\\u0E48"
" 8 \\u0E01\\u0E31\\u0e19\\u0e22\\u0e32\\u0e22\\u0e19 \\u0e04.\\u0e28. 2001");
UDate expectDate = 999932400000.0;
Locale loc("th_TH_TRADITIONAL@calendar=gregorian");
simpleTest(loc, expect, expectDate, status);
}
}
void
DateFormatMiscTests::test4097450()
{
//
// Date parse requiring 4 digit year.
//
UnicodeString dstring [] = {
UnicodeString("97"),
UnicodeString("1997"),
UnicodeString("97"),
UnicodeString("1997"),
UnicodeString("01"),
UnicodeString("2001"),
UnicodeString("01"),
UnicodeString("2001"),
UnicodeString("1"),
UnicodeString("1"),
UnicodeString("11"),
UnicodeString("11"),
UnicodeString("111"),
UnicodeString("111")
};
UnicodeString dformat [] = {
UnicodeString("yy"),
UnicodeString("yy"),
UnicodeString("yyyy"),
UnicodeString("yyyy"),
UnicodeString("yy"),
UnicodeString("yy"),
UnicodeString("yyyy"),
UnicodeString("yyyy"),
UnicodeString("yy"),
UnicodeString("yyyy"),
UnicodeString("yy"),
UnicodeString("yyyy"),
UnicodeString("yy"),
UnicodeString("yyyy")
};
UErrorCode status = U_ZERO_ERROR;
SimpleDateFormat *formatter;
SimpleDateFormat *resultFormatter = new SimpleDateFormat((UnicodeString)"yyyy", status);
if (U_FAILURE(status)) {
dataerrln("Fail new SimpleDateFormat: %s", u_errorName(status));
return;
}
logln("Format\tSource\tResult");
logln("-------\t-------\t-------");
for (int i = 0; i < 14/*dstring.length*/; i++)
{
log(dformat[i] + "\t" + dstring[i] + "\t");
formatter = new SimpleDateFormat(dformat[i], status);
if(failure(status, "new SimpleDateFormat")) return;
//try {
UnicodeString str;
FieldPosition pos(FieldPosition::DONT_CARE);
logln(resultFormatter->format(formatter->parse(dstring[i], status), str, pos));
failure(status, "resultFormatter->format");
//if ( !dresult[i] ) System.out.print(" <-- error!");
/*}
catch (ParseException exception) {
//if ( dresult[i] ) System.out.print(" <-- error!");
System.out.print("exception --> " + exception);
}*/
delete formatter;
logln();
}
delete resultFormatter;
}
/**
* Test various generic API methods of DateTimePatternGenerator for API coverage.
*/
void IntlTestDateTimePatternGeneratorAPI::testAPI(/*char *par*/)
{
UnicodeString patternData[] = {
UnicodeString("yM"),
UnicodeString("yMMM"),
UnicodeString("yMd"),
UnicodeString("yMMMd"),
UnicodeString("Md"),
UnicodeString("MMMd"),
UnicodeString("yQQQ"),
UnicodeString("hhmm"),
UnicodeString("HHmm"),
UnicodeString("jjmm"),
UnicodeString("mmss"),
UnicodeString("yyyyMMMM"),
UnicodeString(),
};
const char* testLocale[MAX_LOCALE][4] = {
{"en", "US", "", ""},
{"en", "US", "", "calendar=japanese"},
{"zh", "Hans", "CN", ""},
{"de", "DE", "", ""},
{"fi", "", "", ""},
{"ja", "", "", ""},
{"ja", "", "", "calendar=japanese"},
{"zh", "TW", "", "calendar=roc"},
};
UnicodeString patternResults[] = {
UnicodeString("1/1999"), // en_US
UnicodeString("Jan 1999"),
UnicodeString("1/13/1999"),
UnicodeString("Jan 13, 1999"),
UnicodeString("1/13"),
UnicodeString("Jan 13"),
UnicodeString("Q1 1999"),
UnicodeString("11:58 PM"),
UnicodeString("23:58"),
UnicodeString("11:58 PM"), // en_US 9: jjmm
UnicodeString("58:59"),
UnicodeString("January 1999"), // en_US 11: yyyyMMMM
// currently the following for en_US@calendar=japanese just verify the correct fallback behavior for ticket:5702;
// however some are not the "correct" results. To fix that, root needs better DateTimePatterns/availableFormats
// data; cldrbug #1994 is for that.
UnicodeString("H 11-01"), // en_US@calendar=japanese 0: yM
UnicodeString("H 11 Jan"), // en_US@calendar=japanese 1: yMMM
UnicodeString("H 11-01-13"), // en_US@calendar=japanese 2: yMd
UnicodeString("H 11 Jan 13"), // en_US@calendar=japanese 3: yMMMd
UnicodeString("1-13"), // en_US@calendar=japanese 4: Md
UnicodeString("Jan 13"), // en_US@calendar=japanese 5: MMMd
UnicodeString("H 11 Q1"), // en_US@calendar=japanese 6: yQQQ
UnicodeString("11:58 PM"), // en_US@calendar=japanese 7: hhmm
UnicodeString("23:58"), // en_US@calendar=japanese 8: HHmm
UnicodeString("23:58"), // en_US@calendar=japanese 9: jjmm
UnicodeString("58:59"), // en_US@calendar=japanese 10: mmss
UnicodeString("H 11 January"), // en_US@calendar=japanese 11: yyyyMMMM
UnicodeString("1999-1", -1, US_INV), // zh_Hans_CN: yM
CharsToUnicodeString("1999\\u5E741\\u6708"), // zh_Hans_CN: yMMM -> yyyy\u5E74MMM (fixed expected result per ticket:6626:)
CharsToUnicodeString("1999\\u5E741\\u670813\\u65E5"),
CharsToUnicodeString("1999\\u5E741\\u670813\\u65E5"), // zh_Hans_CN: yMMMd -> yyyy\u5E74MMMd\u65E5 (fixed expected result per ticket:6626:)
UnicodeString("1-13"),
CharsToUnicodeString("1\\u670813\\u65E5"), // zh_Hans_CN: MMMd -> MMMd\u65E5 (fixed expected result per ticket:6626:)
CharsToUnicodeString("1999\\u5E741\\u5B63"),
CharsToUnicodeString("\\u4E0B\\u534811:58"),
UnicodeString("23:58"),
CharsToUnicodeString("\\u4E0B\\u534811:58"), // zh_Hans_CN 9: jjmm
UnicodeString("58:59"),
CharsToUnicodeString("1999\\u5E741\\u6708"), // zh_Hans_CN 11: yyyyMMMM -> yyyy\u5E74MMM
UnicodeString("1999-1"), // de_DE
UnicodeString("Jan 1999"),
UnicodeString("13.1.1999"),
UnicodeString("13. Jan 1999"),
UnicodeString("13.1."),
UnicodeString("13. Jan"),
UnicodeString("Q1 1999"),
UnicodeString("11:58 nachm."),
UnicodeString("23:58"),
UnicodeString("23:58"), // de 9: jjmm
UnicodeString("58:59"),
UnicodeString("Januar 1999"), // de 11: yyyyMMMM
UnicodeString("1.1999"), // fi: yM (fixed expected result per ticket:6626:)
UnicodeString("tammikuuta 1999"),
UnicodeString("13.1.1999"),
UnicodeString("13. tammikuuta 1999"),
UnicodeString("13.1."),
UnicodeString("13. tammikuuta"),
UnicodeString("1. nelj. 1999"),
UnicodeString("11.58 ip."), // fi 7: hhmm
UnicodeString("23.58"),
UnicodeString("23.58"), // fi 9: jjmm
UnicodeString("58.59"),
UnicodeString("tammikuuta 1999"), // fi 11: yyyyMMMM
UnicodeString("1999/1"), // ja 0: yM -> y/M
CharsToUnicodeString("1999\\u5E741\\u6708"), // ja 1: yMMM -> y\u5E74M\u6708
UnicodeString("1999/1/13"), // ja 2: yMd -> y/M/d
CharsToUnicodeString("1999\\u5E741\\u670813\\u65E5"), // ja 3: yMMMd -> y\u5E74M\u6708d\u65E5
UnicodeString("1/13"), // ja 4: Md -> M/d
CharsToUnicodeString("1\\u670813\\u65E5"), // ja 5: MMMd -> M\u6708d\u65E5
UnicodeString("1999Q1"), // ja 6: yQQQ -> yQQQ
CharsToUnicodeString("\\u5348\\u5F8C11:58"), // ja 7: hhmm
UnicodeString("23:58"), // ja 8: HHmm -> HH:mm
UnicodeString("23:58"), // ja 9: jjmm
UnicodeString("58:59"), // ja 10: mmss -> mm:ss
CharsToUnicodeString("1999\\u5E741\\u6708"), // ja 11: yyyyMMMM -> y\u5E74M\u6708
CharsToUnicodeString("\\u5E73\\u621011/1"), // ja@japanese 0: yM -> Gy/m
CharsToUnicodeString("\\u5E73\\u621011\\u5E741\\u6708"), // ja@japanese 1: yMMM -> Gy\u5E74M\u6708
CharsToUnicodeString("\\u5E73\\u621011/1/13"), // ja@japanese 2: yMd -> Gy/m/d
CharsToUnicodeString("\\u5E73\\u621011\\u5E741\\u670813\\u65E5"), // ja@japanese 3: yMMMd -> Gy\u5E74M\u6708d\u65E5
UnicodeString("1/13"), // ja@japanese 4: Md -> M/d
CharsToUnicodeString("1\\u670813\\u65E5"), // ja@japanese 5: MMMd -> M\u6708d\u65E5
CharsToUnicodeString("\\u5E73\\u621011/Q1"), // ja@japanese 6: yQQQ -> Gy/QQQ
CharsToUnicodeString("\\u5348\\u5F8C11:58"), // ja@japanese 7: hhmm ->
UnicodeString("23:58"), // ja@japanese 8: HHmm -> HH:mm (as for ja)
UnicodeString("23:58"), // ja@japanese 9: jjmm
UnicodeString("58:59"), // ja@japanese 10: mmss -> mm:ss (as for ja)
CharsToUnicodeString("\\u5E73\\u621011\\u5E741\\u6708"), // ja@japanese 11: yyyyMMMM -> Gyyyy\u5E74M\u6708
CharsToUnicodeString("\\u6C11\\u570B88/1"), // zh_TW@roc 0: yM -> Gy/M
CharsToUnicodeString("\\u6C11\\u570B88\\u5E741\\u6708"), // zh_TW@roc 1: yMMM -> Gy\u5E74M\u6708
CharsToUnicodeString("\\u6C11\\u570B88/1/13"), // zh_TW@roc 2: yMd -> Gy/M/d
CharsToUnicodeString("\\u6C11\\u570B88\\u5E741\\u670813\\u65E5"), // zh_TW@roc 3: yMMMd -> Gy\u5E74M\u6708d\u65E5
UnicodeString("1/13"), // zh_TW@roc 4: Md -> M/d
CharsToUnicodeString("1\\u670813\\u65E5"), // zh_TW@roc 5: MMMd ->M\u6708d\u65E5
CharsToUnicodeString("\\u6C11\\u570B88 1\\u5B63"), // zh_TW@roc 6: yQQQ -> Gy QQQ
CharsToUnicodeString("\\u4E0B\\u534811:58"), // zh_TW@roc 7: hhmm ->
UnicodeString("23:58"), // zh_TW@roc 8: HHmm ->
CharsToUnicodeString("\\u4E0B\\u534811:58"), // zh_TW@roc 9: jjmm
UnicodeString("58:59"), // zh_TW@roc 10: mmss ->
CharsToUnicodeString("\\u6C11\\u570B88\\u5E741\\u6708"), // zh_TW@roc 11: yyyyMMMM -> Gy\u5E74M\u670
UnicodeString(),
};
UnicodeString patternTests2[] = {
UnicodeString("yyyyMMMdd"),
UnicodeString("yyyyqqqq"),
UnicodeString("yMMMdd"),
UnicodeString("EyyyyMMMdd"),
UnicodeString("yyyyMMdd"),
UnicodeString("yyyyMMM"),
UnicodeString("yyyyMM"),
UnicodeString("yyMM"),
UnicodeString("yMMMMMd"),
UnicodeString("EEEEEMMMMMd"),
UnicodeString("MMMd"),
UnicodeString("MMMdhmm"),
UnicodeString("EMMMdhmms"),
UnicodeString("MMdhmm"),
UnicodeString("EEEEMMMdhmms"),
UnicodeString("yyyyMMMddhhmmss"),
UnicodeString("EyyyyMMMddhhmmss"),
UnicodeString("hmm"),
UnicodeString("hhmm"),
UnicodeString("hhmmVVVV"),
UnicodeString(""),
};
UnicodeString patternResults2[] = {
UnicodeString("Oct 14, 1999"),
UnicodeString("4th quarter 1999"),
UnicodeString("Oct 14, 1999"),
UnicodeString("Thu, Oct 14, 1999"),
UnicodeString("10/14/1999"),
UnicodeString("Oct 1999"),
UnicodeString("10/1999"),
UnicodeString("10/99"),
UnicodeString("O 14, 1999"),
UnicodeString("T, O 14"),
UnicodeString("Oct 14"),
UnicodeString("Oct 14 6:58 AM"),
UnicodeString("Thu, Oct 14 6:58:59 AM"),
UnicodeString("10/14 6:58 AM"),
UnicodeString("Thursday, Oct 14 6:58:59 AM"),
UnicodeString("Oct 14, 1999 06:58:59 AM"),
UnicodeString("Thu, Oct 14, 1999 06:58:59 AM"),
UnicodeString("6:58 AM"),
UnicodeString("06:58 AM"),
UnicodeString("06:58 AM GMT+00:00"),
UnicodeString(""),
};
// results for getSkeletons() and getPatternForSkeleton()
const UnicodeString testSkeletonsResults[] = {
UnicodeString("HH:mm"),
UnicodeString("MMMMd"),
UnicodeString("MMMMMd"),
};
const UnicodeString testBaseSkeletonsResults[] = {
UnicodeString("Hm"),
UnicodeString("MMMd"),
UnicodeString("MMMd"),
};
UnicodeString newDecimal(" "); // space
UnicodeString newAppendItemName("hrs.");
UnicodeString newAppendItemFormat("{1} {0}");
UnicodeString newDateTimeFormat("{1} {0}");
UErrorCode status = U_ZERO_ERROR;
UnicodeString conflictingPattern;
UDateTimePatternConflict conflictingStatus;
// ======= Test CreateInstance with default locale
logln("Testing DateTimePatternGenerator createInstance from default locale");
DateTimePatternGenerator *instFromDefaultLocale=DateTimePatternGenerator::createInstance(status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create DateTimePatternGenerator (default) - exitting");
return;
}
else {
delete instFromDefaultLocale;
}
// ======= Test CreateInstance with given locale
logln("Testing DateTimePatternGenerator createInstance from French locale");
status = U_ZERO_ERROR;
DateTimePatternGenerator *instFromLocale=DateTimePatternGenerator::createInstance(Locale::getFrench(), status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create DateTimePatternGenerator (Locale::getFrench()) - exitting");
return;
}
// ======= Test clone DateTimePatternGenerator
logln("Testing DateTimePatternGenerator::clone()");
status = U_ZERO_ERROR;
UnicodeString decimalSymbol = instFromLocale->getDecimal();
UnicodeString newDecimalSymbol = UnicodeString("*");
decimalSymbol = instFromLocale->getDecimal();
instFromLocale->setDecimal(newDecimalSymbol);
DateTimePatternGenerator *cloneDTPatternGen=instFromLocale->clone();
decimalSymbol = cloneDTPatternGen->getDecimal();
if (decimalSymbol != newDecimalSymbol) {
errln("ERROR: inconsistency is found in cloned object.");
}
if ( !(*cloneDTPatternGen == *instFromLocale) ) {
errln("ERROR: inconsistency is found in cloned object.");
}
if ( *cloneDTPatternGen != *instFromLocale ) {
errln("ERROR: inconsistency is found in cloned object.");
}
delete instFromLocale;
delete cloneDTPatternGen;
// ======= Test simple use cases
logln("Testing simple use cases");
status = U_ZERO_ERROR;
Locale deLocale=Locale::getGermany();
UDate sampleDate=LocaleTest::date(99, 9, 13, 23, 58, 59);
DateTimePatternGenerator *gen = DateTimePatternGenerator::createInstance(deLocale, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create DateTimePatternGenerator (Locale::getGermany()) - exitting");
return;
}
UnicodeString findPattern = gen->getBestPattern(UnicodeString("MMMddHmm"), status);
SimpleDateFormat *format = new SimpleDateFormat(findPattern, deLocale, status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create SimpleDateFormat (Locale::getGermany())");
delete gen;
return;
}
TimeZone *zone = TimeZone::createTimeZone(UnicodeString("ECT"));
if (zone==NULL) {
dataerrln("ERROR: Could not create TimeZone ECT");
delete gen;
delete format;
return;
}
format->setTimeZone(*zone);
UnicodeString dateReturned, expectedResult;
dateReturned.remove();
dateReturned = format->format(sampleDate, dateReturned, status);
expectedResult=UnicodeString("14. Okt 8:58", -1, US_INV);
if ( dateReturned != expectedResult ) {
errln("ERROR: Simple test in getBestPattern with Locale::getGermany()).");
}
// add new pattern
status = U_ZERO_ERROR;
conflictingStatus = gen->addPattern(UnicodeString("d'. von' MMMM", -1, US_INV), true, conflictingPattern, status);
if (U_FAILURE(status)) {
errln("ERROR: Could not addPattern - d\'. von\' MMMM");
}
status = U_ZERO_ERROR;
UnicodeString testPattern=gen->getBestPattern(UnicodeString("MMMMdd"), status);
testPattern=gen->getBestPattern(UnicodeString("MMMddHmm"), status);
format->applyPattern(gen->getBestPattern(UnicodeString("MMMMddHmm"), status));
dateReturned.remove();
dateReturned = format->format(sampleDate, dateReturned, status);
expectedResult=UnicodeString("14. von Oktober 8:58", -1, US_INV);
if ( dateReturned != expectedResult ) {
errln("ERROR: Simple test addPattern failed!: d\'. von\' MMMM ");
}
delete format;
// get a pattern and modify it
format = (SimpleDateFormat *)DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull,
deLocale);
format->setTimeZone(*zone);
UnicodeString pattern;
pattern = format->toPattern(pattern);
dateReturned.remove();
dateReturned = format->format(sampleDate, dateReturned, status);
expectedResult=CharsToUnicodeString("Donnerstag, 14. Oktober 1999 08:58:59 Mitteleurop\\u00E4ische Sommerzeit");
if ( dateReturned != expectedResult ) {
errln("ERROR: Simple test uses full date format.");
errln(UnicodeString(" Got: ") + dateReturned + UnicodeString(" Expected: ") + expectedResult);
}
// modify it to change the zone.
UnicodeString newPattern = gen->replaceFieldTypes(pattern, UnicodeString("vvvv"), status);
format->applyPattern(newPattern);
dateReturned.remove();
dateReturned = format->format(sampleDate, dateReturned, status);
expectedResult=UnicodeString("Donnerstag, 14. Oktober 1999 08:58:59 Frankreich");
if ( dateReturned != expectedResult ) {
errln("ERROR: Simple test modify the timezone!");
errln(UnicodeString(" Got: ")+ dateReturned + UnicodeString(" Expected: ") + expectedResult);
}
// setDeciaml(), getDeciaml()
gen->setDecimal(newDecimal);
if (newDecimal != gen->getDecimal()) {
errln("ERROR: unexpected result from setDecimal() and getDecimal()!.\n");
}
// setAppenItemName() , getAppendItemName()
gen->setAppendItemName(UDATPG_HOUR_FIELD, newAppendItemName);
if (newAppendItemName != gen->getAppendItemName(UDATPG_HOUR_FIELD)) {
errln("ERROR: unexpected result from setAppendItemName() and getAppendItemName()!.\n");
}
// setAppenItemFormat() , getAppendItemFormat()
gen->setAppendItemFormat(UDATPG_HOUR_FIELD, newAppendItemFormat);
if (newAppendItemFormat != gen->getAppendItemFormat(UDATPG_HOUR_FIELD)) {
errln("ERROR: unexpected result from setAppendItemFormat() and getAppendItemFormat()!.\n");
}
// setDateTimeFormat() , getDateTimeFormat()
gen->setDateTimeFormat(newDateTimeFormat);
if (newDateTimeFormat != gen->getDateTimeFormat()) {
errln("ERROR: unexpected result from setDateTimeFormat() and getDateTimeFormat()!.\n");
}
// ======== Test getSkeleton and getBaseSkeleton
status = U_ZERO_ERROR;
pattern = UnicodeString("dd-MMM");
UnicodeString expectedSkeleton = UnicodeString("MMMdd");
UnicodeString expectedBaseSkeleton = UnicodeString("MMMd");
UnicodeString retSkeleton = gen->getSkeleton(pattern, status);
if(U_FAILURE(status) || retSkeleton != expectedSkeleton ) {
errln("ERROR: Unexpected result from getSkeleton().\n");
errln(UnicodeString(" Got: ") + retSkeleton + UnicodeString(" Expected: ") + expectedSkeleton );
}
retSkeleton = gen->getBaseSkeleton(pattern, status);
if(U_FAILURE(status) || retSkeleton != expectedBaseSkeleton) {
errln("ERROR: Unexpected result from getBaseSkeleton().\n");
errln(UnicodeString(" Got: ") + retSkeleton + UnicodeString(" Expected:")+ expectedBaseSkeleton);
}
pattern = UnicodeString("dd/MMMM/yy");
expectedSkeleton = UnicodeString("yyMMMMdd");
expectedBaseSkeleton = UnicodeString("yMMMd");
retSkeleton = gen->getSkeleton(pattern, status);
if(U_FAILURE(status) || retSkeleton != expectedSkeleton ) {
errln("ERROR: Unexpected result from getSkeleton().\n");
errln(UnicodeString(" Got: ") + retSkeleton + UnicodeString(" Expected: ") + expectedSkeleton );
}
retSkeleton = gen->getBaseSkeleton(pattern, status);
if(U_FAILURE(status) || retSkeleton != expectedBaseSkeleton) {
errln("ERROR: Unexpected result from getBaseSkeleton().\n");
errln(UnicodeString(" Got: ") + retSkeleton + UnicodeString(" Expected:")+ expectedBaseSkeleton);
}
delete format;
delete zone;
delete gen;
{
// Trac# 6104
status = U_ZERO_ERROR;
pattern = UnicodeString("YYYYMMM");
UnicodeString expR = CharsToUnicodeString("1999\\u5E741\\u6708"); // fixed expected result per ticket:6626:
Locale loc("ja");
UDate testDate1= LocaleTest::date(99, 0, 13, 23, 58, 59);
DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(loc, status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create DateTimePatternGenerator");
return;
}
UnicodeString bPattern = patGen->getBestPattern(pattern, status);
UnicodeString rDate;
SimpleDateFormat sdf(bPattern, loc, status);
rDate.remove();
rDate = sdf.format(testDate1, rDate);
logln(UnicodeString(" ja locale with skeleton: YYYYMMM Best Pattern:") + bPattern);
logln(UnicodeString(" Formatted date:") + rDate);
if ( expR!= rDate ) {
errln(UnicodeString("\nERROR: Test Japanese month hack Got: ") + rDate +
UnicodeString(" Expected: ") + expR );
}
delete patGen;
}
{ // Trac# 6104
Locale loc("zh");
UnicodeString expR = CharsToUnicodeString("1999\\u5E741\\u6708"); // fixed expected result per ticket:6626:
UDate testDate1= LocaleTest::date(99, 0, 13, 23, 58, 59);
DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(loc, status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create DateTimePatternGenerator");
return;
}
UnicodeString bPattern = patGen->getBestPattern(pattern, status);
UnicodeString rDate;
SimpleDateFormat sdf(bPattern, loc, status);
rDate.remove();
rDate = sdf.format(testDate1, rDate);
logln(UnicodeString(" zh locale with skeleton: YYYYMMM Best Pattern:") + bPattern);
logln(UnicodeString(" Formatted date:") + rDate);
if ( expR!= rDate ) {
errln(UnicodeString("\nERROR: Test Chinese month hack Got: ") + rDate +
UnicodeString(" Expected: ") + expR );
}
delete patGen;
}
{
// Trac# 6172 duplicate time pattern
status = U_ZERO_ERROR;
pattern = UnicodeString("hmv");
UnicodeString expR = UnicodeString("h:mm a v"); // avail formats has hm -> "h:mm a" (fixed expected result per ticket:6626:)
Locale loc("en");
DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(loc, status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create DateTimePatternGenerator");
return;
}
UnicodeString bPattern = patGen->getBestPattern(pattern, status);
logln(UnicodeString(" en locale with skeleton: hmv Best Pattern:") + bPattern);
if ( expR!= bPattern ) {
errln(UnicodeString("\nERROR: Test EN time format Got: ") + bPattern +
UnicodeString(" Expected: ") + expR );
}
delete patGen;
}
// ======= Test various skeletons.
logln("Testing DateTimePatternGenerator with various skeleton");
status = U_ZERO_ERROR;
int32_t localeIndex=0;
int32_t resultIndex=0;
UnicodeString resultDate;
UDate testDate= LocaleTest::date(99, 0, 13, 23, 58, 59);
while (localeIndex < MAX_LOCALE )
{
int32_t dataIndex=0;
UnicodeString bestPattern;
Locale loc(testLocale[localeIndex][0], testLocale[localeIndex][1], testLocale[localeIndex][2], testLocale[localeIndex][3]);
logln("\n\n Locale: %s_%s_%s@%s", testLocale[localeIndex][0], testLocale[localeIndex][1], testLocale[localeIndex][2], testLocale[localeIndex][3]);
DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(loc, status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create DateTimePatternGenerator with locale index:%d . - exitting\n", localeIndex);
return;
}
while (patternData[dataIndex].length() > 0) {
log(patternData[dataIndex]);
bestPattern = patGen->getBestPattern(patternData[dataIndex++], status);
logln(UnicodeString(" -> ") + bestPattern);
SimpleDateFormat sdf(bestPattern, loc, status);
resultDate.remove();
resultDate = sdf.format(testDate, resultDate);
if ( resultDate != patternResults[resultIndex] ) {
errln(UnicodeString("\nERROR: Test various skeletons[") + (dataIndex-1) + UnicodeString("], localeIndex ") + localeIndex +
UnicodeString(". Got: ") + resultDate + UnicodeString(" Expected: ") + patternResults[resultIndex] );
}
resultIndex++;
}
delete patGen;
localeIndex++;
}
// ======= More tests ticket#6110
logln("Testing DateTimePatternGenerator with various skeleton");
status = U_ZERO_ERROR;
localeIndex=0;
resultIndex=0;
testDate= LocaleTest::date(99, 9, 13, 23, 58, 59);
{
int32_t dataIndex=0;
UnicodeString bestPattern;
logln("\n\n Test various skeletons for English locale...");
DateTimePatternGenerator *patGen=DateTimePatternGenerator::createInstance(Locale::getEnglish(), status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create DateTimePatternGenerator with locale English . - exitting\n");
return;
}
TimeZone *enZone = TimeZone::createTimeZone(UnicodeString("ECT/GMT"));
if (enZone==NULL) {
dataerrln("ERROR: Could not create TimeZone ECT");
delete patGen;
return;
}
SimpleDateFormat *enFormat = (SimpleDateFormat *)DateFormat::createDateTimeInstance(DateFormat::kFull,
DateFormat::kFull, Locale::getEnglish());
enFormat->setTimeZone(*enZone);
while (patternTests2[dataIndex].length() > 0) {
logln(patternTests2[dataIndex]);
bestPattern = patGen->getBestPattern(patternTests2[dataIndex], status);
logln(UnicodeString(" -> ") + bestPattern);
enFormat->applyPattern(bestPattern);
resultDate.remove();
resultDate = enFormat->format(testDate, resultDate);
if ( resultDate != patternResults2[resultIndex] ) {
errln(UnicodeString("\nERROR: Test various skeletons[") + dataIndex
+ UnicodeString("]. Got: ") + resultDate + UnicodeString(" Expected: ") +
patternResults2[resultIndex] );
}
dataIndex++;
resultIndex++;
}
delete patGen;
delete enZone;
delete enFormat;
}
// ======= Test random skeleton
DateTimePatternGenerator *randDTGen= DateTimePatternGenerator::createInstance(status);
if (U_FAILURE(status)) {
dataerrln("ERROR: Could not create DateTimePatternGenerator (Locale::getFrench()) - exitting");
return;
}
UChar newChar;
int32_t i;
for (i=0; i<10; ++i) {
UnicodeString randomSkeleton;
int32_t len = rand() % 20;
for (int32_t j=0; j<len; ++j ) {
while ((newChar = (UChar)(rand()%0x7f))>=(UChar)0x20) {
randomSkeleton += newChar;
}
}
UnicodeString bestPattern = randDTGen->getBestPattern(randomSkeleton, status);
}
delete randDTGen;
// UnicodeString randomString=Unicode
// ======= Test getStaticClassID()
logln("Testing getStaticClassID()");
status = U_ZERO_ERROR;
DateTimePatternGenerator *test= DateTimePatternGenerator::createInstance(status);
if(test->getDynamicClassID() != DateTimePatternGenerator::getStaticClassID()) {
errln("ERROR: getDynamicClassID() didn't return the expected value");
}
delete test;
// ====== Test createEmptyInstance()
logln("Testing createEmptyInstance()");
status = U_ZERO_ERROR;
test = DateTimePatternGenerator::createEmptyInstance(status);
if(U_FAILURE(status)) {
errln("ERROR: Fail to create an empty instance ! - exitting.\n");
delete test;
return;
}
conflictingStatus = test->addPattern(UnicodeString("MMMMd"), true, conflictingPattern, status);
status = U_ZERO_ERROR;
testPattern=test->getBestPattern(UnicodeString("MMMMdd"), status);
conflictingStatus = test->addPattern(UnicodeString("HH:mm"), true, conflictingPattern, status);
conflictingStatus = test->addPattern(UnicodeString("MMMMMd"), true, conflictingPattern, status); //duplicate pattern
StringEnumeration *output=NULL;
output = test->getRedundants(status);
expectedResult=UnicodeString("MMMMd");
if (output != NULL) {
output->reset(status);
const UnicodeString *dupPattern=output->snext(status);
if ( (dupPattern==NULL) || (*dupPattern != expectedResult) ) {
errln("ERROR: Fail in getRedundants !\n");
}
}
// ======== Test getSkeletons and getBaseSkeletons
StringEnumeration* ptrSkeletonEnum = test->getSkeletons(status);
if(U_FAILURE(status)) {
errln("ERROR: Fail to get skeletons !\n");
}
UnicodeString returnPattern, *ptrSkeleton;
ptrSkeletonEnum->reset(status);
int32_t count=ptrSkeletonEnum->count(status);
for (i=0; i<count; ++i) {
ptrSkeleton = (UnicodeString *)ptrSkeletonEnum->snext(status);
returnPattern = test->getPatternForSkeleton(*ptrSkeleton);
if ( returnPattern != testSkeletonsResults[i] ) {
errln(UnicodeString("ERROR: Unexpected result from getSkeletons and getPatternForSkeleton\nGot: ") + returnPattern
+ UnicodeString("\nExpected: ") + testSkeletonsResults[i]
+ UnicodeString("\n"));
}
}
StringEnumeration* ptrBaseSkeletonEnum = test->getBaseSkeletons(status);
if(U_FAILURE(status)) {
errln("ERROR: Fail to get base skeletons !\n");
}
count=ptrBaseSkeletonEnum->count(status);
for (i=0; i<count; ++i) {
ptrSkeleton = (UnicodeString *)ptrBaseSkeletonEnum->snext(status);
if ( *ptrSkeleton != testBaseSkeletonsResults[i] ) {
errln("ERROR: Unexpected result from getBaseSkeletons() !\n");
}
}
// ========= DateTimePatternGenerator sample code in Userguide
// set up the generator
Locale locale = Locale::getFrench();
status = U_ZERO_ERROR;
DateTimePatternGenerator *generator = DateTimePatternGenerator::createInstance( locale, status);
// get a pattern for an abbreviated month and day
pattern = generator->getBestPattern(UnicodeString("MMMd"), status);
SimpleDateFormat formatter(pattern, locale, status);
zone = TimeZone::createTimeZone(UnicodeString("GMT"));
formatter.setTimeZone(*zone);
// use it to format (or parse)
UnicodeString formatted;
formatted = formatter.format(Calendar::getNow(), formatted, status);
// for French, the result is "13 sept."
formatted.remove();
// cannot use the result from getNow() because the value change evreyday.
testDate= LocaleTest::date(99, 0, 13, 23, 58, 59);
formatted = formatter.format(testDate, formatted, status);
expectedResult=UnicodeString("14 janv.");
if ( formatted != expectedResult ) {
errln("ERROR: Userguide sample code result!");
errln(UnicodeString(" Got: ")+ formatted + UnicodeString(" Expected: ") + expectedResult);
}
delete zone;
delete output;
delete ptrSkeletonEnum;
delete ptrBaseSkeletonEnum;
delete test;
delete generator;
}
static jstring formatDate(JNIEnv* env, const SimpleDateFormat& fmt, const UDate& when) {
UnicodeString str;
fmt.format(when, str);
return env->NewString(str.getBuffer(), str.length());
}
UBool
TimeZoneRegressionTest::checkCalendar314(GregorianCalendar *testCal, TimeZone *testTZ)
{
UErrorCode status = U_ZERO_ERROR;
// GregorianCalendar testCal = (GregorianCalendar)aCal.clone();
int32_t tzOffset, tzRawOffset;
float tzOffsetFloat,tzRawOffsetFloat;
// Here is where the user made an error. They were passing in the value of
// the MILLSECOND field; you need to pass in the millis in the day in STANDARD
// time.
UDate millis = testCal->get(UCAL_MILLISECOND, status) +
1000.0 * (testCal->get(UCAL_SECOND, status) +
60.0 * (testCal->get(UCAL_MINUTE, status) +
60.0 * (testCal->get(UCAL_HOUR_OF_DAY, status)))) -
testCal->get(UCAL_DST_OFFSET, status);
/* Fix up millis to be in range. ASSUME THAT WE ARE NOT AT THE
* BEGINNING OR END OF A MONTH. We must add this code because
* getOffset() has been changed to be more strict about the parameters
* it receives -- it turns out that this test was passing in illegal
* values. */
int32_t date = testCal->get(UCAL_DATE, status);
int32_t dow = testCal->get(UCAL_DAY_OF_WEEK, status);
while(millis < 0) {
millis += U_MILLIS_PER_DAY;
--date;
dow = UCAL_SUNDAY + ((dow - UCAL_SUNDAY + 6) % 7);
}
while (millis >= U_MILLIS_PER_DAY) {
millis -= U_MILLIS_PER_DAY;
++date;
dow = UCAL_SUNDAY + ((dow - UCAL_SUNDAY + 1) % 7);
}
tzOffset = testTZ->getOffset((uint8_t)testCal->get(UCAL_ERA, status),
testCal->get(UCAL_YEAR, status),
testCal->get(UCAL_MONTH, status),
date,
(uint8_t)dow,
(int32_t)millis,
status);
tzRawOffset = testTZ->getRawOffset();
tzOffsetFloat = (float)tzOffset/(float)3600000;
tzRawOffsetFloat = (float)tzRawOffset/(float)3600000;
UDate testDate = testCal->getTime(status);
UBool inDaylightTime = testTZ->inDaylightTime(testDate, status);
SimpleDateFormat *sdf = new SimpleDateFormat((UnicodeString)"MM/dd/yyyy HH:mm", status);
sdf->setCalendar(*testCal);
UnicodeString inDaylightTimeString;
UBool passed;
if(inDaylightTime)
{
inDaylightTimeString = " DST ";
passed = (tzOffset == (tzRawOffset + 3600000));
}
else
{
inDaylightTimeString = " ";
passed = (tzOffset == tzRawOffset);
}
UnicodeString output;
FieldPosition pos(0);
output = testTZ->getID(output) + " " + sdf->format(testDate, output, pos) +
" Offset(" + tzOffsetFloat + ")" +
" RawOffset(" + tzRawOffsetFloat + ")" +
" " + millis/(float)3600000 + " " +
inDaylightTimeString;
if (passed)
output += " ";
else
output += "ERROR";
if (passed)
logln(output);
else
errln(output);
delete sdf;
return passed;
}
/**
* @bug 4162593
* TimeZone broken at midnight. The TimeZone code fails to handle
* transitions at midnight correctly.
*/
void
TimeZoneRegressionTest::Test4162593()
{
UErrorCode status = U_ZERO_ERROR;
SimpleDateFormat *fmt = new SimpleDateFormat("z", Locale::getUS(), status);
if(U_FAILURE(status)) {
dataerrln("Error creating calendar %s", u_errorName(status));
delete fmt;
return;
}
const int32_t ONE_HOUR = 60*60*1000;
SimpleTimeZone *asuncion = new SimpleTimeZone(-4*ONE_HOUR, "America/Asuncion" /*PY%sT*/,
UCAL_OCTOBER, 1, 0 /*DOM*/, 0*ONE_HOUR,
UCAL_MARCH, 1, 0 /*DOM*/, 0*ONE_HOUR, 1*ONE_HOUR, status);
/* Zone
* Starting time
* Transition expected between start+1H and start+2H
*/
TimeZone *DATA_TZ [] = {
0, 0, 0 };
int32_t DATA_INT [] [5] = {
// These years must be AFTER the Gregorian cutover
{1998, UCAL_SEPTEMBER, 30, 22, 0},
{2000, UCAL_FEBRUARY, 28, 22, 0},
{2000, UCAL_FEBRUARY, 29, 22, 0},
};
UBool DATA_BOOL [] = {
TRUE,
FALSE,
TRUE,
};
UnicodeString zone [4];// = new String[4];
DATA_TZ[0] =
new SimpleTimeZone(2*ONE_HOUR, "Asia/Damascus" /*EE%sT*/,
UCAL_APRIL, 1, 0 /*DOM*/, 0*ONE_HOUR,
UCAL_OCTOBER, 1, 0 /*DOM*/, 0*ONE_HOUR, 1*ONE_HOUR, status);
DATA_TZ[1] = asuncion; DATA_TZ[2] = asuncion;
for(int32_t j = 0; j < 3; j++) {
TimeZone *tz = (TimeZone*)DATA_TZ[j];
TimeZone::setDefault(*tz);
fmt->setTimeZone(*tz);
// Must construct the Date object AFTER setting the default zone
int32_t *p = (int32_t*)DATA_INT[j];
UDate d = CalendarRegressionTest::makeDate(p[0], p[1], p[2], p[3], p[4]);
UBool transitionExpected = DATA_BOOL[j];
UnicodeString temp;
logln(tz->getID(temp) + ":");
for (int32_t i = 0; i < 4; ++i) {
FieldPosition pos(0);
zone[i].remove();
zone[i] = fmt->format(d+ i*ONE_HOUR, zone[i], pos);
logln(UnicodeString("") + i + ": " + d + " / " + zone[i]);
//d += (double) ONE_HOUR;
}
if(zone[0] == zone[1] &&
(zone[1] == zone[2]) != transitionExpected &&
zone[2] == zone[3]) {
logln(UnicodeString("Ok: transition ") + transitionExpected);
}
else {
errln("Fail: boundary transition incorrect");
}
}
delete fmt;
delete asuncion;
delete DATA_TZ[0];
}
/**
* @bug 4106807
*/
void DateFormatRegressionTest::Test4106807(void)
{
UDate dt;
DateFormat *df = DateFormat::createDateTimeInstance();
UErrorCode status = U_ZERO_ERROR;
SimpleDateFormat *sdfs [] = {
new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss"), status),
new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss'Z'"), status),
new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss''"), status),
new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss'a''a'"), status),
new SimpleDateFormat(UnicodeString("yyyyMMddHHmmss %"), status)
};
if(U_FAILURE(status)) {
dataerrln("Couldn't create SimpleDateFormat, error %s", u_errorName(status));
delete sdfs[0];
delete sdfs[1];
delete sdfs[2];
delete sdfs[3];
delete sdfs[4];
return;
}
failure(status, "new SimpleDateFormat");
UnicodeString strings [] = {
(UnicodeString) "19980211140000",
(UnicodeString) "19980211140000",
(UnicodeString) "19980211140000",
(UnicodeString) "19980211140000a",
(UnicodeString) "19980211140000 "
};
/*Object[] data = {
new SimpleDateFormat("yyyyMMddHHmmss"), "19980211140000",
new SimpleDateFormat("yyyyMMddHHmmss'Z'"), "19980211140000",
new SimpleDateFormat("yyyyMMddHHmmss''"), "19980211140000",
new SimpleDateFormat("yyyyMMddHHmmss'a''a'"), "19980211140000a",
new SimpleDateFormat("yyyyMMddHHmmss %"), "19980211140000 ",
};*/
GregorianCalendar *gc = new GregorianCalendar(status);
failure(status, "new GregorianCalendar");
TimeZone *timeZone = TimeZone::createDefault();
TimeZone *gmt = timeZone->clone();
gmt->setRawOffset(0);
for(int32_t i = 0; i < 5; i++) {
SimpleDateFormat *format = sdfs[i];
UnicodeString dateString = strings[i];
//try {
format->setTimeZone(*gmt);
dt = format->parse(dateString, status);
// {sfb} some of these parses will fail purposely
if(U_FAILURE(status))
break;
status = U_ZERO_ERROR;
UnicodeString fmtd;
FieldPosition pos(FieldPosition::DONT_CARE);
fmtd = df->format(dt, fmtd, pos);
logln(fmtd);
//logln(df->format(dt));
gc->setTime(dt, status);
failure(status, "gc->getTime");
logln(UnicodeString("") + gc->get(UCAL_ZONE_OFFSET, status));
failure(status, "gc->get");
UnicodeString s;
s = format->format(dt, s, pos);
logln(s);
/*}
catch (ParseException e) {
logln("No way Jose");
}*/
}
delete timeZone;
delete df;
for(int32_t j = 0; j < 5; j++)
delete sdfs [j];
delete gc;
delete gmt;
}
void IntlCalendarTest::TestJapaneseFormat() {
Calendar *cal;
UErrorCode status = U_ZERO_ERROR;
cal = Calendar::createInstance("ja_JP_TRADITIONAL", status);
CHECK(status, UnicodeString("Creating ja_JP_TRADITIONAL calendar"));
Calendar *cal2 = cal->clone();
delete cal;
cal = NULL;
// Test simple parse/format with adopt
UDate aDate = 999932400000.0;
SimpleDateFormat *fmt = new SimpleDateFormat(UnicodeString("MMMM d, yy G"), Locale("en_US@calendar=japanese"), status);
SimpleDateFormat *fmt2 = new SimpleDateFormat(UnicodeString("MMMM d, yyyy G"), Locale("en_US@calendar=gregorian"), status);
CHECK(status, "creating date format instance");
if(!fmt) {
errln("Coudln't create en_US instance");
} else {
UnicodeString str;
fmt2->format(aDate, str);
logln(UnicodeString() + "Test Date: " + str);
str.remove();
fmt->format(aDate, str);
logln(UnicodeString() + "as Japanese Calendar: " + str);
UnicodeString expected("September 8, 13 Heisei");
if(str != expected) {
errln("Expected " + expected + " but got " + str);
}
UDate otherDate = fmt->parse(expected, status);
if(otherDate != aDate) {
UnicodeString str3;
ParsePosition pp;
fmt->parse(expected, *cal2, pp);
fmt->format(otherDate, str3);
errln("Parse incorrect of " + expected + " - wanted " + aDate + " but got " + " = " + otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*cal2) );
} else {
logln("Parsed OK: " + expected);
}
delete fmt;
}
// Test parse with incomplete information
fmt = new SimpleDateFormat(UnicodeString("G y"), Locale("en_US@calendar=japanese"), status);
/* The test data below should points to 1868-09-08T00:00:00 in America/Los_Angeles.
* The time calculated by original test code uses -7:00 UTC offset, because it assumes
* DST is observed (because of a timezone bug, DST is observed for early 20th century
* day to infinite past time). The bug was fixed and DST is no longer used for time before
* 1900 for any zones. However, ICU timezone transition data is represented by 32-bit integer
* (sec) and cannot represent transitions before 1901 defined in Olson tzdata. For example,
* based on Olson definition, offset -7:52:58 should be used for Nov 18, 1883 or older dates.
* If ICU properly capture entire Olson zone definition, the start time of "Meiji 1" is
* -3197117222000. -Yoshito
*/
/* TODO: When ICU support the Olson LMT offset for America/Los_Angeles, we need to update
* the reference data.
*/
//aDate = -3197120400000.;
aDate = -3197116800000.;
CHECK(status, "creating date format instance");
if(!fmt) {
errln("Coudln't create en_US instance");
} else {
UnicodeString str;
fmt2->format(aDate, str);
logln(UnicodeString() + "Test Date: " + str);
str.remove();
fmt->format(aDate, str);
logln(UnicodeString() + "as Japanese Calendar: " + str);
UnicodeString expected("Meiji 1");
if(str != expected) {
errln("Expected " + expected + " but got " + str);
}
UDate otherDate = fmt->parse(expected, status);
if(otherDate != aDate) {
UnicodeString str3;
ParsePosition pp;
fmt->parse(expected, *cal2, pp);
fmt->format(otherDate, str3);
errln("Parse incorrect of " + expected + " - wanted " + aDate + " but got " + " = " +
otherDate + ", " + str3 + " = " + CalendarTest::calToStr(*cal2) );
} else {
logln("Parsed OK: " + expected);
}
delete fmt;
}
delete cal2;
delete fmt2;
CHECK(status, "Error occured");
// Now, try in Japanese
{
UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u67088\\u65e5\\u571f\\u66dc\\u65e5");
UDate expectDate = 999932400000.0; // Testing a recent date
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{
UnicodeString expect = CharsToUnicodeString("\\u5e73\\u621013\\u5e749\\u67088\\u65e5\\u571f\\u66dc\\u65e5");
UDate expectDate = 999932400000.0; // Testing a recent date
Locale loc("ja_JP_TRADITIONAL"); // legacy
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{
UnicodeString expect = CharsToUnicodeString("\\u5b89\\u6c385\\u5e747\\u67084\\u65e5\\u6728\\u66dc\\u65e5");
//UDate expectDate = -6106035600000.0;
UDate expectDate = -6106032000000.0; // 1776-07-04T00:00:00Z-0800
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{ // Jitterbug 1869 - this is an ambiguous era. (Showa 64 = Jan 6 1989, but Showa could be 2 other eras) )
UnicodeString expect = CharsToUnicodeString("\\u662d\\u548c64\\u5e741\\u67086\\u65e5\\u91d1\\u66dc\\u65e5");
UDate expectDate = 600076800000.0;
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
{ // This Feb 29th falls on a leap year by gregorian year, but not by Japanese year.
UnicodeString expect = CharsToUnicodeString("\\u5EB7\\u6B632\\u5e742\\u670829\\u65e5\\u65e5\\u66dc\\u65e5");
// Add -1:00 to the following for historical TZ - aliu
//UDate expectDate = -16214403600000.0; // courtesy of date format round trip test
UDate expectDate = -16214400000000.0; // 1456-03-09T00:00:00Z-0800
Locale loc("ja_JP@calendar=japanese");
status = U_ZERO_ERROR;
simpleTest(loc, expect, expectDate, status);
}
}
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;
}
std::string GlobalizationNDK::getDateNames(const std::string& args)
{
ENamesType type = kNamesWide;
ENamesItem item = kNamesMonths;
if (!args.empty()) {
Json::Reader reader;
Json::Value root;
bool parse = reader.parse(args, root);
if (!parse) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getDateNames: invalid json data: %s",
args.c_str());
return errorInJson(PARSING_ERROR, "Parameters not valid json format!");
}
Json::Value options = root["options"];
std::string error;
if (!handleNamesOptions(options, type, item, error))
return errorInJson(PARSING_ERROR, error);
}
int count;
const char* pattern;
DateFormat::EStyle dstyle;
// Check ICU SimpleDateFormat document for patterns for months and days.
// http://www.icu-project.org/apiref/icu4c/classicu_1_1SimpleDateFormat.html
if (item == kNamesMonths) {
count = 12;
if (type == kNamesWide) {
dstyle = DateFormat::kLong;
pattern = "MMMM";
} else {
dstyle = DateFormat::kShort;
pattern = "MMM";
}
} else {
count = 7;
if (type == kNamesWide) {
dstyle = DateFormat::kLong;
pattern = "eeee";
} else {
dstyle = DateFormat::kShort;
pattern = "eee";
}
}
UErrorCode status = U_ZERO_ERROR;
const Locale& loc = Locale::getDefault();
DateFormat* df = DateFormat::createDateInstance(dstyle, loc);
if (!df) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getDateNames: unable to create DateFormat instance!");
return errorInJson(UNKNOWN_ERROR, "Unable to create DateFormat instance!");
}
std::auto_ptr<DateFormat> deleter(df);
if (df->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getDateNames: DateFormat instance not SimpleDateFormat!");
return errorInJson(UNKNOWN_ERROR, "DateFormat instance not SimpleDateFormat!");
}
SimpleDateFormat* sdf = (SimpleDateFormat*) df;
sdf->applyLocalizedPattern(UnicodeString(pattern, -1), status);
Calendar* cal = Calendar::createInstance(status);
if (!cal) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getDateNames: unable to create Calendar instance: %x.",
status);
return errorInJson(UNKNOWN_ERROR, "Unable to create Calendar instance!");
}
std::auto_ptr<Calendar> caldeleter(cal);
UCalendarDaysOfWeek ud = cal->getFirstDayOfWeek(status);
if (status != U_ZERO_ERROR && status != U_ERROR_WARNING_START) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getDateNames: failed to getFirstDayOfWeek: %d!",
status);
return errorInJson(PARSING_ERROR, "Failed to getFirstDayOfWeek!");
}
if (ud == UCAL_SUNDAY)
cal->set(2014, 0, 5);
else
cal->set(2014, 0, 6);
std::list<std::string> utf8Names;
for (int i = 0; i < count; ++i) {
UnicodeString ucs;
sdf->format(cal->getTime(status), ucs);
if (item == kNamesMonths)
cal->add(UCAL_MONTH, 1, status);
else
cal->add(UCAL_DAY_OF_MONTH, 1, status);
if (ucs.isEmpty())
continue;
std::string utf8;
ucs.toUTF8String(utf8);
utf8Names.push_back(utf8);
}
if (!utf8Names.size()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getDateNames: unable to get symbols: item: %d, type: %d.",
item, type);
return errorInJson(UNKNOWN_ERROR, "Unable to get symbols!");
}
return resultInJson(utf8Names);
}
