| // © 2017 and later: Unicode, Inc. and others. |
| // License & terms of use: http://www.unicode.org/copyright.html |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "putilimp.h" |
| #include "unicode/dcfmtsym.h" |
| #include "numbertest.h" |
| #include "number_utils.h" |
| |
| using namespace icu::number::impl; |
| |
| class DefaultSymbolProvider : public SymbolProvider { |
| DecimalFormatSymbols fSymbols; |
| |
| public: |
| DefaultSymbolProvider(UErrorCode &status) : fSymbols(Locale("ar_SA"), status) {} |
| |
| UnicodeString getSymbol(AffixPatternType type) const U_OVERRIDE { |
| switch (type) { |
| case TYPE_MINUS_SIGN: |
| return u"−"; |
| case TYPE_PLUS_SIGN: |
| return fSymbols.getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kPlusSignSymbol); |
| case TYPE_PERCENT: |
| return fSymbols.getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kPercentSymbol); |
| case TYPE_PERMILLE: |
| return fSymbols.getConstSymbol(DecimalFormatSymbols::ENumberFormatSymbol::kPerMillSymbol); |
| case TYPE_CURRENCY_SINGLE: |
| return u"$"; |
| case TYPE_CURRENCY_DOUBLE: |
| return u"XXX"; |
| case TYPE_CURRENCY_TRIPLE: |
| return u"long name"; |
| case TYPE_CURRENCY_QUAD: |
| return u"\uFFFD"; |
| case TYPE_CURRENCY_QUINT: |
| // TODO: Add support for narrow currency symbols here. |
| return u"\uFFFD"; |
| case TYPE_CURRENCY_OVERFLOW: |
| return u"\uFFFD"; |
| default: |
| UPRV_UNREACHABLE; |
| } |
| } |
| }; |
| |
| void AffixUtilsTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char *) { |
| if (exec) { |
| logln("TestSuite AffixUtilsTest: "); |
| } |
| TESTCASE_AUTO_BEGIN; |
| TESTCASE_AUTO(testEscape); |
| TESTCASE_AUTO(testUnescape); |
| TESTCASE_AUTO(testContainsReplaceType); |
| TESTCASE_AUTO(testInvalid); |
| TESTCASE_AUTO(testUnescapeWithSymbolProvider); |
| TESTCASE_AUTO_END; |
| } |
| |
| void AffixUtilsTest::testEscape() { |
| static const char16_t *cases[][2] = {{u"", u""}, |
| {u"abc", u"abc"}, |
| {u"-", u"'-'"}, |
| {u"-!", u"'-'!"}, |
| {u"−", u"−"}, |
| {u"---", u"'---'"}, |
| {u"-%-", u"'-%-'"}, |
| {u"'", u"''"}, |
| {u"-'", u"'-'''"}, |
| {u"-'-", u"'-''-'"}, |
| {u"a-'-", u"a'-''-'"}}; |
| |
| for (auto &cas : cases) { |
| UnicodeString input(cas[0]); |
| UnicodeString expected(cas[1]); |
| UnicodeString result = AffixUtils::escape(input); |
| assertEquals(input, expected, result); |
| } |
| } |
| |
| void AffixUtilsTest::testUnescape() { |
| static struct TestCase { |
| const char16_t *input; |
| bool currency; |
| int32_t expectedLength; |
| const char16_t *output; |
| } cases[] = {{u"", false, 0, u""}, |
| {u"abc", false, 3, u"abc"}, |
| {u"-", false, 1, u"−"}, |
| {u"-!", false, 2, u"−!"}, |
| {u"+", false, 1, u"\u061C+"}, |
| {u"+!", false, 2, u"\u061C+!"}, |
| {u"‰", false, 1, u"؉"}, |
| {u"‰!", false, 2, u"؉!"}, |
| {u"-x", false, 2, u"−x"}, |
| {u"'-'x", false, 2, u"-x"}, |
| {u"'--''-'-x", false, 6, u"--'-−x"}, |
| {u"''", false, 1, u"'"}, |
| {u"''''", false, 2, u"''"}, |
| {u"''''''", false, 3, u"'''"}, |
| {u"''x''", false, 3, u"'x'"}, |
| {u"¤", true, 1, u"$"}, |
| {u"¤¤", true, 2, u"XXX"}, |
| {u"¤¤¤", true, 3, u"long name"}, |
| {u"¤¤¤¤", true, 4, u"\uFFFD"}, |
| {u"¤¤¤¤¤", true, 5, u"\uFFFD"}, |
| {u"¤¤¤¤¤¤", true, 6, u"\uFFFD"}, |
| {u"¤¤¤a¤¤¤¤", true, 8, u"long namea\uFFFD"}, |
| {u"a¤¤¤¤b¤¤¤¤¤c", true, 12, u"a\uFFFDb\uFFFDc"}, |
| {u"¤!", true, 2, u"$!"}, |
| {u"¤¤!", true, 3, u"XXX!"}, |
| {u"¤¤¤!", true, 4, u"long name!"}, |
| {u"-¤¤", true, 3, u"−XXX"}, |
| {u"¤¤-", true, 3, u"XXX−"}, |
| {u"'¤'", false, 1, u"¤"}, |
| {u"%", false, 1, u"٪\u061C"}, |
| {u"'%'", false, 1, u"%"}, |
| {u"¤'-'%", true, 3, u"$-٪\u061C"}, |
| {u"#0#@#*#;#", false, 9, u"#0#@#*#;#"}}; |
| |
| UErrorCode status = U_ZERO_ERROR; |
| DefaultSymbolProvider defaultProvider(status); |
| assertSuccess("Constructing DefaultSymbolProvider", status); |
| |
| for (TestCase cas : cases) { |
| UnicodeString input(cas.input); |
| UnicodeString output(cas.output); |
| |
| assertEquals(input, cas.currency, AffixUtils::hasCurrencySymbols(input, status)); |
| assertSuccess("Spot 1", status); |
| assertEquals(input, cas.expectedLength, AffixUtils::estimateLength(input, status)); |
| assertSuccess("Spot 2", status); |
| |
| UnicodeString actual = unescapeWithDefaults(defaultProvider, input, status); |
| assertSuccess("Spot 3", status); |
| assertEquals(input, output, actual); |
| |
| int32_t ulength = AffixUtils::unescapedCodePointCount(input, defaultProvider, status); |
| assertSuccess("Spot 4", status); |
| assertEquals(input, output.countChar32(), ulength); |
| } |
| } |
| |
| void AffixUtilsTest::testContainsReplaceType() { |
| static struct TestCase { |
| const char16_t *input; |
| bool hasMinusSign; |
| const char16_t *output; |
| } cases[] = {{u"", false, u""}, |
| {u"-", true, u"+"}, |
| {u"-a", true, u"+a"}, |
| {u"a-", true, u"a+"}, |
| {u"a-b", true, u"a+b"}, |
| {u"--", true, u"++"}, |
| {u"x", false, u"x"}}; |
| |
| UErrorCode status = U_ZERO_ERROR; |
| for (TestCase cas : cases) { |
| UnicodeString input(cas.input); |
| bool hasMinusSign = cas.hasMinusSign; |
| UnicodeString output(cas.output); |
| |
| assertEquals( |
| input, hasMinusSign, AffixUtils::containsType(input, TYPE_MINUS_SIGN, status)); |
| assertSuccess("Spot 1", status); |
| assertEquals( |
| input, output, AffixUtils::replaceType(input, TYPE_MINUS_SIGN, u'+', status)); |
| assertSuccess("Spot 2", status); |
| } |
| } |
| |
| void AffixUtilsTest::testInvalid() { |
| static const char16_t *invalidExamples[] = { |
| u"'", u"x'", u"'x", u"'x''", u"''x'"}; |
| |
| UErrorCode status = U_ZERO_ERROR; |
| DefaultSymbolProvider defaultProvider(status); |
| assertSuccess("Constructing DefaultSymbolProvider", status); |
| |
| for (const char16_t *strPtr : invalidExamples) { |
| UnicodeString str(strPtr); |
| |
| status = U_ZERO_ERROR; |
| AffixUtils::hasCurrencySymbols(str, status); |
| assertEquals("Should set error code spot 1", status, U_ILLEGAL_ARGUMENT_ERROR); |
| |
| status = U_ZERO_ERROR; |
| AffixUtils::estimateLength(str, status); |
| assertEquals("Should set error code spot 2", status, U_ILLEGAL_ARGUMENT_ERROR); |
| |
| status = U_ZERO_ERROR; |
| unescapeWithDefaults(defaultProvider, str, status); |
| assertEquals("Should set error code spot 3", status, U_ILLEGAL_ARGUMENT_ERROR); |
| } |
| } |
| |
| class NumericSymbolProvider : public SymbolProvider { |
| public: |
| virtual UnicodeString getSymbol(AffixPatternType type) const { |
| return Int64ToUnicodeString(type < 0 ? -type : type); |
| } |
| }; |
| |
| void AffixUtilsTest::testUnescapeWithSymbolProvider() { |
| static const char16_t* cases[][2] = { |
| {u"", u""}, |
| {u"-", u"1"}, |
| {u"'-'", u"-"}, |
| {u"- + % ‰ ¤ ¤¤ ¤¤¤ ¤¤¤¤ ¤¤¤¤¤", u"1 2 3 4 5 6 7 8 9"}, |
| {u"'¤¤¤¤¤¤'", u"¤¤¤¤¤¤"}, |
| {u"¤¤¤¤¤¤", u"\uFFFD"} |
| }; |
| |
| NumericSymbolProvider provider; |
| |
| UErrorCode status = U_ZERO_ERROR; |
| FormattedStringBuilder sb; |
| for (auto& cas : cases) { |
| UnicodeString input(cas[0]); |
| UnicodeString expected(cas[1]); |
| sb.clear(); |
| AffixUtils::unescape(input, sb, 0, provider, kUndefinedField, status); |
| assertSuccess("Spot 1", status); |
| assertEquals(input, expected, sb.toUnicodeString()); |
| assertEquals(input, expected, sb.toTempUnicodeString()); |
| } |
| |
| // Test insertion position |
| sb.clear(); |
| sb.append(u"abcdefg", kUndefinedField, status); |
| assertSuccess("Spot 2", status); |
| AffixUtils::unescape(u"-+%", sb, 4, provider, kUndefinedField, status); |
| assertSuccess("Spot 3", status); |
| assertEquals(u"Symbol provider into middle", u"abcd123efg", sb.toUnicodeString()); |
| } |
| |
| UnicodeString AffixUtilsTest::unescapeWithDefaults(const SymbolProvider &defaultProvider, |
| UnicodeString input, UErrorCode &status) { |
| FormattedStringBuilder nsb; |
| int32_t length = AffixUtils::unescape(input, nsb, 0, defaultProvider, kUndefinedField, status); |
| assertEquals("Return value of unescape", nsb.length(), length); |
| return nsb.toUnicodeString(); |
| } |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
