/* ******************************************************************************* * Copyright (C) 2015, International Business Machines Corporation and * * others. All Rights Reserved. * ******************************************************************************* * * File NUMBERFORMAT2TEST.CPP * ******************************************************************************* */ #include "unicode/utypes.h" #include "intltest.h" #if !UCONFIG_NO_FORMATTING #include "unicode/localpointer.h" #include "unicode/plurrule.h" #include "affixpatternparser.h" #include "charstr.h" #include "datadrivennumberformattestsuite.h" #include "decimalformatpattern.h" #include "digitaffixesandpadding.h" #include "digitformatter.h" #include "digitgrouping.h" #include "digitinterval.h" #include "digitlst.h" #include "fphdlimp.h" #include "plurrule_impl.h" #include "precision.h" #include "significantdigitinterval.h" #include "smallintformatter.h" #include "uassert.h" #include "valueformatter.h" #include "visibledigits.h" struct NumberFormat2Test_Attributes { int32_t id; int32_t spos; int32_t epos; }; class NumberFormat2Test_FieldPositionHandler : public FieldPositionHandler { public: NumberFormat2Test_Attributes attributes[100]; int32_t count; UBool bRecording; NumberFormat2Test_FieldPositionHandler() : count(0), bRecording(TRUE) { attributes[0].spos = -1; } NumberFormat2Test_FieldPositionHandler(UBool recording) : count(0), bRecording(recording) { attributes[0].spos = -1; } virtual ~NumberFormat2Test_FieldPositionHandler(); virtual void addAttribute(int32_t id, int32_t start, int32_t limit); virtual void shiftLast(int32_t delta); virtual UBool isRecording(void) const; }; NumberFormat2Test_FieldPositionHandler::~NumberFormat2Test_FieldPositionHandler() { } void NumberFormat2Test_FieldPositionHandler::addAttribute( int32_t id, int32_t start, int32_t limit) { if (count == UPRV_LENGTHOF(attributes) - 1) { return; } attributes[count].id = id; attributes[count].spos = start; attributes[count].epos = limit; ++count; attributes[count].spos = -1; } void NumberFormat2Test_FieldPositionHandler::shiftLast(int32_t /* delta */) { } UBool NumberFormat2Test_FieldPositionHandler::isRecording() const { return bRecording; } class NumberFormat2Test : public IntlTest { public: void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0); private: void TestQuantize(); void TestConvertScientificNotation(); void TestLowerUpperExponent(); void TestRounding(); void TestRoundingIncrement(); void TestDigitInterval(); void TestGroupingUsed(); void TestBenchmark(); void TestBenchmark2(); void TestSmallIntFormatter(); void TestPositiveIntDigitFormatter(); void TestDigitListInterval(); void TestLargeIntValue(); void TestIntInitVisibleDigits(); void TestIntInitVisibleDigitsToDigitList(); void TestDoubleInitVisibleDigits(); void TestDoubleInitVisibleDigitsToDigitList(); void TestDigitListInitVisibleDigits(); void TestSpecialInitVisibleDigits(); void TestVisibleDigitsWithExponent(); void TestDigitAffixesAndPadding(); void TestPluralsAndRounding(); void TestPluralsAndRoundingScientific(); void TestValueFormatterIsFastFormattable(); void TestCurrencyAffixInfo(); void TestAffixPattern(); void TestAffixPatternAppend(); void TestAffixPatternAppendAjoiningLiterals(); void TestAffixPatternDoubleQuote(); void TestAffixPatternParser(); void TestPluralAffix(); void TestDigitAffix(); void TestDigitFormatterDefaultCtor(); void TestDigitFormatterMonetary(); void TestDigitFormatter(); void TestSciFormatterDefaultCtor(); void TestSciFormatter(); void TestToPatternScientific11648(); void verifyInterval(const DigitInterval &, int32_t minInclusive, int32_t maxExclusive); void verifyAffix( const UnicodeString &expected, const DigitAffix &affix, const NumberFormat2Test_Attributes *expectedAttributes); void verifyAffixesAndPadding( const UnicodeString &expected, const DigitAffixesAndPadding &aaf, DigitList &digits, const ValueFormatter &vf, const PluralRules *optPluralRules, const NumberFormat2Test_Attributes *expectedAttributes); void verifyAffixesAndPaddingInt32( const UnicodeString &expected, const DigitAffixesAndPadding &aaf, int32_t value, const ValueFormatter &vf, const PluralRules *optPluralRules, const NumberFormat2Test_Attributes *expectedAttributes); void verifyDigitList( const UnicodeString &expected, const DigitList &digits); void verifyVisibleDigits( const UnicodeString &expected, UBool bNegative, const VisibleDigits &digits); void verifyVisibleDigitsWithExponent( const UnicodeString &expected, UBool bNegative, const VisibleDigitsWithExponent &digits); void verifyDigitFormatter( const UnicodeString &expected, const DigitFormatter &formatter, const VisibleDigits &digits, const DigitGrouping &grouping, const DigitFormatterOptions &options, const NumberFormat2Test_Attributes *expectedAttributes); void verifySciFormatter( const UnicodeString &expected, const DigitFormatter &formatter, const VisibleDigitsWithExponent &digits, const SciFormatterOptions &options, const NumberFormat2Test_Attributes *expectedAttributes); void verifySmallIntFormatter( const UnicodeString &expected, int32_t positiveValue, int32_t minDigits, int32_t maxDigits); void verifyPositiveIntDigitFormatter( const UnicodeString &expected, const DigitFormatter &formatter, int32_t value, int32_t minDigits, int32_t maxDigits, const NumberFormat2Test_Attributes *expectedAttributes); void verifyAttributes( const NumberFormat2Test_Attributes *expected, const NumberFormat2Test_Attributes *actual); void verifyIntValue( int64_t expected, const VisibleDigits &digits); void verifySource( double expected, const VisibleDigits &digits); }; void NumberFormat2Test::runIndexedTest( int32_t index, UBool exec, const char *&name, char *) { if (exec) { logln("TestSuite ScientificNumberFormatterTest: "); } TESTCASE_AUTO_BEGIN; TESTCASE_AUTO(TestQuantize); TESTCASE_AUTO(TestConvertScientificNotation); TESTCASE_AUTO(TestLowerUpperExponent); TESTCASE_AUTO(TestRounding); TESTCASE_AUTO(TestRoundingIncrement); TESTCASE_AUTO(TestDigitInterval); TESTCASE_AUTO(TestGroupingUsed); TESTCASE_AUTO(TestDigitListInterval); TESTCASE_AUTO(TestDigitFormatterDefaultCtor); TESTCASE_AUTO(TestDigitFormatterMonetary); TESTCASE_AUTO(TestDigitFormatter); TESTCASE_AUTO(TestSciFormatterDefaultCtor); TESTCASE_AUTO(TestSciFormatter); TESTCASE_AUTO(TestBenchmark); TESTCASE_AUTO(TestBenchmark2); TESTCASE_AUTO(TestSmallIntFormatter); TESTCASE_AUTO(TestPositiveIntDigitFormatter); TESTCASE_AUTO(TestCurrencyAffixInfo); TESTCASE_AUTO(TestAffixPattern); TESTCASE_AUTO(TestAffixPatternAppend); TESTCASE_AUTO(TestAffixPatternAppendAjoiningLiterals); TESTCASE_AUTO(TestAffixPatternDoubleQuote); TESTCASE_AUTO(TestAffixPatternParser); TESTCASE_AUTO(TestPluralAffix); TESTCASE_AUTO(TestDigitAffix); TESTCASE_AUTO(TestValueFormatterIsFastFormattable); TESTCASE_AUTO(TestLargeIntValue); TESTCASE_AUTO(TestIntInitVisibleDigits); TESTCASE_AUTO(TestIntInitVisibleDigitsToDigitList); TESTCASE_AUTO(TestDoubleInitVisibleDigits); TESTCASE_AUTO(TestDoubleInitVisibleDigitsToDigitList); TESTCASE_AUTO(TestDigitListInitVisibleDigits); TESTCASE_AUTO(TestSpecialInitVisibleDigits); TESTCASE_AUTO(TestVisibleDigitsWithExponent); TESTCASE_AUTO(TestDigitAffixesAndPadding); TESTCASE_AUTO(TestPluralsAndRounding); TESTCASE_AUTO(TestPluralsAndRoundingScientific); TESTCASE_AUTO(TestToPatternScientific11648); TESTCASE_AUTO_END; } void NumberFormat2Test::TestDigitInterval() { DigitInterval all; DigitInterval threeInts; DigitInterval fourFrac; threeInts.setIntDigitCount(3); fourFrac.setFracDigitCount(4); verifyInterval(all, INT32_MIN, INT32_MAX); verifyInterval(threeInts, INT32_MIN, 3); verifyInterval(fourFrac, -4, INT32_MAX); { DigitInterval result(threeInts); result.shrinkToFitWithin(fourFrac); verifyInterval(result, -4, 3); assertEquals("", 7, result.length()); } { DigitInterval result(threeInts); result.expandToContain(fourFrac); verifyInterval(result, INT32_MIN, INT32_MAX); } { DigitInterval result(threeInts); result.setIntDigitCount(0); verifyInterval(result, INT32_MIN, 0); result.setIntDigitCount(-1); verifyInterval(result, INT32_MIN, INT32_MAX); } { DigitInterval result(fourFrac); result.setFracDigitCount(0); verifyInterval(result, 0, INT32_MAX); result.setFracDigitCount(-1); verifyInterval(result, INT32_MIN, INT32_MAX); } { DigitInterval result; result.setIntDigitCount(3); result.setFracDigitCount(1); result.expandToContainDigit(0); result.expandToContainDigit(-1); result.expandToContainDigit(2); verifyInterval(result, -1, 3); result.expandToContainDigit(3); verifyInterval(result, -1, 4); result.expandToContainDigit(-2); verifyInterval(result, -2, 4); result.expandToContainDigit(15); result.expandToContainDigit(-15); verifyInterval(result, -15, 16); } { DigitInterval result; result.setIntDigitCount(3); result.setFracDigitCount(1); assertTrue("", result.contains(2)); assertTrue("", result.contains(-1)); assertFalse("", result.contains(3)); assertFalse("", result.contains(-2)); } } void NumberFormat2Test::verifyInterval( const DigitInterval &interval, int32_t minInclusive, int32_t maxExclusive) { assertEquals("", minInclusive, interval.getLeastSignificantInclusive()); assertEquals("", maxExclusive, interval.getMostSignificantExclusive()); assertEquals("", maxExclusive, interval.getIntDigitCount()); } void NumberFormat2Test::TestGroupingUsed() { { DigitGrouping grouping; assertFalse("", grouping.isGroupingUsed()); } { DigitGrouping grouping; grouping.fGrouping = 2; assertTrue("", grouping.isGroupingUsed()); } } void NumberFormat2Test::TestDigitListInterval() { DigitInterval result; DigitList digitList; { digitList.set(12345); verifyInterval(digitList.getSmallestInterval(result), 0, 5); } { digitList.set(1000.00); verifyInterval(digitList.getSmallestInterval(result), 0, 4); } { digitList.set(43.125); verifyInterval(digitList.getSmallestInterval(result), -3, 2); } { digitList.set(.0078125); verifyInterval(digitList.getSmallestInterval(result), -7, 0); } { digitList.set(1000.00); digitList.getSmallestInterval(result); result.expandToContainDigit(3); verifyInterval(result, 0, 4); } { digitList.set(1000.00); digitList.getSmallestInterval(result); result.expandToContainDigit(4); verifyInterval(result, 0, 5); } { digitList.set(1000.00); digitList.getSmallestInterval(result); result.expandToContainDigit(0); verifyInterval(result, 0, 4); } { digitList.set(1000.00); digitList.getSmallestInterval(result); result.expandToContainDigit(-1); verifyInterval(result, -1, 4); } { digitList.set(43.125); digitList.getSmallestInterval(result); result.expandToContainDigit(1); verifyInterval(result, -3, 2); } { digitList.set(43.125); digitList.getSmallestInterval(result); result.expandToContainDigit(2); verifyInterval(result, -3, 3); } { digitList.set(43.125); digitList.getSmallestInterval(result); result.expandToContainDigit(-3); verifyInterval(result, -3, 2); } { digitList.set(43.125); digitList.getSmallestInterval(result); result.expandToContainDigit(-4); verifyInterval(result, -4, 2); } } void NumberFormat2Test::TestQuantize() { DigitList quantity; quantity.set(0.00168); quantity.roundAtExponent(-5); DigitList digits; UErrorCode status = U_ZERO_ERROR; { digits.set(1); digits.quantize(quantity, status); verifyDigitList(".9996", digits); } { // round half even up digits.set(1.00044); digits.roundAtExponent(-5); digits.quantize(quantity, status); verifyDigitList("1.00128", digits); } { // round half down digits.set(0.99876); digits.roundAtExponent(-5); digits.quantize(quantity, status); verifyDigitList(".99792", digits); } assertSuccess("", status); } void NumberFormat2Test::TestConvertScientificNotation() { DigitList digits; { digits.set(186283); assertEquals("", 5, digits.toScientific(1, 1)); verifyDigitList( "1.86283", digits); } { digits.set(186283); assertEquals("", 0, digits.toScientific(6, 1)); verifyDigitList( "186283", digits); } { digits.set(186283); assertEquals("", -2, digits.toScientific(8, 1)); verifyDigitList( "18628300", digits); } { digits.set(43561); assertEquals("", 6, digits.toScientific(-1, 3)); verifyDigitList( ".043561", digits); } { digits.set(43561); assertEquals("", 3, digits.toScientific(0, 3)); verifyDigitList( "43.561", digits); } { digits.set(43561); assertEquals("", 3, digits.toScientific(2, 3)); verifyDigitList( "43.561", digits); } { digits.set(43561); assertEquals("", 0, digits.toScientific(3, 3)); verifyDigitList( "43561", digits); } { digits.set(43561); assertEquals("", 0, digits.toScientific(5, 3)); verifyDigitList( "43561", digits); } { digits.set(43561); assertEquals("", -3, digits.toScientific(6, 3)); verifyDigitList( "43561000", digits); } { digits.set(43561); assertEquals("", -3, digits.toScientific(8, 3)); verifyDigitList( "43561000", digits); } { digits.set(43561); assertEquals("", -6, digits.toScientific(9, 3)); verifyDigitList( "43561000000", digits); } } void NumberFormat2Test::TestLowerUpperExponent() { DigitList digits; digits.set(98.7); assertEquals("", -1, digits.getLowerExponent()); assertEquals("", 2, digits.getUpperExponent()); } void NumberFormat2Test::TestRounding() { DigitList digits; uprv_decContextSetRounding(&digits.fContext, DEC_ROUND_CEILING); { // Round at very large exponent digits.set(789.123); digits.roundAtExponent(100); verifyDigitList( "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", // 100 0's after 1 digits); } { // Round at very large exponent digits.set(789.123); digits.roundAtExponent(1); verifyDigitList( "790", // 100 0's after 1 digits); } { // Round at positive exponent digits.set(789.123); digits.roundAtExponent(1); verifyDigitList("790", digits); } { // Round at zero exponent digits.set(788.123); digits.roundAtExponent(0); verifyDigitList("789", digits); } { // Round at negative exponent digits.set(789.123); digits.roundAtExponent(-2); verifyDigitList("789.13", digits); } { // Round to exponent of digits. digits.set(789.123); digits.roundAtExponent(-3); verifyDigitList("789.123", digits); } { // Round at large negative exponent digits.set(789.123); digits.roundAtExponent(-100); verifyDigitList("789.123", digits); } { // Round negative digits.set(-789.123); digits.roundAtExponent(-2); digits.setPositive(TRUE); verifyDigitList("789.12", digits); } { // Round to 1 significant digit digits.set(789.123); digits.roundAtExponent(INT32_MIN, 1); verifyDigitList("800", digits); } { // Round to 5 significant digit digits.set(789.123); digits.roundAtExponent(INT32_MIN, 5); verifyDigitList("789.13", digits); } { // Round to 6 significant digit digits.set(789.123); digits.roundAtExponent(INT32_MIN, 6); verifyDigitList("789.123", digits); } { // no-op digits.set(789.123); digits.roundAtExponent(INT32_MIN, INT32_MAX); verifyDigitList("789.123", digits); } { // Rounding at -1 produces fewer than 5 significant digits digits.set(789.123); digits.roundAtExponent(-1, 5); verifyDigitList("789.2", digits); } { // Rounding at -1 produces exactly 4 significant digits digits.set(789.123); digits.roundAtExponent(-1, 4); verifyDigitList("789.2", digits); } { // Rounding at -1 produces more than 3 significant digits digits.set(788.123); digits.roundAtExponent(-1, 3); verifyDigitList("789", digits); } { digits.set(123.456); digits.round(INT32_MAX); verifyDigitList("123.456", digits); } { digits.set(123.456); digits.round(1); verifyDigitList("200", digits); } } void NumberFormat2Test::TestBenchmark() { /* UErrorCode status = U_ZERO_ERROR; Locale en("en"); DecimalFormatSymbols *sym = new DecimalFormatSymbols(en, status); DecimalFormat2 fmt(en, "0.0000000", status); FieldPosition fpos(0); clock_t start = clock(); for (int32_t i = 0; i < 100000; ++i) { UParseError perror; DecimalFormat2 fmt2("0.0000000", new DecimalFormatSymbols(*sym), perror, status); // UnicodeString append; // fmt.format(4.6692016, append, fpos, status); } errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC); assertSuccess("", status); */ } void NumberFormat2Test::TestBenchmark2() { /* UErrorCode status = U_ZERO_ERROR; Locale en("en"); DecimalFormatSymbols *sym = new DecimalFormatSymbols(en, status); DecimalFormat fmt("0.0000000", sym, status); FieldPosition fpos(0); clock_t start = clock(); for (int32_t i = 0; i < 100000; ++i) { UParseError perror; DecimalFormat fmt("0.0000000", new DecimalFormatSymbols(*sym), perror, status); // UnicodeString append; // fmt.format(4.6692016, append, fpos, status); } errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC); assertSuccess("", status); */ } void NumberFormat2Test::TestSmallIntFormatter() { verifySmallIntFormatter("0", 7, 0, -2); verifySmallIntFormatter("7", 7, 1, -2); verifySmallIntFormatter("07", 7, 2, -2); verifySmallIntFormatter("07", 7, 2, 2); verifySmallIntFormatter("007", 7, 3, 4); verifySmallIntFormatter("7", 7, -1, 3); verifySmallIntFormatter("0", 0, -1, 3); verifySmallIntFormatter("057", 57, 3, 7); verifySmallIntFormatter("0057", 57, 4, 7); // too many digits for small int verifySmallIntFormatter("", 57, 5, 7); // too many digits for small int verifySmallIntFormatter("", 57, 5, 4); verifySmallIntFormatter("03", 3, 2, 3); verifySmallIntFormatter("32", 32, 2, 3); verifySmallIntFormatter("321", 321, 2, 3); verifySmallIntFormatter("219", 3219, 2, 3); verifySmallIntFormatter("4095", 4095, 2, 4); verifySmallIntFormatter("4095", 4095, 2, 5); verifySmallIntFormatter("", 4096, 2, 5); } void NumberFormat2Test::TestPositiveIntDigitFormatter() { DigitFormatter formatter; { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 4}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "0057", formatter, 57, 4, INT32_MAX, expectedAttributes); } { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 5}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "00057", formatter, 57, 5, INT32_MAX, expectedAttributes); } { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 5}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "01000", formatter, 1000, 5, INT32_MAX, expectedAttributes); } { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 3}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "100", formatter, 100, 0, INT32_MAX, expectedAttributes); } { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 10}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "2147483647", formatter, 2147483647, 5, INT32_MAX, expectedAttributes); } { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 12}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "002147483647", formatter, 2147483647, 12, INT32_MAX, expectedAttributes); } { // Test long digit string where we have to append one // character at a time. NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 40}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "0000000000000000000000000000002147483647", formatter, 2147483647, 40, INT32_MAX, expectedAttributes); } { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 4}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "6283", formatter, 186283, 2, 4, expectedAttributes); } { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "0", formatter, 186283, 0, 0, expectedAttributes); } { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {0, -1, 0}}; verifyPositiveIntDigitFormatter( "3", formatter, 186283, 1, 1, expectedAttributes); } } void NumberFormat2Test::TestDigitFormatterDefaultCtor() { DigitFormatter formatter; VisibleDigits digits; FixedPrecision precision; UErrorCode status = U_ZERO_ERROR; precision.initVisibleDigits(246.801, digits, status); assertSuccess("", status); DigitGrouping grouping; DigitFormatterOptions options; verifyDigitFormatter( "246.801", formatter, digits, grouping, options, NULL); } void NumberFormat2Test::TestDigitFormatterMonetary() { UErrorCode status = U_ZERO_ERROR; DecimalFormatSymbols symbols("en", status); if (!assertSuccess("", status)) { return; } symbols.setSymbol( DecimalFormatSymbols::kMonetarySeparatorSymbol, "decimal separator"); symbols.setSymbol( DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol, "grouping separator"); DigitFormatter formatter(symbols); VisibleDigits visibleDigits; DigitGrouping grouping; FixedPrecision precision; precision.initVisibleDigits(43560.02, visibleDigits, status); if (!assertSuccess("", status)) { return; } DigitFormatterOptions options; grouping.fGrouping = 3; { verifyDigitFormatter( "43,560.02", formatter, visibleDigits, grouping, options, NULL); formatter.setDecimalFormatSymbolsForMonetary(symbols); verifyDigitFormatter( "43grouping separator560decimal separator02", formatter, visibleDigits, grouping, options, NULL); } } void NumberFormat2Test::TestDigitFormatter() { UErrorCode status = U_ZERO_ERROR; DecimalFormatSymbols symbols("en", status); if (!assertSuccess("", status)) { return; } DigitFormatter formatter(symbols); DigitInterval interval; { VisibleDigits visibleDigits; DigitGrouping grouping; FixedPrecision precision; precision.initVisibleDigits((int64_t) 8192, visibleDigits, status); if (!assertSuccess("", status)) { return; } DigitFormatterOptions options; verifyDigitFormatter( "8192", formatter, visibleDigits, grouping, options, NULL); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 4}, {UNUM_DECIMAL_SEPARATOR_FIELD, 4, 5}, {0, -1, 0}}; options.fAlwaysShowDecimal = TRUE; verifyDigitFormatter( "8192.", formatter, visibleDigits, grouping, options, expectedAttributes); // Turn on grouping grouping.fGrouping = 3; options.fAlwaysShowDecimal = FALSE; verifyDigitFormatter( "8,192", formatter, visibleDigits, grouping, options, NULL); // turn on min grouping which will suppress grouping grouping.fMinGrouping = 2; verifyDigitFormatter( "8192", formatter, visibleDigits, grouping, options, NULL); // adding one more digit will enable grouping once again. precision.initVisibleDigits((int64_t) 43560, visibleDigits, status); if (!assertSuccess("", status)) { return; } verifyDigitFormatter( "43,560", formatter, visibleDigits, grouping, options, NULL); } { DigitGrouping grouping; FixedPrecision precision; VisibleDigits visibleDigits; precision.initVisibleDigits( 31415926.0078125, visibleDigits, status); if (!assertSuccess("", status)) { return; } DigitFormatterOptions options; verifyDigitFormatter( "31415926.0078125", formatter, visibleDigits, grouping, options, NULL); // Turn on grouping with secondary. grouping.fGrouping = 2; grouping.fGrouping2 = 3; verifyDigitFormatter( "314,159,26.0078125", formatter, visibleDigits, grouping, options, NULL); // Pad with zeros by widening interval. precision.fMin.setIntDigitCount(9); precision.fMin.setFracDigitCount(10); precision.initVisibleDigits( 31415926.0078125, visibleDigits, status); if (!assertSuccess("", status)) { return; } NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_GROUPING_SEPARATOR_FIELD, 1, 2}, {UNUM_GROUPING_SEPARATOR_FIELD, 5, 6}, {UNUM_GROUPING_SEPARATOR_FIELD, 9, 10}, {UNUM_INTEGER_FIELD, 0, 12}, {UNUM_DECIMAL_SEPARATOR_FIELD, 12, 13}, {UNUM_FRACTION_FIELD, 13, 23}, {0, -1, 0}}; verifyDigitFormatter( "0,314,159,26.0078125000", formatter, visibleDigits, grouping, options, expectedAttributes); } { DigitGrouping grouping; FixedPrecision precision; VisibleDigits visibleDigits; DigitFormatterOptions options; precision.fMax.setIntDigitCount(0); precision.fMax.setFracDigitCount(0); precision.initVisibleDigits( 3125.0, visibleDigits, status); if (!assertSuccess("", status)) { return; } NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {0, -1, 0}}; verifyDigitFormatter( "0", formatter, visibleDigits, grouping, options, expectedAttributes); NumberFormat2Test_Attributes expectedAttributesWithDecimal[] = { {UNUM_INTEGER_FIELD, 0, 1}, {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, {0, -1, 0}}; options.fAlwaysShowDecimal = TRUE; verifyDigitFormatter( "0.", formatter, visibleDigits, grouping, options, expectedAttributesWithDecimal); } { DigitGrouping grouping; FixedPrecision precision; VisibleDigits visibleDigits; DigitFormatterOptions options; precision.fMax.setIntDigitCount(1); precision.fMin.setFracDigitCount(1); precision.initVisibleDigits( 3125.0, visibleDigits, status); if (!assertSuccess("", status)) { return; } NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, {UNUM_FRACTION_FIELD, 2, 3}, {0, -1, 0}}; options.fAlwaysShowDecimal = TRUE; verifyDigitFormatter( "5.0", formatter, visibleDigits, grouping, options, expectedAttributes); } } void NumberFormat2Test::TestSciFormatterDefaultCtor() { DigitFormatter formatter; ScientificPrecision precision; VisibleDigitsWithExponent visibleDigits; UErrorCode status = U_ZERO_ERROR; precision.initVisibleDigitsWithExponent( 6.02E23, visibleDigits, status); if (!assertSuccess("", status)) { return; } SciFormatterOptions options; verifySciFormatter( "6.02E23", formatter, visibleDigits, options, NULL); precision.initVisibleDigitsWithExponent( 6.62E-34, visibleDigits, status); if (!assertSuccess("", status)) { return; } verifySciFormatter( "6.62E-34", formatter, visibleDigits, options, NULL); } void NumberFormat2Test::TestSciFormatter() { DigitFormatter formatter; ScientificPrecision precision; precision.fMantissa.fMin.setIntDigitCount(4); precision.fMantissa.fMax.setIntDigitCount(4); precision.fMantissa.fMin.setFracDigitCount(0); precision.fMantissa.fMax.setFracDigitCount(0); precision.fMinExponentDigits = 3; VisibleDigitsWithExponent visibleDigits; UErrorCode status = U_ZERO_ERROR; precision.initVisibleDigitsWithExponent( 1.248E26, visibleDigits, status); if (!assertSuccess("", status)) { return; } SciFormatterOptions options; { options.fExponent.fAlwaysShowSign = TRUE; NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 4}, {UNUM_EXPONENT_SYMBOL_FIELD, 4, 5}, {UNUM_EXPONENT_SIGN_FIELD, 5, 6}, {UNUM_EXPONENT_FIELD, 6, 9}, {0, -1, 0}}; verifySciFormatter( "1248E+023", formatter, visibleDigits, options, expectedAttributes); } { options.fMantissa.fAlwaysShowDecimal = TRUE; options.fExponent.fAlwaysShowSign = FALSE; NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 4}, {UNUM_DECIMAL_SEPARATOR_FIELD, 4, 5}, {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6}, {UNUM_EXPONENT_FIELD, 6, 9}, {0, -1, 0}}; verifySciFormatter( "1248.E023", formatter, visibleDigits, options, expectedAttributes); } } void NumberFormat2Test::TestValueFormatterIsFastFormattable() { UErrorCode status = U_ZERO_ERROR; DecimalFormatSymbols symbols("en", status); if (!assertSuccess("", status)) { return; } DigitFormatter formatter(symbols); DigitGrouping grouping; FixedPrecision precision; DigitFormatterOptions options; ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); assertTrue("", vf.isFastFormattable(0)); assertTrue("", vf.isFastFormattable(35)); assertTrue("", vf.isFastFormattable(-48)); assertTrue("", vf.isFastFormattable(2147483647)); assertTrue("", vf.isFastFormattable(-2147483647)); assertFalse("", vf.isFastFormattable(-2147483648L)); { DigitGrouping grouping; grouping.fGrouping = 3; ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); assertTrue("0", vf.isFastFormattable(0)); assertTrue("62", vf.isFastFormattable(62)); assertTrue("999", vf.isFastFormattable(999)); assertFalse("1000", vf.isFastFormattable(1000)); assertTrue("-1", vf.isFastFormattable(-1)); assertTrue("-38", vf.isFastFormattable(-38)); assertTrue("-999", vf.isFastFormattable(-999)); assertFalse("-1000", vf.isFastFormattable(-1000)); grouping.fMinGrouping = 2; assertTrue("-1000", vf.isFastFormattable(-1000)); assertTrue("-4095", vf.isFastFormattable(-4095)); assertTrue("4095", vf.isFastFormattable(4095)); // We give up on acounting digits at 4096 assertFalse("-4096", vf.isFastFormattable(-4096)); assertFalse("4096", vf.isFastFormattable(4096)); } { // grouping on but with max integer digits set. DigitGrouping grouping; grouping.fGrouping = 4; FixedPrecision precision; precision.fMax.setIntDigitCount(4); ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); assertTrue("-4096", vf.isFastFormattable(-4096)); assertTrue("4096", vf.isFastFormattable(4096)); assertTrue("-10000", vf.isFastFormattable(-10000)); assertTrue("10000", vf.isFastFormattable(10000)); assertTrue("-2147483647", vf.isFastFormattable(-2147483647)); assertTrue("2147483647", vf.isFastFormattable(2147483647)); precision.fMax.setIntDigitCount(5); assertFalse("-4096", vf.isFastFormattable(-4096)); assertFalse("4096", vf.isFastFormattable(4096)); } { // grouping on but with min integer digits set. DigitGrouping grouping; grouping.fGrouping = 3; FixedPrecision precision; precision.fMin.setIntDigitCount(3); ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); assertTrue("-999", vf.isFastFormattable(-999)); assertTrue("999", vf.isFastFormattable(999)); assertFalse("-1000", vf.isFastFormattable(-1000)); assertFalse("1000", vf.isFastFormattable(1000)); precision.fMin.setIntDigitCount(4); assertFalse("-999", vf.isFastFormattable(-999)); assertFalse("999", vf.isFastFormattable(999)); assertFalse("-2147483647", vf.isFastFormattable(-2147483647)); assertFalse("2147483647", vf.isFastFormattable(2147483647)); } { // options set. DigitFormatterOptions options; ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); assertTrue("5125", vf.isFastFormattable(5125)); options.fAlwaysShowDecimal = TRUE; assertFalse("5125", vf.isFastFormattable(5125)); options.fAlwaysShowDecimal = FALSE; assertTrue("5125", vf.isFastFormattable(5125)); } { // test fraction digits FixedPrecision precision; ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); assertTrue("7127", vf.isFastFormattable(7127)); precision.fMin.setFracDigitCount(1); assertFalse("7127", vf.isFastFormattable(7127)); } { // test presence of significant digits FixedPrecision precision; ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); assertTrue("1049", vf.isFastFormattable(1049)); precision.fSignificant.setMin(1); assertFalse("1049", vf.isFastFormattable(1049)); } { // test presence of rounding increment FixedPrecision precision; ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); assertTrue("1099", vf.isFastFormattable(1099)); precision.fRoundingIncrement.set(2.3); assertFalse("1099", vf.isFastFormattable(1099)); } { // test scientific notation ScientificPrecision precision; SciFormatterOptions options; ValueFormatter vf; vf.prepareScientificFormatting( formatter, precision, options); assertFalse("1081", vf.isFastFormattable(1081)); } } void NumberFormat2Test::TestDigitAffix() { DigitAffix affix; { affix.append("foo"); affix.append("--", UNUM_SIGN_FIELD); affix.append("%", UNUM_PERCENT_FIELD); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 3, 5}, {UNUM_PERCENT_FIELD, 5, 6}, {0, -1, 0}}; verifyAffix("foo--%", affix, expectedAttributes); } { affix.remove(); affix.append("USD", UNUM_CURRENCY_FIELD); affix.append(" "); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_CURRENCY_FIELD, 0, 3}, {0, -1, 0}}; verifyAffix("USD ", affix, expectedAttributes); } { affix.setTo("%%", UNUM_PERCENT_FIELD); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_PERCENT_FIELD, 0, 2}, {0, -1, 0}}; verifyAffix("%%", affix, expectedAttributes); } } void NumberFormat2Test::TestPluralAffix() { UErrorCode status = U_ZERO_ERROR; PluralAffix part; part.setVariant("one", "Dollar", status); part.setVariant("few", "DollarFew", status); part.setVariant("other", "Dollars", status); PluralAffix dollar(part); PluralAffix percent(part); part.remove(); part.setVariant("one", "Percent", status); part.setVariant("many", "PercentMany", status); part.setVariant("other", "Percents", status); percent = part; part.remove(); part.setVariant("one", "foo", status); PluralAffix pa; assertEquals("", "", pa.getOtherVariant().toString()); pa.append(dollar, UNUM_CURRENCY_FIELD, status); pa.append(" and "); pa.append(percent, UNUM_PERCENT_FIELD, status); pa.append("-", UNUM_SIGN_FIELD); { // other NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_CURRENCY_FIELD, 0, 7}, {UNUM_PERCENT_FIELD, 12, 20}, {UNUM_SIGN_FIELD, 20, 21}, {0, -1, 0}}; verifyAffix( "Dollars and Percents-", pa.getByCategory("other"), expectedAttributes); } { // two which is same as other NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_CURRENCY_FIELD, 0, 7}, {UNUM_PERCENT_FIELD, 12, 20}, {UNUM_SIGN_FIELD, 20, 21}, {0, -1, 0}}; verifyAffix( "Dollars and Percents-", pa.getByCategory("two"), expectedAttributes); } { // bad which is same as other NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_CURRENCY_FIELD, 0, 7}, {UNUM_PERCENT_FIELD, 12, 20}, {UNUM_SIGN_FIELD, 20, 21}, {0, -1, 0}}; verifyAffix( "Dollars and Percents-", pa.getByCategory("bad"), expectedAttributes); } { // one NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_CURRENCY_FIELD, 0, 6}, {UNUM_PERCENT_FIELD, 11, 18}, {UNUM_SIGN_FIELD, 18, 19}, {0, -1, 0}}; verifyAffix( "Dollar and Percent-", pa.getByCategory("one"), expectedAttributes); } { // few NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_CURRENCY_FIELD, 0, 9}, {UNUM_PERCENT_FIELD, 14, 22}, {UNUM_SIGN_FIELD, 22, 23}, {0, -1, 0}}; verifyAffix( "DollarFew and Percents-", pa.getByCategory("few"), expectedAttributes); } { // many NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_CURRENCY_FIELD, 0, 7}, {UNUM_PERCENT_FIELD, 12, 23}, {UNUM_SIGN_FIELD, 23, 24}, {0, -1, 0}}; verifyAffix( "Dollars and PercentMany-", pa.getByCategory("many"), expectedAttributes); } assertTrue("", pa.hasMultipleVariants()); pa.remove(); pa.append("$$$", UNUM_CURRENCY_FIELD); assertFalse("", pa.hasMultipleVariants()); } void NumberFormat2Test::TestCurrencyAffixInfo() { CurrencyAffixInfo info; assertTrue("", info.isDefault()); UnicodeString expectedSymbol("\\u00a4"); UnicodeString expectedSymbolIso("\\u00a4\\u00a4"); UnicodeString expectedSymbols("\\u00a4\\u00a4\\u00a4"); assertEquals("", expectedSymbol.unescape(), info.getSymbol()); assertEquals("", expectedSymbolIso.unescape(), info.getISO()); assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("one").toString()); assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("other").toString()); assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("two").toString()); UErrorCode status = U_ZERO_ERROR; static UChar USD[] = {0x55, 0x53, 0x44, 0x0}; LocalPointer rules(PluralRules::forLocale("en", status)); if (!assertSuccess("", status)) { return; } info.set("en", rules.getAlias(), USD, status); assertEquals("", "$", info.getSymbol(), TRUE); assertEquals("", "USD", info.getISO(), TRUE); assertEquals("", "US dollar", info.getLong().getByCategory("one").toString(), TRUE); assertEquals("", "US dollars", info.getLong().getByCategory("other").toString(), TRUE); assertEquals("", "US dollars", info.getLong().getByCategory("two").toString(), TRUE); assertFalse("", info.isDefault()); info.set(NULL, NULL, NULL, status); assertTrue("", info.isDefault()); assertEquals("", expectedSymbol.unescape(), info.getSymbol()); assertEquals("", expectedSymbolIso.unescape(), info.getISO()); assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("one").toString()); assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("other").toString()); assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("two").toString()); info.setSymbol("$"); assertFalse("", info.isDefault()); info.set(NULL, NULL, NULL, status); assertTrue("", info.isDefault()); info.setISO("USD"); assertFalse("", info.isDefault()); assertSuccess("", status); } void NumberFormat2Test::TestAffixPattern() { static UChar chars[500]; for (int32_t i = 0; i < UPRV_LENGTHOF(chars); ++i) { chars[i] = (UChar) (i + 1); } AffixPattern first; first.add(AffixPattern::kPercent); first.addLiteral(chars, 0, 200); first.addLiteral(chars, 200, 300); first.addCurrency(2); first.addLiteral(chars, 0, 256); AffixPattern second; second.add(AffixPattern::kPercent); second.addLiteral(chars, 0, 300); second.addLiteral(chars, 300, 200); second.addCurrency(2); second.addLiteral(chars, 0, 150); second.addLiteral(chars, 150, 106); assertTrue("", first.equals(second)); AffixPatternIterator iter; second.remove(); assertFalse("", second.iterator(iter).nextToken()); assertTrue("", first.iterator(iter).nextToken()); assertEquals("", AffixPattern::kPercent, iter.getTokenType()); assertEquals("", 1, iter.getTokenLength()); assertTrue("", iter.nextToken()); UnicodeString str; assertEquals("", 500, iter.getLiteral(str).length()); assertEquals("", AffixPattern::kLiteral, iter.getTokenType()); assertEquals("", 500, iter.getTokenLength()); assertTrue("", iter.nextToken()); assertEquals("", AffixPattern::kCurrency, iter.getTokenType()); assertEquals("", 2, iter.getTokenLength()); assertTrue("", iter.nextToken()); assertEquals("", 256, iter.getLiteral(str).length()); assertEquals("", AffixPattern::kLiteral, iter.getTokenType()); assertEquals("", 256, iter.getTokenLength()); assertFalse("", iter.nextToken()); } void NumberFormat2Test::TestAffixPatternDoubleQuote() { UnicodeString str("'Don''t'"); AffixPattern expected; // Don't static UChar chars[] = {0x44, 0x6F, 0x6E, 0x27, 0x74}; expected.addLiteral(chars, 0, UPRV_LENGTHOF(chars)); AffixPattern actual; UErrorCode status = U_ZERO_ERROR; AffixPattern::parseUserAffixString(str, actual, status); assertTrue("", expected.equals(actual)); UnicodeString formattedString; assertEquals("", "Don''t", actual.toUserString(formattedString)); assertSuccess("", status); } void NumberFormat2Test::TestAffixPatternParser() { UErrorCode status = U_ZERO_ERROR; static UChar USD[] = {0x55, 0x53, 0x44, 0x0}; LocalPointer rules(PluralRules::forLocale("en", status)); DecimalFormatSymbols symbols("en", status); if (U_FAILURE(status)) { dataerrln("Error creating DecimalFormatSymbols - %s", u_errorName(status)); return; } AffixPatternParser parser(symbols); CurrencyAffixInfo currencyAffixInfo; currencyAffixInfo.set("en", rules.getAlias(), USD, status); PluralAffix affix; UnicodeString str("'--y'''dz'%'\\u00a4\\u00a4\\u00a4\\u00a4 y '\\u00a4\\u00a4\\u00a4 or '\\u00a4\\u00a4 but '\\u00a4"); str = str.unescape(); assertSuccess("", status); AffixPattern affixPattern; parser.parse( AffixPattern::parseAffixString(str, affixPattern, status), currencyAffixInfo, affix, status); UnicodeString formattedStr; affixPattern.toString(formattedStr); UnicodeString expectedFormattedStr("'--y''dz'%'\\u00a4\\u00a4\\u00a4\\u00a4 y '\\u00a4\\u00a4\\u00a4 or '\\u00a4\\u00a4 but '\\u00a4"); expectedFormattedStr = expectedFormattedStr.unescape(); assertEquals("1", expectedFormattedStr, formattedStr); AffixPattern userAffixPattern; UnicodeString userStr("-'-'y'''d'z%\\u00a4\\u00a4\\u00a4'\\u00a4' y \\u00a4\\u00a4\\u00a4 or \\u00a4\\u00a4 but \\u00a4"); userStr = userStr.unescape(); AffixPattern::parseUserAffixString(userStr, userAffixPattern, status), assertTrue("", affixPattern.equals(userAffixPattern)); AffixPattern userAffixPattern2; UnicodeString formattedUserStr; AffixPattern::parseUserAffixString( userAffixPattern.toUserString(formattedUserStr), userAffixPattern2, status); UnicodeString expectedFormattedUserStr( "-'-'y''dz%\\u00a4\\u00a4\\u00a4'\\u00a4' y \\u00a4\\u00a4\\u00a4 or \\u00a4\\u00a4 but \\u00a4"); assertEquals("2", expectedFormattedUserStr.unescape(), formattedUserStr); assertTrue("", userAffixPattern2.equals(userAffixPattern)); assertSuccess("", status); assertTrue("", affixPattern.usesCurrency()); assertTrue("", affixPattern.usesPercent()); assertFalse("", affixPattern.usesPermill()); assertTrue("", affix.hasMultipleVariants()); { // other NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 0, 1}, {UNUM_PERCENT_FIELD, 6, 7}, {UNUM_CURRENCY_FIELD, 7, 17}, {UNUM_CURRENCY_FIELD, 21, 31}, {UNUM_CURRENCY_FIELD, 35, 38}, {UNUM_CURRENCY_FIELD, 43, 44}, {0, -1, 0}}; verifyAffix( "--y'dz%US dollars\\u00a4 y US dollars or USD but $", affix.getByCategory("other"), expectedAttributes); } { // one NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 0, 1}, {UNUM_PERCENT_FIELD, 6, 7}, {UNUM_CURRENCY_FIELD, 7, 16}, {UNUM_CURRENCY_FIELD, 20, 29}, {UNUM_CURRENCY_FIELD, 33, 36}, {UNUM_CURRENCY_FIELD, 41, 42}, {0, -1, 0}}; verifyAffix( "--y'dz%US dollar\\u00a4 y US dollar or USD but $", affix.getByCategory("one"), expectedAttributes); } affix.remove(); str = "%'-"; affixPattern.remove(); parser.parse( AffixPattern::parseAffixString(str, affixPattern, status), currencyAffixInfo, affix, status); assertSuccess("", status); assertFalse("", affixPattern.usesCurrency()); assertFalse("", affixPattern.usesPercent()); assertFalse("", affixPattern.usesPermill()); assertFalse("", affix.hasMultipleVariants()); { // other NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 1, 2}, {0, -1, 0}}; verifyAffix( "%-", affix.getByCategory("other"), expectedAttributes); } UnicodeString a4("\\u00a4"); AffixPattern scratchPattern; AffixPattern::parseAffixString(a4.unescape(), scratchPattern, status); assertFalse("", scratchPattern.usesCurrency()); // Test really long string > 256 chars. str = "'\\u2030012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789"; str = str.unescape(); affixPattern.remove(); affix.remove(); parser.parse( AffixPattern::parseAffixString(str, affixPattern, status), currencyAffixInfo, affix, status); assertSuccess("", status); assertFalse("", affixPattern.usesCurrency()); assertFalse("", affixPattern.usesPercent()); assertTrue("", affixPattern.usesPermill()); assertFalse("", affix.hasMultipleVariants()); { UnicodeString expected = "\\u2030012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789" "012345678901234567890123456789012345678901234567890123456789"; expected = expected.unescape(); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_PERMILL_FIELD, 0, 1}, {0, -1, 0}}; verifyAffix( expected, affix.getOtherVariant(), expectedAttributes); } } void NumberFormat2Test::TestAffixPatternAppend() { AffixPattern pattern; UErrorCode status = U_ZERO_ERROR; UnicodeString patternStr("%\\u2030"); AffixPattern::parseUserAffixString( patternStr.unescape(), pattern, status); AffixPattern appendPattern; UnicodeString appendPatternStr("-\\u00a4\\u00a4*"); AffixPattern::parseUserAffixString( appendPatternStr.unescape(), appendPattern, status); AffixPattern expectedPattern; UnicodeString expectedPatternStr("%\\u2030-\\u00a4\\u00a4*"); AffixPattern::parseUserAffixString( expectedPatternStr.unescape(), expectedPattern, status); assertTrue("", pattern.append(appendPattern).equals(expectedPattern)); assertSuccess("", status); } void NumberFormat2Test::TestAffixPatternAppendAjoiningLiterals() { AffixPattern pattern; UErrorCode status = U_ZERO_ERROR; UnicodeString patternStr("%baaa"); AffixPattern::parseUserAffixString( patternStr, pattern, status); AffixPattern appendPattern; UnicodeString appendPatternStr("caa%"); AffixPattern::parseUserAffixString( appendPatternStr, appendPattern, status); AffixPattern expectedPattern; UnicodeString expectedPatternStr("%baaacaa%"); AffixPattern::parseUserAffixString( expectedPatternStr, expectedPattern, status); assertTrue("", pattern.append(appendPattern).equals(expectedPattern)); assertSuccess("", status); } void NumberFormat2Test::TestLargeIntValue() { VisibleDigits digits; { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; // Last 18 digits for int values. verifyIntValue( 223372036854775807LL, precision.initVisibleDigits(INT64_MAX, digits, status)); assertSuccess("INT64_MAX", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setIntDigitCount(5); // Last 18 digits for int values. verifyIntValue( 75807LL, precision.initVisibleDigits(INT64_MAX, digits, status)); verifySource(75807.0, digits); assertSuccess("75807", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; // Last 18 digits for int values. verifyIntValue( 223372036854775808LL, precision.initVisibleDigits(INT64_MIN, digits, status)); assertSuccess("INT64_MIN", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setIntDigitCount(5); // Last 18 digits for int values. verifyIntValue( 75808LL, precision.initVisibleDigits(INT64_MIN, digits, status)); verifySource(75808.0, digits); assertSuccess("75808", status); } } void NumberFormat2Test::TestIntInitVisibleDigits() { VisibleDigits digits; { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; verifyVisibleDigits( "13", FALSE, precision.initVisibleDigits((int64_t) 13LL, digits, status)); assertSuccess("13", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; verifyVisibleDigits( "17", TRUE, precision.initVisibleDigits((int64_t) -17LL, digits, status)); assertSuccess("-17", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; verifyVisibleDigits( "9223372036854775808", TRUE, precision.initVisibleDigits(INT64_MIN, digits, status)); assertSuccess("-9223372036854775808", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; verifyVisibleDigits( "9223372036854775807", FALSE, precision.initVisibleDigits(INT64_MAX, digits, status)); assertSuccess("9223372036854775807", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; verifyVisibleDigits( "31536000", TRUE, precision.initVisibleDigits((int64_t) -31536000LL, digits, status)); assertSuccess("-31536000", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; verifyVisibleDigits( "0", FALSE, precision.initVisibleDigits((int64_t) 0LL, digits, status)); assertSuccess("0", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMin.setIntDigitCount(4); precision.fMin.setFracDigitCount(2); verifyVisibleDigits( "0000.00", FALSE, precision.initVisibleDigits((int64_t) 0LL, digits, status)); assertSuccess("0", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMin.setIntDigitCount(4); precision.fMin.setFracDigitCount(2); verifyVisibleDigits( "0057.00", FALSE, precision.initVisibleDigits((int64_t) 57LL, digits, status)); assertSuccess("57", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMin.setIntDigitCount(4); precision.fMin.setFracDigitCount(2); verifyVisibleDigits( "0057.00", TRUE, precision.initVisibleDigits((int64_t) -57LL, digits, status)); assertSuccess("-57", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setIntDigitCount(2); precision.fMin.setFracDigitCount(1); verifyVisibleDigits( "35.0", FALSE, precision.initVisibleDigits((int64_t) 235LL, digits, status)); assertSuccess("235", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setIntDigitCount(2); precision.fMin.setFracDigitCount(1); precision.fFailIfOverMax = TRUE; precision.initVisibleDigits((int64_t) 239LL, digits, status); if (status != U_ILLEGAL_ARGUMENT_ERROR) { errln("239: Expected U_ILLEGAL_ARGUMENT_ERROR"); } } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMin(5); verifyVisibleDigits( "153.00", FALSE, precision.initVisibleDigits((int64_t) 153LL, digits, status)); assertSuccess("153", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMax(2); precision.fExactOnly = TRUE; precision.initVisibleDigits((int64_t) 154LL, digits, status); if (status != U_FORMAT_INEXACT_ERROR) { errln("154: Expected U_FORMAT_INEXACT_ERROR"); } } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMax(5); verifyVisibleDigits( "150", FALSE, precision.initVisibleDigits((int64_t) 150LL, digits, status)); assertSuccess("150", status); } } void NumberFormat2Test::TestIntInitVisibleDigitsToDigitList() { VisibleDigits digits; { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fRoundingIncrement.set(7.3); verifyVisibleDigits( "29.2", TRUE, precision.initVisibleDigits((int64_t) -30LL, digits, status)); assertSuccess("-29.2", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fRoundingIncrement.set(7.3); precision.fRoundingMode = DecimalFormat::kRoundFloor; verifyVisibleDigits( "36.5", TRUE, precision.initVisibleDigits((int64_t) -30LL, digits, status)); assertSuccess("-36.5", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMax(3); precision.fRoundingMode = DecimalFormat::kRoundCeiling; verifyVisibleDigits( "1390", FALSE, precision.initVisibleDigits((int64_t) 1381LL, digits, status)); assertSuccess("1390", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMax(1); precision.fRoundingMode = DecimalFormat::kRoundFloor; verifyVisibleDigits( "2000", TRUE, precision.initVisibleDigits((int64_t) -1381LL, digits, status)); assertSuccess("-2000", status); } } void NumberFormat2Test::TestDoubleInitVisibleDigits() { VisibleDigits digits; { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; verifyVisibleDigits( "2.05", FALSE, precision.initVisibleDigits(2.05, digits, status)); assertSuccess("2.05", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; verifyVisibleDigits( "3547", FALSE, precision.initVisibleDigits(3547.0, digits, status)); assertSuccess("3547", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setFracDigitCount(2); precision.fMax.setIntDigitCount(1); precision.fFailIfOverMax = TRUE; precision.fExactOnly = TRUE; verifyVisibleDigits( "2.05", TRUE, precision.initVisibleDigits(-2.05, digits, status)); assertSuccess("-2.05", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setFracDigitCount(1); precision.fMax.setIntDigitCount(1); precision.fFailIfOverMax = TRUE; precision.fExactOnly = TRUE; precision.initVisibleDigits(-2.05, digits, status); if (status != U_FORMAT_INEXACT_ERROR) { errln("6245.3: Expected U_FORMAT_INEXACT_ERROR"); } } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setFracDigitCount(2); precision.fMax.setIntDigitCount(0); precision.fFailIfOverMax = TRUE; precision.fExactOnly = TRUE; precision.initVisibleDigits(-2.05, digits, status); if (status != U_ILLEGAL_ARGUMENT_ERROR) { errln("-2.05: Expected U_ILLEGAL_ARGUMENT_ERROR"); } } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMin.setIntDigitCount(5); precision.fMin.setFracDigitCount(2); precision.fExactOnly = TRUE; verifyVisibleDigits( "06245.30", FALSE, precision.initVisibleDigits(6245.3, digits, status)); assertSuccess("06245.30", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMax(5); precision.fExactOnly = TRUE; verifyVisibleDigits( "6245.3", FALSE, precision.initVisibleDigits(6245.3, digits, status)); assertSuccess("6245.3", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMax(4); precision.fExactOnly = TRUE; precision.initVisibleDigits(6245.3, digits, status); if (status != U_FORMAT_INEXACT_ERROR) { errln("6245.3: Expected U_FORMAT_INEXACT_ERROR"); } } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setIntDigitCount(3); precision.fMin.setFracDigitCount(2); verifyVisibleDigits( "384.90", FALSE, precision.initVisibleDigits(2384.9, digits, status)); assertSuccess("380.00", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setIntDigitCount(3); precision.fMin.setFracDigitCount(2); precision.fFailIfOverMax = TRUE; precision.initVisibleDigits(2384.9, digits, status); if (status != U_ILLEGAL_ARGUMENT_ERROR) { errln("2384.9: Expected U_ILLEGAL_ARGUMENT_ERROR"); } } } void NumberFormat2Test::TestDoubleInitVisibleDigitsToDigitList() { VisibleDigits digits; { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; // 2.01 produces round off error when multiplied by powers of // 10 forcing the use of DigitList. verifyVisibleDigits( "2.01", TRUE, precision.initVisibleDigits(-2.01, digits, status)); assertSuccess("-2.01", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMax(3); precision.fMin.setFracDigitCount(2); verifyVisibleDigits( "2380.00", FALSE, precision.initVisibleDigits(2385.0, digits, status)); assertSuccess("2380.00", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setFracDigitCount(2); verifyVisibleDigits( "45.83", TRUE, precision.initVisibleDigits(-45.8251, digits, status)); assertSuccess("45.83", status); } } void NumberFormat2Test::TestDigitListInitVisibleDigits() { VisibleDigits digits; DigitList dlist; { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fMax.setIntDigitCount(3); precision.fMin.setFracDigitCount(2); precision.fFailIfOverMax = TRUE; dlist.set(2384.9); precision.initVisibleDigits(dlist, digits, status); if (status != U_ILLEGAL_ARGUMENT_ERROR) { errln("2384.9: Expected U_ILLEGAL_ARGUMENT_ERROR"); } } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMax(4); precision.fExactOnly = TRUE; dlist.set(6245.3); precision.initVisibleDigits(dlist, digits, status); if (status != U_FORMAT_INEXACT_ERROR) { errln("6245.3: Expected U_FORMAT_INEXACT_ERROR"); } } } void NumberFormat2Test::TestSpecialInitVisibleDigits() { VisibleDigits digits; { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.fSignificant.setMax(3); precision.fMin.setFracDigitCount(2); precision.initVisibleDigits(-uprv_getInfinity(), digits, status); assertFalse("", digits.isNaN()); assertTrue("", digits.isInfinite()); assertTrue("", digits.isNegative()); assertSuccess("-Inf", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.initVisibleDigits(uprv_getInfinity(), digits, status); assertFalse("", digits.isNaN()); assertTrue("", digits.isInfinite()); assertFalse("", digits.isNegative()); assertSuccess("Inf", status); } { UErrorCode status = U_ZERO_ERROR; FixedPrecision precision; precision.initVisibleDigits(uprv_getNaN(), digits, status); assertTrue("", digits.isNaN()); assertSuccess("Inf", status); } } void NumberFormat2Test::TestVisibleDigitsWithExponent() { VisibleDigitsWithExponent digits; { UErrorCode status = U_ZERO_ERROR; ScientificPrecision precision; precision.initVisibleDigitsWithExponent(389.256, digits, status); verifyVisibleDigitsWithExponent( "3.89256E2", FALSE, digits); assertSuccess("3.89256E2", status); } { UErrorCode status = U_ZERO_ERROR; ScientificPrecision precision; precision.initVisibleDigitsWithExponent(-389.256, digits, status); verifyVisibleDigitsWithExponent( "3.89256E2", TRUE, digits); assertSuccess("-3.89256E2", status); } { UErrorCode status = U_ZERO_ERROR; ScientificPrecision precision; precision.fMinExponentDigits = 3; precision.fMantissa.fMin.setIntDigitCount(1); precision.fMantissa.fMax.setIntDigitCount(3); precision.initVisibleDigitsWithExponent(12345.67, digits, status); verifyVisibleDigitsWithExponent( "12.34567E003", FALSE, digits); assertSuccess("12.34567E003", status); } { UErrorCode status = U_ZERO_ERROR; ScientificPrecision precision; precision.fMantissa.fRoundingIncrement.set(0.073); precision.fMantissa.fMin.setIntDigitCount(2); precision.fMantissa.fMax.setIntDigitCount(2); precision.initVisibleDigitsWithExponent(999.74, digits, status); verifyVisibleDigitsWithExponent( "10.001E2", FALSE, digits); assertSuccess("10.001E2", status); } } void NumberFormat2Test::TestDigitAffixesAndPadding() { UErrorCode status = U_ZERO_ERROR; DecimalFormatSymbols symbols("en", status); if (!assertSuccess("", status)) { return; } DigitFormatter formatter(symbols); DigitGrouping grouping; grouping.fGrouping = 3; FixedPrecision precision; DigitFormatterOptions options; options.fAlwaysShowDecimal = TRUE; ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); DigitAffixesAndPadding aap; aap.fPositivePrefix.append("(+", UNUM_SIGN_FIELD); aap.fPositiveSuffix.append("+)", UNUM_SIGN_FIELD); aap.fNegativePrefix.append("(-", UNUM_SIGN_FIELD); aap.fNegativeSuffix.append("-)", UNUM_SIGN_FIELD); aap.fWidth = 10; aap.fPadPosition = DigitAffixesAndPadding::kPadBeforePrefix; { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 4, 6}, {UNUM_INTEGER_FIELD, 6, 7}, {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8}, {UNUM_SIGN_FIELD, 8, 10}, {0, -1, 0}}; verifyAffixesAndPaddingInt32( "****(+3.+)", aap, 3, vf, NULL, expectedAttributes); } aap.fPadPosition = DigitAffixesAndPadding::kPadAfterPrefix; { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 0, 2}, {UNUM_INTEGER_FIELD, 6, 7}, {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8}, {UNUM_SIGN_FIELD, 8, 10}, {0, -1, 0}}; verifyAffixesAndPaddingInt32( "(+****3.+)", aap, 3, vf, NULL, expectedAttributes); } aap.fPadPosition = DigitAffixesAndPadding::kPadBeforeSuffix; { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 0, 2}, {UNUM_INTEGER_FIELD, 2, 3}, {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4}, {UNUM_SIGN_FIELD, 8, 10}, {0, -1, 0}}; verifyAffixesAndPaddingInt32( "(+3.****+)", aap, 3, vf, NULL, expectedAttributes); } aap.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix; { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 0, 2}, {UNUM_INTEGER_FIELD, 2, 3}, {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4}, {UNUM_SIGN_FIELD, 4, 6}, {0, -1, 0}}; verifyAffixesAndPaddingInt32( "(+3.+)****", aap, 3, vf, NULL, expectedAttributes); } aap.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix; { DigitList digits; digits.set(-1234.5); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 0, 2}, {UNUM_GROUPING_SEPARATOR_FIELD, 3, 4}, {UNUM_INTEGER_FIELD, 2, 7}, {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8}, {UNUM_FRACTION_FIELD, 8, 9}, {UNUM_SIGN_FIELD, 9, 11}, {0, -1, 0}}; verifyAffixesAndPadding( "(-1,234.5-)", aap, digits, vf, NULL, expectedAttributes); } assertFalse("", aap.needsPluralRules()); aap.fWidth = 0; aap.fPositivePrefix.remove(); aap.fPositiveSuffix.remove(); aap.fNegativePrefix.remove(); aap.fNegativeSuffix.remove(); // Set up for plural currencies. aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD); { PluralAffix part; part.setVariant("one", " Dollar", status); part.setVariant("other", " Dollars", status); aap.fPositiveSuffix.append(part, UNUM_CURRENCY_FIELD, status); } aap.fNegativeSuffix = aap.fPositiveSuffix; LocalPointer rules(PluralRules::forLocale("en", status)); if (!assertSuccess("", status)) { return; } // Exercise the fastrack path { options.fAlwaysShowDecimal = FALSE; NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 0, 1}, {UNUM_INTEGER_FIELD, 1, 3}, {UNUM_CURRENCY_FIELD, 3, 11}, {0, -1, 0}}; verifyAffixesAndPaddingInt32( "-45 Dollars", aap, -45, vf, NULL, expectedAttributes); options.fAlwaysShowDecimal = TRUE; } // Now test plurals assertTrue("", aap.needsPluralRules()); { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, {UNUM_CURRENCY_FIELD, 2, 9}, {0, -1, 0}}; verifyAffixesAndPaddingInt32( "1. Dollar", aap, 1, vf, rules.getAlias(), expectedAttributes); } { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 0, 1}, {UNUM_INTEGER_FIELD, 1, 2}, {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3}, {UNUM_CURRENCY_FIELD, 3, 10}, {0, -1, 0}}; verifyAffixesAndPaddingInt32( "-1. Dollar", aap, -1, vf, rules.getAlias(), expectedAttributes); } precision.fMin.setFracDigitCount(2); { NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, {UNUM_FRACTION_FIELD, 2, 4}, {UNUM_CURRENCY_FIELD, 4, 12}, {0, -1, 0}}; verifyAffixesAndPaddingInt32( "1.00 Dollars", aap, 1, vf, rules.getAlias(), expectedAttributes); } } void NumberFormat2Test::TestPluralsAndRounding() { UErrorCode status = U_ZERO_ERROR; DecimalFormatSymbols symbols("en", status); if (!assertSuccess("", status)) { return; } DigitFormatter formatter(symbols); DigitGrouping grouping; FixedPrecision precision; precision.fSignificant.setMax(3); DigitFormatterOptions options; ValueFormatter vf; vf.prepareFixedDecimalFormatting( formatter, grouping, precision, options); DigitList digits; DigitAffixesAndPadding aap; // Set up for plural currencies. aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD); { PluralAffix part; part.setVariant("one", " Dollar", status); part.setVariant("other", " Dollars", status); aap.fPositiveSuffix.append(part, UNUM_CURRENCY_FIELD, status); } aap.fNegativeSuffix = aap.fPositiveSuffix; aap.fWidth = 14; LocalPointer rules(PluralRules::forLocale("en", status)); if (!assertSuccess("", status)) { return; } { digits.set(0.999); verifyAffixesAndPadding( "*0.999 Dollars", aap, digits, vf, rules.getAlias(), NULL); } { digits.set(0.9996); verifyAffixesAndPadding( "******1 Dollar", aap, digits, vf, rules.getAlias(), NULL); } { digits.set(1.004); verifyAffixesAndPadding( "******1 Dollar", aap, digits, vf, rules.getAlias(), NULL); } precision.fSignificant.setMin(2); { digits.set(0.9996); verifyAffixesAndPadding( "***1.0 Dollars", aap, digits, vf, rules.getAlias(), NULL); } { digits.set(1.004); verifyAffixesAndPadding( "***1.0 Dollars", aap, digits, vf, rules.getAlias(), NULL); } precision.fSignificant.setMin(0); { digits.set(-79.214); verifyAffixesAndPadding( "*-79.2 Dollars", aap, digits, vf, rules.getAlias(), NULL); } // No more sig digits just max fractions precision.fSignificant.setMax(0); precision.fMax.setFracDigitCount(4); { digits.set(79.213562); verifyAffixesAndPadding( "79.2136 Dollars", aap, digits, vf, rules.getAlias(), NULL); } } void NumberFormat2Test::TestPluralsAndRoundingScientific() { UErrorCode status = U_ZERO_ERROR; DecimalFormatSymbols symbols("en", status); if (!assertSuccess("", status)) { return; } DigitFormatter formatter(symbols); ScientificPrecision precision; precision.fMantissa.fSignificant.setMax(4); SciFormatterOptions options; ValueFormatter vf; vf.prepareScientificFormatting( formatter, precision, options); DigitList digits; DigitAffixesAndPadding aap; aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD); { PluralAffix part; part.setVariant("one", " Meter", status); part.setVariant("other", " Meters", status); aap.fPositiveSuffix.append(part, UNUM_FIELD_COUNT, status); } aap.fNegativeSuffix = aap.fPositiveSuffix; LocalPointer rules(PluralRules::forLocale("en", status)); if (!assertSuccess("", status)) { return; } { digits.set(0.99996); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {UNUM_EXPONENT_SYMBOL_FIELD, 1, 2}, {UNUM_EXPONENT_FIELD, 2, 3}, {0, -1, 0}}; verifyAffixesAndPadding( "1E0 Meters", aap, digits, vf, rules.getAlias(), expectedAttributes); } options.fMantissa.fAlwaysShowDecimal = TRUE; { digits.set(0.99996); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, {UNUM_EXPONENT_SYMBOL_FIELD, 2, 3}, {UNUM_EXPONENT_FIELD, 3, 4}, {0, -1, 0}}; verifyAffixesAndPadding( "1.E0 Meters", aap, digits, vf, rules.getAlias(), expectedAttributes); } { digits.set(-299792458); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_SIGN_FIELD, 0, 1}, {UNUM_INTEGER_FIELD, 1, 2}, {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3}, {UNUM_FRACTION_FIELD, 3, 6}, {UNUM_EXPONENT_SYMBOL_FIELD, 6, 7}, {UNUM_EXPONENT_FIELD, 7, 8}, {0, -1, 0}}; verifyAffixesAndPadding( "-2.998E8 Meters", aap, digits, vf, rules.getAlias(), expectedAttributes); } precision.fMantissa.fSignificant.setMin(4); options.fExponent.fAlwaysShowSign = TRUE; precision.fMinExponentDigits = 3; { digits.set(3); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, {UNUM_FRACTION_FIELD, 2, 5}, {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6}, {UNUM_EXPONENT_SIGN_FIELD, 6, 7}, {UNUM_EXPONENT_FIELD, 7, 10}, {0, -1, 0}}; verifyAffixesAndPadding( "3.000E+000 Meters", aap, digits, vf, rules.getAlias(), expectedAttributes); } precision.fMantissa.fMax.setIntDigitCount(3); { digits.set(0.00025001); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 3}, {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4}, {UNUM_FRACTION_FIELD, 4, 5}, {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6}, {UNUM_EXPONENT_SIGN_FIELD, 6, 7}, {UNUM_EXPONENT_FIELD, 7, 10}, {0, -1, 0}}; verifyAffixesAndPadding( "250.0E-006 Meters", aap, digits, vf, rules.getAlias(), expectedAttributes); } { digits.set(0.0000025001); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, {UNUM_FRACTION_FIELD, 2, 5}, {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6}, {UNUM_EXPONENT_SIGN_FIELD, 6, 7}, {UNUM_EXPONENT_FIELD, 7, 10}, {0, -1, 0}}; verifyAffixesAndPadding( "2.500E-006 Meters", aap, digits, vf, rules.getAlias(), expectedAttributes); } precision.fMantissa.fMax.setFracDigitCount(1); { digits.set(0.0000025499); NumberFormat2Test_Attributes expectedAttributes[] = { {UNUM_INTEGER_FIELD, 0, 1}, {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, {UNUM_FRACTION_FIELD, 2, 3}, {UNUM_EXPONENT_SYMBOL_FIELD, 3, 4}, {UNUM_EXPONENT_SIGN_FIELD, 4, 5}, {UNUM_EXPONENT_FIELD, 5, 8}, {0, -1, 0}}; verifyAffixesAndPadding( "2.5E-006 Meters", aap, digits, vf, rules.getAlias(), expectedAttributes); } precision.fMantissa.fMax.setIntDigitCount(1); precision.fMantissa.fMax.setFracDigitCount(2); { digits.set(299792458); verifyAffixesAndPadding( "3.00E+008 Meters", aap, digits, vf, rules.getAlias(), NULL); } // clear significant digits precision.fMantissa.fSignificant.setMin(0); precision.fMantissa.fSignificant.setMax(0); // set int and fraction digits precision.fMantissa.fMin.setFracDigitCount(2); precision.fMantissa.fMax.setFracDigitCount(4); precision.fMantissa.fMin.setIntDigitCount(2); precision.fMantissa.fMax.setIntDigitCount(3); { digits.set(-0.0000025300001); verifyAffixesAndPadding( "-253.00E-008 Meters", aap, digits, vf, rules.getAlias(), NULL); } { digits.set(-0.0000025300006); verifyAffixesAndPadding( "-253.0001E-008 Meters", aap, digits, vf, rules.getAlias(), NULL); } { digits.set(-0.000025300006); verifyAffixesAndPadding( "-25.30E-006 Meters", aap, digits, vf, rules.getAlias(), NULL); } } void NumberFormat2Test::TestRoundingIncrement() { UErrorCode status = U_ZERO_ERROR; DecimalFormatSymbols symbols("en", status); if (U_FAILURE(status)) { dataerrln("Error creating DecimalFormatSymbols - %s", u_errorName(status)); return; } DigitFormatter formatter(symbols); ScientificPrecision precision; SciFormatterOptions options; precision.fMantissa.fRoundingIncrement.set(0.25); precision.fMantissa.fSignificant.setMax(4); DigitGrouping grouping; ValueFormatter vf; // fixed vf.prepareFixedDecimalFormatting( formatter, grouping, precision.fMantissa, options.fMantissa); DigitList digits; DigitAffixesAndPadding aap; aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD); { digits.set(3.7); verifyAffixesAndPadding( "3.75", aap, digits, vf, NULL, NULL); } { digits.set(-7.4); verifyAffixesAndPadding( "-7.5", aap, digits, vf, NULL, NULL); } { digits.set(99.8); verifyAffixesAndPadding( "99.75", aap, digits, vf, NULL, NULL); } precision.fMantissa.fMin.setFracDigitCount(2); { digits.set(99.1); verifyAffixesAndPadding( "99.00", aap, digits, vf, NULL, NULL); } { digits.set(-639.65); verifyAffixesAndPadding( "-639.80", aap, digits, vf, NULL, NULL); } precision.fMantissa.fMin.setIntDigitCount(2); // Scientific notation vf.prepareScientificFormatting( formatter, precision, options); { digits.set(-6396.5); verifyAffixesAndPadding( "-64.00E2", aap, digits, vf, NULL, NULL); } { digits.set(-0.00092374); verifyAffixesAndPadding( "-92.25E-5", aap, digits, vf, NULL, NULL); } precision.fMantissa.fMax.setIntDigitCount(3); { digits.set(-0.00092374); verifyAffixesAndPadding( "-923.80E-6", aap, digits, vf, NULL, NULL); } } void NumberFormat2Test::TestToPatternScientific11648() { /* UErrorCode status = U_ZERO_ERROR; Locale en("en"); DecimalFormat2 fmt(en, "0.00", status); fmt.setScientificNotation(TRUE); UnicodeString pattern; // Fails, produces "0.00E" assertEquals("", "0.00E0", fmt.toPattern(pattern)); DecimalFormat fmt2(pattern, status); // Fails, bad pattern. assertSuccess("", status); */ } void NumberFormat2Test::verifyAffixesAndPadding( const UnicodeString &expected, const DigitAffixesAndPadding &aaf, DigitList &digits, const ValueFormatter &vf, const PluralRules *optPluralRules, const NumberFormat2Test_Attributes *expectedAttributes) { UnicodeString appendTo; NumberFormat2Test_FieldPositionHandler handler; UErrorCode status = U_ZERO_ERROR; assertEquals( "", expected, aaf.format( digits, vf, handler, optPluralRules, appendTo, status)); if (!assertSuccess("", status)) { return; } if (expectedAttributes != NULL) { verifyAttributes(expectedAttributes, handler.attributes); } } void NumberFormat2Test::verifyAffixesAndPaddingInt32( const UnicodeString &expected, const DigitAffixesAndPadding &aaf, int32_t value, const ValueFormatter &vf, const PluralRules *optPluralRules, const NumberFormat2Test_Attributes *expectedAttributes) { UnicodeString appendTo; NumberFormat2Test_FieldPositionHandler handler; UErrorCode status = U_ZERO_ERROR; assertEquals( "", expected, aaf.formatInt32( value, vf, handler, optPluralRules, appendTo, status)); if (!assertSuccess("", status)) { return; } if (expectedAttributes != NULL) { verifyAttributes(expectedAttributes, handler.attributes); } DigitList digits; digits.set(value); verifyAffixesAndPadding( expected, aaf, digits, vf, optPluralRules, expectedAttributes); } void NumberFormat2Test::verifyAffix( const UnicodeString &expected, const DigitAffix &affix, const NumberFormat2Test_Attributes *expectedAttributes) { UnicodeString appendTo; NumberFormat2Test_FieldPositionHandler handler; assertEquals( "", expected.unescape(), affix.format(handler, appendTo)); if (expectedAttributes != NULL) { verifyAttributes(expectedAttributes, handler.attributes); } } // Right now only works for positive values. void NumberFormat2Test::verifyDigitList( const UnicodeString &expected, const DigitList &digits) { DigitFormatter formatter; DigitGrouping grouping; VisibleDigits visibleDigits; FixedPrecision precision; precision.fMin.setIntDigitCount(0); DigitFormatterOptions options; UErrorCode status = U_ZERO_ERROR; DigitList dlCopy(digits); precision.initVisibleDigits( dlCopy, visibleDigits, status); if (!assertSuccess("", status)) { return; } verifyDigitFormatter( expected, formatter, visibleDigits, grouping, options, NULL); } void NumberFormat2Test::verifyVisibleDigits( const UnicodeString &expected, UBool bNegative, const VisibleDigits &digits) { DigitFormatter formatter; DigitGrouping grouping; DigitFormatterOptions options; verifyDigitFormatter( expected, formatter, digits, grouping, options, NULL); if (digits.isNegative() != bNegative) { errln(expected + ": Wrong sign."); } if (digits.isNaN() || digits.isInfinite()) { errln(expected + ": Require real value."); } } void NumberFormat2Test::verifyVisibleDigitsWithExponent( const UnicodeString &expected, UBool bNegative, const VisibleDigitsWithExponent &digits) { DigitFormatter formatter; SciFormatterOptions options; verifySciFormatter( expected, formatter, digits, options, NULL); if (digits.isNegative() != bNegative) { errln(expected + ": Wrong sign."); } if (digits.isNaN() || digits.isInfinite()) { errln(expected + ": Require real value."); } } void NumberFormat2Test::verifySciFormatter( const UnicodeString &expected, const DigitFormatter &formatter, const VisibleDigitsWithExponent &digits, const SciFormatterOptions &options, const NumberFormat2Test_Attributes *expectedAttributes) { assertEquals( "", expected.countChar32(), formatter.countChar32(digits, options)); UnicodeString appendTo; NumberFormat2Test_FieldPositionHandler handler; assertEquals( "", expected, formatter.format( digits, options, handler, appendTo)); if (expectedAttributes != NULL) { verifyAttributes(expectedAttributes, handler.attributes); } } void NumberFormat2Test::verifyPositiveIntDigitFormatter( const UnicodeString &expected, const DigitFormatter &formatter, int32_t value, int32_t minDigits, int32_t maxDigits, const NumberFormat2Test_Attributes *expectedAttributes) { IntDigitCountRange range(minDigits, maxDigits); UnicodeString appendTo; NumberFormat2Test_FieldPositionHandler handler; assertEquals( "", expected, formatter.formatPositiveInt32( value, range, handler, appendTo)); if (expectedAttributes != NULL) { verifyAttributes(expectedAttributes, handler.attributes); } } void NumberFormat2Test::verifyDigitFormatter( const UnicodeString &expected, const DigitFormatter &formatter, const VisibleDigits &digits, const DigitGrouping &grouping, const DigitFormatterOptions &options, const NumberFormat2Test_Attributes *expectedAttributes) { assertEquals( "", expected.countChar32(), formatter.countChar32(digits, grouping, options)); UnicodeString appendTo; NumberFormat2Test_FieldPositionHandler handler; assertEquals( "", expected, formatter.format( digits, grouping, options, handler, appendTo)); if (expectedAttributes != NULL) { verifyAttributes(expectedAttributes, handler.attributes); } } void NumberFormat2Test::verifySmallIntFormatter( const UnicodeString &expected, int32_t positiveValue, int32_t minDigits, int32_t maxDigits) { IntDigitCountRange range(minDigits, maxDigits); if (!SmallIntFormatter::canFormat(positiveValue, range)) { UnicodeString actual; assertEquals("", expected, actual); return; } UnicodeString actual; assertEquals("", expected, SmallIntFormatter::format(positiveValue, range, actual)); } void NumberFormat2Test::verifyAttributes( const NumberFormat2Test_Attributes *expected, const NumberFormat2Test_Attributes *actual) { int32_t idx = 0; while (expected[idx].spos != -1 && actual[idx].spos != -1) { assertEquals("id", expected[idx].id, actual[idx].id); assertEquals("spos", expected[idx].spos, actual[idx].spos); assertEquals("epos", expected[idx].epos, actual[idx].epos); ++idx; } assertEquals( "expected and actual not same length", expected[idx].spos, actual[idx].spos); } void NumberFormat2Test::verifyIntValue( int64_t expected, const VisibleDigits &digits) { double unusedSource; int64_t intValue; int64_t unusedF; int64_t unusedT; int32_t unusedV; UBool unusedHasIntValue; digits.getFixedDecimal( unusedSource, intValue, unusedF, unusedT, unusedV, unusedHasIntValue); assertEquals("", expected, intValue); } void NumberFormat2Test::verifySource( double expected, const VisibleDigits &digits) { double source; int64_t unusedIntValue; int64_t unusedF; int64_t unusedT; int32_t unusedV; UBool unusedHasIntValue; digits.getFixedDecimal( source, unusedIntValue, unusedF, unusedT, unusedV, unusedHasIntValue); if (expected != source) { errln("Expected %f, got %f instead", expected, source); } } extern IntlTest *createNumberFormat2Test() { return new NumberFormat2Test(); } #endif /* !UCONFIG_NO_FORMATTING */