[apple/icu.git] / icuSources / test / intltest / numfmtdatadriventest.cpp

// © 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
Commit	Line	Data
0f5d89e8 A	1	// © 2018 and later: Unicode, Inc. and others.
	2	// License & terms of use: http://www.unicode.org/copyright.html
	3
	4	#include "unicode/utypes.h"
	5
	6	#if !UCONFIG_NO_FORMATTING
	7
	8	#include "numfmtst.h"
0f5d89e8 A	9	#include "number_decimalquantity.h"
	10	#include "putilimp.h"
	11	#include "charstr.h"
	12	#include <cmath>
	13
3d1f044b A	14	using icu::number::impl::DecimalQuantity;
3d1f044b A	15
0f5d89e8 A	16	void NumberFormatDataDrivenTest::runIndexedTest(int32_t index, UBool exec, const char& name, char) {
	17	if (exec) {
	18	logln("TestSuite NumberFormatDataDrivenTest: ");
	19	}
	20	TESTCASE_AUTO_BEGIN;
	21	TESTCASE_AUTO(TestNumberFormatTestTuple);
	22	TESTCASE_AUTO(TestDataDrivenICU4C);
	23	TESTCASE_AUTO_END;
	24	}
	25
3d1f044b A	26	static DecimalQuantity&
3d1f044b A	27	strToDigitList(const UnicodeString& str, DecimalQuantity& digitList, UErrorCode& status) {
0f5d89e8 A	28	if (U_FAILURE(status)) {
	29	return digitList;
	30	}
	31	if (str == "NaN") {
3d1f044b	32	digitList.setToDouble(uprv_getNaN());
0f5d89e8 A	33	return digitList;
	34	}
	35	if (str == "-Inf") {
3d1f044b	36	digitList.setToDouble(-1 * uprv_getInfinity());
0f5d89e8 A	37	return digitList;
	38	}
	39	if (str == "Inf") {
3d1f044b	40	digitList.setToDouble(uprv_getInfinity());
0f5d89e8 A	41	return digitList;
	42	}
	43	CharString formatValue;
	44	formatValue.appendInvariantChars(str, status);
3d1f044b	45	digitList.setToDecNumber({formatValue.data(), formatValue.length()}, status);
0f5d89e8 A	46	return digitList;
	47	}
	48
	49	static UnicodeString&
3d1f044b	50	format(const DecimalFormat& fmt, const DecimalQuantity& digitList, UnicodeString& appendTo,
0f5d89e8 A	51	UErrorCode& status) {
	52	if (U_FAILURE(status)) {
	53	return appendTo;
	54	}
	55	FieldPosition fpos(FieldPosition::DONT_CARE);
	56	return fmt.format(digitList, appendTo, fpos, status);
	57	}
	58
	59	template<class T>
	60	static UnicodeString&
	61	format(const DecimalFormat& fmt, T value, UnicodeString& appendTo, UErrorCode& status) {
	62	if (U_FAILURE(status)) {
	63	return appendTo;
	64	}
	65	FieldPosition fpos(FieldPosition::DONT_CARE);
	66	return fmt.format(value, appendTo, fpos, status);
	67	}
	68
	69	static void adjustDecimalFormat(const NumberFormatTestTuple& tuple, DecimalFormat& fmt,
	70	UnicodeString& appendErrorMessage) {
	71	if (tuple.minIntegerDigitsFlag) {
	72	fmt.setMinimumIntegerDigits(tuple.minIntegerDigits);
	73	}
	74	if (tuple.maxIntegerDigitsFlag) {
	75	fmt.setMaximumIntegerDigits(tuple.maxIntegerDigits);
	76	}
	77	if (tuple.minFractionDigitsFlag) {
	78	fmt.setMinimumFractionDigits(tuple.minFractionDigits);
	79	}
	80	if (tuple.maxFractionDigitsFlag) {
	81	fmt.setMaximumFractionDigits(tuple.maxFractionDigits);
	82	}
	83	if (tuple.currencyFlag) {
	84	UErrorCode status = U_ZERO_ERROR;
	85	UnicodeString currency(tuple.currency);
	86	const UChar* terminatedCurrency = currency.getTerminatedBuffer();
	87	fmt.setCurrency(terminatedCurrency, status);
	88	if (U_FAILURE(status)) {
	89	appendErrorMessage.append("Error setting currency.");
	90	}
	91	}
	92	if (tuple.minGroupingDigitsFlag) {
	93	fmt.setMinimumGroupingDigits(tuple.minGroupingDigits);
	94	}
	95	if (tuple.useSigDigitsFlag) {
	96	fmt.setSignificantDigitsUsed(tuple.useSigDigits != 0);
	97	}
	98	if (tuple.minSigDigitsFlag) {
	99	fmt.setMinimumSignificantDigits(tuple.minSigDigits);
	100	}
	101	if (tuple.maxSigDigitsFlag) {
	102	fmt.setMaximumSignificantDigits(tuple.maxSigDigits);
	103	}
	104	if (tuple.useGroupingFlag) {
	105	fmt.setGroupingUsed(tuple.useGrouping != 0);
	106	}
	107	if (tuple.multiplierFlag) {
	108	fmt.setMultiplier(tuple.multiplier);
	109	}
	110	if (tuple.roundingIncrementFlag) {
	111	fmt.setRoundingIncrement(tuple.roundingIncrement);
	112	}
	113	if (tuple.formatWidthFlag) {
	114	fmt.setFormatWidth(tuple.formatWidth);
115	}
116	if (tuple.padCharacterFlag) {
117	fmt.setPadCharacter(tuple.padCharacter);
118	}
119	if (tuple.useScientificFlag) {
120	fmt.setScientificNotation(tuple.useScientific != 0);
121	}
122	if (tuple.groupingFlag) {
123	fmt.setGroupingSize(tuple.grouping);
124	}
125	if (tuple.grouping2Flag) {
126	fmt.setSecondaryGroupingSize(tuple.grouping2);
127	}
128	if (tuple.roundingModeFlag) {
129	fmt.setRoundingMode(tuple.roundingMode);
130	}
131	if (tuple.currencyUsageFlag) {
132	UErrorCode status = U_ZERO_ERROR;
133	fmt.setCurrencyUsage(tuple.currencyUsage, &status);
134	if (U_FAILURE(status)) {
135	appendErrorMessage.append("CurrencyUsage: error setting.");
136	}
137	}
138	if (tuple.minimumExponentDigitsFlag) {
139	fmt.setMinimumExponentDigits(tuple.minimumExponentDigits);
140	}
141	if (tuple.exponentSignAlwaysShownFlag) {
142	fmt.setExponentSignAlwaysShown(tuple.exponentSignAlwaysShown != 0);
143	}
144	if (tuple.decimalSeparatorAlwaysShownFlag) {
145	fmt.setDecimalSeparatorAlwaysShown(
146	tuple.decimalSeparatorAlwaysShown != 0);
147	}
148	if (tuple.padPositionFlag) {
149	fmt.setPadPosition(tuple.padPosition);
150	}
151	if (tuple.positivePrefixFlag) {
152	fmt.setPositivePrefix(tuple.positivePrefix);
153	}
154	if (tuple.positiveSuffixFlag) {
155	fmt.setPositiveSuffix(tuple.positiveSuffix);
156	}
157	if (tuple.negativePrefixFlag) {
158	fmt.setNegativePrefix(tuple.negativePrefix);
159	}
160	if (tuple.negativeSuffixFlag) {
161	fmt.setNegativeSuffix(tuple.negativeSuffix);
162	}
3d1f044b A	163	if (tuple.signAlwaysShownFlag) {
3d1f044b A	164	fmt.setSignAlwaysShown(tuple.signAlwaysShown != 0);
0f5d89e8 A	165	}
	166	if (tuple.localizedPatternFlag) {
	167	UErrorCode status = U_ZERO_ERROR;
	168	fmt.applyLocalizedPattern(tuple.localizedPattern, status);
	169	if (U_FAILURE(status)) {
	170	appendErrorMessage.append("Error setting localized pattern.");
	171	}
	172	}
	173	fmt.setLenient(NFTT_GET_FIELD(tuple, lenient, 1) != 0);
	174	if (tuple.parseIntegerOnlyFlag) {
	175	fmt.setParseIntegerOnly(tuple.parseIntegerOnly != 0);
	176	}
	177	if (tuple.decimalPatternMatchRequiredFlag) {
	178	fmt.setDecimalPatternMatchRequired(
	179	tuple.decimalPatternMatchRequired != 0);
	180	}
	181	if (tuple.parseNoExponentFlag) {
	182	UErrorCode status = U_ZERO_ERROR;
	183	fmt.setAttribute(
	184	UNUM_PARSE_NO_EXPONENT, tuple.parseNoExponent, status);
	185	if (U_FAILURE(status)) {
	186	appendErrorMessage.append("Error setting parse no exponent flag.");
	187	}
	188	}
3d1f044b A	189	if (tuple.parseCaseSensitiveFlag) {
3d1f044b A	190	fmt.setParseCaseSensitive(tuple.parseCaseSensitive != 0);
0f5d89e8 A	191	}
	192	}
	193
	194	static DecimalFormat*
	195	newDecimalFormat(const Locale& locale, const UnicodeString& pattern, UErrorCode& status) {
	196	if (U_FAILURE(status)) {
	197	return NULL;
	198	}
	199	LocalPointer<DecimalFormatSymbols> symbols(
	200	new DecimalFormatSymbols(locale, status), status);
	201	if (U_FAILURE(status)) {
	202	return NULL;
	203	}
	204	UParseError perror;
	205	LocalPointer<DecimalFormat> result(
	206	new DecimalFormat(
	207	pattern, symbols.getAlias(), perror, status), status);
	208	if (!result.isNull()) {
	209	symbols.orphan();
	210	}
	211	if (U_FAILURE(status)) {
	212	return NULL;
	213	}
	214	return result.orphan();
	215	}
	216
	217	static DecimalFormat* newDecimalFormat(const NumberFormatTestTuple& tuple, UErrorCode& status) {
	218	if (U_FAILURE(status)) {
	219	return NULL;
	220	}
	221	Locale en("en");
	222	return newDecimalFormat(NFTT_GET_FIELD(tuple, locale, en),
	223	NFTT_GET_FIELD(tuple, pattern, "0"),
	224	status);
	225	}
	226
	227	UBool NumberFormatDataDrivenTest::isFormatPass(const NumberFormatTestTuple& tuple,
	228	UnicodeString& appendErrorMessage, UErrorCode& status) {
	229	if (U_FAILURE(status)) {
	230	return FALSE;
	231	}
	232	LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status));
	233	if (U_FAILURE(status)) {
	234	appendErrorMessage.append("Error creating DecimalFormat.");
	235	return FALSE;
	236	}
	237	adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage);
	238	if (appendErrorMessage.length() > 0) {
	239	return FALSE;
	240	}
3d1f044b	241	DecimalQuantity digitList;
0f5d89e8 A	242	strToDigitList(tuple.format, digitList, status);
	243	{
	244	UnicodeString appendTo;
	245	format(*fmtPtr, digitList, appendTo, status);
	246	if (U_FAILURE(status)) {
	247	appendErrorMessage.append("Error formatting.");
	248	return FALSE;
	249	}
	250	if (appendTo != tuple.output) {
	251	appendErrorMessage.append(
	252	UnicodeString("Expected: ") + tuple.output + ", got: " + appendTo);
	253	return FALSE;
	254	}
	255	}
3d1f044b A	256	double doubleVal = digitList.toDouble();
	257	DecimalQuantity doubleCheck;
	258	doubleCheck.setToDouble(doubleVal);
0f5d89e8 A	259	if (digitList == doubleCheck) { // skip cases where the double does not round-trip
	260	UnicodeString appendTo;
	261	format(*fmtPtr, doubleVal, appendTo, status);
	262	if (U_FAILURE(status)) {
	263	appendErrorMessage.append("Error formatting.");
	264	return FALSE;
	265	}
	266	if (appendTo != tuple.output) {
	267	appendErrorMessage.append(
	268	UnicodeString("double Expected: ") + tuple.output + ", got: " + appendTo);
	269	return FALSE;
	270	}
	271	}
3d1f044b A	272	if (!uprv_isNaN(doubleVal) && !uprv_isInfinite(doubleVal) && digitList.fitsInLong()) {
3d1f044b A	273	int64_t intVal = digitList.toLong();
0f5d89e8 A	274	{
	275	UnicodeString appendTo;
	276	format(*fmtPtr, intVal, appendTo, status);
	277	if (U_FAILURE(status)) {
	278	appendErrorMessage.append("Error formatting.");
	279	return FALSE;
	280	}
	281	if (appendTo != tuple.output) {
	282	appendErrorMessage.append(
	283	UnicodeString("int64 Expected: ") + tuple.output + ", got: " + appendTo);
	284	return FALSE;
	285	}
	286	}
	287	}
	288	return TRUE;
	289	}
	290
	291	UBool NumberFormatDataDrivenTest::isToPatternPass(const NumberFormatTestTuple& tuple,
	292	UnicodeString& appendErrorMessage, UErrorCode& status) {
	293	if (U_FAILURE(status)) {
	294	return FALSE;
	295	}
	296	LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status));
	297	if (U_FAILURE(status)) {
	298	appendErrorMessage.append("Error creating DecimalFormat.");
	299	return FALSE;
	300	}
	301	adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage);
	302	if (appendErrorMessage.length() > 0) {
	303	return FALSE;
	304	}
	305	if (tuple.toPatternFlag) {
	306	UnicodeString actual;
	307	fmtPtr->toPattern(actual);
	308	if (actual != tuple.toPattern) {
	309	appendErrorMessage.append(
	310	UnicodeString("Expected: ") + tuple.toPattern + ", got: " + actual + ". ");
	311	}
	312	}
	313	if (tuple.toLocalizedPatternFlag) {
	314	UnicodeString actual;
	315	fmtPtr->toLocalizedPattern(actual);
	316	if (actual != tuple.toLocalizedPattern) {
	317	appendErrorMessage.append(
	318	UnicodeString("Expected: ") + tuple.toLocalizedPattern + ", got: " + actual + ". ");
	319	}
	320	}
	321	return appendErrorMessage.length() == 0;
	322	}
	323
	324	UBool NumberFormatDataDrivenTest::isParsePass(const NumberFormatTestTuple& tuple,
	325	UnicodeString& appendErrorMessage, UErrorCode& status) {
	326	if (U_FAILURE(status)) {
	327	return FALSE;
	328	}
	329	LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status));
	330	if (U_FAILURE(status)) {
	331	appendErrorMessage.append("Error creating DecimalFormat.");
	332	return FALSE;
	333	}
	334	adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage);
	335	if (appendErrorMessage.length() > 0) {
	336	return FALSE;
	337	}
338	Formattable result;
339	ParsePosition ppos;
340	fmtPtr->parse(tuple.parse, result, ppos);
341	if (ppos.getIndex() == 0) {
342	appendErrorMessage.append("Parse failed; got error index ");
343	appendErrorMessage = appendErrorMessage + ppos.getErrorIndex();
344	return FALSE;
345	}
346	if (tuple.output == "fail") {
347	appendErrorMessage.append(
348	UnicodeString("Parse succeeded: ") + result.getDouble() + ", but was expected to fail.");
349	return TRUE; // TRUE because failure handling is in the test suite
350	}
351	if (tuple.output == "NaN") {
352	if (!uprv_isNaN(result.getDouble())) {
353	appendErrorMessage.append(UnicodeString("Expected NaN, but got: ") + result.getDouble());
354	return FALSE;
355	}
356	return TRUE;
357	} else if (tuple.output == "Inf") {
358	if (!uprv_isInfinite(result.getDouble()) \|\| result.getDouble() < 0) {
359	appendErrorMessage.append(UnicodeString("Expected Inf, but got: ") + result.getDouble());
360	return FALSE;
361	}
362	return TRUE;
363	} else if (tuple.output == "-Inf") {
364	if (!uprv_isInfinite(result.getDouble()) \|\| result.getDouble() > 0) {
365	appendErrorMessage.append(UnicodeString("Expected -Inf, but got: ") + result.getDouble());
366	return FALSE;
367	}
368	return TRUE;
369	} else if (tuple.output == "-0.0") {
370	if (!std::signbit(result.getDouble()) \|\| result.getDouble() != 0) {
371	appendErrorMessage.append(UnicodeString("Expected -0.0, but got: ") + result.getDouble());
372	return FALSE;
373	}
374	return TRUE;
375	}
3d1f044b	376	// All other cases parse to a DecimalQuantity, not a double.
0f5d89e8	377
3d1f044b A	378	DecimalQuantity expectedQuantity;
	379	strToDigitList(tuple.output, expectedQuantity, status);
	380	UnicodeString expectedString = expectedQuantity.toScientificString();
0f5d89e8 A	381	if (U_FAILURE(status)) {
0f5d89e8 A	382	appendErrorMessage.append("[Error parsing decnumber] ");
3d1f044b A	383	// If this happens, assume that tuple.output is exactly the same format as
	384	// DecimalQuantity.toScientificString()
	385	expectedString = tuple.output;
	386	status = U_ZERO_ERROR;
0f5d89e8	387	}
3d1f044b A	388	UnicodeString actualString = result.getDecimalQuantity()->toScientificString();
	389	if (expectedString != actualString) {
	390	appendErrorMessage.append(
	391	UnicodeString("Expected: ") + tuple.output + " (i.e., " + expectedString + "), but got: " +
	392	actualString + " (" + ppos.getIndex() + ":" + ppos.getErrorIndex() + ")");
0f5d89e8 A	393	return FALSE;
	394	}
	395
	396	return TRUE;
	397	}
	398
	399	UBool NumberFormatDataDrivenTest::isParseCurrencyPass(const NumberFormatTestTuple& tuple,
	400	UnicodeString& appendErrorMessage,
	401	UErrorCode& status) {
	402	if (U_FAILURE(status)) {
	403	return FALSE;
	404	}
	405	LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status));
	406	if (U_FAILURE(status)) {
	407	appendErrorMessage.append("Error creating DecimalFormat.");
	408	return FALSE;
	409	}
	410	adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage);
	411	if (appendErrorMessage.length() > 0) {
	412	return FALSE;
	413	}
	414	ParsePosition ppos;
	415	LocalPointer<CurrencyAmount> currAmt(
	416	fmtPtr->parseCurrency(tuple.parse, ppos));
	417	if (ppos.getIndex() == 0) {
	418	appendErrorMessage.append("Parse failed; got error index ");
	419	appendErrorMessage = appendErrorMessage + ppos.getErrorIndex();
	420	return FALSE;
	421	}
	422	UnicodeString currStr(currAmt->getISOCurrency());
3d1f044b A	423	U_ASSERT(currAmt->getNumber().getDecimalQuantity() != nullptr); // no doubles in currency tests
3d1f044b A	424	UnicodeString resultStr = currAmt->getNumber().getDecimalQuantity()->toScientificString();
0f5d89e8	425	if (tuple.output == "fail") {
3d1f044b A	426	appendErrorMessage.append(
3d1f044b A	427	UnicodeString("Parse succeeded: ") + resultStr + ", but was expected to fail.");
0f5d89e8 A	428	return TRUE; // TRUE because failure handling is in the test suite
	429	}
	430
3d1f044b A	431	DecimalQuantity expectedQuantity;
	432	strToDigitList(tuple.output, expectedQuantity, status);
	433	UnicodeString expectedString = expectedQuantity.toScientificString();
0f5d89e8 A	434	if (U_FAILURE(status)) {
0f5d89e8 A	435	appendErrorMessage.append("Error parsing decnumber");
3d1f044b A	436	// If this happens, assume that tuple.output is exactly the same format as
	437	// DecimalQuantity.toNumberString()
	438	expectedString = tuple.output;
	439	status = U_ZERO_ERROR;
0f5d89e8	440	}
3d1f044b A	441	if (expectedString != resultStr) {
	442	appendErrorMessage.append(
	443	UnicodeString("Expected: ") + tuple.output + " (i.e., " + expectedString + "), but got: " +
	444	resultStr + " (" + ppos.getIndex() + ":" + ppos.getErrorIndex() + ")");
0f5d89e8 A	445	return FALSE;
	446	}
	447
	448	if (currStr != tuple.outputCurrency) {
3d1f044b A	449	appendErrorMessage.append(
	450	UnicodeString(
	451	"Expected currency: ") + tuple.outputCurrency + ", got: " + currStr + ". ");
0f5d89e8 A	452	return FALSE;
	453	}
	454	return TRUE;
	455	}
	456
	457	void NumberFormatDataDrivenTest::TestNumberFormatTestTuple() {
	458	NumberFormatTestTuple tuple;
	459	UErrorCode status = U_ZERO_ERROR;
	460
	461	tuple.setField(
	462	NumberFormatTestTuple::getFieldByName("locale"), "en", status);
	463	tuple.setField(
	464	NumberFormatTestTuple::getFieldByName("pattern"), "#,##0.00", status);
	465	tuple.setField(
	466	NumberFormatTestTuple::getFieldByName("minIntegerDigits"), "-10", status);
	467	if (!assertSuccess("", status)) {
	468	return;
	469	}
	470
	471	// only what we set should be set.
	472	assertEquals("", "en", tuple.locale.getName());
	473	assertEquals("", "#,##0.00", tuple.pattern);
	474	assertEquals("", -10, tuple.minIntegerDigits);
	475	assertTrue("", tuple.localeFlag);
	476	assertTrue("", tuple.patternFlag);
	477	assertTrue("", tuple.minIntegerDigitsFlag);
	478	assertFalse("", tuple.formatFlag);
	479
	480	UnicodeString appendTo;
	481	assertEquals(
	482	"", "{locale: en, pattern: #,##0.00, minIntegerDigits: -10}", tuple.toString(appendTo));
	483
	484	tuple.clear();
	485	appendTo.remove();
	486	assertEquals(
	487	"", "{}", tuple.toString(appendTo));
	488	tuple.setField(
	489	NumberFormatTestTuple::getFieldByName("aBadFieldName"), "someValue", status);
	490	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
	491	errln("Expected U_ILLEGAL_ARGUMENT_ERROR");
	492	}
	493	status = U_ZERO_ERROR;
	494	tuple.setField(
	495	NumberFormatTestTuple::getFieldByName("minIntegerDigits"), "someBadValue", status);
	496	if (status != U_ILLEGAL_ARGUMENT_ERROR) {
	497	errln("Expected U_ILLEGAL_ARGUMENT_ERROR");
	498	}
	499	}
	500
	501	void NumberFormatDataDrivenTest::TestDataDrivenICU4C() {
	502	run("numberformattestspecification.txt", TRUE);
	503	}
	504
	505	#endif // !UCONFIG_NO_FORMATTING