static void umsg_set_timezone(MessageFormatter_object *mfo,
intl_error& err)
{
MessageFormat *mf = (MessageFormat *)mfo->mf_data.umsgf;
TimeZone *used_tz = NULL;
const Format **formats;
int32_t count;
/* Unfortanely, this cannot change the time zone for arguments that
* appear inside complex formats because ::getFormats() returns NULL
* for all uncached formats, which is the case for complex formats
* unless they were set via one of the ::setFormat() methods */
if (mfo->mf_data.tz_set) {
return; /* already done */
}
formats = mf->getFormats(count);
if (formats == NULL) {
intl_errors_set(&err, U_MEMORY_ALLOCATION_ERROR,
"Out of memory retrieving subformats", 0);
}
for (int i = 0; U_SUCCESS(err.code) && i < count; i++) {
DateFormat* df = dynamic_cast<DateFormat*>(
const_cast<Format *>(formats[i]));
if (df == NULL) {
continue;
}
if (used_tz == NULL) {
zval nullzv, *zvptr = &nullzv;
ZVAL_NULL(zvptr);
used_tz = timezone_process_timezone_argument(zvptr, &err, "msgfmt_format");
if (used_tz == NULL) {
continue;
}
}
df->setTimeZone(*used_tz);
}
if (U_SUCCESS(err.code)) {
mfo->mf_data.tz_set = 1;
}
}
UnicodeString&
CalendarTimeZoneTest::dateToString(UDate d, UnicodeString& str,
const TimeZone& tz)
{
str.remove();
DateFormat* format = getDateFormat();
if (format == 0)
{
str += "DATE_FORMAT_FAILURE";
return str;
}
TimeZone* save = format->getTimeZone().clone();
format->setTimeZone(tz);
format->format(d, str);
format->adoptTimeZone(save);
releaseDateFormat(format);
return str;
}
void CalendarCaseTest::IslamicCivil()
{
static const TestCase tests[] = {
//
// Most of these test cases were taken from the back of
// "Calendrical Calculations", with some extras added to help
// debug a few of the problems that cropped up in development.
//
// The months in this table are 1-based rather than 0-based,
// because it's easier to edit that way.
// Islamic
// Julian Day Era Year Month Day WkDay Hour Min Sec
{ 1507231.5, 0, -1245, 12, 9, SUN, 0, 0, 0},
{ 1660037.5, 0, -813, 2, 23, WED, 0, 0, 0},
{ 1746893.5, 0, -568, 4, 1, WED, 0, 0, 0},
{ 1770641.5, 0, -501, 4, 6, SUN, 0, 0, 0},
{ 1892731.5, 0, -157, 10, 17, WED, 0, 0, 0},
{ 1931579.5, 0, -47, 6, 3, MON, 0, 0, 0},
{ 1974851.5, 0, 75, 7, 13, SAT, 0, 0, 0},
{ 2091164.5, 0, 403, 10, 5, SUN, 0, 0, 0},
{ 2121509.5, 0, 489, 5, 22, SUN, 0, 0, 0},
{ 2155779.5, 0, 586, 2, 7, FRI, 0, 0, 0},
{ 2174029.5, 0, 637, 8, 7, SAT, 0, 0, 0},
{ 2191584.5, 0, 687, 2, 20, FRI, 0, 0, 0},
{ 2195261.5, 0, 697, 7, 7, SUN, 0, 0, 0},
{ 2229274.5, 0, 793, 7, 1, SUN, 0, 0, 0},
{ 2245580.5, 0, 839, 7, 6, WED, 0, 0, 0},
{ 2266100.5, 0, 897, 6, 1, SAT, 0, 0, 0},
{ 2288542.5, 0, 960, 9, 30, SAT, 0, 0, 0},
{ 2290901.5, 0, 967, 5, 27, SAT, 0, 0, 0},
{ 2323140.5, 0, 1058, 5, 18, WED, 0, 0, 0},
{ 2334848.5, 0, 1091, 6, 2, SUN, 0, 0, 0},
{ 2348020.5, 0, 1128, 8, 4, FRI, 0, 0, 0},
{ 2366978.5, 0, 1182, 2, 3, SUN, 0, 0, 0},
{ 2385648.5, 0, 1234, 10, 10, MON, 0, 0, 0},
{ 2392825.5, 0, 1255, 1, 11, WED, 0, 0, 0},
{ 2416223.5, 0, 1321, 1, 21, SUN, 0, 0, 0},
{ 2425848.5, 0, 1348, 3, 19, SUN, 0, 0, 0},
{ 2430266.5, 0, 1360, 9, 8, MON, 0, 0, 0},
{ 2430833.5, 0, 1362, 4, 13, MON, 0, 0, 0},
{ 2431004.5, 0, 1362, 10, 7, THU, 0, 0, 0},
{ 2448698.5, 0, 1412, 9, 13, TUE, 0, 0, 0},
{ 2450138.5, 0, 1416, 10, 5, SUN, 0, 0, 0},
{ 2465737.5, 0, 1460, 10, 12, WED, 0, 0, 0},
{ 2486076.5, 0, 1518, 3, 5, SUN, 0, 0, 0},
{ -1,-1,-1,-1,-1,-1,-1,-1,-1 }
};
UErrorCode status = U_ZERO_ERROR;
Calendar *c = Calendar::createInstance("ar@calendar=islamic-civil", status);
if (failure(status, "Calendar::createInstance", TRUE)) return;
c->setLenient(TRUE);
doTestCases(tests, c);
static const UChar expectedUChars[] = {
0x0627, 0x0644, 0x062e, 0x0645, 0x064a, 0x0633, 0x060c, 0x0020, 0x0662, 0x0662, 0x0020,
0x0634, 0x0648, 0x0627, 0x0644, 0x060c, 0x0020, 0x0661, 0x0663, 0x0668, 0x0669, 0x0020, 0x0647, 0x0640, 0
};
UnicodeString result;
DateFormat *fmt = DateFormat::createDateInstance(DateFormat::kFull, Locale("ar_JO@calendar=islamic-civil"));
if (fmt == NULL) {
dataerrln("Error calling DateFormat::createDateInstance");
delete c;
return;
}
fmt->setTimeZone(*TimeZone::getGMT());
fmt->format((UDate)2486076.5, result);
if (result != expectedUChars) {
errln((UnicodeString)"FAIL: DateFormatting failed. Got " + result + " and expected " + UnicodeString(expectedUChars) + UnicodeString("\n"));
errln("Maybe the resource aliasing isn't working");
}
delete fmt;
delete c;
}
/**
* This test checks various generic API methods in DateFormat to achieve 100%
* API coverage.
*/
void IntlTestDateFormatAPI::testAPI(/* char* par */)
{
UErrorCode status = U_ZERO_ERROR;
// ======= Test constructors
logln("Testing DateFormat constructors");
DateFormat *def = DateFormat::createInstance();
DateFormat *fr = DateFormat::createTimeInstance(DateFormat::FULL, Locale::getFrench());
DateFormat *it = DateFormat::createDateInstance(DateFormat::MEDIUM, Locale::getItalian());
DateFormat *de = DateFormat::createDateTimeInstance(DateFormat::LONG, DateFormat::LONG, Locale::getGerman());
if (def == NULL || fr == NULL || it == NULL || de == NULL){
dataerrln("Error creating instnaces.");
}
// ======= Test equality
if (fr != NULL && def != NULL)
{
logln("Testing equality operator");
if( *fr == *it ) {
errln("ERROR: == failed");
}
}
// ======= Test various format() methods
if (fr != NULL && it != NULL && de != NULL)
{
logln("Testing various format() methods");
UDate d = 837039928046.0;
Formattable fD(d, Formattable::kIsDate);
UnicodeString res1, res2, res3;
FieldPosition pos1(0), pos2(0);
status = U_ZERO_ERROR;
res1 = fr->format(d, res1, pos1, status);
if(U_FAILURE(status)) {
errln("ERROR: format() failed (French)");
}
logln( (UnicodeString) "" + d + " formatted to " + res1);
res2 = it->format(d, res2, pos2);
logln( (UnicodeString) "" + d + " formatted to " + res2);
res3 = de->format(d, res3);
logln( (UnicodeString) "" + d + " formatted to " + res3);
}
// ======= Test parse()
if (def != NULL)
{
logln("Testing parse()");
UnicodeString text("02/03/76 2:50 AM, CST");
Formattable result1;
UDate result2, result3;
ParsePosition pos(0), pos01(0);
def->parseObject(text, result1, pos);
if(result1.getType() != Formattable::kDate) {
errln("ERROR: parseObject() failed for " + text);
}
logln(text + " parsed into " + result1.getDate());
status = U_ZERO_ERROR;
result2 = def->parse(text, status);
if(U_FAILURE(status)) {
errln("ERROR: parse() failed, stopping testing");
return;
}
logln(text + " parsed into " + result2);
result3 = def->parse(text, pos01);
logln(text + " parsed into " + result3);
}
// ======= Test getters and setters
if (fr != NULL && it != NULL && de != NULL)
{
logln("Testing getters and setters");
int32_t count = 0;
const Locale *locales = DateFormat::getAvailableLocales(count);
logln((UnicodeString) "Got " + count + " locales" );
for(int32_t i = 0; i < count; i++) {
UnicodeString name;
name = locales[i].getName();
logln(name);
}
fr->setLenient(it->isLenient());
if(fr->isLenient() != it->isLenient()) {
errln("ERROR: setLenient() failed");
}
const Calendar *cal = def->getCalendar();
Calendar *newCal = cal->clone();
de->adoptCalendar(newCal);
it->setCalendar(*newCal);
if( *(de->getCalendar()) != *(it->getCalendar())) {
errln("ERROR: adopt or set Calendar() failed");
}
const NumberFormat *nf = def->getNumberFormat();
NumberFormat *newNf = (NumberFormat*) nf->clone();
de->adoptNumberFormat(newNf);
it->setNumberFormat(*newNf);
if( *(de->getNumberFormat()) != *(it->getNumberFormat())) {
errln("ERROR: adopt or set NumberFormat() failed");
}
const TimeZone& tz = def->getTimeZone();
TimeZone *newTz = tz.clone();
de->adoptTimeZone(newTz);
it->setTimeZone(*newTz);
if( de->getTimeZone() != it->getTimeZone()) {
errln("ERROR: adopt or set TimeZone() failed");
}
}
// ======= Test getStaticClassID()
logln("Testing getStaticClassID()");
status = U_ZERO_ERROR;
DateFormat *test = new SimpleDateFormat(status);
if(U_FAILURE(status)) {
errln("ERROR: Couldn't create a DateFormat");
}
if(test->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {
errln("ERROR: getDynamicClassID() didn't return the expected value");
}
delete test;
delete def;
delete fr;
delete it;
delete de;
}
static void umsg_set_timezone(MessageFormatter_object *mfo,
intl_error& err)
{
MessageFormat *mf = (MessageFormat *)mfo->mf_data.umsgf;
TimeZone *used_tz = NULL;
const Format **formats;
int32_t count;
/* Unfortanely, this cannot change the time zone for arguments that
* appear inside complex formats because ::getFormats() returns NULL
* for all uncached formats, which is the case for complex formats
* unless they were set via one of the ::setFormat() methods */
if (mfo->mf_data.tz_set) {
return; /* already done */
}
/* There is a bug in ICU which prevents MessageFormatter::getFormats()
to handle more than 10 formats correctly. The enumerator could be
used to walk through the present formatters using getFormat(), which
however seems to provide just a readonly access. This workaround
prevents crash when there are > 10 formats but doesn't set any error.
As a result, only DateFormatters with > 10 subformats are affected.
This workaround should be ifdef'd out, when the bug has been fixed
in ICU. */
icu::StringEnumeration* fnames = mf->getFormatNames(err.code);
if (!fnames || U_FAILURE(err.code)) {
return;
}
count = fnames->count(err.code);
delete fnames;
if (count > 10) {
return;
}
formats = mf->getFormats(count);
if (formats == NULL) {
intl_errors_set(&err, U_MEMORY_ALLOCATION_ERROR,
"Out of memory retrieving subformats", 0);
}
for (int i = 0; U_SUCCESS(err.code) && i < count; i++) {
DateFormat* df = dynamic_cast<DateFormat*>(
const_cast<Format *>(formats[i]));
if (df == NULL) {
continue;
}
if (used_tz == NULL) {
zval nullzv, *zvptr = &nullzv;
ZVAL_NULL(zvptr);
used_tz = timezone_process_timezone_argument(zvptr, &err, "msgfmt_format");
if (used_tz == NULL) {
continue;
}
}
df->setTimeZone(*used_tz);
}
if (U_SUCCESS(err.code)) {
mfo->mf_data.tz_set = 1;
}
}
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;
}
