| // © 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 "number_decimalquantity.h" |
| #include "number_decnum.h" |
| #include "math.h" |
| #include <cmath> |
| #include "number_utils.h" |
| #include "numbertest.h" |
| |
| void DecimalQuantityTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char *) { |
| if (exec) { |
| logln("TestSuite DecimalQuantityTest: "); |
| } |
| TESTCASE_AUTO_BEGIN; |
| TESTCASE_AUTO(testDecimalQuantityBehaviorStandalone); |
| TESTCASE_AUTO(testSwitchStorage); |
| TESTCASE_AUTO(testCopyMove); |
| TESTCASE_AUTO(testAppend); |
| if (!quick) { |
| // Slow test: run in exhaustive mode only |
| TESTCASE_AUTO(testConvertToAccurateDouble); |
| } |
| TESTCASE_AUTO(testUseApproximateDoubleWhenAble); |
| TESTCASE_AUTO(testHardDoubleConversion); |
| TESTCASE_AUTO(testToDouble); |
| TESTCASE_AUTO(testMaxDigits); |
| TESTCASE_AUTO(testNickelRounding); |
| TESTCASE_AUTO(testCompactDecimalSuppressedExponent); |
| TESTCASE_AUTO(testSuppressedExponentUnchangedByInitialScaling); |
| TESTCASE_AUTO_END; |
| } |
| |
| void DecimalQuantityTest::assertDoubleEquals(UnicodeString message, double a, double b) { |
| if (a == b) { |
| return; |
| } |
| |
| double diff = a - b; |
| diff = diff < 0 ? -diff : diff; |
| double bound = a < 0 ? -a * 1e-6 : a * 1e-6; |
| if (diff > bound) { |
| errln(message + u": " + DoubleToUnicodeString(a) + u" vs " + DoubleToUnicodeString(b) + u" differ by " + DoubleToUnicodeString(diff)); |
| } |
| } |
| |
| void DecimalQuantityTest::assertHealth(const DecimalQuantity &fq) { |
| const char16_t* health = fq.checkHealth(); |
| if (health != nullptr) { |
| errln(UnicodeString(u"HEALTH FAILURE: ") + UnicodeString(health) + u": " + fq.toString()); |
| } |
| } |
| |
| void |
| DecimalQuantityTest::assertToStringAndHealth(const DecimalQuantity &fq, const UnicodeString &expected) { |
| UnicodeString actual = fq.toString(); |
| assertEquals("DecimalQuantity toString failed", expected, actual); |
| assertHealth(fq); |
| } |
| |
| void DecimalQuantityTest::checkDoubleBehavior(double d, bool explicitRequired) { |
| DecimalQuantity fq; |
| fq.setToDouble(d); |
| if (explicitRequired) { |
| assertTrue("Should be using approximate double", !fq.isExplicitExactDouble()); |
| } |
| UnicodeString baseStr = fq.toString(); |
| fq.roundToInfinity(); |
| UnicodeString newStr = fq.toString(); |
| if (explicitRequired) { |
| assertTrue("Should not be using approximate double", fq.isExplicitExactDouble()); |
| } |
| assertDoubleEquals( |
| UnicodeString(u"After conversion to exact BCD (double): ") + baseStr + u" vs " + newStr, |
| d, fq.toDouble()); |
| } |
| |
| void DecimalQuantityTest::testDecimalQuantityBehaviorStandalone() { |
| UErrorCode status = U_ZERO_ERROR; |
| DecimalQuantity fq; |
| assertToStringAndHealth(fq, u"<DecimalQuantity 0:0 long 0E0>"); |
| fq.setToInt(51423); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 0:0 long 51423E0>"); |
| fq.adjustMagnitude(-3); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 0:0 long 51423E-3>"); |
| |
| fq.setToLong(90909090909000L); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 0:0 long 90909090909E3>"); |
| fq.setMinInteger(2); |
| fq.applyMaxInteger(5); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 2:0 long 9E3>"); |
| fq.setMinFraction(3); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 2:-3 long 9E3>"); |
| |
| fq.setToDouble(987.654321); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 2:-3 long 987654321E-6>"); |
| fq.roundToInfinity(); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 2:-3 long 987654321E-6>"); |
| fq.roundToIncrement(0.005, RoundingMode::UNUM_ROUND_HALFEVEN, status); |
| assertSuccess("Rounding to increment", status); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 2:-3 long 987655E-3>"); |
| fq.roundToMagnitude(-2, RoundingMode::UNUM_ROUND_HALFEVEN, status); |
| assertSuccess("Rounding to magnitude", status); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 2:-3 long 98766E-2>"); |
| } |
| |
| void DecimalQuantityTest::testSwitchStorage() { |
| UErrorCode status = U_ZERO_ERROR; |
| DecimalQuantity fq; |
| |
| fq.setToLong(1234123412341234L); |
| assertFalse("Should not be using byte array", fq.isUsingBytes()); |
| assertEquals("Failed on initialize", u"1.234123412341234E+15", fq.toScientificString()); |
| assertHealth(fq); |
| // Long -> Bytes |
| fq.appendDigit(5, 0, true); |
| assertTrue("Should be using byte array", fq.isUsingBytes()); |
| assertEquals("Failed on multiply", u"1.2341234123412345E+16", fq.toScientificString()); |
| assertHealth(fq); |
| // Bytes -> Long |
| fq.roundToMagnitude(5, RoundingMode::UNUM_ROUND_HALFEVEN, status); |
| assertSuccess("Rounding to magnitude", status); |
| assertFalse("Should not be using byte array", fq.isUsingBytes()); |
| assertEquals("Failed on round", u"1.23412341234E+16", fq.toScientificString()); |
| assertHealth(fq); |
| // Bytes with popFromLeft |
| fq.setToDecNumber({"999999999999999999"}, status); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 0:0 bytes 999999999999999999E0>"); |
| fq.applyMaxInteger(17); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 0:0 bytes 99999999999999999E0>"); |
| fq.applyMaxInteger(16); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 0:0 long 9999999999999999E0>"); |
| fq.applyMaxInteger(15); |
| assertToStringAndHealth(fq, u"<DecimalQuantity 0:0 long 999999999999999E0>"); |
| } |
| |
| void DecimalQuantityTest::testCopyMove() { |
| // Small numbers (fits in BCD long) |
| { |
| DecimalQuantity a; |
| a.setToLong(1234123412341234L); |
| DecimalQuantity b = a; // copy constructor |
| assertToStringAndHealth(a, u"<DecimalQuantity 0:0 long 1234123412341234E0>"); |
| assertToStringAndHealth(b, u"<DecimalQuantity 0:0 long 1234123412341234E0>"); |
| DecimalQuantity c(std::move(a)); // move constructor |
| assertToStringAndHealth(c, u"<DecimalQuantity 0:0 long 1234123412341234E0>"); |
| c.setToLong(54321L); |
| assertToStringAndHealth(c, u"<DecimalQuantity 0:0 long 54321E0>"); |
| c = b; // copy assignment |
| assertToStringAndHealth(b, u"<DecimalQuantity 0:0 long 1234123412341234E0>"); |
| assertToStringAndHealth(c, u"<DecimalQuantity 0:0 long 1234123412341234E0>"); |
| b.setToLong(45678); |
| c.setToLong(56789); |
| c = std::move(b); // move assignment |
| assertToStringAndHealth(c, u"<DecimalQuantity 0:0 long 45678E0>"); |
| a = std::move(c); // move assignment to a defunct object |
| assertToStringAndHealth(a, u"<DecimalQuantity 0:0 long 45678E0>"); |
| } |
| |
| // Large numbers (requires byte allocation) |
| { |
| IcuTestErrorCode status(*this, "testCopyMove"); |
| DecimalQuantity a; |
| a.setToDecNumber({"1234567890123456789", -1}, status); |
| DecimalQuantity b = a; // copy constructor |
| assertToStringAndHealth(a, u"<DecimalQuantity 0:0 bytes 1234567890123456789E0>"); |
| assertToStringAndHealth(b, u"<DecimalQuantity 0:0 bytes 1234567890123456789E0>"); |
| DecimalQuantity c(std::move(a)); // move constructor |
| assertToStringAndHealth(c, u"<DecimalQuantity 0:0 bytes 1234567890123456789E0>"); |
| c.setToDecNumber({"9876543210987654321", -1}, status); |
| assertToStringAndHealth(c, u"<DecimalQuantity 0:0 bytes 9876543210987654321E0>"); |
| c = b; // copy assignment |
| assertToStringAndHealth(b, u"<DecimalQuantity 0:0 bytes 1234567890123456789E0>"); |
| assertToStringAndHealth(c, u"<DecimalQuantity 0:0 bytes 1234567890123456789E0>"); |
| b.setToDecNumber({"876543210987654321", -1}, status); |
| c.setToDecNumber({"987654321098765432", -1}, status); |
| c = std::move(b); // move assignment |
| assertToStringAndHealth(c, u"<DecimalQuantity 0:0 bytes 876543210987654321E0>"); |
| a = std::move(c); // move assignment to a defunct object |
| assertToStringAndHealth(a, u"<DecimalQuantity 0:0 bytes 876543210987654321E0>"); |
| } |
| } |
| |
| void DecimalQuantityTest::testAppend() { |
| DecimalQuantity fq; |
| fq.appendDigit(1, 0, true); |
| assertEquals("Failed on append", u"1E+0", fq.toScientificString()); |
| assertHealth(fq); |
| fq.appendDigit(2, 0, true); |
| assertEquals("Failed on append", u"1.2E+1", fq.toScientificString()); |
| assertHealth(fq); |
| fq.appendDigit(3, 1, true); |
| assertEquals("Failed on append", u"1.203E+3", fq.toScientificString()); |
| assertHealth(fq); |
| fq.appendDigit(0, 1, true); |
| assertEquals("Failed on append", u"1.203E+5", fq.toScientificString()); |
| assertHealth(fq); |
| fq.appendDigit(4, 0, true); |
| assertEquals("Failed on append", u"1.203004E+6", fq.toScientificString()); |
| assertHealth(fq); |
| fq.appendDigit(0, 0, true); |
| assertEquals("Failed on append", u"1.203004E+7", fq.toScientificString()); |
| assertHealth(fq); |
| fq.appendDigit(5, 0, false); |
| assertEquals("Failed on append", u"1.20300405E+7", fq.toScientificString()); |
| assertHealth(fq); |
| fq.appendDigit(6, 0, false); |
| assertEquals("Failed on append", u"1.203004056E+7", fq.toScientificString()); |
| assertHealth(fq); |
| fq.appendDigit(7, 3, false); |
| assertEquals("Failed on append", u"1.2030040560007E+7", fq.toScientificString()); |
| assertHealth(fq); |
| UnicodeString baseExpected(u"1.2030040560007"); |
| for (int i = 0; i < 10; i++) { |
| fq.appendDigit(8, 0, false); |
| baseExpected.append(u'8'); |
| UnicodeString expected(baseExpected); |
| expected.append(u"E+7"); |
| assertEquals("Failed on append", expected, fq.toScientificString()); |
| assertHealth(fq); |
| } |
| fq.appendDigit(9, 2, false); |
| baseExpected.append(u"009"); |
| UnicodeString expected(baseExpected); |
| expected.append(u"E+7"); |
| assertEquals("Failed on append", expected, fq.toScientificString()); |
| assertHealth(fq); |
| } |
| |
| void DecimalQuantityTest::testConvertToAccurateDouble() { |
| // based on https://github.com/google/double-conversion/issues/28 |
| static double hardDoubles[] = { |
| 1651087494906221570.0, |
| 2.207817077636718750000000000000, |
| 1.818351745605468750000000000000, |
| 3.941719055175781250000000000000, |
| 3.738609313964843750000000000000, |
| 3.967735290527343750000000000000, |
| 1.328025817871093750000000000000, |
| 3.920967102050781250000000000000, |
| 1.015235900878906250000000000000, |
| 1.335227966308593750000000000000, |
| 1.344520568847656250000000000000, |
| 2.879127502441406250000000000000, |
| 3.695838928222656250000000000000, |
| 1.845344543457031250000000000000, |
| 3.793952941894531250000000000000, |
| 3.211402893066406250000000000000, |
| 2.565971374511718750000000000000, |
| 0.965156555175781250000000000000, |
| 2.700004577636718750000000000000, |
| 0.767097473144531250000000000000, |
| 1.780448913574218750000000000000, |
| 2.624839782714843750000000000000, |
| 1.305290222167968750000000000000, |
| 3.834922790527343750000000000000,}; |
| |
| static double exactDoubles[] = { |
| 51423, |
| 51423e10, |
| -5074790912492772E-327, |
| 83602530019752571E-327, |
| 4.503599627370496E15, |
| 6.789512076111555E15, |
| 9.007199254740991E15, |
| 9.007199254740992E15}; |
| |
| for (double d : hardDoubles) { |
| checkDoubleBehavior(d, true); |
| } |
| |
| for (double d : exactDoubles) { |
| checkDoubleBehavior(d, false); |
| } |
| |
| assertDoubleEquals(u"NaN check failed", NAN, DecimalQuantity().setToDouble(NAN).toDouble()); |
| assertDoubleEquals( |
| u"Inf check failed", INFINITY, DecimalQuantity().setToDouble(INFINITY).toDouble()); |
| assertDoubleEquals( |
| u"-Inf check failed", -INFINITY, DecimalQuantity().setToDouble(-INFINITY).toDouble()); |
| |
| // Generate random doubles |
| for (int32_t i = 0; i < 10000; i++) { |
| uint8_t bytes[8]; |
| for (int32_t j = 0; j < 8; j++) { |
| bytes[j] = static_cast<uint8_t>(rand() % 256); |
| } |
| double d; |
| uprv_memcpy(&d, bytes, 8); |
| if (std::isnan(d) || !std::isfinite(d)) { continue; } |
| checkDoubleBehavior(d, false); |
| } |
| } |
| |
| void DecimalQuantityTest::testUseApproximateDoubleWhenAble() { |
| static const struct TestCase { |
| double d; |
| int32_t maxFrac; |
| RoundingMode roundingMode; |
| bool usesExact; |
| } cases[] = {{1.2345678, 1, RoundingMode::UNUM_ROUND_HALFEVEN, false}, |
| {1.2345678, 7, RoundingMode::UNUM_ROUND_HALFEVEN, false}, |
| {1.2345678, 12, RoundingMode::UNUM_ROUND_HALFEVEN, false}, |
| {1.2345678, 13, RoundingMode::UNUM_ROUND_HALFEVEN, true}, |
| {1.235, 1, RoundingMode::UNUM_ROUND_HALFEVEN, false}, |
| {1.235, 2, RoundingMode::UNUM_ROUND_HALFEVEN, true}, |
| {1.235, 3, RoundingMode::UNUM_ROUND_HALFEVEN, false}, |
| {1.000000000000001, 0, RoundingMode::UNUM_ROUND_HALFEVEN, false}, |
| {1.000000000000001, 0, RoundingMode::UNUM_ROUND_CEILING, true}, |
| {1.235, 1, RoundingMode::UNUM_ROUND_CEILING, false}, |
| {1.235, 2, RoundingMode::UNUM_ROUND_CEILING, false}, |
| {1.235, 3, RoundingMode::UNUM_ROUND_CEILING, true}}; |
| |
| UErrorCode status = U_ZERO_ERROR; |
| for (TestCase cas : cases) { |
| DecimalQuantity fq; |
| fq.setToDouble(cas.d); |
| assertTrue("Should be using approximate double", !fq.isExplicitExactDouble()); |
| fq.roundToMagnitude(-cas.maxFrac, cas.roundingMode, status); |
| assertSuccess("Rounding to magnitude", status); |
| if (cas.usesExact != fq.isExplicitExactDouble()) { |
| errln(UnicodeString(u"Using approximate double after rounding: ") + fq.toString()); |
| } |
| } |
| } |
| |
| void DecimalQuantityTest::testHardDoubleConversion() { |
| static const struct TestCase { |
| double input; |
| const char16_t* expectedOutput; |
| } cases[] = { |
| { 512.0000000000017, u"512.0000000000017" }, |
| { 4095.9999999999977, u"4095.9999999999977" }, |
| { 4095.999999999998, u"4095.999999999998" }, |
| { 4095.9999999999986, u"4095.9999999999986" }, |
| { 4095.999999999999, u"4095.999999999999" }, |
| { 4095.9999999999995, u"4095.9999999999995" }, |
| { 4096.000000000001, u"4096.000000000001" }, |
| { 4096.000000000002, u"4096.000000000002" }, |
| { 4096.000000000003, u"4096.000000000003" }, |
| { 4096.000000000004, u"4096.000000000004" }, |
| { 4096.000000000005, u"4096.000000000005" }, |
| { 4096.0000000000055, u"4096.0000000000055" }, |
| { 4096.000000000006, u"4096.000000000006" }, |
| { 4096.000000000007, u"4096.000000000007" } }; |
| |
| for (auto& cas : cases) { |
| DecimalQuantity q; |
| q.setToDouble(cas.input); |
| q.roundToInfinity(); |
| UnicodeString actualOutput = q.toPlainString(); |
| assertEquals("", cas.expectedOutput, actualOutput); |
| } |
| } |
| |
| void DecimalQuantityTest::testToDouble() { |
| IcuTestErrorCode status(*this, "testToDouble"); |
| static const struct TestCase { |
| const char* input; // char* for the decNumber constructor |
| double expected; |
| } cases[] = { |
| { "0", 0.0 }, |
| { "514.23", 514.23 }, |
| { "-3.142E-271", -3.142e-271 } }; |
| |
| for (auto& cas : cases) { |
| status.setScope(cas.input); |
| DecimalQuantity q; |
| q.setToDecNumber({cas.input, -1}, status); |
| double actual = q.toDouble(); |
| assertEquals("Doubles should exactly equal", cas.expected, actual); |
| } |
| } |
| |
| void DecimalQuantityTest::testMaxDigits() { |
| IcuTestErrorCode status(*this, "testMaxDigits"); |
| DecimalQuantity dq; |
| dq.setToDouble(876.543); |
| dq.roundToInfinity(); |
| dq.setMinInteger(0); |
| dq.applyMaxInteger(2); |
| dq.setMinFraction(0); |
| dq.roundToMagnitude(-2, UNUM_ROUND_FLOOR, status); |
| assertEquals("Should trim, toPlainString", "76.54", dq.toPlainString()); |
| assertEquals("Should trim, toScientificString", "7.654E+1", dq.toScientificString()); |
| assertEquals("Should trim, toLong", 76LL, dq.toLong(true)); |
| assertEquals("Should trim, toFractionLong", (int64_t) 54, (int64_t) dq.toFractionLong(false)); |
| assertEquals("Should trim, toDouble", 76.54, dq.toDouble()); |
| // To test DecNum output, check the round-trip. |
| DecNum dn; |
| dq.toDecNum(dn, status); |
| DecimalQuantity copy; |
| copy.setToDecNum(dn, status); |
| assertEquals("Should trim, toDecNum", "76.54", copy.toPlainString()); |
| } |
| |
| void DecimalQuantityTest::testNickelRounding() { |
| IcuTestErrorCode status(*this, "testNickelRounding"); |
| struct TestCase { |
| double input; |
| int32_t magnitude; |
| UNumberFormatRoundingMode roundingMode; |
| const char16_t* expected; |
| } cases[] = { |
| {1.000, -2, UNUM_ROUND_HALFEVEN, u"1"}, |
| {1.001, -2, UNUM_ROUND_HALFEVEN, u"1"}, |
| {1.010, -2, UNUM_ROUND_HALFEVEN, u"1"}, |
| {1.020, -2, UNUM_ROUND_HALFEVEN, u"1"}, |
| {1.024, -2, UNUM_ROUND_HALFEVEN, u"1"}, |
| {1.025, -2, UNUM_ROUND_HALFEVEN, u"1"}, |
| {1.025, -2, UNUM_ROUND_HALFDOWN, u"1"}, |
| {1.025, -2, UNUM_ROUND_HALFUP, u"1.05"}, |
| {1.026, -2, UNUM_ROUND_HALFEVEN, u"1.05"}, |
| {1.030, -2, UNUM_ROUND_HALFEVEN, u"1.05"}, |
| {1.040, -2, UNUM_ROUND_HALFEVEN, u"1.05"}, |
| {1.050, -2, UNUM_ROUND_HALFEVEN, u"1.05"}, |
| {1.060, -2, UNUM_ROUND_HALFEVEN, u"1.05"}, |
| {1.070, -2, UNUM_ROUND_HALFEVEN, u"1.05"}, |
| {1.074, -2, UNUM_ROUND_HALFEVEN, u"1.05"}, |
| {1.075, -2, UNUM_ROUND_HALFDOWN, u"1.05"}, |
| {1.075, -2, UNUM_ROUND_HALFUP, u"1.1"}, |
| {1.075, -2, UNUM_ROUND_HALFEVEN, u"1.1"}, |
| {1.076, -2, UNUM_ROUND_HALFEVEN, u"1.1"}, |
| {1.080, -2, UNUM_ROUND_HALFEVEN, u"1.1"}, |
| {1.090, -2, UNUM_ROUND_HALFEVEN, u"1.1"}, |
| {1.099, -2, UNUM_ROUND_HALFEVEN, u"1.1"}, |
| {1.999, -2, UNUM_ROUND_HALFEVEN, u"2"}, |
| {2.25, -1, UNUM_ROUND_HALFEVEN, u"2"}, |
| {2.25, -1, UNUM_ROUND_HALFUP, u"2.5"}, |
| {2.75, -1, UNUM_ROUND_HALFDOWN, u"2.5"}, |
| {2.75, -1, UNUM_ROUND_HALFEVEN, u"3"}, |
| {3.00, -1, UNUM_ROUND_CEILING, u"3"}, |
| {3.25, -1, UNUM_ROUND_CEILING, u"3.5"}, |
| {3.50, -1, UNUM_ROUND_CEILING, u"3.5"}, |
| {3.75, -1, UNUM_ROUND_CEILING, u"4"}, |
| {4.00, -1, UNUM_ROUND_FLOOR, u"4"}, |
| {4.25, -1, UNUM_ROUND_FLOOR, u"4"}, |
| {4.50, -1, UNUM_ROUND_FLOOR, u"4.5"}, |
| {4.75, -1, UNUM_ROUND_FLOOR, u"4.5"}, |
| {5.00, -1, UNUM_ROUND_UP, u"5"}, |
| {5.25, -1, UNUM_ROUND_UP, u"5.5"}, |
| {5.50, -1, UNUM_ROUND_UP, u"5.5"}, |
| {5.75, -1, UNUM_ROUND_UP, u"6"}, |
| {6.00, -1, UNUM_ROUND_DOWN, u"6"}, |
| {6.25, -1, UNUM_ROUND_DOWN, u"6"}, |
| {6.50, -1, UNUM_ROUND_DOWN, u"6.5"}, |
| {6.75, -1, UNUM_ROUND_DOWN, u"6.5"}, |
| {7.00, -1, UNUM_ROUND_UNNECESSARY, u"7"}, |
| {7.50, -1, UNUM_ROUND_UNNECESSARY, u"7.5"}, |
| }; |
| for (const auto& cas : cases) { |
| UnicodeString message = DoubleToUnicodeString(cas.input) + u" @ " + Int64ToUnicodeString(cas.magnitude) + u" / " + Int64ToUnicodeString(cas.roundingMode); |
| status.setScope(message); |
| DecimalQuantity dq; |
| dq.setToDouble(cas.input); |
| dq.roundToNickel(cas.magnitude, cas.roundingMode, status); |
| status.errIfFailureAndReset(); |
| UnicodeString actual = dq.toPlainString(); |
| assertEquals(message, cas.expected, actual); |
| } |
| status.setScope(""); |
| DecimalQuantity dq; |
| dq.setToDouble(7.1); |
| dq.roundToNickel(-1, UNUM_ROUND_UNNECESSARY, status); |
| status.expectErrorAndReset(U_FORMAT_INEXACT_ERROR); |
| } |
| |
| void DecimalQuantityTest::testCompactDecimalSuppressedExponent() { |
| IcuTestErrorCode status(*this, "testCompactDecimalSuppressedExponent"); |
| Locale ulocale("fr-FR"); |
| |
| struct TestCase { |
| UnicodeString skeleton; |
| double input; |
| const char16_t* expectedString; |
| int64_t expectedLong; |
| double expectedDouble; |
| const char16_t* expectedPlainString; |
| int32_t expectedSuppressedExponent; |
| } cases[] = { |
| // unlocalized formatter skeleton, input, string output, long output, double output, BigDecimal output, plain string, suppressed exponent |
| {u"", 123456789, u"123 456 789", 123456789L, 123456789.0, u"123456789", 0}, |
| {u"compact-long", 123456789, u"123 millions", 123000000L, 123000000.0, u"123000000", 6}, |
| {u"compact-short", 123456789, u"123 M", 123000000L, 123000000.0, u"123000000", 6}, |
| {u"scientific", 123456789, u"1,234568E8", 123456800L, 123456800.0, u"123456800", 8}, |
| |
| {u"", 1234567, u"1 234 567", 1234567L, 1234567.0, u"1234567", 0}, |
| {u"compact-long", 1234567, u"1,2 million", 1200000L, 1200000.0, u"1200000", 6}, |
| {u"compact-short", 1234567, u"1,2 M", 1200000L, 1200000.0, u"1200000", 6}, |
| {u"scientific", 1234567, u"1,234567E6", 1234567L, 1234567.0, u"1234567", 6}, |
| |
| {u"", 123456, u"123 456", 123456L, 123456.0, u"123456", 0}, |
| {u"compact-long", 123456, u"123 mille", 123000L, 123000.0, u"123000", 3}, |
| {u"compact-short", 123456, u"123 k", 123000L, 123000.0, u"123000", 3}, |
| {u"scientific", 123456, u"1,23456E5", 123456L, 123456.0, u"123456", 5}, |
| |
| {u"", 123, u"123", 123L, 123.0, u"123", 0}, |
| {u"compact-long", 123, u"123", 123L, 123.0, u"123", 0}, |
| {u"compact-short", 123, u"123", 123L, 123.0, u"123", 0}, |
| {u"scientific", 123, u"1,23E2", 123L, 123.0, u"123", 2}, |
| |
| {u"", 1.2, u"1,2", 1L, 1.2, u"1.2", 0}, |
| {u"compact-long", 1.2, u"1,2", 1L, 1.2, u"1.2", 0}, |
| {u"compact-short", 1.2, u"1,2", 1L, 1.2, u"1.2", 0}, |
| {u"scientific", 1.2, u"1,2E0", 1L, 1.2, u"1.2", 0}, |
| |
| {u"", 0.12, u"0,12", 0L, 0.12, u"0.12", 0}, |
| {u"compact-long", 0.12, u"0,12", 0L, 0.12, u"0.12", 0}, |
| {u"compact-short", 0.12, u"0,12", 0L, 0.12, u"0.12", 0}, |
| {u"scientific", 0.12, u"1,2E-1", 0L, 0.12, u"0.12", -1}, |
| |
| {u"", 0.012, u"0,012", 0L, 0.012, u"0.012", 0}, |
| {u"compact-long", 0.012, u"0,012", 0L, 0.012, u"0.012", 0}, |
| {u"compact-short", 0.012, u"0,012", 0L, 0.012, u"0.012", 0}, |
| {u"scientific", 0.012, u"1,2E-2", 0L, 0.012, u"0.012", -2}, |
| |
| {u"", 999.9, u"999,9", 999L, 999.9, u"999.9", 0}, |
| {u"compact-long", 999.9, u"1 millier", 1000L, 1000.0, u"1000", 3}, |
| {u"compact-short", 999.9, u"1 k", 1000L, 1000.0, u"1000", 3}, |
| {u"scientific", 999.9, u"9,999E2", 999L, 999.9, u"999.9", 2}, |
| |
| {u"", 1000.0, u"1 000", 1000L, 1000.0, u"1000", 0}, |
| {u"compact-long", 1000.0, u"1 millier", 1000L, 1000.0, u"1000", 3}, |
| {u"compact-short", 1000.0, u"1 k", 1000L, 1000.0, u"1000", 3}, |
| {u"scientific", 1000.0, u"1E3", 1000L, 1000.0, u"1000", 3}, |
| }; |
| for (const auto& cas : cases) { |
| // test the helper methods used to compute plural operand values |
| |
| LocalizedNumberFormatter formatter = |
| NumberFormatter::forSkeleton(cas.skeleton, status) |
| .locale(ulocale); |
| FormattedNumber fn = formatter.formatDouble(cas.input, status); |
| DecimalQuantity dq; |
| fn.getDecimalQuantity(dq, status); |
| UnicodeString actualString = fn.toString(status); |
| int64_t actualLong = dq.toLong(); |
| double actualDouble = dq.toDouble(); |
| UnicodeString actualPlainString = dq.toPlainString(); |
| int32_t actualSuppressedExponent = dq.getExponent(); |
| |
| assertEquals( |
| u"formatted number " + cas.skeleton + u" toString: " + cas.input, |
| cas.expectedString, |
| actualString); |
| assertEquals( |
| u"compact decimal " + cas.skeleton + u" toLong: " + cas.input, |
| cas.expectedLong, |
| actualLong); |
| assertDoubleEquals( |
| u"compact decimal " + cas.skeleton + u" toDouble: " + cas.input, |
| cas.expectedDouble, |
| actualDouble); |
| assertEquals( |
| u"formatted number " + cas.skeleton + u" toPlainString: " + cas.input, |
| cas.expectedPlainString, |
| actualPlainString); |
| assertEquals( |
| u"compact decimal " + cas.skeleton + u" suppressed exponent: " + cas.input, |
| cas.expectedSuppressedExponent, |
| actualSuppressedExponent); |
| |
| // test the actual computed values of the plural operands |
| |
| double expectedNOperand = cas.expectedDouble; |
| double expectedIOperand = cas.expectedLong; |
| double expectedEOperand = cas.expectedSuppressedExponent; |
| double actualNOperand = dq.getPluralOperand(PLURAL_OPERAND_N); |
| double actualIOperand = dq.getPluralOperand(PLURAL_OPERAND_I); |
| double actualEOperand = dq.getPluralOperand(PLURAL_OPERAND_E); |
| |
| assertDoubleEquals( |
| u"compact decimal " + cas.skeleton + u" n operand: " + cas.input, |
| expectedNOperand, |
| actualNOperand); |
| assertDoubleEquals( |
| u"compact decimal " + cas.skeleton + u" i operand: " + cas.input, |
| expectedIOperand, |
| actualIOperand); |
| assertDoubleEquals( |
| u"compact decimal " + cas.skeleton + " e operand: " + cas.input, |
| expectedEOperand, |
| actualEOperand); |
| } |
| } |
| |
| void DecimalQuantityTest::testSuppressedExponentUnchangedByInitialScaling() { |
| IcuTestErrorCode status(*this, "testCompactDecimalSuppressedExponent"); |
| Locale ulocale("fr-FR"); |
| LocalizedNumberFormatter withLocale = NumberFormatter::withLocale(ulocale); |
| LocalizedNumberFormatter compactLong = |
| withLocale.notation(Notation::compactLong()); |
| LocalizedNumberFormatter compactScaled = |
| compactLong.scale(Scale::powerOfTen(3)); |
| |
| struct TestCase { |
| int32_t input; |
| UnicodeString expectedString; |
| double expectedNOperand; |
| double expectedIOperand; |
| double expectedEOperand; |
| } cases[] = { |
| // input, compact long string output, |
| // compact n operand, compact i operand, compact e operand |
| {123456789, "123 millions", 123000000.0, 123000000.0, 6.0}, |
| {1234567, "1,2 million", 1200000.0, 1200000.0, 6.0}, |
| {123456, "123 mille", 123000.0, 123000.0, 3.0}, |
| {123, "123", 123.0, 123.0, 0.0}, |
| }; |
| |
| for (const auto& cas : cases) { |
| FormattedNumber fnCompactScaled = compactScaled.formatInt(cas.input, status); |
| DecimalQuantity dqCompactScaled; |
| fnCompactScaled.getDecimalQuantity(dqCompactScaled, status); |
| double compactScaledEOperand = dqCompactScaled.getPluralOperand(PLURAL_OPERAND_E); |
| |
| FormattedNumber fnCompact = compactLong.formatInt(cas.input, status); |
| DecimalQuantity dqCompact; |
| fnCompact.getDecimalQuantity(dqCompact, status); |
| UnicodeString actualString = fnCompact.toString(status); |
| double compactNOperand = dqCompact.getPluralOperand(PLURAL_OPERAND_N); |
| double compactIOperand = dqCompact.getPluralOperand(PLURAL_OPERAND_I); |
| double compactEOperand = dqCompact.getPluralOperand(PLURAL_OPERAND_E); |
| assertEquals( |
| u"formatted number " + Int64ToUnicodeString(cas.input) + " compactLong toString: ", |
| cas.expectedString, |
| actualString); |
| assertDoubleEquals( |
| u"compact decimal " + DoubleToUnicodeString(cas.input) + ", n operand vs. expected", |
| cas.expectedNOperand, |
| compactNOperand); |
| assertDoubleEquals( |
| u"compact decimal " + DoubleToUnicodeString(cas.input) + ", i operand vs. expected", |
| cas.expectedIOperand, |
| compactIOperand); |
| assertDoubleEquals( |
| u"compact decimal " + DoubleToUnicodeString(cas.input) + ", e operand vs. expected", |
| cas.expectedEOperand, |
| compactEOperand); |
| |
| // By scaling by 10^3 in a locale that has words / compact notation |
| // based on powers of 10^3, we guarantee that the suppressed |
| // exponent will differ by 3. |
| assertDoubleEquals( |
| u"decimal " + DoubleToUnicodeString(cas.input) + ", e operand for compact vs. compact scaled", |
| compactEOperand + 3, |
| compactScaledEOperand); |
| } |
| } |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
