+/**
+ * The search depth for TestExtremeDates. The total number of
+ * dates that will be tested is (2^EXTREME_DATES_DEPTH) - 1.
+ */
+#define EXTREME_DATES_DEPTH 8
+
+/**
+ * Support for TestExtremeDates (below).
+ *
+ * Test a single date to see whether udat_format handles it properly.
+ */
+static UBool _aux1ExtremeDates(UDateFormat* fmt, UDate date,
+ UChar* buf, int32_t buflen, char* cbuf,
+ UErrorCode* ec) {
+ int32_t len = udat_format(fmt, date, buf, buflen, 0, ec);
+ if (!assertSuccess("udat_format", ec)) return FALSE;
+ u_austrncpy(cbuf, buf, buflen);
+ if (len < 4) {
+ log_err("FAIL: udat_format(%g) => \"%s\"\n", date, cbuf);
+ } else {
+ log_verbose("udat_format(%g) => \"%s\"\n", date, cbuf);
+ }
+ return TRUE;
+}
+
+/**
+ * Support for TestExtremeDates (below).
+ *
+ * Recursively test between 'small' and 'large', up to the depth
+ * limit specified by EXTREME_DATES_DEPTH.
+ */
+static UBool _aux2ExtremeDates(UDateFormat* fmt, UDate small, UDate large,
+ UChar* buf, int32_t buflen, char* cbuf,
+ int32_t count,
+ UErrorCode* ec) {
+ /* Logarithmic midpoint; see below */
+ UDate mid = (UDate) exp((log(small) + log(large)) / 2);
+ if (count == EXTREME_DATES_DEPTH) {
+ return TRUE;
+ }
+ return
+ _aux1ExtremeDates(fmt, mid, buf, buflen, cbuf, ec) &&
+ _aux2ExtremeDates(fmt, small, mid, buf, buflen, cbuf, count+1, ec) &&
+ _aux2ExtremeDates(fmt, mid, large, buf, buflen, cbuf, count+1, ec);
+}
+
+/**
+ * http://www.jtcsv.com/cgibin/icu-bugs?findid=3659
+ *
+ * For certain large dates, udat_format crashes on MacOS. This test
+ * attempts to reproduce this problem by doing a recursive logarithmic*
+ * binary search of a predefined interval (from 'small' to 'large').
+ *
+ * The limit of the search is given by EXTREME_DATES_DEPTH, above.
+ *
+ * *The search has to be logarithmic, not linear. A linear search of the
+ * range 0..10^30, for example, will find 0.5*10^30, then 0.25*10^30 and
+ * 0.75*10^30, etc. A logarithmic search will find 10^15, then 10^7.5
+ * and 10^22.5, etc.
+ */
+static void TestExtremeDates() {
+ UDateFormat *fmt;
+ UErrorCode ec;
+ UChar buf[256];
+ char cbuf[256];
+ const double small = 1000; /* 1 sec */
+ const double large = 1e+30; /* well beyond usable UDate range */
+
+ /* There is no need to test larger values from 1e+30 to 1e+300;
+ the failures occur around 1e+27, and never above 1e+30. */
+
+ ec = U_ZERO_ERROR;
+ fmt = udat_open(UDAT_LONG, UDAT_LONG, "en_US",
+ 0, 0, 0, 0, &ec);
+ if (U_FAILURE(ec)) {
+ log_data_err("FAIL: udat_open (%s) (Are you missing data?)\n", u_errorName(ec));
+ return;
+ }
+
+ _aux2ExtremeDates(fmt, small, large, buf, UPRV_LENGTHOF(buf), cbuf, 0, &ec);
+
+ udat_close(fmt);
+}
+
+static void TestAllLocales(void) {
+ int32_t idx, dateIdx, timeIdx, localeCount;
+ static const UDateFormatStyle style[] = {
+ UDAT_FULL, UDAT_LONG, UDAT_MEDIUM, UDAT_SHORT
+ };
+ localeCount = uloc_countAvailable();
+ for (idx = 0; idx < localeCount; idx++) {
+ for (dateIdx = 0; dateIdx < UPRV_LENGTHOF(style); dateIdx++) {
+ for (timeIdx = 0; timeIdx < UPRV_LENGTHOF(style); timeIdx++) {
+ UErrorCode status = U_ZERO_ERROR;
+ udat_close(udat_open(style[dateIdx], style[timeIdx],
+ uloc_getAvailable(idx), NULL, 0, NULL, 0, &status));
+ if (U_FAILURE(status)) {
+ log_err("FAIL: udat_open(%s) failed with (%s) dateIdx=%d, timeIdx=%d\n",
+ uloc_getAvailable(idx), u_errorName(status), dateIdx, timeIdx);
+ }
+ }
+ }
+ }
+}
+
+static void TestRelativeCrash(void) {
+ static const UChar tzName[] = { 0x0055, 0x0053, 0x002F, 0x0050, 0x0061, 0x0063, 0x0069, 0x0066, 0x0069, 0x0063, 0 };
+ static const UDate aDate = -631152000000.0;
+
+ UErrorCode status = U_ZERO_ERROR;
+ UErrorCode expectStatus = U_ILLEGAL_ARGUMENT_ERROR;
+ UDateFormat icudf;
+
+ icudf = udat_open(UDAT_NONE, UDAT_SHORT_RELATIVE, "en", tzName, -1, NULL, 0, &status);
+ if ( U_SUCCESS(status) ) {
+ const char *what = "???";
+ {
+ UErrorCode subStatus = U_ZERO_ERROR;
+ what = "udat_set2DigitYearStart";
+ log_verbose("Trying %s on a relative date..\n", what);
+ udat_set2DigitYearStart(icudf, aDate, &subStatus);
+ if(subStatus == expectStatus) {
+ log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
+ } else {
+ log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
+ }
+ }
+ {
+ /* clone works polymorphically. try it anyways */
+ UErrorCode subStatus = U_ZERO_ERROR;
+ UDateFormat *oth;
+ what = "clone";
+ log_verbose("Trying %s on a relative date..\n", what);
+ oth = udat_clone(icudf, &subStatus);
+ if(subStatus == U_ZERO_ERROR) {
+ log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
+ udat_close(oth); /* ? */
+ } else {
+ log_err("FAIL: didn't crash on %s, but got %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
+ }
+ }
+ {
+ UErrorCode subStatus = U_ZERO_ERROR;
+ what = "udat_get2DigitYearStart";
+ log_verbose("Trying %s on a relative date..\n", what);
+ udat_get2DigitYearStart(icudf, &subStatus);
+ if(subStatus == expectStatus) {
+ log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
+ } else {
+ log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
+ }
+ }
+ {
+ /* Now udat_toPattern works for relative date formatters, unless localized is TRUE */
+ UErrorCode subStatus = U_ZERO_ERROR;
+ what = "udat_toPattern";
+ log_verbose("Trying %s on a relative date..\n", what);
+ udat_toPattern(icudf, TRUE,NULL,0, &subStatus);
+ if(subStatus == expectStatus) {
+ log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
+ } else {
+ log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
+ }
+ }
+ {
+ UErrorCode subStatus = U_ZERO_ERROR;
+ what = "udat_applyPattern";
+ log_verbose("Trying %s on a relative date..\n", what);
+ udat_applyPattern(icudf, FALSE,tzName,-1);
+ subStatus = U_ILLEGAL_ARGUMENT_ERROR; /* what it should be, if this took an errorcode. */
+ if(subStatus == expectStatus) {
+ log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
+ } else {
+ log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
+ }
+ }
+ {
+ UChar erabuf[32];
+ UErrorCode subStatus = U_ZERO_ERROR;
+ what = "udat_getSymbols";
+ log_verbose("Trying %s on a relative date..\n", what);
+ udat_getSymbols(icudf, UDAT_ERAS,0,erabuf,UPRV_LENGTHOF(erabuf), &subStatus);
+ if(subStatus == U_ZERO_ERROR) {
+ log_verbose("Success: %s returned %s.\n", what, u_errorName(subStatus));
+ } else {
+ log_err("FAIL: didn't crash on %s, but got %s instead of U_ZERO_ERROR.\n", what, u_errorName(subStatus));
+ }
+ }
+ {
+ UErrorCode subStatus = U_ZERO_ERROR;
+ UChar symbolValue = 0x0041;
+ what = "udat_setSymbols";
+ log_verbose("Trying %s on a relative date..\n", what);
+ udat_setSymbols(icudf, UDAT_ERAS,0,&symbolValue,1, &subStatus); /* bogus values */
+ if(subStatus == expectStatus) {
+ log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
+ } else {
+ log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
+ }
+ }
+ {
+ UErrorCode subStatus = U_ZERO_ERROR;
+ what = "udat_countSymbols";
+ log_verbose("Trying %s on a relative date..\n", what);
+ udat_countSymbols(icudf, UDAT_ERAS);
+ subStatus = U_ILLEGAL_ARGUMENT_ERROR; /* should have an errorcode. */
+ if(subStatus == expectStatus) {
+ log_verbose("Success: did not crash on %s, but got %s.\n", what, u_errorName(subStatus));
+ } else {
+ log_err("FAIL: didn't crash on %s, but got success %s instead of %s. \n", what, u_errorName(subStatus), u_errorName(expectStatus));
+ }
+ }
+
+ udat_close(icudf);
+ } else {
+ log_data_err("FAIL: err calling udat_open() ->%s (Are you missing data?)\n", u_errorName(status));
+ }
+}
+
+static const UChar skeleton_yMMMM[] = { 0x79,0x4D,0x4D,0x4D,0x4D,0 }; /* "yMMMM"; fr maps to "MMMM y", cs maps to "LLLL y" */
+static const UChar july2008_frDefault[] = { 0x6A,0x75,0x69,0x6C,0x6C,0x65,0x74,0x20,0x32,0x30,0x30,0x38,0 }; /* "juillet 2008" */
+static const UChar july2008_frTitle[] = { 0x4A,0x75,0x69,0x6C,0x6C,0x65,0x74,0x20,0x32,0x30,0x30,0x38,0 }; /* "Juillet 2008" sentence-begin, standalone */
+static const UChar july2008_csDefault[] = { 0x10D,0x65,0x72,0x76,0x65,0x6E,0x65,0x63,0x20,0x32,0x30,0x30,0x38,0 }; /* "c(hacek)ervenec 2008" */
+static const UChar july2008_csTitle[] = { 0x10C,0x65,0x72,0x76,0x65,0x6E,0x65,0x63,0x20,0x32,0x30,0x30,0x38,0 }; /* "C(hacek)ervenec 2008" sentence-begin, uiListOrMenu */
+
+typedef struct {
+ const char * locale;
+ const UChar * skeleton;
+ UDisplayContext capitalizationContext;
+ const UChar * expectedFormat;
+} TestContextItem;
+
+static const TestContextItem textContextItems[] = {
+ { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_NONE, july2008_frDefault },
+#if !UCONFIG_NO_BREAK_ITERATION
+ { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, july2008_frDefault },
+ { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, july2008_frTitle },
+ { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, july2008_frDefault },
+ { "fr", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, july2008_frTitle },
+#endif
+ { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_NONE, july2008_csDefault },
+#if !UCONFIG_NO_BREAK_ITERATION
+ { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, july2008_csDefault },
+ { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, july2008_csTitle },
+ { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, july2008_csTitle },
+ { "cs", skeleton_yMMMM, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, july2008_csDefault },
+#endif
+ { NULL, NULL, (UDisplayContext)0, NULL }
+};
+
+static const UChar today_enDefault[] = { 0x74,0x6F,0x64,0x61,0x79,0 }; /* "today" */
+static const UChar today_enTitle[] = { 0x54,0x6F,0x64,0x61,0x79,0 }; /* "Today" sentence-begin, uiListOrMenu, standalone */
+static const UChar yesterday_enDefault[] = { 0x79,0x65,0x73,0x74,0x65,0x72,0x64,0x61,0x79,0 }; /* "yesterday" */
+static const UChar yesterday_enTitle[] = { 0x59,0x65,0x73,0x74,0x65,0x72,0x64,0x61,0x79,0 }; /* "Yesterday" sentence-begin, uiListOrMenu, standalone */
+static const UChar today_nbDefault[] = { 0x69,0x20,0x64,0x61,0x67,0 }; /* "i dag" */
+static const UChar today_nbTitle[] = { 0x49,0x20,0x64,0x61,0x67,0 }; /* "I dag" sentence-begin, standalone */
+static const UChar yesterday_nbDefault[] = { 0x69,0x20,0x67,0xE5,0x72,0 };
+static const UChar yesterday_nbTitle[] = { 0x49,0x20,0x67,0xE5,0x72,0 };
+
+typedef struct {
+ const char * locale;
+ UDisplayContext capitalizationContext;
+ const UChar * expectedFormatToday;
+ const UChar * expectedFormatYesterday;
+} TestRelativeContextItem;
+
+static const TestRelativeContextItem textContextRelativeItems[] = {
+ { "en", UDISPCTX_CAPITALIZATION_NONE, today_enDefault, yesterday_enDefault },
+#if !UCONFIG_NO_BREAK_ITERATION
+ { "en", UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, today_enDefault, yesterday_enDefault },
+ { "en", UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, today_enTitle, yesterday_enTitle },
+ { "en", UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, today_enTitle, yesterday_enTitle },
+ { "en", UDISPCTX_CAPITALIZATION_FOR_STANDALONE, today_enTitle, yesterday_enTitle },
+#endif
+ { "nb", UDISPCTX_CAPITALIZATION_NONE, today_nbDefault, yesterday_nbDefault },
+#if !UCONFIG_NO_BREAK_ITERATION
+ { "nb", UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, today_nbDefault, yesterday_nbDefault },
+ { "nb", UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, today_nbTitle, yesterday_nbTitle },
+ { "nb", UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, today_nbDefault, yesterday_nbDefault },
+ { "nb", UDISPCTX_CAPITALIZATION_FOR_STANDALONE, today_nbTitle, yesterday_nbTitle },
+#endif
+ { NULL, (UDisplayContext)0, NULL, NULL }
+};
+
+static const UChar january_esDefault[] = { 0x65,0x6E,0x65,0x72,0x6F,0 }; /* "enero" */
+static const UChar january_esTitle[] = { 0x45,0x6E,0x65,0x72,0x6F,0 }; /* "Enero */
+static const UChar monday_daDefault[] = { 0x6D,0x61,0x6E,0x64,0x61,0x67,0 }; /* "mandag" */
+static const UChar monday_daTitle[] = { 0x4D,0x61,0x6E,0x64,0x61,0x67,0 }; /* "Mandag */
+
+typedef struct {
+ const char * locale;
+ UDateFormatSymbolType type;
+ int32_t index;
+ UDisplayContext capitalizationContext;
+ const UChar * expectedFormat;
+} TestSymbolContextItem;
+
+static const TestSymbolContextItem testContextSymbolItems[] = {
+ { "es", UDAT_MONTHS, 0, UDISPCTX_CAPITALIZATION_NONE, january_esDefault },
+#if !UCONFIG_NO_BREAK_ITERATION
+ { "es", UDAT_MONTHS, 0, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, january_esDefault },
+ { "es", UDAT_MONTHS, 0, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, january_esTitle },
+ { "es", UDAT_MONTHS, 0, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, january_esTitle },
+ { "es", UDAT_MONTHS, 0, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, january_esTitle },
+#endif
+ { "da", UDAT_WEEKDAYS, 2, UDISPCTX_CAPITALIZATION_NONE, monday_daDefault },
+#if !UCONFIG_NO_BREAK_ITERATION
+ { "da", UDAT_WEEKDAYS, 2, UDISPCTX_CAPITALIZATION_FOR_MIDDLE_OF_SENTENCE, monday_daDefault },
+ { "da", UDAT_WEEKDAYS, 2, UDISPCTX_CAPITALIZATION_FOR_BEGINNING_OF_SENTENCE, monday_daTitle },
+ { "da", UDAT_WEEKDAYS, 2, UDISPCTX_CAPITALIZATION_FOR_UI_LIST_OR_MENU, monday_daDefault },
+ { "da", UDAT_WEEKDAYS, 2, UDISPCTX_CAPITALIZATION_FOR_STANDALONE, monday_daDefault },
+#endif
+ { NULL, (UDateFormatSymbolType)0, 0, (UDisplayContext)0, NULL }
+};
+
+static const UChar zoneGMT[] = { 0x47,0x4D,0x54,0 }; /* "GMT" */
+static const UDate july022008 = 1215000000000.0;
+enum { kUbufMax = 64, kBbufMax = 3*kUbufMax };
+
+static void TestContext(void) {
+ const TestContextItem* textContextItemPtr;
+ const TestRelativeContextItem* textRelContextItemPtr;
+ const TestSymbolContextItem* testSymContextItemPtr;
+
+ for (textContextItemPtr = textContextItems; textContextItemPtr->locale != NULL; ++textContextItemPtr) {
+ UErrorCode status = U_ZERO_ERROR;
+ UDateTimePatternGenerator* udtpg = udatpg_open(textContextItemPtr->locale, &status);
+ if ( U_SUCCESS(status) ) {
+ UChar ubuf[kUbufMax];
+ int32_t len = udatpg_getBestPattern(udtpg, textContextItemPtr->skeleton, -1, ubuf, kUbufMax, &status);
+ if ( U_SUCCESS(status) ) {
+ UDateFormat* udfmt = udat_open(UDAT_PATTERN, UDAT_PATTERN, textContextItemPtr->locale, zoneGMT, -1, ubuf, len, &status);
+ if ( U_SUCCESS(status) ) {
+ udat_setContext(udfmt, textContextItemPtr->capitalizationContext, &status);
+ if ( U_SUCCESS(status) ) {
+ UDisplayContext getContext;
+ len = udat_format(udfmt, july022008, ubuf, kUbufMax, NULL, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("FAIL: udat_format for locale %s, capitalizationContext %d, status %s\n",
+ textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext, u_errorName(status) );
+ status = U_ZERO_ERROR;
+ } else if (u_strncmp(ubuf, textContextItemPtr->expectedFormat, kUbufMax) != 0) {
+ char bbuf1[kBbufMax];
+ char bbuf2[kBbufMax];
+ log_err("FAIL: udat_format for locale %s, capitalizationContext %d, expected %s, got %s\n",
+ textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext,
+ u_austrncpy(bbuf1,textContextItemPtr->expectedFormat,kUbufMax), u_austrncpy(bbuf2,ubuf,kUbufMax) );
+ }
+ getContext = udat_getContext(udfmt, UDISPCTX_TYPE_CAPITALIZATION, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("FAIL: udat_getContext for locale %s, capitalizationContext %d, status %s\n",
+ textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext, u_errorName(status) );
+ } else if (getContext != textContextItemPtr->capitalizationContext) {
+ log_err("FAIL: udat_getContext for locale %s, capitalizationContext %d, got context %d\n",
+ textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext, (int)getContext );
+ }
+ } else {
+ log_err("FAIL: udat_setContext for locale %s, capitalizationContext %d, status %s\n",
+ textContextItemPtr->locale, (int)textContextItemPtr->capitalizationContext, u_errorName(status) );
+ }
+ udat_close(udfmt);
+ } else {
+ log_data_err("FAIL: udat_open for locale %s, status %s\n", textContextItemPtr->locale, u_errorName(status) );
+ }
+ } else {
+ log_err("FAIL: udatpg_getBestPattern for locale %s, status %s\n", textContextItemPtr->locale, u_errorName(status) );
+ }
+ udatpg_close(udtpg);
+ } else {
+ log_data_err("FAIL: udatpg_open for locale %s, status %s\n", textContextItemPtr->locale, u_errorName(status) );
+ }
+ }
+
+ for (textRelContextItemPtr = textContextRelativeItems; textRelContextItemPtr->locale != NULL; ++textRelContextItemPtr) {
+ UErrorCode status = U_ZERO_ERROR;
+ UCalendar* ucal = ucal_open(zoneGMT, -1, "root", UCAL_GREGORIAN, &status);
+ if ( U_SUCCESS(status) ) {
+ UDateFormat* udfmt = udat_open(UDAT_NONE, UDAT_LONG_RELATIVE, textRelContextItemPtr->locale, zoneGMT, -1, NULL, 0, &status);
+ if ( U_SUCCESS(status) ) {
+ udat_setContext(udfmt, textRelContextItemPtr->capitalizationContext, &status);
+ if ( U_SUCCESS(status) ) {
+ UDate yesterday, today = ucal_getNow();
+ UChar ubuf[kUbufMax];
+ char bbuf1[kBbufMax];
+ char bbuf2[kBbufMax];
+ int32_t len = udat_format(udfmt, today, ubuf, kUbufMax, NULL, &status);
+ (void)len;
+ if ( U_FAILURE(status) ) {
+ log_err("FAIL: udat_format today for locale %s, capitalizationContext %d, status %s\n",
+ textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext, u_errorName(status) );
+ } else if (u_strncmp(ubuf, textRelContextItemPtr->expectedFormatToday, kUbufMax) != 0) {
+ log_err("FAIL: udat_format today for locale %s, capitalizationContext %d, expected %s, got %s\n",
+ textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext,
+ u_austrncpy(bbuf1,textRelContextItemPtr->expectedFormatToday,kUbufMax), u_austrncpy(bbuf2,ubuf,kUbufMax) );
+ }
+ status = U_ZERO_ERROR;
+ ucal_setMillis(ucal, today, &status);
+ ucal_add(ucal, UCAL_DATE, -1, &status);
+ yesterday = ucal_getMillis(ucal, &status);
+ if ( U_SUCCESS(status) ) {
+ len = udat_format(udfmt, yesterday, ubuf, kUbufMax, NULL, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("FAIL: udat_format yesterday for locale %s, capitalizationContext %d, status %s\n",
+ textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext, u_errorName(status) );
+ } else if (u_strncmp(ubuf, textRelContextItemPtr->expectedFormatYesterday, kUbufMax) != 0) {
+ log_err("FAIL: udat_format yesterday for locale %s, capitalizationContext %d, expected %s, got %s\n",
+ textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext,
+ u_austrncpy(bbuf1,textRelContextItemPtr->expectedFormatYesterday,kUbufMax), u_austrncpy(bbuf2,ubuf,kUbufMax) );
+ }
+ }
+ } else {
+ log_err("FAIL: udat_setContext relative for locale %s, capitalizationContext %d, status %s\n",
+ textRelContextItemPtr->locale, (int)textRelContextItemPtr->capitalizationContext, u_errorName(status) );
+ }
+ udat_close(udfmt);
+ } else {
+ log_data_err("FAIL: udat_open relative for locale %s, status %s\n", textRelContextItemPtr->locale, u_errorName(status) );
+ }
+ ucal_close(ucal);
+ } else {
+ log_data_err("FAIL: ucal_open for locale root, status %s\n", u_errorName(status) );
+ }
+ }
+
+ for (testSymContextItemPtr = testContextSymbolItems; testSymContextItemPtr->locale != NULL; ++testSymContextItemPtr) {
+ UErrorCode status = U_ZERO_ERROR;
+ UDateFormat* udfmt = udat_open(UDAT_MEDIUM, UDAT_FULL, testSymContextItemPtr->locale, zoneGMT, -1, NULL, 0, &status);
+ if ( U_SUCCESS(status) ) {
+ udat_setContext(udfmt, testSymContextItemPtr->capitalizationContext, &status);
+ if ( U_SUCCESS(status) ) {
+ UChar ubuf[kUbufMax];
+ int32_t len = udat_getSymbols(udfmt, testSymContextItemPtr->type, testSymContextItemPtr->index, ubuf, kUbufMax, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("FAIL: udat_getSymbols for locale %s, capitalizationContext %d, status %s\n",
+ testSymContextItemPtr->locale, (int)testSymContextItemPtr->capitalizationContext, u_errorName(status) );
+ } else if (u_strncmp(ubuf, testSymContextItemPtr->expectedFormat, kUbufMax) != 0) {
+ char bbuf1[kBbufMax];
+ char bbuf2[kBbufMax];
+ log_err("FAIL: udat_getSymbols for locale %s, capitalizationContext %d, expected %s, got %s\n",
+ testSymContextItemPtr->locale, (int)testSymContextItemPtr->capitalizationContext,
+ u_austrncpy(bbuf1,testSymContextItemPtr->expectedFormat,kUbufMax), u_austrncpy(bbuf2,ubuf,kUbufMax) );
+ }
+ } else {
+ log_err("FAIL: udat_setContext std for locale %s, capitalizationContext %d, status %s\n",
+ testSymContextItemPtr->locale, (int)testSymContextItemPtr->capitalizationContext, u_errorName(status) );
+ }
+ udat_close(udfmt);
+ } else {
+ log_data_err("FAIL: udat_open std for locale %s, status %s\n", testSymContextItemPtr->locale, u_errorName(status) );
+ }
+ }
+}
+
+
+// overrideNumberFormat[i][0] is to tell which field to set,
+// overrideNumberFormat[i][1] is the expected result
+static const char * overrideNumberFormat[][2] = {
+ {"", "\\u521D\\u4E03 \\u521D\\u4E8C"},
+ {"d", "07 \\u521D\\u4E8C"},
+ {"do", "07 \\u521D\\u4E8C"},
+ {"Md", "\\u521D\\u4E03 \\u521D\\u4E8C"},
+ {"MdMMd", "\\u521D\\u4E03 \\u521D\\u4E8C"},
+ {"mixed", "\\u521D\\u4E03 \\u521D\\u4E8C"}
+};
+
+static void TestOverrideNumberFormat(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UChar pattern[50];
+ UChar expected[50];
+ UChar fields[50];
+ char bbuf1[kBbufMax];
+ char bbuf2[kBbufMax];
+ const char* localeString = "zh@numbers=hanidays";
+ UDateFormat* fmt;
+ const UNumberFormat* getter_result;
+ int32_t i;
+
+ u_uastrcpy(fields, "d");
+ u_uastrcpy(pattern,"MM d");
+
+ fmt=udat_open(UDAT_PATTERN, UDAT_PATTERN, "en_US", zoneGMT, -1, pattern, u_strlen(pattern), &status);
+ if (!assertSuccess("udat_open()", &status)) {
+ return;
+ }
+
+ // loop 5 times to check getter/setter
+ for (i = 0; i < 5; i++){
+ UNumberFormat* overrideFmt;
+ overrideFmt = unum_open(UNUM_DEFAULT, NULL, 0, localeString, NULL, &status);
+ assertSuccess("unum_open()", &status);
+ udat_adoptNumberFormatForFields(fmt, fields, overrideFmt, &status);
+ overrideFmt = NULL; // no longer valid
+ assertSuccess("udat_setNumberFormatForField()", &status);
+
+ getter_result = udat_getNumberFormatForField(fmt, 0x0064 /*'d'*/);
+ if(getter_result == NULL) {
+ log_err("FAIL: udat_getNumberFormatForField did not return a valid pointer\n");
+ }
+ }
+ {
+ UNumberFormat* overrideFmt;
+ overrideFmt = unum_open(UNUM_DEFAULT, NULL, 0, localeString, NULL, &status);
+ assertSuccess("unum_open()", &status);
+ udat_setNumberFormat(fmt, overrideFmt); // test the same override NF will not crash
+ unum_close(overrideFmt);
+ }
+ udat_close(fmt);
+
+ for (i=0; i<UPRV_LENGTHOF(overrideNumberFormat); i++){
+ UChar ubuf[kUbufMax];
+ UDateFormat* fmt2;
+ UNumberFormat* overrideFmt2;
+
+ fmt2 =udat_open(UDAT_PATTERN, UDAT_PATTERN,"en_US", zoneGMT, -1, pattern, u_strlen(pattern), &status);
+ assertSuccess("udat_open() with en_US", &status);
+
+ overrideFmt2 = unum_open(UNUM_DEFAULT, NULL, 0, localeString, NULL, &status);
+ assertSuccess("unum_open() in loop", &status);
+
+ u_uastrcpy(fields, overrideNumberFormat[i][0]);
+ u_unescape(overrideNumberFormat[i][1], expected, UPRV_LENGTHOF(expected));
+
+ if ( strcmp(overrideNumberFormat[i][0], "") == 0 ) { // use the one w/o field
+ udat_adoptNumberFormat(fmt2, overrideFmt2);
+ } else if ( strcmp(overrideNumberFormat[i][0], "mixed") == 0 ) { // set 1 field at first but then full override, both(M & d) should be override
+ const char* singleLocale = "en@numbers=hebr";
+ UNumberFormat* singleOverrideFmt;
+ u_uastrcpy(fields, "d");
+
+ singleOverrideFmt = unum_open(UNUM_DEFAULT, NULL, 0, singleLocale, NULL, &status);
+ assertSuccess("unum_open() in mixed", &status);
+
+ udat_adoptNumberFormatForFields(fmt2, fields, singleOverrideFmt, &status);
+ assertSuccess("udat_setNumberFormatForField() in mixed", &status);
+
+ udat_adoptNumberFormat(fmt2, overrideFmt2);
+ } else if ( strcmp(overrideNumberFormat[i][0], "do") == 0 ) { // o is an invalid field
+ udat_adoptNumberFormatForFields(fmt2, fields, overrideFmt2, &status);
+ if(status == U_INVALID_FORMAT_ERROR) {
+ udat_close(fmt2);
+ status = U_ZERO_ERROR;
+ continue;
+ }
+ } else {
+ udat_adoptNumberFormatForFields(fmt2, fields, overrideFmt2, &status);
+ assertSuccess("udat_setNumberFormatForField() in loop", &status);
+ }
+
+ udat_format(fmt2, july022008, ubuf, kUbufMax, NULL, &status);
+ assertSuccess("udat_format() july022008", &status);
+
+ if (u_strncmp(ubuf, expected, kUbufMax) != 0)
+ log_err("fail: udat_format for locale, expected %s, got %s\n",
+ u_austrncpy(bbuf1,expected,kUbufMax), u_austrncpy(bbuf2,ubuf,kUbufMax) );
+
+ udat_close(fmt2);
+ }
+}
+
+/*
+ * Ticket #11523
+ * udat_parse and udat_parseCalendar should have the same error code when given the same invalid input.
+ */
+static void TestParseErrorReturnValue(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UErrorCode expectStatus = U_PARSE_ERROR;
+ UDateFormat* df;
+ UCalendar* cal;
+
+ df = udat_open(UDAT_DEFAULT, UDAT_DEFAULT, NULL, NULL, -1, NULL, -1, &status);
+ if (!assertSuccessCheck("udat_open()", &status, TRUE)) {
+ return;
+ }
+
+ cal = ucal_open(NULL, 0, "en_US", UCAL_GREGORIAN, &status);
+ if (!assertSuccess("ucal_open()", &status)) {
+ return;
+ }
+
+ udat_parse(df, NULL, -1, NULL, &status);
+ if (status != expectStatus) {
+ log_err("%s should have been returned by udat_parse when given an invalid input, instead got - %s\n", u_errorName(expectStatus), u_errorName(status));
+ }
+
+ status = U_ZERO_ERROR;
+ udat_parseCalendar(df, cal, NULL, -1, NULL, &status);
+ if (status != expectStatus) {
+ log_err("%s should have been returned by udat_parseCalendar when given an invalid input, instead got - %s\n", u_errorName(expectStatus), u_errorName(status));
+ }
+
+ ucal_close(cal);
+ udat_close(df);
+}
+
+/*
+ * Ticket #11553
+ * Test new udat_formatForFields, udat_formatCalendarForFields (and UFieldPositionIterator)
+ */
+static const char localeForFields[] = "en_US";
+/* zoneGMT[]defined above */
+static const UDate date2015Feb25 = 1424841000000.0; /* Wednesday, February 25, 2015 at 5:10:00 AM GMT */
+static const UChar patNoFields[] = { 0x0027, 0x0078, 0x0078, 0x0078, 0x0027, 0 }; /* "'xxx'" */
+
+typedef struct {
+ int32_t field;
+ int32_t beginPos;
+ int32_t endPos;
+} FieldsData;
+static const FieldsData expectedFields[] = {
+ { UDAT_DAY_OF_WEEK_FIELD /* 9*/, 0, 9 },
+ { UDAT_MONTH_FIELD /* 2*/, 11, 19 },
+ { UDAT_DATE_FIELD /* 3*/, 20, 22 },
+ { UDAT_YEAR_FIELD /* 1*/, 24, 28 },
+ { UDAT_HOUR1_FIELD /*15*/, 32, 33 },
+#if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR
+ { UDAT_TIME_SEPARATOR_FIELD /*35*/, 33, 34 },
+#endif
+ { UDAT_MINUTE_FIELD /* 6*/, 34, 36 },
+#if UDAT_HAS_PATTERN_CHAR_FOR_TIME_SEPARATOR
+ { UDAT_TIME_SEPARATOR_FIELD /*35*/, 36, 37 },
+#endif
+ { UDAT_SECOND_FIELD /* 7*/, 37, 39 },
+ { UDAT_AM_PM_FIELD /*14*/, 40, 42 },
+ { UDAT_TIMEZONE_FIELD /*17*/, 43, 46 },
+ { -1, -1, -1 },
+};
+
+enum {kUBufFieldsLen = 128, kBBufFieldsLen = 256 };
+
+static void TestFormatForFields(void) {
+ UErrorCode status = U_ZERO_ERROR;
+ UFieldPositionIterator* fpositer = ufieldpositer_open(&status);
+ if ( U_FAILURE(status) ) {
+ log_err("ufieldpositer_open fails, status %s\n", u_errorName(status));
+ } else {
+ UDateFormat* udfmt = udat_open(UDAT_LONG, UDAT_FULL, localeForFields, zoneGMT, -1, NULL, 0, &status);
+ UCalendar* ucal = ucal_open(zoneGMT, -1, localeForFields, UCAL_DEFAULT, &status);
+ if ( U_FAILURE(status) ) {
+ log_data_err("udat_open or ucal_open fails for locale %s, status %s (Are you missing data?)\n", localeForFields, u_errorName(status));
+ } else {
+ int32_t ulen, field, beginPos, endPos;
+ UChar ubuf[kUBufFieldsLen];
+ const FieldsData * fptr;
+
+ status = U_ZERO_ERROR;
+ ulen = udat_formatForFields(udfmt, date2015Feb25, ubuf, kUBufFieldsLen, fpositer, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_formatForFields fails, status %s\n", u_errorName(status));
+ } else {
+ for (fptr = expectedFields; ; fptr++) {
+ field = ufieldpositer_next(fpositer, &beginPos, &endPos);
+ if (field != fptr->field || (field >= 0 && (beginPos != fptr->beginPos || endPos != fptr->endPos))) {
+ if (fptr->field >= 0) {
+ log_err("udat_formatForFields as \"%s\"; expect field %d range %d-%d, get field %d range %d-%d\n",
+ aescstrdup(ubuf, ulen), fptr->field, fptr->beginPos, fptr->endPos, field, beginPos, endPos);
+ } else {
+ log_err("udat_formatForFields as \"%s\"; expect field < 0, get field %d range %d-%d\n",
+ aescstrdup(ubuf, ulen), field, beginPos, endPos);
+ }
+ break;
+ }
+ if (field < 0) {
+ break;
+ }
+ }
+ }
+
+ ucal_setMillis(ucal, date2015Feb25, &status);
+ status = U_ZERO_ERROR;
+ ulen = udat_formatCalendarForFields(udfmt, ucal, ubuf, kUBufFieldsLen, fpositer, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_formatCalendarForFields fails, status %s\n", u_errorName(status));
+ } else {
+ for (fptr = expectedFields; ; fptr++) {
+ field = ufieldpositer_next(fpositer, &beginPos, &endPos);
+ if (field != fptr->field || (field >= 0 && (beginPos != fptr->beginPos || endPos != fptr->endPos))) {
+ if (fptr->field >= 0) {
+ log_err("udat_formatFudat_formatCalendarForFieldsorFields as \"%s\"; expect field %d range %d-%d, get field %d range %d-%d\n",
+ aescstrdup(ubuf, ulen), fptr->field, fptr->beginPos, fptr->endPos, field, beginPos, endPos);
+ } else {
+ log_err("udat_formatCalendarForFields as \"%s\"; expect field < 0, get field %d range %d-%d\n",
+ aescstrdup(ubuf, ulen), field, beginPos, endPos);
+ }
+ break;
+ }
+ if (field < 0) {
+ break;
+ }
+ }
+ }
+
+ udat_applyPattern(udfmt, FALSE, patNoFields, -1);
+ status = U_ZERO_ERROR;
+ ulen = udat_formatForFields(udfmt, date2015Feb25, ubuf, kUBufFieldsLen, fpositer, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_formatForFields with no-field pattern fails, status %s\n", u_errorName(status));
+ } else {
+ field = ufieldpositer_next(fpositer, &beginPos, &endPos);
+ if (field >= 0) {
+ log_err("udat_formatForFields with no-field pattern as \"%s\"; expect field < 0, get field %d range %d-%d\n",
+ aescstrdup(ubuf, ulen), field, beginPos, endPos);
+ }
+ }
+
+ ucal_close(ucal);
+ udat_close(udfmt);
+ }
+ ufieldpositer_close(fpositer);
+ }
+}
+
+static void TestForceGannenNumbering(void) {
+ UErrorCode status;
+ const char* locID = "ja_JP@calendar=japanese";
+ UDate refDate = 600336000000.0; // 1989 Jan 9 Monday = Heisei 1
+ const UChar* testSkeleton = u"yMMMd";
+
+ // Test Gannen year forcing
+ status = U_ZERO_ERROR;
+ UDateTimePatternGenerator* dtpgen = udatpg_open(locID, &status);
+ if (U_FAILURE(status)) {
+ log_data_err("Fail in udatpg_open locale %s: %s", locID, u_errorName(status));
+ } else {
+ UChar pattern[kUbufMax];
+ int32_t patlen = udatpg_getBestPattern(dtpgen, testSkeleton, -1, pattern, kUbufMax, &status);
+ if (U_FAILURE(status)) {
+ log_data_err("Fail in udatpg_getBestPattern locale %s: %s", locID, u_errorName(status));
+ } else {
+ UDateFormat *testFmt = udat_open(UDAT_PATTERN, UDAT_PATTERN, locID, NULL, 0, pattern, patlen, &status);
+ if (U_FAILURE(status)) {
+ log_data_err("Fail in udat_open locale %s: %s", locID, u_errorName(status));
+ } else {
+ UChar testString[kUbufMax];
+ int32_t testStrLen = udat_format(testFmt, refDate, testString, kUbufMax, NULL, &status);
+ if (U_FAILURE(status)) {
+ log_err("Fail in udat_format locale %s: %s", locID, u_errorName(status));
+ } else if (testStrLen < 3 || testString[2] != 0x5143) {
+ char bbuf[kBbufMax];
+ UErrorCode convStatus = U_ZERO_ERROR;
+ u_strToUTF8(bbuf, kBbufMax, NULL, testString, testStrLen, &convStatus);
+ log_err("Formatting year 1 as Gannen, (conv status %s) got %s but expected 3rd char to be 0x5143", u_errorName(convStatus), bbuf);
+ }
+ udat_close(testFmt);
+ }
+ }
+ udatpg_close(dtpgen);
+ }
+}
+
+/* defined above
+static const UChar zoneGMT[] = { 0x47,0x4D,0x54,0 }; // "GMT"
+static const UDate date2015Feb25 = 1424841000000.0; // Wednesday, February 25, 2015 at 5:10:00 AM GMT
+*/
+
+typedef struct {
+ const char * locale;
+ UDateFormatStyle dateStyle;
+ UDateFormatStyle timeStyle;
+ const char * expect; /* for zoneGMT and date2015Feb25 */
+} StandardPatternItem;
+
+static const StandardPatternItem stdPatternItems[] = {
+ { "en_JP", UDAT_MEDIUM, UDAT_SHORT, "Feb 25, 2015 5:10" },
+ { "en_CN", UDAT_MEDIUM, UDAT_SHORT, "Feb 25, 2015 at 5:10 AM" },
+ { "en_TW", UDAT_MEDIUM, UDAT_SHORT, "Feb 25, 2015 at 5:10 AM" },
+ { "en_KR", UDAT_MEDIUM, UDAT_SHORT, "25 Feb 2015 at 5:10 AM" },
+ { NULL, (UDateFormatStyle)0, (UDateFormatStyle)0, NULL } /* terminator */
+};
+
+enum { kUbufStdMax = 64, kBbufStdMax = 3*kUbufStdMax };
+
+static void TestStandardPatterns(void) {
+ const StandardPatternItem* itemPtr;
+ for (itemPtr = stdPatternItems; itemPtr->locale != NULL; itemPtr++) {
+ UErrorCode status = U_ZERO_ERROR;
+ UDateFormat* udfmt = udat_open(itemPtr->timeStyle, itemPtr->dateStyle, itemPtr->locale, zoneGMT, -1, NULL, 0, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_open(%d, %d, \"%s\",...) fails, status %s\n",
+ (int)itemPtr->timeStyle, (int)itemPtr->dateStyle, itemPtr->locale, u_errorName(status));
+ } else {
+ UChar uget[kUbufStdMax];
+ int32_t ugetlen = udat_format(udfmt, date2015Feb25, uget, kUbufStdMax, NULL, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_format for (%d, %d, \"%s\",...) fails, status %s\n",
+ (int)itemPtr->timeStyle, (int)itemPtr->dateStyle, itemPtr->locale, u_errorName(status));
+ } else {
+ UChar uexpect[kUbufStdMax];
+ int32_t uexpectlen = u_unescape(itemPtr->expect, uexpect, kUbufStdMax);
+ if (ugetlen != uexpectlen || u_strncmp(uget, uexpect, uexpectlen) != 0) {
+ char bexpect[kBbufStdMax];
+ char bget[kBbufStdMax];
+ u_austrcpy(bexpect, uexpect);
+ u_austrcpy(bget, uget);
+ log_err("udat_format for (%d, %d, \"%s\",...):\n expect %s\n get %s\n",
+ (int)itemPtr->timeStyle, (int)itemPtr->dateStyle, itemPtr->locale, bexpect, bget);
+ }
+ }
+ udat_close(udfmt);
+ }
+ }
+}
+
+/* defined above
+static const UChar zoneGMT[] = { 0x47,0x4D,0x54,0 }; // "GMT"
+static const UDate date2015Feb25 = 1424841000000.0; // Wednesday, February 25, 2015 at 5:10:00 AM GMT
+*/
+static const UChar patternHmm[] = { 0x48,0x3A,0x6D,0x6D,0 }; /* "H:mm" */
+static const UChar formattedHmm[] = { 0x35,0x3A,0x31,0x30,0 }; /* "5:10" */
+
+enum { kUBufOverrideSepMax = 32, kBBufOverrideSepMax = 64 };
+
+static void TestApplyPatnOverridesTimeSep(void) {
+ UErrorCode status;
+ UDateFormat* udfmt;
+ const char *locale = "da"; /* uses period for time separator */
+ UChar ubuf[kUBufOverrideSepMax];
+ int32_t ulen;
+
+ status = U_ZERO_ERROR;
+ udfmt = udat_open(UDAT_PATTERN, UDAT_PATTERN, locale, zoneGMT, -1, patternHmm, -1, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_open(UDAT_PATTERN, UDAT_PATTERN, \"%s\",...) fails, status %s\n", locale, u_errorName(status));
+ } else {
+ ulen = udat_format(udfmt, date2015Feb25, ubuf, kUBufOverrideSepMax, NULL, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_format fails for UDAT_PATTERN \"%s\", status %s\n", locale, u_errorName(status));
+ } else if (u_strcmp(ubuf, formattedHmm) != 0) {
+ char bbuf[kBBufOverrideSepMax];
+ u_strToUTF8(bbuf, kBBufOverrideSepMax, NULL, ubuf, ulen, &status);
+ log_err("udat_format fails for UDAT_PATTERN \"%s\", expected 5:10, got %s\n", locale, bbuf);
+ }
+ udat_close(udfmt);
+ }
+
+ status = U_ZERO_ERROR;
+ udfmt = udat_open(UDAT_SHORT, UDAT_NONE, locale, zoneGMT, -1, NULL, 0, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_open(UDAT_SHORT, UDAT_NONE, \"%s\",...) fails, status %s\n", locale, u_errorName(status));
+ } else {
+ udat_applyPattern(udfmt, FALSE, patternHmm, -1);
+ ulen = udat_format(udfmt, date2015Feb25, ubuf, kUBufOverrideSepMax, NULL, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_format fails for UDAT_SHORT \"%s\" + applyPattern, status %s\n", locale, u_errorName(status));
+ } else if (u_strcmp(ubuf, formattedHmm) != 0) {
+ char bbuf[kBBufOverrideSepMax];
+ u_strToUTF8(bbuf, kBBufOverrideSepMax, NULL, ubuf, ulen, &status);
+ log_err("udat_format fails for UDAT_SHORT \"%s\" + applyPattern, expected 5:10, got %s\n", locale, bbuf);
+ }
+ udat_close(udfmt);
+ }
+
+}
+
+#define UDATE_SECOND (1000.0)
+#define UDATE_MINUTE (60.0*UDATE_SECOND)
+#define UDATE_HOUR (60.0*UDATE_MINUTE)
+
+static const double dayOffsets[] = {
+ 0.0, /* 00:00:00 */
+ UDATE_SECOND, /* 00:00:01 */
+ UDATE_MINUTE, /* 00:01:00 */
+ UDATE_HOUR, /* 01:00:00 */
+ 11.0*UDATE_HOUR + 59.0*UDATE_MINUTE, /* 11:59:00 */
+ 12.0*UDATE_HOUR, /* 12:00:00 */
+ 12.0*UDATE_HOUR + UDATE_SECOND, /* 12:00:01 */
+ 12.0*UDATE_HOUR + UDATE_MINUTE, /* 12:01:00 */
+ 13.0*UDATE_HOUR, /* 13:00:00 */
+ 23.0*UDATE_HOUR + 59.0*UDATE_MINUTE, /* 23:59:00 */
+};
+enum { kNumDayOffsets = UPRV_LENGTHOF(dayOffsets) };
+
+static const char* ja12HrFmt_hm[kNumDayOffsets] = { /* aK:mm */
+ "\\u5348\\u524D0:00", /* "午前0:00" */
+ "\\u5348\\u524D0:00",
+ "\\u5348\\u524D0:01",
+ "\\u5348\\u524D1:00",
+ "\\u5348\\u524D11:59",
+ "\\u5348\\u5F8C0:00", /* "午後0:00" */
+ "\\u5348\\u5F8C0:00",
+ "\\u5348\\u5F8C0:01", /* "午後0:01" */
+ "\\u5348\\u5F8C1:00",
+ "\\u5348\\u5F8C11:59",
+};
+
+static const char* ja12HrFmt_h[kNumDayOffsets] = { /* aK時 */
+ "\\u5348\\u524D0\\u6642", /* "午前0時" */
+ "\\u5348\\u524D0\\u6642",
+ "\\u5348\\u524D0\\u6642",
+ "\\u5348\\u524D1\\u6642",
+ "\\u5348\\u524D11\\u6642",
+ "\\u5348\\u5F8C0\\u6642", /* "午後0時" */
+ "\\u5348\\u5F8C0\\u6642",
+ "\\u5348\\u5F8C0\\u6642", /* "午後0時" */
+ "\\u5348\\u5F8C1\\u6642",
+ "\\u5348\\u5F8C11\\u6642",
+};
+typedef struct {
+ const char* locale;
+ const char* skeleton;
+ const char ** expected;
+} Test12HrFmtItem;
+
+static const Test12HrFmtItem test12HrFmtItems[] = {
+ { "ja", "hm", ja12HrFmt_hm },
+ { "ja", "h", ja12HrFmt_h },
+ { NULL, NULL, NULL } /* terminator */
+};
+
+enum { kUBufMax = 128, };
+static void Test12HrFormats(void) {
+ const Test12HrFmtItem* itemPtr;
+ for (itemPtr = test12HrFmtItems; itemPtr->locale != NULL; itemPtr++) {
+ UErrorCode status = U_ZERO_ERROR;
+ UCalendar* ucal = ucal_open(NULL, 0, itemPtr->locale, UCAL_DEFAULT, &status);
+ if ( U_FAILURE(status) ) {
+ log_data_err("ucal_open fails for locale %s: status %s (Are you missing data?)\n", itemPtr->locale, u_errorName(status));
+ } else {
+ ucal_clear(ucal);
+ ucal_setDateTime(ucal, 2016, UCAL_JANUARY, 1, 0, 0, 0, &status);
+ UDate baseDate = ucal_getMillis(ucal, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("ucal_setDateTime or ucal_getMillis fails for locale %s: status %s\n", itemPtr->locale, u_errorName(status));
+ } else {
+ UDateTimePatternGenerator* udatpg = udatpg_open(itemPtr->locale, &status);
+ if ( U_FAILURE(status) ) {
+ log_data_err("udatpg_open fails for locale %s: status %s (Are you missing data?)\n", itemPtr->locale, u_errorName(status));
+ } else {
+ UChar ubuf1[kUbufMax], ubuf2[kUbufMax];
+ int32_t ulen1 = u_unescape(itemPtr->skeleton, ubuf1, kUbufMax);
+ int32_t ulen2 = udatpg_getBestPattern(udatpg, ubuf1, ulen1, ubuf2, kUbufMax, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udatpg_getBestPattern fails for locale %s, skeleton %s: status %s\n",
+ itemPtr->locale, itemPtr->skeleton, u_errorName(status));
+ } else {
+ UDateFormat* udat = udat_open(UDAT_PATTERN, UDAT_PATTERN, itemPtr->locale, NULL, 0, ubuf2, ulen2, &status);
+ if ( U_FAILURE(status) ) {
+ log_data_err("udat_open fails for locale %s, skeleton %s: status %s (Are you missing data?)\n",
+ itemPtr->locale, itemPtr->skeleton, u_errorName(status));
+ } else {
+ int32_t iDayOffset;
+ for (iDayOffset = 0; iDayOffset < kNumDayOffsets; iDayOffset++) {
+ status = U_ZERO_ERROR;
+ ulen1 = udat_format(udat, baseDate + dayOffsets[iDayOffset], ubuf1, kUbufMax, NULL, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_format fails for locale %s, skeleton %s, iDayOffset %d: status %s\n",
+ itemPtr->locale, itemPtr->skeleton, iDayOffset, u_errorName(status));
+ } else {
+ ulen2 = u_unescape(itemPtr->expected[iDayOffset], ubuf2, kUbufMax);
+ if (ulen1 != ulen2 || u_strncmp(ubuf1, ubuf2, ulen2) != 0) {
+ char bbuf1[kBbufMax], bbuf2[kBbufMax];
+ u_austrncpy(bbuf1, ubuf1, ulen1);
+ u_austrncpy(bbuf2, ubuf2, ulen2);
+ log_err("udat_format fails for locale %s, skeleton %s, iDayOffset %d:\n expect %s\n get %s\n",
+ itemPtr->locale, itemPtr->skeleton, iDayOffset, bbuf2, bbuf1);
+ }
+ }
+
+ }
+ udat_close(udat);
+ }
+ }
+ udatpg_close(udatpg);
+ }
+ }
+ ucal_close(ucal);
+ }
+ }
+}
+
+#if !U_PLATFORM_HAS_WIN32_API
+/* *** */
+
+typedef struct {
+ const char* locale;
+ UATimeUnitTimePattern patType;
+ const char* expect; /* universal char subset + escaped Unicode chars */
+} TimePatternItem;
+static const TimePatternItem timePatternItems[] = {
+ { "en", UATIMEUNITTIMEPAT_HM, "h:mm" },
+ { "en", UATIMEUNITTIMEPAT_HMS, "h:mm:ss" },
+ { "en", UATIMEUNITTIMEPAT_MS, "m:ss" },
+ { "da", UATIMEUNITTIMEPAT_HM, "h.mm" },
+ { "da", UATIMEUNITTIMEPAT_HMS, "h.mm.ss" },
+ { "da", UATIMEUNITTIMEPAT_MS, "m.ss" },
+ { NULL, 0, NULL }
+};
+
+typedef struct {
+ const char* locale;
+ UATimeUnitStyle width;
+ UATimeUnitListPattern patType;
+ const char* expect; /* universal char subset + escaped Unicode chars */
+} ListPatternItem;
+static const ListPatternItem listPatternItems[] = {
+ { "en", UATIMEUNITSTYLE_FULL, UATIMEUNITLISTPAT_TWO_ONLY, "{0}, {1}" },
+ { "en", UATIMEUNITSTYLE_FULL, UATIMEUNITLISTPAT_END_PIECE, "{0}, {1}" },
+ { "en", UATIMEUNITSTYLE_FULL, UATIMEUNITLISTPAT_MIDDLE_PIECE, "{0}, {1}" },
+ { "en", UATIMEUNITSTYLE_FULL, UATIMEUNITLISTPAT_START_PIECE, "{0}, {1}" },
+ { "en", UATIMEUNITSTYLE_NARROW, UATIMEUNITLISTPAT_TWO_ONLY, "{0} {1}" },
+ { "en", UATIMEUNITSTYLE_NARROW, UATIMEUNITLISTPAT_END_PIECE, "{0} {1}" },
+ { "en", UATIMEUNITSTYLE_NARROW, UATIMEUNITLISTPAT_MIDDLE_PIECE, "{0} {1}" },
+ { "en", UATIMEUNITSTYLE_NARROW, UATIMEUNITLISTPAT_START_PIECE, "{0} {1}" },
+ { "en", UATIMEUNITSTYLE_SHORTER, UATIMEUNITLISTPAT_TWO_ONLY, "{0} {1}" },
+ { "fr", UATIMEUNITSTYLE_FULL, UATIMEUNITLISTPAT_TWO_ONLY, "{0} et {1}" },
+ { "fr", UATIMEUNITSTYLE_FULL, UATIMEUNITLISTPAT_END_PIECE, "{0} et {1}" },
+ { "fr", UATIMEUNITSTYLE_FULL, UATIMEUNITLISTPAT_MIDDLE_PIECE, "{0}, {1}" },
+ { "fr", UATIMEUNITSTYLE_FULL, UATIMEUNITLISTPAT_START_PIECE, "{0}, {1}" },
+ { "fr", UATIMEUNITSTYLE_NARROW, UATIMEUNITLISTPAT_TWO_ONLY, "{0} {1}" },
+ { "fr", UATIMEUNITSTYLE_NARROW, UATIMEUNITLISTPAT_END_PIECE, "{0} {1}" },
+ { "fr", UATIMEUNITSTYLE_NARROW, UATIMEUNITLISTPAT_MIDDLE_PIECE, "{0} {1}" },
+ { "fr", UATIMEUNITSTYLE_NARROW, UATIMEUNITLISTPAT_START_PIECE, "{0} {1}" },
+ { "fr", UATIMEUNITSTYLE_SHORTER, UATIMEUNITLISTPAT_TWO_ONLY, "{0} {1}" },
+ { NULL, 0, 0, NULL }
+};
+
+enum {kUBufTimeUnitLen = 128, kBBufTimeUnitLen = 256 };
+
+static void TestTimeUnitFormat(void) { /* Apple-specific */
+ const TimePatternItem* timePatItemPtr;
+ const ListPatternItem* listPatItemPtr;
+ UChar uActual[kUBufTimeUnitLen];
+ UChar uExpect[kUBufTimeUnitLen];
+
+ for (timePatItemPtr = timePatternItems; timePatItemPtr->locale != NULL; timePatItemPtr++) {
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t ulenActual = uatmufmt_getTimePattern(timePatItemPtr->locale, timePatItemPtr->patType, uActual, kUBufTimeUnitLen, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("uatmufmt_getTimePattern for locale %s, patType %d: status %s\n", timePatItemPtr->locale, (int)timePatItemPtr->patType, u_errorName(status));
+ } else {
+ int32_t ulenExpect = u_unescape(timePatItemPtr->expect, uExpect, kUBufTimeUnitLen);
+ if (ulenActual != ulenExpect || u_strncmp(uActual, uExpect, ulenExpect) != 0) {
+ char bActual[kBBufTimeUnitLen];
+ u_strToUTF8(bActual, kBBufTimeUnitLen, NULL, uActual, ulenActual, &status);
+ log_err("uatmufmt_getTimePattern for locale %s, patType %d: unexpected result %s\n", timePatItemPtr->locale, (int)timePatItemPtr->patType, bActual);
+ }
+ }
+ }
+
+ for (listPatItemPtr = listPatternItems; listPatItemPtr->locale != NULL; listPatItemPtr++) {
+ UErrorCode status = U_ZERO_ERROR;
+ int32_t ulenActual = uatmufmt_getListPattern(listPatItemPtr->locale, listPatItemPtr->width, listPatItemPtr->patType, uActual, kUBufTimeUnitLen, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("uatmufmt_getListPattern for locale %s, width %d, patType %d: status %s\n", listPatItemPtr->locale, (int)listPatItemPtr->width, (int)listPatItemPtr->patType, u_errorName(status));
+ } else {
+ int32_t ulenExpect = u_unescape(listPatItemPtr->expect, uExpect, kUBufTimeUnitLen);
+ if (ulenActual != ulenExpect || u_strncmp(uActual, uExpect, ulenExpect) != 0) {
+ char bActual[kBBufTimeUnitLen];
+ u_strToUTF8(bActual, kBBufTimeUnitLen, NULL, uActual, ulenActual, &status);
+ log_err("uatmufmt_getListPattern for locale %s, width %d, patType %d: unexpected result %s\n", listPatItemPtr->locale, (int)listPatItemPtr->width, (int)listPatItemPtr->patType, bActual);
+ }
+ }
+ }
+
+}
+#endif
+
+typedef enum RemapTesttype {
+ REMAP_TESTTYPE_FULL = UDAT_FULL, // 0
+ REMAP_TESTTYPE_LONG = UDAT_LONG, // 1
+ REMAP_TESTTYPE_MEDIUM = UDAT_MEDIUM, // 2
+ REMAP_TESTTYPE_SHORT = UDAT_SHORT, // 3
+ REMAP_TESTTYPE_LONG_DF = UDAT_LONG + 4, // 5 long time, full date
+ REMAP_TESTTYPE_SHORT_DS = UDAT_SHORT + 16, // 3 short time, short date
+ REMAP_TESTTYPE_SKELETON = -1,
+ REMAP_TESTTYPE_PATTERN = -2,
+} RemapTesttype;
+
+typedef struct {
+ const char * pattern;
+ RemapTesttype testtype;
+ uint32_t options;
+} RemapPatternTestItem;
+
+static const RemapPatternTestItem remapPatItems[] = {
+ { "full", REMAP_TESTTYPE_FULL, 0 },
+ { "full", REMAP_TESTTYPE_FULL, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "full", REMAP_TESTTYPE_FULL, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "long", REMAP_TESTTYPE_LONG, 0 },
+ { "long", REMAP_TESTTYPE_LONG, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "long", REMAP_TESTTYPE_LONG, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "medium", REMAP_TESTTYPE_MEDIUM, 0 },
+ { "medium", REMAP_TESTTYPE_MEDIUM, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "medium", REMAP_TESTTYPE_MEDIUM, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "short", REMAP_TESTTYPE_SHORT, 0 },
+ { "short", REMAP_TESTTYPE_SHORT, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "short", REMAP_TESTTYPE_SHORT, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "long_df", REMAP_TESTTYPE_LONG_DF, 0 },
+ { "long_df", REMAP_TESTTYPE_LONG_DF, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "long_df", REMAP_TESTTYPE_LONG_DF, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "short_ds", REMAP_TESTTYPE_SHORT_DS, 0 },
+ { "short_ds", REMAP_TESTTYPE_SHORT_DS, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "short_ds", REMAP_TESTTYPE_SHORT_DS, UADATPG_FORCE_12_HOUR_CYCLE },
+
+ { "jmmss", REMAP_TESTTYPE_SKELETON, 0 },
+ { "jmmss", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "jmmss", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "jjmmss", REMAP_TESTTYPE_SKELETON, 0 },
+ { "jjmmss", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "jjmmss", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_24_HOUR_CYCLE | UDATPG_MATCH_HOUR_FIELD_LENGTH },
+ { "jjmmss", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "jjmmss", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_12_HOUR_CYCLE | UDATPG_MATCH_HOUR_FIELD_LENGTH },
+ { "Jmm", REMAP_TESTTYPE_SKELETON, 0 },
+ { "Jmm", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "Jmm", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "jmsv", REMAP_TESTTYPE_SKELETON, 0 },
+ { "jmsv", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "jmsv", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "jmsz", REMAP_TESTTYPE_SKELETON, 0 },
+ { "jmsz", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "jmsz", REMAP_TESTTYPE_SKELETON, UADATPG_FORCE_12_HOUR_CYCLE },
+
+ { "h:mm:ss a", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE }, // 12=hour patterns
+ { "h:mm:ss a", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "a'xx'h:mm:ss d MMM y", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "a'xx'h:mm:ss d MMM y", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "EEE, d MMM y 'aha' a'xx'h:mm:ss", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "EEE, d MMM y 'aha' a'xx'h:mm:ss", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "yyMMddhhmmss", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "yyMMddhhmmss", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_24_HOUR_CYCLE },
+
+ { "H:mm:ss", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE }, // 24=hour patterns
+ { "H:mm:ss", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "H:mm:ss d MMM y", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "H:mm:ss d MMM y", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "EEE, d MMM y 'aha' H:mm:ss 'hrs'", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "EEE, d MMM y 'aha' H:mm:ss 'hrs'", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_24_HOUR_CYCLE },
+ { "EEE, d MMM y 'aha' H'h'mm'm'ss", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE },
+ { "EEE, d MMM y 'aha' H'h'mm'm'ss", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_24_HOUR_CYCLE },
+
+ // special cases per bugs
+ { "uuuu-MM-dd HH:mm:ss '+0000'", REMAP_TESTTYPE_PATTERN, UADATPG_FORCE_12_HOUR_CYCLE }, // <rdar://problem/38826484>
+
+ { NULL, (RemapTesttype)0, 0 }
+};
+
+static const char * remapResults_root[] = {
+ "HH:mm:ss zzzz", // full
+ "HH:mm:ss zzzz", // force24
+ "h:mm:ss a zzzz", // force12
+ "HH:mm:ss z", // long
+ "HH:mm:ss z", // force24
+ "h:mm:ss a z", // force12
+ "HH:mm:ss", // medium
+ "HH:mm:ss", // force24
+ "h:mm:ss a", // force12
+ "HH:mm", // short
+ "HH:mm", // force24
+ "h:mm a", // force12
+ "y MMMM d, EEEE HH:mm:ss z", // long_df
+ "y MMMM d, EEEE HH:mm:ss z", // force24
+ "y MMMM d, EEEE h:mm:ss a z", // force12
+ "y-MM-dd HH:mm", // short_ds
+ "y-MM-dd HH:mm", // force24
+ "y-MM-dd h:mm a", // force12
+
+ "HH:mm:ss", // jmmss
+ "HH:mm:ss", // force24
+ "h:mm:ss a", // force12
+ "HH:mm:ss", // jjmmss
+ "HH:mm:ss", // force24
+ "HH:mm:ss", // force24 | match hour field length
+ "h:mm:ss a", // force12
+ "hh:mm:ss a", // force12 | match hour field length
+ "HH:mm", // Jmm
+ "HH:mm", // force24
+ "hh:mm", // force12
+ "HH:mm:ss v", // jmsv
+ "HH:mm:ss v", // force24
+ "h:mm:ss a v", // force12
+ "HH:mm:ss z", // jmsz
+ "HH:mm:ss z", // force24
+ "h:mm:ss a z", // force12
+
+ "h:mm:ss a", // "h:mm:ss"
+ "HH:mm:ss", //
+ "a'xx'h:mm:ss d MMM y", // "a'xx'h:mm:ss d MMM y"
+ "HH:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' h:mm:ss a 'hrs'"
+ "EEE, d MMM y 'aha' HH:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a'xx'h:mm:ss", // "EEE, d MMM y 'aha' a'xx'h:mm:ss"
+ "EEE, d MMM y 'aha' HH:mm:ss", //
+ "yyMMddhhmmss", // "yyMMddhhmmss"
+ "yyMMddHHmmss", //
+
+ "h:mm:ss a", // "H:mm:ss"
+ "H:mm:ss", //
+ "h:mm:ss a d MMM y", // "H:mm:ss d MMM y"
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' H:mm:ss 'hrs'"
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' h'h'mm'm'ss a", // "EEE, d MMM y 'aha' H'h'mm'm'ss"
+ "EEE, d MMM y 'aha' H'h'mm'm'ss", //
+
+ "uuuu-MM-dd h:mm:ss a '+0000'", //
+
+ NULL
+};
+
+static const char * remapResults_en[] = {
+ "h:mm:ss a zzzz", // full
+ "HH:mm:ss zzzz", // force24
+ "h:mm:ss a zzzz", // force12
+ "h:mm:ss a z", // long
+ "HH:mm:ss z", // force24
+ "h:mm:ss a z", // force12
+ "h:mm:ss a", // medium
+ "HH:mm:ss", // force24
+ "h:mm:ss a", // force12
+ "h:mm a", // short
+ "HH:mm", // force24
+ "h:mm a", // force12
+ "EEEE, MMMM d, y 'at' h:mm:ss a z", // long_df
+ "EEEE, MMMM d, y 'at' HH:mm:ss z", // force24
+ "EEEE, MMMM d, y 'at' h:mm:ss a z", // force12
+ "M/d/yy, h:mm a", // short_ds
+ "M/d/yy, HH:mm", // force24
+ "M/d/yy, h:mm a", // force12
+
+ "h:mm:ss a", // jmmss
+ "HH:mm:ss", // force24
+ "h:mm:ss a", // force12
+ "h:mm:ss a", // jjmmss
+ "HH:mm:ss", // force24
+ "HH:mm:ss", // force24 | match hour field length
+ "h:mm:ss a", // force12
+ "hh:mm:ss a", // force12 | match hour field length
+ "hh:mm", // Jmm
+ "HH:mm", // force24
+ "hh:mm", // force12
+ "h:mm:ss a v", // jmsv
+ "HH:mm:ss v", // force24
+ "h:mm:ss a v", // force12
+ "h:mm:ss a z", // jmsz
+ "HH:mm:ss z", // force24
+ "h:mm:ss a z", // force12
+
+ "h:mm:ss a", // "h:mm:ss"
+ "HH:mm:ss", //
+ "a'xx'h:mm:ss d MMM y", // "a'xx'h:mm:ss d MMM y"
+ "HH:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' h:mm:ss a 'hrs'"
+ "EEE, d MMM y 'aha' HH:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a'xx'h:mm:ss", // "EEE, d MMM y 'aha' a'xx'h:mm:ss"
+ "EEE, d MMM y 'aha' HH:mm:ss", //
+ "yyMMddhhmmss", // "yyMMddhhmmss"
+ "yyMMddHHmmss", //
+
+ "h:mm:ss a", // "H:mm:ss"
+ "H:mm:ss", //
+ "h:mm:ss a d MMM y", // "H:mm:ss d MMM y"
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' H:mm:ss 'hrs'"
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' h'h'mm'm'ss a", // "EEE, d MMM y 'aha' H'h'mm'm'ss"
+ "EEE, d MMM y 'aha' H'h'mm'm'ss", //
+
+ "uuuu-MM-dd h:mm:ss a '+0000'", //
+
+ NULL
+};
+
+static const char * remapResults_ja[] = {
+ "H\\u6642mm\\u5206ss\\u79D2 zzzz", // full
+ "H\\u6642mm\\u5206ss\\u79D2 zzzz", // force24
+ "aK:mm:ss zzzz", // force12
+ "H:mm:ss z", // long
+ "H:mm:ss z", // force24
+ "aK:mm:ss z", // force12
+ "H:mm:ss", // medium
+ "H:mm:ss", // force24
+ "aK:mm:ss", // force12
+ "H:mm", // short
+ "H:mm", // force24
+ "aK:mm", // force12
+ "y\\u5E74M\\u6708d\\u65E5 EEEE H:mm:ss z", // long_df
+ "y\\u5E74M\\u6708d\\u65E5 EEEE H:mm:ss z", // force24
+ "y\\u5E74M\\u6708d\\u65E5 EEEE aK:mm:ss z", // force12
+ "y/MM/dd H:mm", // short_ds
+ "y/MM/dd H:mm", // force24
+ "y/MM/dd aK:mm", // force12
+
+ "H:mm:ss", // jmmss
+ "H:mm:ss", // force24
+ "aK:mm:ss", // force12
+ "H:mm:ss", // jjmmss
+ "H:mm:ss", // force24
+ "HH:mm:ss", // force24 | match hour field length
+ "aK:mm:ss", // force12
+ "aKK:mm:ss", // force12 | match hour field length
+ "H:mm", // Jmm
+ "H:mm", // force24
+ "h:mm", // force12
+ "H:mm:ss v", // jmsv
+ "H:mm:ss v", // force24
+ "aK:mm:ss v", // force12
+ "H:mm:ss z", // jmsz
+ "H:mm:ss z", // force24
+ "aK:mm:ss z", // force12
+
+ "h:mm:ss a", // "h:mm:ss"
+ "H:mm:ss", //
+ "a'xx'h:mm:ss d MMM y", // "a'xx'h:mm:ss d MMM y"
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' h:mm:ss a 'hrs'"
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a'xx'h:mm:ss", // "EEE, d MMM y 'aha' a'xx'h:mm:ss"
+ "EEE, d MMM y 'aha' H:mm:ss", //
+ "yyMMddhhmmss", // "yyMMddhhmmss"
+ "yyMMddHHmmss", //
+
+ "aK:mm:ss", // "H:mm:ss"
+ "H:mm:ss", //
+ "aK:mm:ss d MMM y", // "H:mm:ss d MMM y"
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' aK:mm:ss 'hrs'", // "EEE, d MMM y 'aha' H:mm:ss 'hrs'"
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' aK'h'mm'm'ss", // "EEE, d MMM y 'aha' H'h'mm'm'ss"
+ "EEE, d MMM y 'aha' H'h'mm'm'ss", //
+
+ "uuuu-MM-dd aK:mm:ss '+0000'", //
+
+ NULL
+};
+
+static const char * remapResults_ko[] = {
+ "a h\\uC2DC m\\uBD84 s\\uCD08 zzzz", // full
+ "H\\uC2DC m\\uBD84 s\\uCD08 zzzz", // force24
+ "a h\\uC2DC m\\uBD84 s\\uCD08 zzzz", // force12
+ "a h\\uC2DC m\\uBD84 s\\uCD08 z", // long
+ "H\\uC2DC m\\uBD84 s\\uCD08 z", // force24
+ "a h\\uC2DC m\\uBD84 s\\uCD08 z", // force12
+ "a h:mm:ss", // medium
+ "HH:mm:ss", // force24
+ "a h:mm:ss", // force12
+ "a h:mm", // short
+ "HH:mm", // force24
+ "a h:mm", // force12
+ "y\\uB144 M\\uC6D4 d\\uC77C EEEE a h\\uC2DC m\\uBD84 s\\uCD08 z", // long_df
+ "y\\uB144 M\\uC6D4 d\\uC77C EEEE H\\uC2DC m\\uBD84 s\\uCD08 z", // force24
+ "y\\uB144 M\\uC6D4 d\\uC77C EEEE a h\\uC2DC m\\uBD84 s\\uCD08 z", // force12
+ "y. M. d. a h:mm", // short_ds
+ "y. M. d. HH:mm", // force24
+ "y. M. d. a h:mm", // force12
+
+ "a h:mm:ss", // jmmss
+ "HH:mm:ss", // force24
+ "a h:mm:ss", // force12
+ "a h:mm:ss", // jjmmss
+ "HH:mm:ss", // force24
+ "HH:mm:ss", // force24 | match hour field length
+ "a h:mm:ss", // force12
+ "a hh:mm:ss", // force12 | match hour field length
+ "hh:mm", // Jmm
+ "HH:mm", // force24
+ "hh:mm", // force12
+ "a h:mm:ss v", // jmsv
+ "H\\uC2DC m\\uBD84 s\\uCD08 v", // force24
+ "a h:mm:ss v", // force12
+ "a h\\uC2DC m\\uBD84 s\\uCD08 z", // jmsz
+ "H\\uC2DC m\\uBD84 s\\uCD08 z", // force24
+ "a h\\uC2DC m\\uBD84 s\\uCD08 z", // force12
+
+ "h:mm:ss a", // "h:mm:ss"
+ "HH:mm:ss", //
+ "a'xx'h:mm:ss d MMM y", // "a'xx'h:mm:ss d MMM y"
+ "HH:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' h:mm:ss a 'hrs'"
+ "EEE, d MMM y 'aha' HH:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a'xx'h:mm:ss", // "EEE, d MMM y 'aha' a'xx'h:mm:ss"
+ "EEE, d MMM y 'aha' HH:mm:ss", //
+ "yyMMddhhmmss", // "yyMMddhhmmss"
+ "yyMMddHHmmss", //
+
+ "a h:mm:ss", // "H:mm:ss"
+ "H:mm:ss", //
+ "a h:mm:ss d MMM y", // "H:mm:ss d MMM y"
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' a h:mm:ss 'hrs'", // "EEE, d MMM y 'aha' H:mm:ss 'hrs'"
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a h'h'mm'm'ss", // "EEE, d MMM y 'aha' H'h'mm'm'ss"
+ "EEE, d MMM y 'aha' H'h'mm'm'ss", //
+
+ "uuuu-MM-dd a h:mm:ss '+0000'", //
+
+ NULL
+};
+
+static const char * remapResults_th[] = {
+ "H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 zzzz", // full
+ "H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 zzzz", // force24
+ "h:mm:ss a zzzz", // force12
+ "H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 z", // long
+ "H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 z", // force24
+ "h:mm:ss a z", // force12
+ "HH:mm:ss", // medium
+ "HH:mm:ss", // force24
+ "h:mm:ss a", // force12
+ "HH:mm", // short
+ "HH:mm", // force24
+ "h:mm a", // force12
+ "EEEE\\u0E17\\u0E35\\u0E48 d MMMM G y H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 z", // long_df
+ "EEEE\\u0E17\\u0E35\\u0E48 d MMMM G y H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 z", // force24
+ "EEEE\\u0E17\\u0E35\\u0E48 d MMMM G y h:mm:ss a z", // force12
+ "d/M/yy HH:mm", // short_ds
+ "d/M/yy HH:mm", // force24
+ "d/M/yy h:mm a", // force12
+
+ "HH:mm:ss", // jmmss
+ "HH:mm:ss", // force24
+ "h:mm:ss a", // force12
+ "HH:mm:ss", // jjmmss
+ "HH:mm:ss", // force24
+ "HH:mm:ss", // force24 | match hour field length
+ "h:mm:ss a", // force12
+ "hh:mm:ss a", // force12 | match hour field length
+ "HH:mm", // Jmm
+ "HH:mm", // force24
+ "hh:mm", // force12
+ "H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 v", // jmsv
+ "H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 v", // force24
+ "h:mm:ss a v", // force12
+ "H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 z", // jmsz
+ "H \\u0E19\\u0E32\\u0E2C\\u0E34\\u0E01\\u0E32 mm \\u0E19\\u0E32\\u0E17\\u0E35 ss \\u0E27\\u0E34\\u0E19\\u0E32\\u0E17\\u0E35 z", // force24
+ "h:mm:ss a z", // force12
+
+ "h:mm:ss a", // "h:mm:ss"
+ "HH:mm:ss", //
+ "a'xx'h:mm:ss d MMM y", // "a'xx'h:mm:ss d MMM y"
+ "HH:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' h:mm:ss a 'hrs'"
+ "EEE, d MMM y 'aha' HH:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a'xx'h:mm:ss", // "EEE, d MMM y 'aha' a'xx'h:mm:ss"
+ "EEE, d MMM y 'aha' HH:mm:ss", //
+ "yyMMddhhmmss", // "yyMMddhhmmss"
+ "yyMMddHHmmss", //
+
+ "h:mm:ss a", // "H:mm:ss"
+ "H:mm:ss", //
+ "h:mm:ss a d MMM y", // "H:mm:ss d MMM y"
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' H:mm:ss 'hrs'"
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' h'h'mm'm'ss a", // "EEE, d MMM y 'aha' H'h'mm'm'ss"
+ "EEE, d MMM y 'aha' H'h'mm'm'ss", //
+
+ "uuuu-MM-dd h:mm:ss a '+0000'", //
+
+ NULL
+};
+
+static const char * remapResults_hi[] = {
+ "a h:mm:ss zzzz", // full
+ "HH:mm:ss zzzz", // force24
+ "a h:mm:ss zzzz", // force12
+ "a h:mm:ss z", // long
+ "HH:mm:ss z", // force24
+ "a h:mm:ss z", // force12
+ "a h:mm:ss", // medium
+ "HH:mm:ss", // force24
+ "a h:mm:ss", // force12
+ "a h:mm", // short
+ "HH:mm", // force24
+ "a h:mm", // force12
+ "EEEE, d MMMM y, a h:mm:ss z", // long_df
+ "EEEE, d MMMM y, HH:mm:ss z", // force24
+ "EEEE, d MMMM y, a h:mm:ss z", // force12
+ "d/M/yy, a h:mm", // short_ds
+ "d/M/yy, HH:mm", // force24
+ "d/M/yy, a h:mm", // force12
+
+ "a h:mm:ss", // jmmss
+ "HH:mm:ss", // force24
+ "a h:mm:ss", // force12
+ "a h:mm:ss", // jjmmss
+ "HH:mm:ss", // force24
+ "HH:mm:ss", // force24 | match hour field length
+ "a h:mm:ss", // force12
+ "a hh:mm:ss", // force12 | match hour field length
+ "hh:mm", // Jmm
+ "HH:mm", // force24
+ "hh:mm", // force12
+ "a h:mm:ss v", // jmsv
+ "HH:mm:ss v", // force24
+ "a h:mm:ss v", // force12
+ "a h:mm:ss z", // jmsz
+ "HH:mm:ss z", // force24
+ "a h:mm:ss z", // force12
+
+ "h:mm:ss a", // "h:mm:ss"
+ "HH:mm:ss", //
+ "a'xx'h:mm:ss d MMM y", // "a'xx'h:mm:ss d MMM y"
+ "HH:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' h:mm:ss a 'hrs'"
+ "EEE, d MMM y 'aha' HH:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a'xx'h:mm:ss", // "EEE, d MMM y 'aha' a'xx'h:mm:ss"
+ "EEE, d MMM y 'aha' HH:mm:ss", //
+ "yyMMddhhmmss", // "yyMMddhhmmss"
+ "yyMMddHHmmss", //
+
+ "a h:mm:ss", // "H:mm:ss"
+ "H:mm:ss", //
+ "a h:mm:ss d MMM y", // "H:mm:ss d MMM y"
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' a h:mm:ss 'hrs'", // "EEE, d MMM y 'aha' H:mm:ss 'hrs'"
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a h'h'mm'm'ss", // "EEE, d MMM y 'aha' H'h'mm'm'ss"
+ "EEE, d MMM y 'aha' H'h'mm'm'ss", //
+
+ "uuuu-MM-dd a h:mm:ss '+0000'", //
+
+ NULL
+};
+
+static const char * remapResults_ar[] = {
+ "h:mm:ss\\u00A0a zzzz", // full
+ "HH:mm:ss zzzz", // force24
+ "h:mm:ss\\u00A0a zzzz", // force12
+ "h:mm:ss\\u00A0a z", // long
+ "HH:mm:ss z", // force24
+ "h:mm:ss\\u00A0a z", // force12
+ "h:mm:ss\\u00A0a", // medium
+ "HH:mm:ss", // force24
+ "h:mm:ss\\u00A0a", // force12
+ "h:mm\\u00A0a", // short
+ "HH:mm", // force24
+ "h:mm\\u00A0a", // force12
+ "EEEE\\u060C d MMMM\\u060C y\\u060C h:mm:ss\\u00A0a z", // long_df
+ "EEEE\\u060C d MMMM\\u060C y\\u060C HH:mm:ss z", // force24
+ "EEEE\\u060C d MMMM\\u060C y\\u060C h:mm:ss\\u00A0a z", // force12
+ "d\\u200F/M\\u200F/y\\u060C h:mm\\u00A0a", // short_ds
+ "d\\u200F/M\\u200F/y\\u060C HH:mm", // force24
+ "d\\u200F/M\\u200F/y\\u060C h:mm\\u00A0a", // force12
+
+ "h:mm:ss\\u00A0a", // jmmss
+ "HH:mm:ss", // force24
+ "h:mm:ss\\u00A0a", // force12
+ "h:mm:ss\\u00A0a", // jjmmss
+ "HH:mm:ss", // force24
+ "HH:mm:ss", // force24 | match hour field length
+ "h:mm:ss\\u00A0a", // force12
+ "hh:mm:ss\\u00A0a", // force12 | match hour field length
+ "hh:mm", // Jmm
+ "HH:mm", // force24
+ "hh:mm", // force12
+ "h:mm:ss\\u00A0a v", // jmsv
+ "HH:mm:ss v", // force24
+ "h:mm:ss\\u00A0a v", // force12
+ "h:mm:ss\\u00A0a z", // jmsz
+ "HH:mm:ss z", // force24
+ "h:mm:ss\\u00A0a z", // force12
+
+ "h:mm:ss a", // "h:mm:ss"
+ "HH:mm:ss", //
+ "a'xx'h:mm:ss d MMM y", // "a'xx'h:mm:ss d MMM y"
+ "HH:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' h:mm:ss a 'hrs'"
+ "EEE, d MMM y 'aha' HH:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a'xx'h:mm:ss", // "EEE, d MMM y 'aha' a'xx'h:mm:ss"
+ "EEE, d MMM y 'aha' HH:mm:ss", //
+ "yyMMddhhmmss", // "yyMMddhhmmss"
+ "yyMMddHHmmss", //
+
+ "h:mm:ssa", // "H:mm:ss" (should there be \\u00A0 before a?)
+ "H:mm:ss", //
+ "h:mm:ssa d MMM y", // "H:mm:ss d MMM y" (should there be \\u00A0 before a?)
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ssa 'hrs'", // "EEE, d MMM y 'aha' H:mm:ss 'hrs'" (should there be \\u00A0 before a?)
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' h'h'mm'm'ssa", // "EEE, d MMM y 'aha' H'h'mm'm'ss" (should there be \\u00A0 before a?)
+ "EEE, d MMM y 'aha' H'h'mm'm'ss", //
+
+ "uuuu-MM-dd h:mm:ss\\u00A0a '+0000'", //
+
+ NULL
+};
+
+static const char * remapResults_en_IL[] = {
+ "H:mm:ss zzzz", // full
+ "H:mm:ss zzzz", // force24
+ "h:mm:ss a zzzz", // force12
+ "H:mm:ss z", // long
+ "H:mm:ss z", // force24
+ "h:mm:ss a z", // force12
+ "H:mm:ss", // medium
+ "H:mm:ss", // force24
+ "h:mm:ss a", // force12
+ "H:mm", // short
+ "H:mm", // force24
+ "h:mm a", // force12
+ "EEEE, d MMMM y 'at' H:mm:ss z", // long_df
+ "EEEE, d MMMM y 'at' H:mm:ss z", // force24
+ "EEEE, d MMMM y 'at' h:mm:ss a z", // force12
+ "dd/MM/y, H:mm", // short_ds
+ "dd/MM/y, H:mm", // force24
+ "dd/MM/y, h:mm a", // force12
+
+ "H:mm:ss", // jmmss
+ "H:mm:ss", // force24
+ "h:mm:ss a", // force12
+ "H:mm:ss", // jjmmss
+ "H:mm:ss", // force24
+ "HH:mm:ss", // force24 | match hour field length
+ "h:mm:ss a", // force12
+ "hh:mm:ss a", // force12 | match hour field length
+ "H:mm", // Jmm
+ "H:mm", // force24
+ "h:mm", // force12
+ "H:mm:ss v", // jmsv
+ "H:mm:ss v", // force24
+ "h:mm:ss a v", // force12
+ "H:mm:ss z", // jmsz
+ "H:mm:ss z", // force24
+ "h:mm:ss a z", // force12
+
+ "h:mm:ss a", // "h:mm:ss"
+ "H:mm:ss", //
+ "a'xx'h:mm:ss d MMM y", // "a'xx'h:mm:ss d MMM y"
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' h:mm:ss a 'hrs'"
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' a'xx'h:mm:ss", // "EEE, d MMM y 'aha' a'xx'h:mm:ss"
+ "EEE, d MMM y 'aha' H:mm:ss", //
+ "yyMMddhhmmss", // "yyMMddhhmmss"
+ "yyMMddHHmmss", //
+
+ "h:mm:ss a", // "H:mm:ss"
+ "H:mm:ss", //
+ "h:mm:ss a d MMM y", // "H:mm:ss d MMM y"
+ "H:mm:ss d MMM y", //
+ "EEE, d MMM y 'aha' h:mm:ss a 'hrs'", // "EEE, d MMM y 'aha' H:mm:ss 'hrs'"
+ "EEE, d MMM y 'aha' H:mm:ss 'hrs'", //
+ "EEE, d MMM y 'aha' h'h'mm'm'ss a", // "EEE, d MMM y 'aha' H'h'mm'm'ss"
+ "EEE, d MMM y 'aha' H'h'mm'm'ss", //
+
+ "uuuu-MM-dd h:mm:ss a '+0000'", //
+
+ NULL
+};
+
+typedef struct {
+ const char * locale;
+ const char ** resultsPtr;
+} RemapPatternLocaleResults;
+
+static const RemapPatternLocaleResults remapLocResults[] = {
+ { "root", remapResults_root },
+ { "en", remapResults_en },
+ { "ja", remapResults_ja },
+ { "ko", remapResults_ko },
+ { "th", remapResults_th },
+ { "hi", remapResults_hi },
+ { "ar", remapResults_ar },
+ { "en_IL", remapResults_en_IL },
+ { NULL, NULL }
+};
+
+enum { kUBufRemapMax = 64, kBBufRemapMax = 128 };
+
+static void TestRemapPatternWithOpts(void) { /* Apple-specific */
+ const RemapPatternLocaleResults * locResPtr;
+ for (locResPtr = remapLocResults; locResPtr->locale != NULL; locResPtr++) {
+ UErrorCode status = U_ZERO_ERROR;
+ UDateTimePatternGenerator* dtpg = udatpg_open(locResPtr->locale, &status);
+ if ( U_FAILURE(status) ) {
+ log_data_err("udatpg_open fails for locale %s, status %s (Are you missing data?)\n", locResPtr->locale, u_errorName(status));
+ } else {
+ const RemapPatternTestItem * testItemPtr = remapPatItems;
+ const char ** expResultsPtr = locResPtr->resultsPtr;
+ for (; testItemPtr->pattern != NULL && *expResultsPtr != NULL; testItemPtr++, expResultsPtr++) {
+ UChar uskel[kUBufRemapMax];
+ UChar upatn[kUBufRemapMax];
+ UChar uget[kUBufRemapMax];
+ UChar uexp[kUBufRemapMax];
+ int32_t uelen, ulen = 0;
+
+ status = U_ZERO_ERROR;
+ if (testItemPtr->testtype >= 0) {
+ UDateFormatStyle timeStyle = (UDateFormatStyle)((int32_t)testItemPtr->testtype & 0x03);
+ UDateFormatStyle dateStyle = (UDateFormatStyle)((((int32_t)testItemPtr->testtype >> 2) & 0x07) - 1);
+ UDateFormat* dfmt = udat_open(timeStyle, dateStyle, locResPtr->locale, NULL, 0, NULL, 0, &status);
+ if ( U_FAILURE(status) ) {
+ log_data_err("udat_open fails for locale %s, status %s (Are you missing data?)\n", locResPtr->locale, u_errorName(status));
+ continue;
+ } else {
+ ulen = udat_toPattern(dfmt, FALSE, upatn, kUBufRemapMax, &status);
+ udat_close(dfmt);
+ if ( U_FAILURE(status) ) {
+ log_err("udat_toPattern fails for locale %s, status %s\n", locResPtr->locale, u_errorName(status));
+ continue;
+ }
+ }
+ } else if (testItemPtr->testtype == REMAP_TESTTYPE_SKELETON) {
+ u_strFromUTF8(uskel, kUBufRemapMax, &ulen, testItemPtr->pattern, -1, &status);
+ ulen = udatpg_getBestPatternWithOptions(dtpg, uskel, ulen, (UDateTimePatternMatchOptions)testItemPtr->options, upatn, kUBufRemapMax, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("udatpg_getBestPatternWithOptions fails for locale %s, skeleton \"%s\": status %s\n", locResPtr->locale, testItemPtr->pattern, u_errorName(status));
+ continue;
+ }
+ } else {
+ ulen = u_unescape(testItemPtr->pattern, upatn, kUBufRemapMax);
+ }
+ uelen = u_unescape(*expResultsPtr, uexp, kUBufRemapMax);
+ ulen = uadatpg_remapPatternWithOptions(dtpg, upatn, ulen, (UDateTimePatternMatchOptions)testItemPtr->options, uget, kUBufRemapMax, &status);
+ if ( U_FAILURE(status) ) {
+ log_err("uadatpg_remapPatternWithOptions fails for locale %s pattern \"%s\" opts %08X: status %s\n",
+ locResPtr->locale, testItemPtr->pattern, testItemPtr->options, u_errorName(status));
+ } else if (uelen != ulen || u_strncmp(uget, uexp, ulen) != 0) {
+ char bebuf[kBBufRemapMax];
+ char bbuf[kBBufRemapMax];
+ UErrorCode tempStatus = U_ZERO_ERROR;
+ u_strToUTF8(bebuf, kBBufRemapMax, NULL, uexp, uelen, &tempStatus);
+ u_strToUTF8(bbuf, kBBufRemapMax, NULL, uget, ulen, &tempStatus);
+ log_err("uadatpg_remapPatternWithOptions for locale %s pattern \"%s\" opts %08X: expect \"%s\", get \"%s\"\n",
+ locResPtr->locale, testItemPtr->pattern, testItemPtr->options, bebuf, bbuf);
+ }
+ }
+ udatpg_close(dtpg);
+ }
+ }
+}
+
projects / apple / icu.git / blobdiff