void DateFormatRegressionTest::Test714(void)
{
//try {
UDate d(978103543000.);
DateFormat *fmt = DateFormat::createDateTimeInstance(DateFormat::NONE,
DateFormat::MEDIUM,
Locale::getUS());
if (fmt == NULL) {
dataerrln("Error calling DateFormat::createDateTimeInstance");
return;
}
UnicodeString s;
UnicodeString tests =
(UnicodeString) "7:25:43 AM" ;
UErrorCode status = U_ZERO_ERROR;
fmt->format (d,s);
if(U_FAILURE(status))
{
errln((UnicodeString) "Fail, errmsg " + u_errorName(status));
return;
}
if(s != tests)
{
errln((UnicodeString) "Fail: " + s + " != " + tests);
}
else
{
logln("OK: " + s + " == " + tests);
}
delete fmt;
}
/**
* Test that the equals method works correctly.
*/
void IntlTestDateFormatAPI::TestEquals(void)
{
UErrorCode status = U_ZERO_ERROR;
// Create two objects at different system times
DateFormat *a = DateFormat::createInstance();
UDate start = Calendar::getNow();
while (Calendar::getNow() == start) ; // Wait for time to change
DateFormat *b = DateFormat::createInstance();
if (a == NULL || b == NULL){
dataerrln("Error calling DateFormat::createInstance()");
delete a;
delete b;
return;
}
if (!(*a == *b))
errln("FAIL: DateFormat objects created at different times are unequal.");
if (b->getDynamicClassID() == SimpleDateFormat::getStaticClassID())
{
double ONE_YEAR = 365*24*60*60*1000.0;
((SimpleDateFormat*)b)->set2DigitYearStart(start + 50*ONE_YEAR, status);
if (U_FAILURE(status))
errln("FAIL: setTwoDigitStartDate failed.");
else if (*a == *b)
errln("FAIL: DateFormat objects with different two digit start dates are equal.");
}
delete a;
delete b;
}
U_CAPI UDateFormat* U_EXPORT2
udat_open(UDateFormatStyle timeStyle,
UDateFormatStyle dateStyle,
const char *locale,
const UChar *tzID,
int32_t tzIDLength,
const UChar *pattern,
int32_t patternLength,
UErrorCode *status)
{
DateFormat *fmt;
if(U_FAILURE(*status)) {
return 0;
}
if(gOpener!=NULL) { // if it's registered
fmt = (DateFormat*) (*gOpener)(timeStyle,dateStyle,locale,tzID,tzIDLength,pattern,patternLength,status);
if(fmt!=NULL) {
return (UDateFormat*)fmt;
} // else fall through.
}
if(timeStyle != UDAT_PATTERN) {
if(locale == 0) {
fmt = DateFormat::createDateTimeInstance((DateFormat::EStyle)dateStyle,
(DateFormat::EStyle)timeStyle);
}
else {
fmt = DateFormat::createDateTimeInstance((DateFormat::EStyle)dateStyle,
(DateFormat::EStyle)timeStyle,
Locale(locale));
}
}
else {
UnicodeString pat((UBool)(patternLength == -1), pattern, patternLength);
if(locale == 0) {
fmt = new SimpleDateFormat(pat, *status);
}
else {
fmt = new SimpleDateFormat(pat, Locale(locale), *status);
}
}
if(fmt == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
return 0;
}
if(tzID != 0) {
TimeZone *zone = TimeZone::createTimeZone(UnicodeString((UBool)(tzIDLength == -1), tzID, tzIDLength));
if(zone == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
delete fmt;
return 0;
}
fmt->adoptTimeZone(zone);
}
return (UDateFormat*)fmt;
}
std::string GlobalizationNDK::stringToDate(const std::string& args)
{
if (args.empty())
return errorInJson(PARSING_ERROR, "No dateString provided!");
Json::Reader reader;
Json::Value root;
bool parse = reader.parse(args, root);
if (!parse) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::stringToDate: invalid json data: %s",
args.c_str());
return errorInJson(PARSING_ERROR, "Parameters not valid json format!");
}
Json::Value dateString = root["dateString"];
if (!dateString.isString()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::stringToDate: invalid dateString type: %d",
dateString.type());
return errorInJson(PARSING_ERROR, "dateString not a string!");
}
std::string dateValue = dateString.asString();
if (dateValue.empty()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::stringToDate: empty dateString.");
return errorInJson(PARSING_ERROR, "dateString is empty!");
}
Json::Value options = root["options"];
DateFormat::EStyle dstyle, tstyle;
std::string error;
if (!handleDateOptions(options, dstyle, tstyle, error))
return errorInJson(PARSING_ERROR, error);
const Locale& loc = Locale::getDefault();
DateFormat* df = DateFormat::createDateTimeInstance(dstyle, tstyle, loc);
if (!df) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::stringToDate: unable to create DateFormat instance!");
return errorInJson(UNKNOWN_ERROR, "Unable to create DateFormat instance!");
}
std::auto_ptr<DateFormat> deleter(df);
UnicodeString uDate = UnicodeString::fromUTF8(dateValue);
UErrorCode status = U_ZERO_ERROR;
UDate date = df->parse(uDate, status);
// Note: not sure why U_ERROR_WARNING_START is returned when parse succeeded.
if (status != U_ZERO_ERROR && status != U_ERROR_WARNING_START) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::stringToDate: DataFormat::parse error: %d: %s",
status, dateValue.c_str());
return errorInJson(PARSING_ERROR, "Failed to parse dateString!");
}
return resultDateInJson(date);
}
std::string GlobalizationNDK::getDatePattern(const std::string& args)
{
DateFormat::EStyle dstyle = DateFormat::kShort, tstyle = DateFormat::kShort;
if (!args.empty()) {
Json::Reader reader;
Json::Value root;
bool parse = reader.parse(args, root);
if (!parse) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getDatePattern: 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 (!handleDateOptions(options, dstyle, tstyle, error))
return errorInJson(PARSING_ERROR, error);
}
UErrorCode status = U_ZERO_ERROR;
const Locale& loc = Locale::getDefault();
DateFormat* df = DateFormat::createDateTimeInstance(dstyle, tstyle, loc);
if (!df) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::getDatePattern: 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::getDatePattern: DateFormat instance not SimpleDateFormat!");
return errorInJson(UNKNOWN_ERROR, "DateFormat instance not SimpleDateFormat!");
}
SimpleDateFormat* sdf = (SimpleDateFormat*) df;
UnicodeString pt;
sdf->toPattern(pt);
std::string ptUtf8;
pt.toUTF8String(ptUtf8);
const TimeZone& tz = sdf->getTimeZone();
UnicodeString tzName;
tz.getDisplayName(tzName);
std::string tzUtf8;
tzName.toUTF8String(tzUtf8);
int utc_offset = tz.getRawOffset() / 1000; // UTC_OFFSET in seconds.
int dst_offset = tz.getDSTSavings() / 1000; // DST_OFFSET in seconds;
return resultInJson(ptUtf8, tzUtf8, utc_offset, dst_offset);
}
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
fmt = DateFormat::createDateInstance(DateFormat::kFull, loc);
// Format the date
str.remove();
fmt->format(date, str, status);
// Display the formatted date string
printf("Date (%s): ", LANGUAGE[i]);
uprintf(escape(str));
printf("\n\n");
}
printf("Exiting successfully\n");
return 0;
}
UDate L10n::ParseDateTime(const std::string& dateTimeString, const std::string& dateTimeFormat, const Locale& locale) const
{
UErrorCode success = U_ZERO_ERROR;
UnicodeString utf16DateTimeString = UnicodeString::fromUTF8(dateTimeString.c_str());
UnicodeString utf16DateTimeFormat = UnicodeString::fromUTF8(dateTimeFormat.c_str());
DateFormat* dateFormatter = new SimpleDateFormat(utf16DateTimeFormat, locale, success);
UDate date = dateFormatter->parse(utf16DateTimeString, success);
delete dateFormatter;
return date;
}
/**
* @bug 4060212
*/
void DateFormatRegressionTest::Test4060212(void)
{
UnicodeString dateString = "1995-040.05:01:29";
logln( "dateString= " + dateString );
logln("Using yyyy-DDD.hh:mm:ss");
UErrorCode status = U_ZERO_ERROR;
SimpleDateFormat *formatter = new SimpleDateFormat(UnicodeString("yyyy-DDD.hh:mm:ss"), status);
if (failure(status, "new SimpleDateFormat", TRUE)) return;
ParsePosition pos(0);
UDate myDate = formatter->parse( dateString, pos );
UnicodeString myString;
DateFormat *fmt = DateFormat::createDateTimeInstance( DateFormat::FULL,
DateFormat::LONG);
if (fmt == NULL) {
dataerrln("Error calling DateFormat::createDateTimeInstance");
delete formatter;
return;
}
myString = fmt->format( myDate, myString);
logln( myString );
Calendar *cal = new GregorianCalendar(status);
failure(status, "new GregorianCalendar");
cal->setTime(myDate, status);
failure(status, "cal->setTime");
if ((cal->get(UCAL_DAY_OF_YEAR, status) != 40) || failure(status, "cal->get"))
errln((UnicodeString) "Fail: Got " + cal->get(UCAL_DAY_OF_YEAR, status) +
" Want 40");
// this is an odd usage of "ddd" and it doesn't
// work now that date values are range checked per #3579.
logln("Using yyyy-ddd.hh:mm:ss");
delete formatter;
formatter = NULL;
formatter = new SimpleDateFormat(UnicodeString("yyyy-ddd.hh:mm:ss"), status);
if(failure(status, "new SimpleDateFormat")) return;
pos.setIndex(0);
myDate = formatter->parse( dateString, pos );
myString = fmt->format( myDate, myString );
logln( myString );
cal->setTime(myDate, status);
failure(status, "cal->setTime");
if ((cal->get(UCAL_DAY_OF_YEAR, status) != 40) || failure(status, "cal->get"))
errln((UnicodeString) "Fail: Got " + cal->get(UCAL_DAY_OF_YEAR, status) +
" Want 40");
delete formatter;
delete fmt;
delete cal;
}
std::string GlobalizationNDK::dateToString(const std::string& args)
{
if (args.empty())
return errorInJson(PARSING_ERROR, "No date provided!");
Json::Reader reader;
Json::Value root;
bool parse = reader.parse(args, root);
if (!parse) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::dateToString: invalid json data: %s",
args.c_str());
return errorInJson(PARSING_ERROR, "Parameters not valid json format!");
}
Json::Value date = root["date"];
if (date.isNull()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::dateToString: no date provided.");
return errorInJson(PARSING_ERROR, "No date provided!");
}
if (!date.isNumeric()) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::dateToString: date is not a numeric: %d.",
date.type());
return errorInJson(PARSING_ERROR, "Date in wrong format!");
}
Json::Value options = root["options"];
DateFormat::EStyle dstyle, tstyle;
std::string error;
if (!handleDateOptions(options, dstyle, tstyle, error))
return errorInJson(PARSING_ERROR, error);
UErrorCode status = U_ZERO_ERROR;
const Locale& loc = Locale::getDefault();
DateFormat* df = DateFormat::createDateTimeInstance(dstyle, tstyle, loc);
if (!df) {
slog2f(0, ID_G11N, SLOG2_ERROR, "GlobalizationNDK::dateToString: unable to create DateFormat!");
return errorInJson(UNKNOWN_ERROR, "Unable to create DateFormat instance!");
}
std::auto_ptr<DateFormat> deleter(df);
UnicodeString result;
df->format(date.asDouble(), result);
std::string utf8;
result.toUTF8String(utf8);
return resultInJson(utf8);
}
std::string L10n::LocalizeDateTime(const UDate& dateTime, const DateTimeType& type, const DateFormat::EStyle& style) const
{
UnicodeString utf16Date;
DateFormat* dateFormatter = CreateDateTimeInstance(type, style, currentLocale);
dateFormatter->format(dateTime, utf16Date);
char utf8Date[512];
CheckedArrayByteSink sink(utf8Date, ARRAY_SIZE(utf8Date));
utf16Date.toUTF8(sink);
ENSURE(!sink.Overflowed());
delete dateFormatter;
return std::string(utf8Date, sink.NumberOfBytesWritten());
}
UnicodeString&
CalendarTimeZoneTest::dateToString(UDate d, UnicodeString& str)
{
str.remove();
DateFormat* format = getDateFormat();
if (format == 0)
{
str += "DATE_FORMAT_FAILURE";
return str;
}
format->format(d, str);
releaseDateFormat(format);
return str;
}
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;
}
}
void
CalendarLimitTest::TestCalendarExtremeLimit()
{
UErrorCode status = U_ZERO_ERROR;
Calendar *cal = Calendar::createInstance(status);
if (failure(status, "Calendar::createInstance", TRUE)) return;
cal->adoptTimeZone(TimeZone::createTimeZone("GMT"));
DateFormat *fmt = DateFormat::createDateTimeInstance();
if(!fmt || !cal) {
dataerrln("can't open cal and/or fmt");
return;
}
fmt->adoptCalendar(cal);
((SimpleDateFormat*) fmt)->applyPattern("HH:mm:ss.SSS Z, EEEE, MMMM d, yyyy G");
// This test used to test the algorithmic limits of the dates that
// GregorianCalendar could handle. However, the algorithm has
// been rewritten completely since then and the prior limits no
// longer apply. Instead, we now do basic round-trip testing of
// some extreme (but still manageable) dates.
UDate m;
logln("checking 1e16..1e17");
for ( m = 1e16; m < 1e17; m *= 1.1) {
test(m, cal, fmt);
}
logln("checking -1e14..-1e15");
for ( m = -1e14; m > -1e15; m *= 1.1) {
test(m, cal, fmt);
}
// This is 2^52 - 1, the largest allowable mantissa with a 0
// exponent in a 64-bit double
UDate VERY_EARLY_MILLIS = - 4503599627370495.0;
UDate VERY_LATE_MILLIS = 4503599627370495.0;
// I am removing the previousDouble and nextDouble calls below for
// two reasons: 1. As part of jitterbug 986, I am deprecating
// these methods and removing calls to them. 2. This test is a
// non-critical boundary behavior test.
test(VERY_EARLY_MILLIS, cal, fmt);
//test(previousDouble(VERY_EARLY_MILLIS), cal, fmt);
test(VERY_LATE_MILLIS, cal, fmt);
//test(nextDouble(VERY_LATE_MILLIS), cal, fmt);
delete fmt;
}
/**
* @bug 4071441
*/
void DateFormatRegressionTest::Test4071441(void)
{
DateFormat *fmtA = DateFormat::createInstance();
DateFormat *fmtB = DateFormat::createInstance();
if (fmtA == NULL || fmtB == NULL){
dataerrln("Error calling DateFormat::createInstance");
delete fmtA;
delete fmtB;
return;
}
// {sfb} Is it OK to cast away const here?
Calendar *calA = (Calendar*) fmtA->getCalendar();
Calendar *calB = (Calendar*) fmtB->getCalendar();
if(!calA || !calB) {
errln("Couldn't get proper calendars, exiting");
delete fmtA;
delete fmtB;
return;
}
UDate epoch = date(0, 0, 0);
UDate xmas = date(61, UCAL_DECEMBER, 25);
UErrorCode status = U_ZERO_ERROR;
calA->setTime(epoch, status);
failure(status, "calA->setTime");
calB->setTime(epoch, status);
failure(status, "calB->setTime");
if (*calA != *calB)
errln("Fail: Can't complete test; Calendar instances unequal");
if (*fmtA != *fmtB)
errln("Fail: DateFormat unequal when Calendars equal");
calB->setTime(xmas, status);
failure(status, "calB->setTime");
if (*calA == *calB)
errln("Fail: Can't complete test; Calendar instances equal");
if (*fmtA != *fmtB)
errln("Fail: DateFormat unequal when Calendars equivalent");
logln("DateFormat.equals ok");
delete fmtA;
delete fmtB;
}
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;
}
int main(int argc, char **argv) {
Calendar *cal;
DateFormat *fmt;
DateFormat *defFmt;
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);
// 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\n");
}
// Clean up
delete fmt;
delete cal;
printf("Exiting successfully\n");
return 0;
}
/* {{{ */
static void datefmt_ctor(INTERNAL_FUNCTION_PARAMETERS)
{
zval *object;
const char *locale_str;
size_t locale_len = 0;
Locale locale;
zend_long date_type = 0;
zend_long time_type = 0;
zval *calendar_zv = NULL;
Calendar *calendar = NULL;
zend_long calendar_type;
bool calendar_owned;
zval *timezone_zv = NULL;
TimeZone *timezone = NULL;
bool explicit_tz;
char* pattern_str = NULL;
size_t pattern_str_len = 0;
UChar* svalue = NULL; /* UTF-16 pattern_str */
int32_t slength = 0;
IntlDateFormatter_object* dfo;
intl_error_reset(NULL);
object = return_value;
/* Parse parameters. */
if (zend_parse_parameters(ZEND_NUM_ARGS(), "sll|zzs",
&locale_str, &locale_len, &date_type, &time_type, &timezone_zv,
&calendar_zv, &pattern_str, &pattern_str_len) == FAILURE) {
intl_error_set( NULL, U_ILLEGAL_ARGUMENT_ERROR, "datefmt_create: "
"unable to parse input parameters", 0);
Z_OBJ_P(return_value) = NULL;
return;
}
INTL_CHECK_LOCALE_LEN_OBJ(locale_len, return_value);
if (locale_len == 0) {
locale_str = intl_locale_get_default();
}
locale = Locale::createFromName(locale_str);
DATE_FORMAT_METHOD_FETCH_OBJECT_NO_CHECK;
if (DATE_FORMAT_OBJECT(dfo) != NULL) {
intl_errors_set(INTL_DATA_ERROR_P(dfo), U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_create: cannot call constructor twice", 0);
return;
}
/* process calendar */
if (datefmt_process_calendar_arg(calendar_zv, locale, "datefmt_create",
INTL_DATA_ERROR_P(dfo), calendar, calendar_type,
calendar_owned)
== FAILURE) {
goto error;
}
/* process timezone */
explicit_tz = timezone_zv != NULL && Z_TYPE_P(timezone_zv) != IS_NULL;
if (explicit_tz || calendar_owned ) {
//we have an explicit time zone or a non-object calendar
timezone = timezone_process_timezone_argument(timezone_zv,
INTL_DATA_ERROR_P(dfo), "datefmt_create");
if (timezone == NULL) {
goto error;
}
}
/* Convert pattern (if specified) to UTF-16. */
if (pattern_str && pattern_str_len > 0) {
intl_convert_utf8_to_utf16(&svalue, &slength,
pattern_str, pattern_str_len, &INTL_DATA_ERROR_CODE(dfo));
if (U_FAILURE(INTL_DATA_ERROR_CODE(dfo))) {
/* object construction -> only set global error */
intl_error_set(NULL, INTL_DATA_ERROR_CODE(dfo), "datefmt_create: "
"error converting pattern to UTF-16", 0);
goto error;
}
}
if (pattern_str && pattern_str_len > 0) {
DATE_FORMAT_OBJECT(dfo) = udat_open(UDAT_IGNORE, UDAT_IGNORE,
locale_str, NULL, 0, svalue, slength,
&INTL_DATA_ERROR_CODE(dfo));
} else {
DATE_FORMAT_OBJECT(dfo) = udat_open((UDateFormatStyle)time_type,
(UDateFormatStyle)date_type, locale_str, NULL, 0, svalue,
slength, &INTL_DATA_ERROR_CODE(dfo));
}
if (!U_FAILURE(INTL_DATA_ERROR_CODE(dfo))) {
DateFormat *df = (DateFormat*)DATE_FORMAT_OBJECT(dfo);
if (calendar_owned) {
df->adoptCalendar(calendar);
calendar_owned = false;
} else {
df->setCalendar(*calendar);
}
if (timezone != NULL) {
df->adoptTimeZone(timezone);
}
} else {
intl_error_set(NULL, INTL_DATA_ERROR_CODE(dfo), "datefmt_create: date "
"formatter creation failed", 0);
goto error;
}
/* Set the class variables */
dfo->date_type = date_type;
dfo->time_type = time_type;
dfo->calendar = calendar_type;
dfo->requested_locale = estrdup(locale_str);
error:
if (svalue) {
efree(svalue);
}
if (timezone != NULL && DATE_FORMAT_OBJECT(dfo) == NULL) {
delete timezone;
}
if (calendar != NULL && calendar_owned) {
delete calendar;
}
if (U_FAILURE(intl_error_get_code(NULL))) {
/* free_object handles partially constructed instances fine */
Z_OBJ_P(return_value) = NULL;
}
}
U_CFUNC PHP_FUNCTION(datefmt_format_object)
{
zval *object,
*format = NULL;
const char *locale_str = NULL;
size_t locale_len;
bool pattern = false;
UDate date;
TimeZone *timeZone = NULL;
UErrorCode status = U_ZERO_ERROR;
DateFormat *df = NULL;
Calendar *cal = NULL;
DateFormat::EStyle dateStyle = DateFormat::kDefault,
timeStyle = DateFormat::kDefault;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "o|zs!",
&object, &format, &locale_str, &locale_len) == FAILURE) {
RETURN_FALSE;
}
if (!locale_str) {
locale_str = intl_locale_get_default();
}
if (format == NULL || Z_TYPE_P(format) == IS_NULL) {
//nothing
} else if (Z_TYPE_P(format) == IS_ARRAY) {
HashTable *ht = Z_ARRVAL_P(format);
HashPosition pos = {0};
zval *z;
if (zend_hash_num_elements(ht) != 2) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad format; if array, it must have "
"two elements", 0);
RETURN_FALSE;
}
zend_hash_internal_pointer_reset_ex(ht, &pos);
z = zend_hash_get_current_data_ex(ht, &pos);
if (!valid_format(z)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad format; the date format (first "
"element of the array) is not valid", 0);
RETURN_FALSE;
}
dateStyle = (DateFormat::EStyle)Z_LVAL_P(z);
zend_hash_move_forward_ex(ht, &pos);
z = zend_hash_get_current_data_ex(ht, &pos);
if (!valid_format(z)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad format; the time format ("
"second element of the array) is not valid", 0);
RETURN_FALSE;
}
timeStyle = (DateFormat::EStyle)Z_LVAL_P(z);
} else if (Z_TYPE_P(format) == IS_LONG) {
if (!valid_format(format)) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: the date/time format type is invalid",
0);
RETURN_FALSE;
}
dateStyle = timeStyle = (DateFormat::EStyle)Z_LVAL_P(format);
} else {
convert_to_string_ex(format);
if (Z_STRLEN_P(format) == 0) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: the format is empty", 0);
RETURN_FALSE;
}
pattern = true;
}
//there's no support for relative time in ICU yet
timeStyle = (DateFormat::EStyle)(timeStyle & ~DateFormat::kRelative);
zend_class_entry *instance_ce = Z_OBJCE_P(object);
if (instanceof_function(instance_ce, Calendar_ce_ptr)) {
Calendar *obj_cal = calendar_fetch_native_calendar(object);
if (obj_cal == NULL) {
intl_error_set(NULL, U_ILLEGAL_ARGUMENT_ERROR,
"datefmt_format_object: bad IntlCalendar instance: "
"not initialized properly", 0);
RETURN_FALSE;
}
timeZone = obj_cal->getTimeZone().clone();
date = obj_cal->getTime(status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status,
"datefmt_format_object: error obtaining instant from "
"IntlCalendar", 0);
RETVAL_FALSE;
goto cleanup;
}
cal = obj_cal->clone();
} else if (instanceof_function(instance_ce, php_date_get_date_ce())) {
if (intl_datetime_decompose(object, &date, &timeZone, NULL,
"datefmt_format_object") == FAILURE) {
RETURN_FALSE;
}
cal = new GregorianCalendar(Locale::createFromName(locale_str), status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status,
"datefmt_format_object: could not create GregorianCalendar",
0);
RETVAL_FALSE;
goto cleanup;
}
} else {
intl_error_set(NULL, status, "datefmt_format_object: the passed object "
"must be an instance of either IntlCalendar or DateTime",
0);
RETURN_FALSE;
}
if (pattern) {
df = new SimpleDateFormat(
UnicodeString(Z_STRVAL_P(format), Z_STRLEN_P(format),
UnicodeString::kInvariant),
Locale::createFromName(locale_str),
status);
if (U_FAILURE(status)) {
intl_error_set(NULL, status,
"datefmt_format_object: could not create SimpleDateFormat",
0);
RETVAL_FALSE;
goto cleanup;
}
} else {
df = DateFormat::createDateTimeInstance(dateStyle, timeStyle,
Locale::createFromName(locale_str));
if (df == NULL) { /* according to ICU sources, this should never happen */
intl_error_set(NULL, status,
"datefmt_format_object: could not create DateFormat",
0);
RETVAL_FALSE;
goto cleanup;
}
}
//must be in this order (or have the cal adopt the tz)
df->adoptCalendar(cal);
cal = NULL;
df->adoptTimeZone(timeZone);
timeZone = NULL;
{
char *ret_str;
int ret_str_len;
UnicodeString result = UnicodeString();
df->format(date, result);
if (intl_charFromString(result, &ret_str, &ret_str_len, &status) == FAILURE) {
intl_error_set(NULL, status,
"datefmt_format_object: error converting result to UTF-8",
0);
RETVAL_FALSE;
goto cleanup;
}
RETVAL_STRINGL(ret_str, ret_str_len);
//???
efree(ret_str);
}
cleanup:
delete df;
delete timeZone;
delete cal;
}
String IndicationFormatter::_localizeDateTime(
const CIMDateTime & propertyValueDateTime,
const Locale & locale)
{
PEG_METHOD_ENTER (TRC_IND_FORMATTER,
"IndicationFormatter::_localizeDateTime");
// Convert dateTimeValue to be microSeconds,
// the number of microseconds from the epoch starting
// 0/0/0000 (12 am Jan 1, 1BCE)
//
CIMDateTime dateTimeValue = propertyValueDateTime;
Uint64 dateTimeValueInMicroSecs =
dateTimeValue.toMicroSeconds();
// In ICU, as UTC milliseconds from the epoch starting
// (1 January 1970 0:00 UTC)
CIMDateTime dt;
dt.set("19700101000000.000000+000");
// Convert dateTimeValue to be milliSeconds,
// the number of milliSeconds from the epoch starting
// (1 January 1970 0:00 UTC)
UDate dateTimeValueInMilliSecs =
(Sint64)(dateTimeValueInMicroSecs - dt.toMicroSeconds())/1000;
// Create a formatter for DATE and TIME with medium length
// such as Jan 12, 1952 3:30:32pm
DateFormat *fmt;
try
{
if (locale == 0)
{
fmt = DateFormat::createDateTimeInstance(DateFormat::MEDIUM,
DateFormat::MEDIUM);
}
else
{
fmt = DateFormat::createDateTimeInstance(DateFormat::MEDIUM,
DateFormat::MEDIUM,
locale);
}
}
catch(Exception& e)
{
PEG_TRACE_STRING(TRC_IND_FORMATTER, Tracer::LEVEL4, e.getMessage());
PEG_METHOD_EXIT();
return (dateTimeValue.toString());
}
catch(...)
{
PEG_TRACE_STRING(TRC_IND_FORMATTER, Tracer::LEVEL4,
"Caught General Exception During DateFormat::createDateTimeInstance");
PEG_METHOD_EXIT();
return (dateTimeValue.toString());
}
if (fmt == 0)
{
PEG_TRACE_STRING(TRC_IND_FORMATTER, Tracer::LEVEL4,
"Memory allocation error creating DateTime instance.");
PEG_METHOD_EXIT();
return (dateTimeValue.toString());
}
// Format the Date and Time
UErrorCode status = U_ZERO_ERROR;
UnicodeString dateTimeUniStr;
fmt->format(dateTimeValueInMilliSecs, dateTimeUniStr, status);
if (U_FAILURE(status))
{
delete fmt;
PEG_METHOD_EXIT();
return (dateTimeValue.toString());
}
// convert UnicodeString to char *
char dateTimeBuffer[256];
char *extractedStr = 0;
// Copy the contents of the string into dateTimeBuffer
Uint32 strLen = dateTimeUniStr.extract(0, sizeof(dateTimeBuffer),
dateTimeBuffer);
// There is not enough space in dateTimeBuffer
if (strLen > sizeof(dateTimeBuffer))
{
extractedStr = new char[strLen + 1];
strLen = dateTimeUniStr.extract(0, strLen + 1, extractedStr);
}
else
{
extractedStr = dateTimeBuffer;
}
String datetimeStr = extractedStr;
if (extractedStr != dateTimeBuffer)
{
delete extractedStr;
}
delete fmt;
PEG_METHOD_EXIT();
return (datetimeStr);
}
/**
* 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;
}
/**
* @bug 4052408
*/
void DateFormatRegressionTest::Test4052408(void)
{
DateFormat *fmt = DateFormat::createDateTimeInstance(DateFormat::SHORT,
DateFormat::SHORT, Locale::getUS());
if (fmt == NULL) {
dataerrln("Error calling DateFormat::createDateTimeInstance");
return;
}
UDate dt = date(97, UCAL_MAY, 3, 8, 55);
UnicodeString str;
str = fmt->format(dt, str);
logln(str);
if(str != "5/3/97 8:55 AM")
errln("Fail: Test broken; Want 5/3/97 8:55 AM Got " + str);
UnicodeString expected[] = {
(UnicodeString) "", //"ERA_FIELD",
(UnicodeString) "97", //"YEAR_FIELD",
(UnicodeString) "5", //"MONTH_FIELD",
(UnicodeString) "3", //"DATE_FIELD",
(UnicodeString) "", //"HOUR_OF_DAY1_FIELD",
(UnicodeString) "", //"HOUR_OF_DAY0_FIELD",
(UnicodeString) "55", //"MINUTE_FIELD",
(UnicodeString) "", //"SECOND_FIELD",
(UnicodeString) "", //"MILLISECOND_FIELD",
(UnicodeString) "", //"DAY_OF_WEEK_FIELD",
(UnicodeString) "", //"DAY_OF_YEAR_FIELD",
(UnicodeString) "", //"DAY_OF_WEEK_IN_MONTH_FIELD",
(UnicodeString) "", //"WEEK_OF_YEAR_FIELD",
(UnicodeString) "", //"WEEK_OF_MONTH_FIELD",
(UnicodeString) "AM", //"AM_PM_FIELD",
(UnicodeString) "8", //"HOUR1_FIELD",
(UnicodeString) "", //"HOUR0_FIELD",
(UnicodeString) "" //"TIMEZONE_FIELD"
};
//Hashtable expected;// = new Hashtable();
//expected.put(new LongKey(DateFormat.MONTH_FIELD), "5");
//expected.put(new LongKey(DateFormat.DATE_FIELD), "3");
//expected.put(new LongKey(DateFormat.YEAR_FIELD), "97");
//expected.put(new LongKey(DateFormat.HOUR1_FIELD), "8");
//expected.put(new LongKey(DateFormat.MINUTE_FIELD), "55");
//expected.put(new LongKey(DateFormat.AM_PM_FIELD), "AM");
//StringBuffer buf = new StringBuffer();
UnicodeString fieldNames[] = {
(UnicodeString) "ERA_FIELD",
(UnicodeString) "YEAR_FIELD",
(UnicodeString) "MONTH_FIELD",
(UnicodeString) "DATE_FIELD",
(UnicodeString) "HOUR_OF_DAY1_FIELD",
(UnicodeString) "HOUR_OF_DAY0_FIELD",
(UnicodeString) "MINUTE_FIELD",
(UnicodeString) "SECOND_FIELD",
(UnicodeString) "MILLISECOND_FIELD",
(UnicodeString) "DAY_OF_WEEK_FIELD",
(UnicodeString) "DAY_OF_YEAR_FIELD",
(UnicodeString) "DAY_OF_WEEK_IN_MONTH_FIELD",
(UnicodeString) "WEEK_OF_YEAR_FIELD",
(UnicodeString) "WEEK_OF_MONTH_FIELD",
(UnicodeString) "AM_PM_FIELD",
(UnicodeString) "HOUR1_FIELD",
(UnicodeString) "HOUR0_FIELD",
(UnicodeString) "TIMEZONE_FIELD"
};
UBool pass = TRUE;
for(int i = 0; i <= 17; ++i) {
FieldPosition pos(i);
UnicodeString buf;
fmt->format(dt, buf, pos);
//char[] dst = new char[pos.getEndIndex() - pos.getBeginIndex()];
UnicodeString dst;
buf.extractBetween(pos.getBeginIndex(), pos.getEndIndex(), dst);
UnicodeString str(dst);
logln((UnicodeString)"" + i + (UnicodeString)": " + fieldNames[i] +
(UnicodeString)", \"" + str + (UnicodeString)"\", " +
pos.getBeginIndex() + (UnicodeString)", " +
pos.getEndIndex());
UnicodeString exp = expected[i];
if((exp.length() == 0 && str.length() == 0) || str == exp)
logln(" ok");
else {
errln(UnicodeString(" expected ") + exp);
pass = FALSE;
}
}
if( ! pass)
errln("Fail: FieldPosition not set right by DateFormat");
delete fmt;
}
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;
}
}
/**
* Test hiding of parse() and format() APIs in the Format hierarchy.
* We test the entire hierarchy, even though this test is located in
* the DateFormat API test.
*/
void
IntlTestDateFormatAPI::TestNameHiding(void) {
// N.B.: This test passes if it COMPILES, since it's a test of
// compile-time name hiding.
UErrorCode status = U_ZERO_ERROR;
Formattable dateObj(0, Formattable::kIsDate);
Formattable numObj(3.1415926535897932384626433832795);
Formattable obj;
UnicodeString str;
FieldPosition fpos;
ParsePosition ppos;
// DateFormat calling Format API
{
logln("DateFormat");
DateFormat *dateFmt = DateFormat::createInstance();
if (dateFmt) {
dateFmt->format(dateObj, str, status);
dateFmt->format(dateObj, str, fpos, status);
delete dateFmt;
} else {
errln("FAIL: Can't create DateFormat");
}
}
// SimpleDateFormat calling Format & DateFormat API
{
logln("SimpleDateFormat");
status = U_ZERO_ERROR;
SimpleDateFormat sdf(status);
// Format API
sdf.format(dateObj, str, status);
sdf.format(dateObj, str, fpos, status);
// DateFormat API
sdf.format((UDate)0, str, fpos);
sdf.format((UDate)0, str);
sdf.parse(str, status);
sdf.parse(str, ppos);
}
// NumberFormat calling Format API
{
logln("NumberFormat");
status = U_ZERO_ERROR;
NumberFormat *fmt = NumberFormat::createInstance(status);
if (fmt) {
fmt->format(numObj, str, status);
fmt->format(numObj, str, fpos, status);
delete fmt;
} else {
errln("FAIL: Can't create NumberFormat()");
}
}
// DecimalFormat calling Format & NumberFormat API
{
logln("DecimalFormat");
status = U_ZERO_ERROR;
DecimalFormat fmt(status);
if(U_SUCCESS(status)) {
// Format API
fmt.format(numObj, str, status);
fmt.format(numObj, str, fpos, status);
// NumberFormat API
fmt.format(2.71828, str);
fmt.format((int32_t)1234567, str);
fmt.format(1.41421, str, fpos);
fmt.format((int32_t)9876543, str, fpos);
fmt.parse(str, obj, ppos);
fmt.parse(str, obj, status);
} else {
errln("FAIL: Couldn't instantiate DecimalFormat, error %s. Quitting test", u_errorName(status));
}
}
// ChoiceFormat calling Format & NumberFormat API
{
logln("ChoiceFormat");
status = U_ZERO_ERROR;
ChoiceFormat fmt("0#foo|1#foos|2#foos", status);
// Format API
fmt.format(numObj, str, status);
fmt.format(numObj, str, fpos, status);
// NumberFormat API
fmt.format(2.71828, str);
fmt.format((int32_t)1234567, str);
fmt.format(1.41421, str, fpos);
fmt.format((int32_t)9876543, str, fpos);
fmt.parse(str, obj, ppos);
fmt.parse(str, obj, status);
}
// MessageFormat calling Format API
{
logln("MessageFormat");
status = U_ZERO_ERROR;
MessageFormat fmt("", status);
// Format API
// We use dateObj, which MessageFormat should reject.
// We're testing name hiding, not the format method.
fmt.format(dateObj, str, status);
fmt.format(dateObj, str, fpos, status);
}
}
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 IntlTestSimpleDateFormatAPI::testAPI(/*char *par*/)
{
UErrorCode status = U_ZERO_ERROR;
// ======= Test constructors
logln("Testing SimpleDateFormat constructors");
SimpleDateFormat def(status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create SimpleDateFormat (default) - exitting");
return;
}
status = U_ZERO_ERROR;
const UnicodeString pattern("yyyy.MM.dd G 'at' hh:mm:ss z");
const UnicodeString override("y=hebr;d=thai;s=arab");
const UnicodeString override_bogus("y=hebr;d=thai;s=bogus");
SimpleDateFormat pat(pattern, status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create SimpleDateFormat (pattern)");
}
status = U_ZERO_ERROR;
SimpleDateFormat pat_fr(pattern, Locale::getFrench(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create SimpleDateFormat (pattern French)");
}
status = U_ZERO_ERROR;
DateFormatSymbols *symbols = new DateFormatSymbols(Locale::getFrench(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create DateFormatSymbols (French)");
}
status = U_ZERO_ERROR;
SimpleDateFormat cust1(pattern, symbols, status);
if(U_FAILURE(status)) {
dataerrln("ERROR: Could not create SimpleDateFormat (pattern, symbols*) - exitting");
return;
}
status = U_ZERO_ERROR;
SimpleDateFormat cust2(pattern, *symbols, status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create SimpleDateFormat (pattern, symbols)");
}
status = U_ZERO_ERROR;
SimpleDateFormat ovr1(pattern, override, status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create SimpleDateFormat (pattern, override)");
}
status = U_ZERO_ERROR;
SimpleDateFormat ovr2(pattern, override, Locale::getGerman(), status);
if(U_FAILURE(status)) {
errln("ERROR: Could not create SimpleDateFormat (pattern, override, locale)");
}
status = U_ZERO_ERROR;
SimpleDateFormat ovr3(pattern, override_bogus, Locale::getGerman(), status);
if(U_SUCCESS(status)) {
errln("ERROR: Should not have been able to create SimpleDateFormat (pattern, override, locale) with a bogus override");
}
SimpleDateFormat copy(pat);
// ======= Test clone(), assignment, and equality
logln("Testing clone(), assignment and equality operators");
if( ! (copy == pat) || copy != pat) {
errln("ERROR: Copy constructor (or ==) failed");
}
copy = cust1;
if(copy != cust1) {
errln("ERROR: Assignment (or !=) failed");
}
Format *clone = def.clone();
if( ! (*clone == def) ) {
errln("ERROR: Clone() (or ==) failed");
}
delete clone;
// ======= Test various format() methods
logln("Testing various format() methods");
UDate d = 837039928046.0;
Formattable fD(d, Formattable::kIsDate);
UnicodeString res1, res2;
FieldPosition pos1(0), pos2(0);
res1 = def.format(d, res1, pos1);
logln( (UnicodeString) "" + d + " formatted to " + res1);
status = U_ZERO_ERROR;
res2 = cust1.format(fD, res2, pos2, status);
if(U_FAILURE(status)) {
errln("ERROR: format(Formattable [Date]) failed");
}
logln((UnicodeString) "" + fD.getDate() + " formatted to " + res2);
// ======= Test parse()
logln("Testing parse()");
UnicodeString text("02/03/76 2:50 AM, CST");
UDate result1, result2;
ParsePosition pos(0);
result1 = def.parse(text, pos);
logln(text + " parsed into " + result1);
status = U_ZERO_ERROR;
result2 = def.parse(text, status);
if(U_FAILURE(status)) {
errln("ERROR: parse() failed");
}
logln(text + " parsed into " + result2);
// ======= Test getters and setters
logln("Testing getters and setters");
const DateFormatSymbols *syms = pat.getDateFormatSymbols();
if(!syms) {
errln("Couldn't obtain DateFormatSymbols. Quitting test!");
return;
}
if(syms->getDynamicClassID() != DateFormatSymbols::getStaticClassID()) {
errln("ERROR: format->getDateFormatSymbols()->getDynamicClassID() != DateFormatSymbols::getStaticClassID()");
}
DateFormatSymbols *newSyms = new DateFormatSymbols(*syms);
def.adoptDateFormatSymbols(newSyms);
pat_fr.setDateFormatSymbols(*newSyms);
if( *(pat.getDateFormatSymbols()) != *(def.getDateFormatSymbols())) {
errln("ERROR: adopt or set DateFormatSymbols() failed");
}
status = U_ZERO_ERROR;
UDate startDate = pat.get2DigitYearStart(status);
if(U_FAILURE(status)) {
errln("ERROR: getTwoDigitStartDate() failed");
}
status = U_ZERO_ERROR;
pat_fr.set2DigitYearStart(startDate, status);
if(U_FAILURE(status)) {
errln("ERROR: setTwoDigitStartDate() failed");
}
// ======= Test DateFormatSymbols constructor
newSyms =new DateFormatSymbols("gregorian", status);
if(U_FAILURE(status)) {
errln("ERROR: new DateFormatSymbols() failed");
}
def.adoptDateFormatSymbols(newSyms);
// ======= Test applyPattern()
logln("Testing applyPattern()");
UnicodeString p1("yyyy.MM.dd G 'at' hh:mm:ss z");
logln("Applying pattern " + p1);
status = U_ZERO_ERROR;
pat.applyPattern(p1);
UnicodeString s2;
s2 = pat.toPattern(s2);
logln("Extracted pattern is " + s2);
if(s2 != p1) {
errln("ERROR: toPattern() result did not match pattern applied");
}
logln("Applying pattern " + p1);
status = U_ZERO_ERROR;
pat.applyLocalizedPattern(p1, status);
if(U_FAILURE(status)) {
errln("ERROR: applyPattern() failed with " + (int32_t) status);
}
UnicodeString s3;
status = U_ZERO_ERROR;
s3 = pat.toLocalizedPattern(s3, status);
if(U_FAILURE(status)) {
errln("ERROR: toLocalizedPattern() failed");
}
logln("Extracted pattern is " + s3);
if(s3 != p1) {
errln("ERROR: toLocalizedPattern() result did not match pattern applied");
}
// ======= Test getStaticClassID()
logln("Testing getStaticClassID()");
status = U_ZERO_ERROR;
DateFormat *test = new SimpleDateFormat(status);
if(U_FAILURE(status)) {
errln("ERROR: Couldn't create a SimpleDateFormat");
}
if(test->getDynamicClassID() != SimpleDateFormat::getStaticClassID()) {
errln("ERROR: getDynamicClassID() didn't return the expected value");
}
delete test;
// ======= Test Ticket 5684 (Parsing with 'e' and 'Y')
SimpleDateFormat object(UNICODE_STRING_SIMPLE("YYYY'W'wwe"), status);
if(U_FAILURE(status)) {
errln("ERROR: Couldn't create a SimpleDateFormat");
}
object.setLenient(false);
ParsePosition pp(0);
UDate udDate = object.parse("2007W014", pp);
if ((double)udDate == 0.0) {
errln("ERROR: Parsing failed using 'Y' and 'e'");
}
}
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;
}
/**
* @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;
}
int main(int argc, char **argv) {
Calendar *cal;
DateFormat *fmt;
DateFormat *defFmt;
Transliterator *greek_latin;
Transliterator *rbtUnaccent;
Transliterator *unaccent;
UParseError pError;
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", UTRANS_FORWARD, status);
if (greek_latin == 0) {
printf("ERROR: Transliterator::createInstance() failed\n");
exit(1);
}
// Create a custom Transliterator
rbtUnaccent = Transliterator::createFromRules("RBTUnaccent",
UNACCENT_RULES,
UTRANS_FORWARD,
pError,
status);
check(status, "Transliterator::createFromRules");
// Create a custom Transliterator
unaccent = new UnaccentTransliterator();
// 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");
unaccent->transliterate(str2);
printf("Transliterated via normalizer unaccent: ");
uprintf(escape(str2));
printf("\n\n");
}
// Clean up
delete fmt;
delete cal;
delete greek_latin;
delete unaccent;
delete rbtUnaccent;
printf("Exiting successfully\n");
return 0;
}
void Win32DateTimeTest::testLocales(TestLog *log)
{
SYSTEMTIME winNow;
UDate icuNow = 0;
SYSTEMTIME st;
FILETIME ft;
UnicodeString zoneID;
const TimeZone *tz = TimeZone::createDefault();
TIME_ZONE_INFORMATION tzi;
tz->getID(zoneID);
if (! uprv_getWindowsTimeZoneInfo(&tzi, zoneID.getBuffer(), zoneID.length())) {
UBool found = FALSE;
int32_t ec = TimeZone::countEquivalentIDs(zoneID);
for (int z = 0; z < ec; z += 1) {
UnicodeString equiv = TimeZone::getEquivalentID(zoneID, z);
if (found = uprv_getWindowsTimeZoneInfo(&tzi, equiv.getBuffer(), equiv.length())) {
break;
}
}
if (! found) {
GetTimeZoneInformation(&tzi);
}
}
GetSystemTime(&st);
SystemTimeToFileTime(&st, &ft);
SystemTimeToTzSpecificLocalTime(&tzi, &st, &winNow);
int64_t wftNow = ((int64_t) ft.dwHighDateTime << 32) + ft.dwLowDateTime;
UErrorCode status = U_ZERO_ERROR;
int64_t udtsNow = utmscale_fromInt64(wftNow, UDTS_WINDOWS_FILE_TIME, &status);
icuNow = (UDate) utmscale_toInt64(udtsNow, UDTS_ICU4C_TIME, &status);
int32_t lcidCount = 0;
Win32Utilities::LCIDRecord *lcidRecords = Win32Utilities::getLocales(lcidCount);
for(int i = 0; i < lcidCount; i += 1) {
UErrorCode status = U_ZERO_ERROR;
WCHAR longDateFormat[81], longTimeFormat[81], wdBuffer[256], wtBuffer[256];
int32_t calType = 0;
// NULL localeID means ICU didn't recognize this locale
if (lcidRecords[i].localeID == NULL) {
continue;
}
GetLocaleInfoW(lcidRecords[i].lcid, LOCALE_SLONGDATE, longDateFormat, 81);
GetLocaleInfoW(lcidRecords[i].lcid, LOCALE_STIMEFORMAT, longTimeFormat, 81);
GetLocaleInfoW(lcidRecords[i].lcid, LOCALE_RETURN_NUMBER|LOCALE_ICALENDARTYPE, (LPWSTR) calType, sizeof(int32_t));
char localeID[64];
uprv_strcpy(localeID, lcidRecords[i].localeID);
uprv_strcat(localeID, getCalendarType(calType));
UnicodeString ubBuffer, udBuffer, utBuffer;
Locale ulocale(localeID);
int32_t wdLength, wtLength;
wdLength = GetDateFormatW(lcidRecords[i].lcid, DATE_LONGDATE, &winNow, NULL, wdBuffer, UPRV_LENGTHOF(wdBuffer));
wtLength = GetTimeFormatW(lcidRecords[i].lcid, 0, &winNow, NULL, wtBuffer, UPRV_LENGTHOF(wtBuffer));
if (uprv_strchr(localeID, '@') > 0) {
uprv_strcat(localeID, ";");
} else {
uprv_strcat(localeID, "@");
}
uprv_strcat(localeID, "compat=host");
Locale wlocale(localeID);
DateFormat *wbf = DateFormat::createDateTimeInstance(DateFormat::kFull, DateFormat::kFull, wlocale);
DateFormat *wdf = DateFormat::createDateInstance(DateFormat::kFull, wlocale);
DateFormat *wtf = DateFormat::createTimeInstance(DateFormat::kFull, wlocale);
wbf->format(icuNow, ubBuffer);
wdf->format(icuNow, udBuffer);
wtf->format(icuNow, utBuffer);
if (ubBuffer.indexOf(wdBuffer, wdLength - 1, 0) < 0) {
UnicodeString baseName(wlocale.getBaseName());
UnicodeString expected(wdBuffer);
log->errln("DateTime format error for locale " + baseName + ": expected date \"" + expected +
"\" got \"" + ubBuffer + "\"");
}
if (ubBuffer.indexOf(wtBuffer, wtLength - 1, 0) < 0) {
UnicodeString baseName(wlocale.getBaseName());
UnicodeString expected(wtBuffer);
log->errln("DateTime format error for locale " + baseName + ": expected time \"" + expected +
"\" got \"" + ubBuffer + "\"");
}
if (udBuffer.compare(wdBuffer) != 0) {
UnicodeString baseName(wlocale.getBaseName());
UnicodeString expected(wdBuffer);
log->errln("Date format error for locale " + baseName + ": expected \"" + expected +
"\" got \"" + udBuffer + "\"");
}
if (utBuffer.compare(wtBuffer) != 0) {
UnicodeString baseName(wlocale.getBaseName());
UnicodeString expected(wtBuffer);
log->errln("Time format error for locale " + baseName + ": expected \"" + expected +
"\" got \"" + utBuffer + "\"");
}
delete wbf;
delete wdf;
delete wtf;
}
Win32Utilities::freeLocales(lcidRecords);
delete tz;
}
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);
}
