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); }