+ const char* names[] = {
+ " (spellout) ",
+ " (ordinal) "
+ // " (duration) " // This is English only, and it's not really supported in CLDR anymore.
+ };
+ double numbers[] = {45.678, 1, 2, 10, 11, 100, 110, 200, 1000, 1111, -1111};
+
+ int32_t count = 0;
+ const Locale* locales = Locale::getAvailableLocales(count);
+ for (int i = 0; i < count; ++i) {
+ const Locale* loc = &locales[i];
+
+ for (int j = 0; j < 2; ++j) {
+ UErrorCode status = U_ZERO_ERROR;
+ RuleBasedNumberFormat* f = new RuleBasedNumberFormat((URBNFRuleSetTag)j, *loc, status);
+
+ if (status == U_USING_DEFAULT_WARNING || status == U_USING_FALLBACK_WARNING) {
+ // Skip it.
+ delete f;
+ break;
+ }
+ if (U_FAILURE(status)) {
+ errln(UnicodeString(loc->getName()) + names[j]
+ + "ERROR could not instantiate -> " + u_errorName(status));
+ continue;
+ }
+#if !UCONFIG_NO_COLLATION
+ for (unsigned int numidx = 0; numidx < UPRV_LENGTHOF(numbers); numidx++) {
+ double n = numbers[numidx];
+ UnicodeString str;
+ f->format(n, str);
+
+ if (verbose) {
+ logln(UnicodeString(loc->getName()) + names[j]
+ + "success: " + n + " -> " + str);
+ }
+
+ // We do not validate the result in this test case,
+ // because there are cases which do not round trip by design.
+ Formattable num;
+
+ // regular parse
+ status = U_ZERO_ERROR;
+ f->setLenient(FALSE);
+ f->parse(str, num, status);
+ if (U_FAILURE(status)) {
+ errln(UnicodeString(loc->getName()) + names[j]
+ + "ERROR could not parse '" + str + "' -> " + u_errorName(status));
+ }
+ // We only check the spellout. The behavior is undefined for numbers < 1 and fractional numbers.
+ if (j == 0) {
+ if (num.getType() == Formattable::kLong && num.getLong() != n) {
+ errln(UnicodeString(loc->getName()) + names[j]
+ + UnicodeString("ERROR could not roundtrip ") + n
+ + UnicodeString(" -> ") + str + UnicodeString(" -> ") + num.getLong());
+ }
+ else if (num.getType() == Formattable::kDouble && (int64_t)(num.getDouble() * 1000) != (int64_t)(n*1000)) {
+ // The epsilon difference is too high.
+ errln(UnicodeString(loc->getName()) + names[j]
+ + UnicodeString("ERROR could not roundtrip ") + n
+ + UnicodeString(" -> ") + str + UnicodeString(" -> ") + num.getDouble());
+ }
+ }
+ if (!quick && !logKnownIssue("9503") ) {
+ // lenient parse
+ status = U_ZERO_ERROR;
+ f->setLenient(TRUE);
+ f->parse(str, num, status);
+ if (U_FAILURE(status)) {
+ errln(UnicodeString(loc->getName()) + names[j]
+ + "ERROR could not parse(lenient) '" + str + "' -> " + u_errorName(status));
+ }
+ // We only check the spellout. The behavior is undefined for numbers < 1 and fractional numbers.
+ if (j == 0) {
+ if (num.getType() == Formattable::kLong && num.getLong() != n) {
+ errln(UnicodeString(loc->getName()) + names[j]
+ + UnicodeString("ERROR could not roundtrip ") + n
+ + UnicodeString(" -> ") + str + UnicodeString(" -> ") + num.getLong());
+ }
+ else if (num.getType() == Formattable::kDouble && (int64_t)(num.getDouble() * 1000) != (int64_t)(n*1000)) {
+ // The epsilon difference is too high.
+ errln(UnicodeString(loc->getName()) + names[j]
+ + UnicodeString("ERROR could not roundtrip ") + n
+ + UnicodeString(" -> ") + str + UnicodeString(" -> ") + num.getDouble());
+ }
+ }
+ }
+ }
+#endif
+ delete f;
+ }
+ }
+}
+
+void
+IntlTestRBNF::TestMultiplierSubstitution(void) {
+ UnicodeString rules("=#,##0=;1,000,000: <##0.###< million;");
+ UErrorCode status = U_ZERO_ERROR;
+ UParseError parse_error;
+ RuleBasedNumberFormat *rbnf =
+ new RuleBasedNumberFormat(rules, Locale::getUS(), parse_error, status);
+ if (U_SUCCESS(status)) {
+ UnicodeString res;
+ FieldPosition pos;
+ double n = 1234000.0;
+ rbnf->format(n, res, pos);
+ delete rbnf;
+
+ UnicodeString expected(UNICODE_STRING_SIMPLE("1.234 million"));
+ if (expected != res) {
+ UnicodeString msg = "Expected: ";
+ msg.append(expected);
+ msg.append(" but got ");
+ msg.append(res);
+ errln(msg);
+ }
+ }
+}
+
+void
+IntlTestRBNF::TestSetDecimalFormatSymbols() {
+ UErrorCode status = U_ZERO_ERROR;
+
+ RuleBasedNumberFormat rbnf(URBNF_ORDINAL, Locale::getEnglish(), status);
+ if (U_FAILURE(status)) {
+ dataerrln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_errorName(status)));
+ return;
+ }
+
+ DecimalFormatSymbols dfs(Locale::getEnglish(), status);
+ if (U_FAILURE(status)) {
+ errln("Unable to create DecimalFormatSymbols - " + UnicodeString(u_errorName(status)));
+ return;
+ }
+
+ UnicodeString expected[] = {
+ UnicodeString("1,001st"),
+ UnicodeString("1&001st")
+ };
+
+ double number = 1001;
+
+ UnicodeString result;
+
+ rbnf.format(number, result);
+ if (result != expected[0]) {
+ errln("Format Error - Got: " + result + " Expected: " + expected[0]);
+ }
+
+ result.remove();
+
+ /* Set new symbol for testing */
+ dfs.setSymbol(DecimalFormatSymbols::kGroupingSeparatorSymbol, UnicodeString("&"), TRUE);
+ rbnf.setDecimalFormatSymbols(dfs);
+
+ rbnf.format(number, result);
+ if (result != expected[1]) {
+ errln("Format Error - Got: " + result + " Expected: " + expected[1]);
+ }
+}
+
+void IntlTestRBNF::TestPluralRules() {
+ UErrorCode status = U_ZERO_ERROR;
+ UnicodeString enRules("%digits-ordinal:-x: ->>;0: =#,##0=$(ordinal,one{st}two{nd}few{rd}other{th})$;");
+ UParseError parseError;
+ RuleBasedNumberFormat enFormatter(enRules, Locale::getEnglish(), parseError, status);
+ if (U_FAILURE(status)) {
+ dataerrln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_errorName(status)));
+ return;
+ }
+ const char* const enTestData[][2] = {
+ { "1", "1st" },
+ { "2", "2nd" },
+ { "3", "3rd" },
+ { "4", "4th" },
+ { "11", "11th" },
+ { "12", "12th" },
+ { "13", "13th" },
+ { "14", "14th" },
+ { "21", "21st" },
+ { "22", "22nd" },
+ { "23", "23rd" },
+ { "24", "24th" },
+ { NULL, NULL }
+ };
+
+ doTest(&enFormatter, enTestData, TRUE);
+
+ // This is trying to model the feminine form, but don't worry about the details too much.
+ // We're trying to test the plural rules.
+ UnicodeString ruRules("%spellout-numbering:"
+ "-x: minus >>;"
+ "x.x: << point >>;"
+ "0: zero;"
+ "1: one;"
+ "2: two;"
+ "3: three;"
+ "4: four;"
+ "5: five;"
+ "6: six;"
+ "7: seven;"
+ "8: eight;"
+ "9: nine;"
+ "10: ten;"
+ "11: eleven;"
+ "12: twelve;"
+ "13: thirteen;"
+ "14: fourteen;"
+ "15: fifteen;"
+ "16: sixteen;"
+ "17: seventeen;"
+ "18: eighteen;"
+ "19: nineteen;"
+ "20: twenty[->>];"
+ "30: thirty[->>];"
+ "40: forty[->>];"
+ "50: fifty[->>];"
+ "60: sixty[->>];"
+ "70: seventy[->>];"
+ "80: eighty[->>];"
+ "90: ninety[->>];"
+ "100: hundred[ >>];"
+ "200: << hundred[ >>];"
+ "300: << hundreds[ >>];"
+ "500: << hundredss[ >>];"
+ "1000: << $(cardinal,one{thousand}few{thousands}other{thousandss})$[ >>];"
+ "1000000: << $(cardinal,one{million}few{millions}other{millionss})$[ >>];");
+ RuleBasedNumberFormat ruFormatter(ruRules, Locale("ru"), parseError, status);
+ const char* const ruTestData[][2] = {
+ { "1", "one" },
+ { "100", "hundred" },
+ { "125", "hundred twenty-five" },
+ { "399", "three hundreds ninety-nine" },
+ { "1,000", "one thousand" },
+ { "1,001", "one thousand one" },
+ { "2,000", "two thousands" },
+ { "2,001", "two thousands one" },
+ { "2,002", "two thousands two" },
+ { "3,333", "three thousands three hundreds thirty-three" },
+ { "5,000", "five thousandss" },
+ { "11,000", "eleven thousandss" },
+ { "21,000", "twenty-one thousand" },
+ { "22,000", "twenty-two thousands" },
+ { "25,001", "twenty-five thousandss one" },
+ { NULL, NULL }
+ };
+
+ if (U_FAILURE(status)) {
+ errln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_errorName(status)));
+ return;
+ }
+ doTest(&ruFormatter, ruTestData, TRUE);
+
+ // Make sure there are no divide by 0 errors.
+ UnicodeString result;
+ RuleBasedNumberFormat(ruRules, Locale("ru"), parseError, status).format((int32_t)21000, result);
+ if (result.compare(UNICODE_STRING_SIMPLE("twenty-one thousand")) != 0) {
+ errln("Got " + result + " for 21000");
+ }
+
+}
+
+void IntlTestRBNF::TestInfinityNaN() {
+ UErrorCode status = U_ZERO_ERROR;
+ UParseError parseError;
+ UnicodeString enRules("%default:"
+ "-x: minus >>;"
+ "Inf: infinite;"
+ "NaN: not a number;"
+ "0: =#,##0=;");
+ RuleBasedNumberFormat enFormatter(enRules, Locale::getEnglish(), parseError, status);
+ const char * const enTestData[][2] = {
+ {"1", "1"},
+ {"\\u221E", "infinite"},
+ {"-\\u221E", "minus infinite"},
+ {"NaN", "not a number"},
+ { NULL, NULL }
+ };
+ if (U_FAILURE(status)) {
+ dataerrln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_errorName(status)));
+ return;
+ }
+
+ doTest(&enFormatter, enTestData, true);
+
+ // Test the default behavior when the rules are undefined.
+ UnicodeString enRules2("%default:"
+ "-x: ->>;"
+ "0: =#,##0=;");
+ RuleBasedNumberFormat enFormatter2(enRules2, Locale::getEnglish(), parseError, status);
+ if (U_FAILURE(status)) {
+ errln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_errorName(status)));
+ return;
+ }
+ const char * const enDefaultTestData[][2] = {
+ {"1", "1"},
+ {"\\u221E", "\\u221E"},
+ {"-\\u221E", "-\\u221E"},
+ {"NaN", "NaN"},
+ { NULL, NULL }
+ };
+
+ doTest(&enFormatter2, enDefaultTestData, true);
+}
+
+void IntlTestRBNF::TestVariableDecimalPoint() {
+ UErrorCode status = U_ZERO_ERROR;
+ UParseError parseError;
+ UnicodeString enRules("%spellout-numbering:"
+ "-x: minus >>;"
+ "x.x: << point >>;"
+ "x,x: << comma >>;"
+ "0.x: xpoint >>;"
+ "0,x: xcomma >>;"
+ "0: zero;"
+ "1: one;"
+ "2: two;"
+ "3: three;"
+ "4: four;"
+ "5: five;"
+ "6: six;"
+ "7: seven;"
+ "8: eight;"
+ "9: nine;");
+ RuleBasedNumberFormat enFormatter(enRules, Locale::getEnglish(), parseError, status);
+ const char * const enTestPointData[][2] = {
+ {"1.1", "one point one"},
+ {"1.23", "one point two three"},
+ {"0.4", "xpoint four"},
+ { NULL, NULL }
+ };
+ if (U_FAILURE(status)) {
+ dataerrln("Unable to create RuleBasedNumberFormat - " + UnicodeString(u_errorName(status)));
+ return;
+ }
+ doTest(&enFormatter, enTestPointData, true);
+
+ DecimalFormatSymbols decimalFormatSymbols(Locale::getEnglish(), status);
+ decimalFormatSymbols.setSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol, UNICODE_STRING_SIMPLE(","));
+ enFormatter.setDecimalFormatSymbols(decimalFormatSymbols);
+ const char * const enTestCommaData[][2] = {
+ {"1.1", "one comma one"},
+ {"1.23", "one comma two three"},
+ {"0.4", "xcomma four"},
+ { NULL, NULL }
+ };
+ doTest(&enFormatter, enTestCommaData, true);
+}
+
+void IntlTestRBNF::TestLargeNumbers() {
+ UErrorCode status = U_ZERO_ERROR;
+ RuleBasedNumberFormat rbnf(URBNF_SPELLOUT, Locale::getEnglish(), status);
+
+ const char * const enTestFullData[][2] = {
+ {"-9007199254740991", "minus nine quadrillion seven trillion one hundred ninety-nine billion two hundred fifty-four million seven hundred forty thousand nine hundred ninety-one"}, // Maximum precision in both a double and a long
+ {"9007199254740991", "nine quadrillion seven trillion one hundred ninety-nine billion two hundred fifty-four million seven hundred forty thousand nine hundred ninety-one"}, // Maximum precision in both a double and a long
+ {"-9007199254740992", "minus nine quadrillion seven trillion one hundred ninety-nine billion two hundred fifty-four million seven hundred forty thousand nine hundred ninety-two"}, // Only precisely contained in a long
+ {"9007199254740992", "nine quadrillion seven trillion one hundred ninety-nine billion two hundred fifty-four million seven hundred forty thousand nine hundred ninety-two"}, // Only precisely contained in a long
+ {"9999999999999998", "nine quadrillion nine hundred ninety-nine trillion nine hundred ninety-nine billion nine hundred ninety-nine million nine hundred ninety-nine thousand nine hundred ninety-eight"},
+ {"9999999999999999", "nine quadrillion nine hundred ninety-nine trillion nine hundred ninety-nine billion nine hundred ninety-nine million nine hundred ninety-nine thousand nine hundred ninety-nine"},
+ {"999999999999999999", "nine hundred ninety-nine quadrillion nine hundred ninety-nine trillion nine hundred ninety-nine billion nine hundred ninety-nine million nine hundred ninety-nine thousand nine hundred ninety-nine"},
+ {"1000000000000000000", "1,000,000,000,000,000,000"}, // The rules don't go to 1 quintillion yet
+ {"-9223372036854775809", "-9,223,372,036,854,775,809"}, // We've gone beyond 64-bit precision
+ {"-9223372036854775808", "-9,223,372,036,854,775,808"}, // We've gone beyond +64-bit precision
+ {"-9223372036854775807", "minus 9,223,372,036,854,775,807"}, // Minimum 64-bit precision
+ {"-9223372036854775806", "minus 9,223,372,036,854,775,806"}, // Minimum 64-bit precision + 1
+ {"9223372036854774111", "9,223,372,036,854,774,111"}, // Below 64-bit precision
+ {"9223372036854774999", "9,223,372,036,854,774,999"}, // Below 64-bit precision
+ {"9223372036854775000", "9,223,372,036,854,775,000"}, // Below 64-bit precision
+ {"9223372036854775806", "9,223,372,036,854,775,806"}, // Maximum 64-bit precision - 1
+ {"9223372036854775807", "9,223,372,036,854,775,807"}, // Maximum 64-bit precision
+ {"9223372036854775808", "9,223,372,036,854,775,808"}, // We've gone beyond 64-bit precision. This can only be represented with BigDecimal.
+ { NULL, NULL }
+ };
+ doTest(&rbnf, enTestFullData, false);
+}
+
+void IntlTestRBNF::TestCompactDecimalFormatStyle() {
+ UErrorCode status = U_ZERO_ERROR;
+ UParseError parseError;
+ // This is not a common use case, but we're testing it anyway.
+ UnicodeString numberPattern("=###0.#####=;"
+ "1000: <###0.00< K;"
+ "1000000: <###0.00< M;"
+ "1000000000: <###0.00< B;"
+ "1000000000000: <###0.00< T;"
+ "1000000000000000: <###0.00< Q;");
+ RuleBasedNumberFormat rbnf(numberPattern, UnicodeString(), Locale::getEnglish(), parseError, status);
+
+ const char * const enTestFullData[][2] = {
+ {"1000", "1.00 K"},
+ {"1234", "1.23 K"},
+ {"999994", "999.99 K"},
+ {"999995", "1000.00 K"},
+ {"1000000", "1.00 M"},
+ {"1200000", "1.20 M"},
+ {"1200000000", "1.20 B"},
+ {"1200000000000", "1.20 T"},
+ {"1200000000000000", "1.20 Q"},
+ {"4503599627370495", "4.50 Q"},
+ {"4503599627370496", "4.50 Q"},
+ {"8990000000000000", "8.99 Q"},
+ {"9008000000000000", "9.00 Q"}, // Number doesn't precisely fit into a double
+ {"9456000000000000", "9.00 Q"}, // Number doesn't precisely fit into a double
+ {"10000000000000000", "10.00 Q"}, // Number doesn't precisely fit into a double
+ {"9223372036854775807", "9223.00 Q"}, // Maximum 64-bit precision
+ {"9223372036854775808", "9,223,372,036,854,775,808"}, // We've gone beyond 64-bit precision. This can only be represented with BigDecimal.
+ { NULL, NULL }
+ };
+ doTest(&rbnf, enTestFullData, false);
+}
+
+void IntlTestRBNF::TestParseFailure() {
+ UErrorCode status = U_ZERO_ERROR;
+ RuleBasedNumberFormat rbnf(URBNF_SPELLOUT, Locale::getJapanese(), status);
+ static const UChar* testData[] = {
+ u"・・・・・・・・・・・・・・・・・・・・・・・・"
+ };
+ if (assertSuccess("", status, true, __FILE__, __LINE__)) {
+ for (int i = 0; i < UPRV_LENGTHOF(testData); ++i) {
+ UnicodeString spelledNumberString(testData[i]);
+ Formattable actualNumber;
+ rbnf.parse(spelledNumberString, actualNumber, status);
+ if (status != U_INVALID_FORMAT_ERROR) { // I would have expected U_PARSE_ERROR, but NumberFormat::parse gives U_INVALID_FORMAT_ERROR
+ errln("FAIL: string should be unparseable index=%d %s", i, u_errorName(status));
+ }
+ }
+ }
+}
+
+void IntlTestRBNF::TestMinMaxIntegerDigitsIgnored() {
+ IcuTestErrorCode status(*this, "TestMinMaxIntegerDigitsIgnored");
+
+ // NOTE: SimpleDateFormat has an optimization that depends on the fact that min/max integer digits
+ // do not affect RBNF (see SimpleDateFormat#zeroPaddingNumber).
+ RuleBasedNumberFormat rbnf(URBNF_SPELLOUT, "en", status);
+ if (status.isSuccess()) {
+ rbnf.setMinimumIntegerDigits(2);
+ rbnf.setMaximumIntegerDigits(3);
+ UnicodeString result;
+ rbnf.format(3, result.remove(), status);
+ assertEquals("Min integer digits are ignored", u"three", result);
+ rbnf.format(1012, result.remove(), status);
+ assertEquals("Max integer digits are ignored", u"one thousand twelve", result);
projects / apple / icu.git / blobdiff