| // © 2018 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 "numfmtst.h" |
| #include "number_decimalquantity.h" |
| #include "putilimp.h" |
| #include "charstr.h" |
| #include <cmath> |
| |
| using icu::number::impl::DecimalQuantity; |
| |
| void NumberFormatDataDrivenTest::runIndexedTest(int32_t index, UBool exec, const char*& name, char*) { |
| if (exec) { |
| logln("TestSuite NumberFormatDataDrivenTest: "); |
| } |
| TESTCASE_AUTO_BEGIN; |
| TESTCASE_AUTO(TestNumberFormatTestTuple); |
| TESTCASE_AUTO(TestDataDrivenICU4C); |
| TESTCASE_AUTO_END; |
| } |
| |
| static DecimalQuantity& |
| strToDigitList(const UnicodeString& str, DecimalQuantity& digitList, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return digitList; |
| } |
| if (str == "NaN") { |
| digitList.setToDouble(uprv_getNaN()); |
| return digitList; |
| } |
| if (str == "-Inf") { |
| digitList.setToDouble(-1 * uprv_getInfinity()); |
| return digitList; |
| } |
| if (str == "Inf") { |
| digitList.setToDouble(uprv_getInfinity()); |
| return digitList; |
| } |
| CharString formatValue; |
| formatValue.appendInvariantChars(str, status); |
| digitList.setToDecNumber({formatValue.data(), formatValue.length()}, status); |
| return digitList; |
| } |
| |
| static UnicodeString& |
| format(const DecimalFormat& fmt, const DecimalQuantity& digitList, UnicodeString& appendTo, |
| UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return appendTo; |
| } |
| FieldPosition fpos(FieldPosition::DONT_CARE); |
| return fmt.format(digitList, appendTo, fpos, status); |
| } |
| |
| template<class T> |
| static UnicodeString& |
| format(const DecimalFormat& fmt, T value, UnicodeString& appendTo, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return appendTo; |
| } |
| FieldPosition fpos(FieldPosition::DONT_CARE); |
| return fmt.format(value, appendTo, fpos, status); |
| } |
| |
| static void adjustDecimalFormat(const NumberFormatTestTuple& tuple, DecimalFormat& fmt, |
| UnicodeString& appendErrorMessage) { |
| if (tuple.minIntegerDigitsFlag) { |
| fmt.setMinimumIntegerDigits(tuple.minIntegerDigits); |
| } |
| if (tuple.maxIntegerDigitsFlag) { |
| fmt.setMaximumIntegerDigits(tuple.maxIntegerDigits); |
| } |
| if (tuple.minFractionDigitsFlag) { |
| fmt.setMinimumFractionDigits(tuple.minFractionDigits); |
| } |
| if (tuple.maxFractionDigitsFlag) { |
| fmt.setMaximumFractionDigits(tuple.maxFractionDigits); |
| } |
| if (tuple.currencyFlag) { |
| UErrorCode status = U_ZERO_ERROR; |
| UnicodeString currency(tuple.currency); |
| const UChar* terminatedCurrency = currency.getTerminatedBuffer(); |
| fmt.setCurrency(terminatedCurrency, status); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error setting currency."); |
| } |
| } |
| if (tuple.minGroupingDigitsFlag) { |
| fmt.setMinimumGroupingDigits(tuple.minGroupingDigits); |
| } |
| if (tuple.useSigDigitsFlag) { |
| fmt.setSignificantDigitsUsed(tuple.useSigDigits != 0); |
| } |
| if (tuple.minSigDigitsFlag) { |
| fmt.setMinimumSignificantDigits(tuple.minSigDigits); |
| } |
| if (tuple.maxSigDigitsFlag) { |
| fmt.setMaximumSignificantDigits(tuple.maxSigDigits); |
| } |
| if (tuple.useGroupingFlag) { |
| fmt.setGroupingUsed(tuple.useGrouping != 0); |
| } |
| if (tuple.multiplierFlag) { |
| fmt.setMultiplier(tuple.multiplier); |
| } |
| if (tuple.roundingIncrementFlag) { |
| fmt.setRoundingIncrement(tuple.roundingIncrement); |
| } |
| if (tuple.formatWidthFlag) { |
| fmt.setFormatWidth(tuple.formatWidth); |
| } |
| if (tuple.padCharacterFlag) { |
| fmt.setPadCharacter(tuple.padCharacter); |
| } |
| if (tuple.useScientificFlag) { |
| fmt.setScientificNotation(tuple.useScientific != 0); |
| } |
| if (tuple.groupingFlag) { |
| fmt.setGroupingSize(tuple.grouping); |
| } |
| if (tuple.grouping2Flag) { |
| fmt.setSecondaryGroupingSize(tuple.grouping2); |
| } |
| if (tuple.roundingModeFlag) { |
| fmt.setRoundingMode(tuple.roundingMode); |
| } |
| if (tuple.currencyUsageFlag) { |
| UErrorCode status = U_ZERO_ERROR; |
| fmt.setCurrencyUsage(tuple.currencyUsage, &status); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("CurrencyUsage: error setting."); |
| } |
| } |
| if (tuple.minimumExponentDigitsFlag) { |
| fmt.setMinimumExponentDigits(tuple.minimumExponentDigits); |
| } |
| if (tuple.exponentSignAlwaysShownFlag) { |
| fmt.setExponentSignAlwaysShown(tuple.exponentSignAlwaysShown != 0); |
| } |
| if (tuple.decimalSeparatorAlwaysShownFlag) { |
| fmt.setDecimalSeparatorAlwaysShown( |
| tuple.decimalSeparatorAlwaysShown != 0); |
| } |
| if (tuple.padPositionFlag) { |
| fmt.setPadPosition(tuple.padPosition); |
| } |
| if (tuple.positivePrefixFlag) { |
| fmt.setPositivePrefix(tuple.positivePrefix); |
| } |
| if (tuple.positiveSuffixFlag) { |
| fmt.setPositiveSuffix(tuple.positiveSuffix); |
| } |
| if (tuple.negativePrefixFlag) { |
| fmt.setNegativePrefix(tuple.negativePrefix); |
| } |
| if (tuple.negativeSuffixFlag) { |
| fmt.setNegativeSuffix(tuple.negativeSuffix); |
| } |
| if (tuple.signAlwaysShownFlag) { |
| fmt.setSignAlwaysShown(tuple.signAlwaysShown != 0); |
| } |
| if (tuple.localizedPatternFlag) { |
| UErrorCode status = U_ZERO_ERROR; |
| fmt.applyLocalizedPattern(tuple.localizedPattern, status); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error setting localized pattern."); |
| } |
| } |
| fmt.setLenient(NFTT_GET_FIELD(tuple, lenient, 1) != 0); |
| if (tuple.parseIntegerOnlyFlag) { |
| fmt.setParseIntegerOnly(tuple.parseIntegerOnly != 0); |
| } |
| if (tuple.decimalPatternMatchRequiredFlag) { |
| fmt.setDecimalPatternMatchRequired( |
| tuple.decimalPatternMatchRequired != 0); |
| } |
| if (tuple.parseNoExponentFlag) { |
| UErrorCode status = U_ZERO_ERROR; |
| fmt.setAttribute( |
| UNUM_PARSE_NO_EXPONENT, tuple.parseNoExponent, status); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error setting parse no exponent flag."); |
| } |
| } |
| if (tuple.parseCaseSensitiveFlag) { |
| fmt.setParseCaseSensitive(tuple.parseCaseSensitive != 0); |
| } |
| } |
| |
| static DecimalFormat* |
| newDecimalFormat(const Locale& locale, const UnicodeString& pattern, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| LocalPointer<DecimalFormatSymbols> symbols( |
| new DecimalFormatSymbols(locale, status), status); |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| UParseError perror; |
| LocalPointer<DecimalFormat> result( |
| new DecimalFormat( |
| pattern, symbols.getAlias(), perror, status), status); |
| if (!result.isNull()) { |
| symbols.orphan(); |
| } |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| return result.orphan(); |
| } |
| |
| static DecimalFormat* newDecimalFormat(const NumberFormatTestTuple& tuple, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return NULL; |
| } |
| Locale en("en"); |
| return newDecimalFormat(NFTT_GET_FIELD(tuple, locale, en), |
| NFTT_GET_FIELD(tuple, pattern, "0"), |
| status); |
| } |
| |
| UBool NumberFormatDataDrivenTest::isFormatPass(const NumberFormatTestTuple& tuple, |
| UnicodeString& appendErrorMessage, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status)); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error creating DecimalFormat."); |
| return FALSE; |
| } |
| adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage); |
| if (appendErrorMessage.length() > 0) { |
| return FALSE; |
| } |
| DecimalQuantity digitList; |
| strToDigitList(tuple.format, digitList, status); |
| { |
| UnicodeString appendTo; |
| format(*fmtPtr, digitList, appendTo, status); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error formatting."); |
| return FALSE; |
| } |
| if (appendTo != tuple.output) { |
| appendErrorMessage.append( |
| UnicodeString("Expected: ") + tuple.output + ", got: " + appendTo); |
| return FALSE; |
| } |
| } |
| double doubleVal = digitList.toDouble(); |
| DecimalQuantity doubleCheck; |
| doubleCheck.setToDouble(doubleVal); |
| if (digitList == doubleCheck) { // skip cases where the double does not round-trip |
| UnicodeString appendTo; |
| format(*fmtPtr, doubleVal, appendTo, status); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error formatting."); |
| return FALSE; |
| } |
| if (appendTo != tuple.output) { |
| appendErrorMessage.append( |
| UnicodeString("double Expected: ") + tuple.output + ", got: " + appendTo); |
| return FALSE; |
| } |
| } |
| if (!uprv_isNaN(doubleVal) && !uprv_isInfinite(doubleVal) && digitList.fitsInLong()) { |
| int64_t intVal = digitList.toLong(); |
| { |
| UnicodeString appendTo; |
| format(*fmtPtr, intVal, appendTo, status); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error formatting."); |
| return FALSE; |
| } |
| if (appendTo != tuple.output) { |
| appendErrorMessage.append( |
| UnicodeString("int64 Expected: ") + tuple.output + ", got: " + appendTo); |
| return FALSE; |
| } |
| } |
| } |
| return TRUE; |
| } |
| |
| UBool NumberFormatDataDrivenTest::isToPatternPass(const NumberFormatTestTuple& tuple, |
| UnicodeString& appendErrorMessage, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status)); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error creating DecimalFormat."); |
| return FALSE; |
| } |
| adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage); |
| if (appendErrorMessage.length() > 0) { |
| return FALSE; |
| } |
| if (tuple.toPatternFlag) { |
| UnicodeString actual; |
| fmtPtr->toPattern(actual); |
| if (actual != tuple.toPattern) { |
| appendErrorMessage.append( |
| UnicodeString("Expected: ") + tuple.toPattern + ", got: " + actual + ". "); |
| } |
| } |
| if (tuple.toLocalizedPatternFlag) { |
| UnicodeString actual; |
| fmtPtr->toLocalizedPattern(actual); |
| if (actual != tuple.toLocalizedPattern) { |
| appendErrorMessage.append( |
| UnicodeString("Expected: ") + tuple.toLocalizedPattern + ", got: " + actual + ". "); |
| } |
| } |
| return appendErrorMessage.length() == 0; |
| } |
| |
| UBool NumberFormatDataDrivenTest::isParsePass(const NumberFormatTestTuple& tuple, |
| UnicodeString& appendErrorMessage, UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status)); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error creating DecimalFormat."); |
| return FALSE; |
| } |
| adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage); |
| if (appendErrorMessage.length() > 0) { |
| return FALSE; |
| } |
| Formattable result; |
| ParsePosition ppos; |
| fmtPtr->parse(tuple.parse, result, ppos); |
| if (ppos.getIndex() == 0) { |
| appendErrorMessage.append("Parse failed; got error index "); |
| appendErrorMessage = appendErrorMessage + ppos.getErrorIndex(); |
| return FALSE; |
| } |
| if (tuple.output == "fail") { |
| appendErrorMessage.append( |
| UnicodeString("Parse succeeded: ") + result.getDouble() + ", but was expected to fail."); |
| return TRUE; // TRUE because failure handling is in the test suite |
| } |
| if (tuple.output == "NaN") { |
| if (!uprv_isNaN(result.getDouble())) { |
| appendErrorMessage.append(UnicodeString("Expected NaN, but got: ") + result.getDouble()); |
| return FALSE; |
| } |
| return TRUE; |
| } else if (tuple.output == "Inf") { |
| if (!uprv_isInfinite(result.getDouble()) || result.getDouble() < 0) { |
| appendErrorMessage.append(UnicodeString("Expected Inf, but got: ") + result.getDouble()); |
| return FALSE; |
| } |
| return TRUE; |
| } else if (tuple.output == "-Inf") { |
| if (!uprv_isInfinite(result.getDouble()) || result.getDouble() > 0) { |
| appendErrorMessage.append(UnicodeString("Expected -Inf, but got: ") + result.getDouble()); |
| return FALSE; |
| } |
| return TRUE; |
| } else if (tuple.output == "-0.0") { |
| if (!std::signbit(result.getDouble()) || result.getDouble() != 0) { |
| appendErrorMessage.append(UnicodeString("Expected -0.0, but got: ") + result.getDouble()); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| // All other cases parse to a DecimalQuantity, not a double. |
| |
| DecimalQuantity expectedQuantity; |
| strToDigitList(tuple.output, expectedQuantity, status); |
| UnicodeString expectedString = expectedQuantity.toScientificString(); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("[Error parsing decnumber] "); |
| // If this happens, assume that tuple.output is exactly the same format as |
| // DecimalQuantity.toScientificString() |
| expectedString = tuple.output; |
| status = U_ZERO_ERROR; |
| } |
| UnicodeString actualString = result.getDecimalQuantity()->toScientificString(); |
| if (expectedString != actualString) { |
| appendErrorMessage.append( |
| UnicodeString("Expected: ") + tuple.output + " (i.e., " + expectedString + "), but got: " + |
| actualString + " (" + ppos.getIndex() + ":" + ppos.getErrorIndex() + ")"); |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| UBool NumberFormatDataDrivenTest::isParseCurrencyPass(const NumberFormatTestTuple& tuple, |
| UnicodeString& appendErrorMessage, |
| UErrorCode& status) { |
| if (U_FAILURE(status)) { |
| return FALSE; |
| } |
| LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status)); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error creating DecimalFormat."); |
| return FALSE; |
| } |
| adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage); |
| if (appendErrorMessage.length() > 0) { |
| return FALSE; |
| } |
| ParsePosition ppos; |
| LocalPointer<CurrencyAmount> currAmt( |
| fmtPtr->parseCurrency(tuple.parse, ppos)); |
| if (ppos.getIndex() == 0) { |
| appendErrorMessage.append("Parse failed; got error index "); |
| appendErrorMessage = appendErrorMessage + ppos.getErrorIndex(); |
| return FALSE; |
| } |
| UnicodeString currStr(currAmt->getISOCurrency()); |
| U_ASSERT(currAmt->getNumber().getDecimalQuantity() != nullptr); // no doubles in currency tests |
| UnicodeString resultStr = currAmt->getNumber().getDecimalQuantity()->toScientificString(); |
| if (tuple.output == "fail") { |
| appendErrorMessage.append( |
| UnicodeString("Parse succeeded: ") + resultStr + ", but was expected to fail."); |
| return TRUE; // TRUE because failure handling is in the test suite |
| } |
| |
| DecimalQuantity expectedQuantity; |
| strToDigitList(tuple.output, expectedQuantity, status); |
| UnicodeString expectedString = expectedQuantity.toScientificString(); |
| if (U_FAILURE(status)) { |
| appendErrorMessage.append("Error parsing decnumber"); |
| // If this happens, assume that tuple.output is exactly the same format as |
| // DecimalQuantity.toNumberString() |
| expectedString = tuple.output; |
| status = U_ZERO_ERROR; |
| } |
| if (expectedString != resultStr) { |
| appendErrorMessage.append( |
| UnicodeString("Expected: ") + tuple.output + " (i.e., " + expectedString + "), but got: " + |
| resultStr + " (" + ppos.getIndex() + ":" + ppos.getErrorIndex() + ")"); |
| return FALSE; |
| } |
| |
| if (currStr != tuple.outputCurrency) { |
| appendErrorMessage.append( |
| UnicodeString( |
| "Expected currency: ") + tuple.outputCurrency + ", got: " + currStr + ". "); |
| return FALSE; |
| } |
| return TRUE; |
| } |
| |
| void NumberFormatDataDrivenTest::TestNumberFormatTestTuple() { |
| NumberFormatTestTuple tuple; |
| UErrorCode status = U_ZERO_ERROR; |
| |
| tuple.setField( |
| NumberFormatTestTuple::getFieldByName("locale"), "en", status); |
| tuple.setField( |
| NumberFormatTestTuple::getFieldByName("pattern"), "#,##0.00", status); |
| tuple.setField( |
| NumberFormatTestTuple::getFieldByName("minIntegerDigits"), "-10", status); |
| if (!assertSuccess("", status)) { |
| return; |
| } |
| |
| // only what we set should be set. |
| assertEquals("", "en", tuple.locale.getName()); |
| assertEquals("", "#,##0.00", tuple.pattern); |
| assertEquals("", -10, tuple.minIntegerDigits); |
| assertTrue("", tuple.localeFlag); |
| assertTrue("", tuple.patternFlag); |
| assertTrue("", tuple.minIntegerDigitsFlag); |
| assertFalse("", tuple.formatFlag); |
| |
| UnicodeString appendTo; |
| assertEquals( |
| "", "{locale: en, pattern: #,##0.00, minIntegerDigits: -10}", tuple.toString(appendTo)); |
| |
| tuple.clear(); |
| appendTo.remove(); |
| assertEquals( |
| "", "{}", tuple.toString(appendTo)); |
| tuple.setField( |
| NumberFormatTestTuple::getFieldByName("aBadFieldName"), "someValue", status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| errln("Expected U_ILLEGAL_ARGUMENT_ERROR"); |
| } |
| status = U_ZERO_ERROR; |
| tuple.setField( |
| NumberFormatTestTuple::getFieldByName("minIntegerDigits"), "someBadValue", status); |
| if (status != U_ILLEGAL_ARGUMENT_ERROR) { |
| errln("Expected U_ILLEGAL_ARGUMENT_ERROR"); |
| } |
| } |
| |
| void NumberFormatDataDrivenTest::TestDataDrivenICU4C() { |
| run("numberformattestspecification.txt", TRUE); |
| } |
| |
| #endif // !UCONFIG_NO_FORMATTING |
