// © 2017 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html#License
package com.ibm.icu.dev.test.format;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.ParsePosition;

import org.junit.Test;

import com.ibm.icu.dev.test.TestUtil;
import com.ibm.icu.impl.number.DecimalFormatProperties;
import com.ibm.icu.impl.number.DecimalFormatProperties.ParseMode;
import com.ibm.icu.impl.number.Padder.PadPosition;
import com.ibm.icu.impl.number.PatternStringParser;
import com.ibm.icu.impl.number.PatternStringUtils;
import com.ibm.icu.impl.number.parse.NumberParserImpl;
import com.ibm.icu.number.LocalizedNumberFormatter;
import com.ibm.icu.number.NumberFormatter;
import com.ibm.icu.text.DecimalFormat;
import com.ibm.icu.text.DecimalFormat.PropertySetter;
import com.ibm.icu.text.DecimalFormatSymbols;
import com.ibm.icu.util.CurrencyAmount;
import com.ibm.icu.util.ULocale;

public class NumberFormatDataDrivenTest {

    private static ULocale EN = new ULocale("en");

    private static Number toNumber(String s) {
        if (s.equals("NaN")) {
            return Double.NaN;
        } else if (s.equals("-Inf")) {
            return Double.NEGATIVE_INFINITY;
        } else if (s.equals("Inf")) {
            return Double.POSITIVE_INFINITY;
        }
        return new BigDecimal(s);
    }

    /**
     * Standard function for comparing expected and actual parse results. Handles NaN, Infinity, and
     * failure cases.
     */
    private static String compareParseResult(String expected, Number actual, ParsePosition ppos) {
        if (actual == null && ppos.getIndex() != 0) {
            throw new AssertionError("Error: value is null but parse position is not zero");
        }
        if (ppos.getIndex() == 0) {
            return "Parse failed; got " + actual + ", but expected " + expected;
        }
        if (expected.equals("NaN")) {
            if (!Double.isNaN(actual.doubleValue())) {
                return "Expected NaN, but got: " + actual;
            }
            return null;
        } else if (expected.equals("Inf")) {
            if (!Double.isInfinite(actual.doubleValue())
                    || Double.compare(actual.doubleValue(), 0.0) < 0) {
                return "Expected Inf, but got: " + actual;
            }
            return null;
        } else if (expected.equals("-Inf")) {
            if (!Double.isInfinite(actual.doubleValue())
                    || Double.compare(actual.doubleValue(), 0.0) > 0) {
                return "Expected -Inf, but got: " + actual;
            }
            return null;
        } else if (expected.equals("fail")) {
            return null;
        } else if (actual.toString().equals("Infinity")) {
            return "Expected " + expected + ", but got Infinity";
        } else {
            BigDecimal expectedDecimal = new BigDecimal(expected);
            BigDecimal actualDecimal;
            try {
                actualDecimal = new BigDecimal(actual.toString());
            } catch (NumberFormatException e) {
                throw new AssertionError("Could not convert to BigDecimal: " + actual.toString() + " - " + e.getMessage());
            }
            if (expectedDecimal.compareTo(actualDecimal) != 0) {
                return "Expected: " + expected + ", got: " + actual;
            } else {
                return null;
            }
        }
    }

    /**
     * Standard function for comparing expected and actual parse-currency results. Handles failure cases.
     * Does not currently handle NaN or Infinity because there are no parse-currency cases with NaN or
     * Infinity.
     */
    private static String compareParseCurrencyResult(
            String expected,
            String expectedCurrency,
            CurrencyAmount actual,
            ParsePosition ppos) {
        if (ppos.getIndex() == 0 || actual.getCurrency().getCurrencyCode().equals("XXX")) {
            return "Parse failed; got " + actual + ", but expected " + expected;
        }
        if (expected.equals("fail")) {
            return null;
        }
        BigDecimal expectedNumber = new BigDecimal(expected);
        if (expectedNumber.compareTo(new BigDecimal(actual.getNumber().toString())) != 0) {
            return "Wrong number: Expected: " + expectedNumber + ", got: " + actual;
        }
        if (!expectedCurrency.equals(actual.getCurrency().toString())) {
            return "Wrong currency: Expected: " + expectedCurrency + ", got: " + actual;
        }
        return null;
    }

    /**
     * Main ICU4J DecimalFormat data-driven test.
     */
    private DataDrivenNumberFormatTestUtility.CodeUnderTest ICU4J = new DataDrivenNumberFormatTestUtility.CodeUnderTest() {
        @Override
        public Character Id() {
            return 'J';
        }

        @Override
        public String format(DataDrivenNumberFormatTestData tuple) {
            DecimalFormat fmt = createDecimalFormat(tuple);
            String actual = fmt.format(toNumber(tuple.format));
            String expected = tuple.output;
            if (!expected.equals(actual)) {
                return "Expected " + expected + ", got " + actual;
            }
            return null;
        }

        @Override
        public String toPattern(DataDrivenNumberFormatTestData tuple) {
            DecimalFormat fmt = createDecimalFormat(tuple);
            StringBuilder result = new StringBuilder();
            if (tuple.toPattern != null) {
                String expected = tuple.toPattern;
                String actual = fmt.toPattern();
                if (!expected.equals(actual)) {
                    result.append("Expected toPattern=" + expected + ", got " + actual);
                }
            }
            if (tuple.toLocalizedPattern != null) {
                String expected = tuple.toLocalizedPattern;
                String actual = fmt.toLocalizedPattern();
                if (!expected.equals(actual)) {
                    result.append("Expected toLocalizedPattern=" + expected + ", got " + actual);
                }
            }
            return result.length() == 0 ? null : result.toString();
        }

        @Override
        public String parse(DataDrivenNumberFormatTestData tuple) {
            DecimalFormat fmt = createDecimalFormat(tuple);
            ParsePosition ppos = new ParsePosition(0);
            Number actual = fmt.parse(tuple.parse, ppos);
            return compareParseResult(tuple.output, actual, ppos);
        }

        @Override
        public String parseCurrency(DataDrivenNumberFormatTestData tuple) {
            DecimalFormat fmt = createDecimalFormat(tuple);
            ParsePosition ppos = new ParsePosition(0);
            CurrencyAmount actual = fmt.parseCurrency(tuple.parse, ppos);
            return compareParseCurrencyResult(tuple.output, tuple.outputCurrency, actual, ppos);
        }

        /**
         * @param tuple
         * @return
         */
        private DecimalFormat createDecimalFormat(DataDrivenNumberFormatTestData tuple) {
            DecimalFormat fmt = new DecimalFormat(tuple.pattern == null ? "0" : tuple.pattern,
                    new DecimalFormatSymbols(tuple.locale == null ? EN : tuple.locale));
            adjustDecimalFormat(tuple, fmt);
            return fmt;
        }

        /**
         * @param tuple
         * @param fmt
         */
        private void adjustDecimalFormat(DataDrivenNumberFormatTestData tuple, DecimalFormat fmt) {
            if (tuple.minIntegerDigits != null) {
                fmt.setMinimumIntegerDigits(tuple.minIntegerDigits);
            }
            if (tuple.maxIntegerDigits != null) {
                fmt.setMaximumIntegerDigits(tuple.maxIntegerDigits);
            }
            if (tuple.minFractionDigits != null) {
                fmt.setMinimumFractionDigits(tuple.minFractionDigits);
            }
            if (tuple.maxFractionDigits != null) {
                fmt.setMaximumFractionDigits(tuple.maxFractionDigits);
            }
            if (tuple.currency != null) {
                fmt.setCurrency(tuple.currency);
            }
            if (tuple.minGroupingDigits != null) {
                fmt.setMinimumGroupingDigits(tuple.minGroupingDigits);
            }
            if (tuple.useSigDigits != null) {
                fmt.setSignificantDigitsUsed(tuple.useSigDigits != 0);
            }
            if (tuple.minSigDigits != null) {
                fmt.setMinimumSignificantDigits(tuple.minSigDigits);
            }
            if (tuple.maxSigDigits != null) {
                fmt.setMaximumSignificantDigits(tuple.maxSigDigits);
            }
            if (tuple.useGrouping != null) {
                fmt.setGroupingUsed(tuple.useGrouping != 0);
            }
            if (tuple.multiplier != null) {
                fmt.setMultiplier(tuple.multiplier);
            }
            if (tuple.roundingIncrement != null) {
                fmt.setRoundingIncrement(tuple.roundingIncrement.doubleValue());
            }
            if (tuple.formatWidth != null) {
                fmt.setFormatWidth(tuple.formatWidth);
            }
            if (tuple.padCharacter != null && tuple.padCharacter.length() > 0) {
                fmt.setPadCharacter(tuple.padCharacter.charAt(0));
            }
            if (tuple.useScientific != null) {
                fmt.setScientificNotation(tuple.useScientific != 0);
            }
            if (tuple.grouping != null) {
                fmt.setGroupingSize(tuple.grouping);
            }
            if (tuple.grouping2 != null) {
                fmt.setSecondaryGroupingSize(tuple.grouping2);
            }
            if (tuple.roundingMode != null) {
                fmt.setRoundingMode(tuple.roundingMode);
            }
            if (tuple.currencyUsage != null) {
                fmt.setCurrencyUsage(tuple.currencyUsage);
            }
            if (tuple.minimumExponentDigits != null) {
                fmt.setMinimumExponentDigits(tuple.minimumExponentDigits.byteValue());
            }
            if (tuple.exponentSignAlwaysShown != null) {
                fmt.setExponentSignAlwaysShown(tuple.exponentSignAlwaysShown != 0);
            }
            if (tuple.decimalSeparatorAlwaysShown != null) {
                fmt.setDecimalSeparatorAlwaysShown(tuple.decimalSeparatorAlwaysShown != 0);
            }
            if (tuple.padPosition != null) {
                fmt.setPadPosition(tuple.padPosition);
            }
            if (tuple.positivePrefix != null) {
                fmt.setPositivePrefix(tuple.positivePrefix);
            }
            if (tuple.positiveSuffix != null) {
                fmt.setPositiveSuffix(tuple.positiveSuffix);
            }
            if (tuple.negativePrefix != null) {
                fmt.setNegativePrefix(tuple.negativePrefix);
            }
            if (tuple.negativeSuffix != null) {
                fmt.setNegativeSuffix(tuple.negativeSuffix);
            }
            if (tuple.signAlwaysShown != null) {
                fmt.setSignAlwaysShown(tuple.signAlwaysShown != 0);
            }
            if (tuple.localizedPattern != null) {
                fmt.applyLocalizedPattern(tuple.localizedPattern);
            }
            int lenient = tuple.lenient == null ? 1 : tuple.lenient.intValue();
            fmt.setParseStrict(lenient == 0);
            if (tuple.parseIntegerOnly != null) {
                fmt.setParseIntegerOnly(tuple.parseIntegerOnly != 0);
            }
            if (tuple.parseCaseSensitive != null) {
                fmt.setParseCaseSensitive(tuple.parseCaseSensitive != 0);
            }
            if (tuple.decimalPatternMatchRequired != null) {
                fmt.setDecimalPatternMatchRequired(tuple.decimalPatternMatchRequired != 0);
            }
            if (tuple.parseNoExponent != null) {
                fmt.setParseNoExponent(tuple.parseNoExponent != 0);
            }
        }
    };

    /**
     * Test of available JDK APIs.
     */
    private DataDrivenNumberFormatTestUtility.CodeUnderTest JDK = new DataDrivenNumberFormatTestUtility.CodeUnderTest() {
        @Override
        public Character Id() {
            return 'K';
        }

        @Override
        public String format(DataDrivenNumberFormatTestData tuple) {
            java.text.DecimalFormat fmt = createDecimalFormat(tuple);
            String actual = fmt.format(toNumber(tuple.format));
            String expected = tuple.output;
            if (!expected.equals(actual)) {
                return "Expected " + expected + ", got " + actual;
            }
            return null;
        }

        @Override
        public String toPattern(DataDrivenNumberFormatTestData tuple) {
            java.text.DecimalFormat fmt = createDecimalFormat(tuple);
            StringBuilder result = new StringBuilder();
            if (tuple.toPattern != null) {
                String expected = tuple.toPattern;
                String actual = fmt.toPattern();
                if (!expected.equals(actual)) {
                    result.append("Expected toPattern=" + expected + ", got " + actual);
                }
            }
            if (tuple.toLocalizedPattern != null) {
                String expected = tuple.toLocalizedPattern;
                String actual = fmt.toLocalizedPattern();
                if (!expected.equals(actual)) {
                    result.append("Expected toLocalizedPattern=" + expected + ", got " + actual);
                }
            }
            return result.length() == 0 ? null : result.toString();
        }

        @Override
        public String parse(DataDrivenNumberFormatTestData tuple) {
            java.text.DecimalFormat fmt = createDecimalFormat(tuple);
            ParsePosition ppos = new ParsePosition(0);
            Number actual = fmt.parse(tuple.parse, ppos);
            return compareParseResult(tuple.output, actual, ppos);
        }

        /**
         * @param tuple
         * @return
         */
        private java.text.DecimalFormat createDecimalFormat(DataDrivenNumberFormatTestData tuple) {
            java.text.DecimalFormat fmt = new java.text.DecimalFormat(
                    tuple.pattern == null ? "0" : tuple.pattern,
                    new java.text.DecimalFormatSymbols(
                            (tuple.locale == null ? EN : tuple.locale).toLocale()));
            adjustDecimalFormat(tuple, fmt);
            return fmt;
        }

        /**
         * @param tuple
         * @param fmt
         */
        private void adjustDecimalFormat(
                DataDrivenNumberFormatTestData tuple,
                java.text.DecimalFormat fmt) {
            if (tuple.minIntegerDigits != null) {
                fmt.setMinimumIntegerDigits(tuple.minIntegerDigits);
            }
            if (tuple.maxIntegerDigits != null) {
                fmt.setMaximumIntegerDigits(tuple.maxIntegerDigits);
            }
            if (tuple.minFractionDigits != null) {
                fmt.setMinimumFractionDigits(tuple.minFractionDigits);
            }
            if (tuple.maxFractionDigits != null) {
                fmt.setMaximumFractionDigits(tuple.maxFractionDigits);
            }
            if (tuple.currency != null) {
                fmt.setCurrency(java.util.Currency.getInstance(tuple.currency.toString()));
            }
            if (tuple.minGroupingDigits != null) {
                // Oops we don't support this.
            }
            if (tuple.useSigDigits != null) {
                // Oops we don't support this
            }
            if (tuple.minSigDigits != null) {
                // Oops we don't support this
            }
            if (tuple.maxSigDigits != null) {
                // Oops we don't support this
            }
            if (tuple.useGrouping != null) {
                fmt.setGroupingUsed(tuple.useGrouping != 0);
            }
            if (tuple.multiplier != null) {
                fmt.setMultiplier(tuple.multiplier);
            }
            if (tuple.roundingIncrement != null) {
                // Not supported
            }
            if (tuple.formatWidth != null) {
                // Not supported
            }
            if (tuple.padCharacter != null && tuple.padCharacter.length() > 0) {
                // Not supported
            }
            if (tuple.useScientific != null) {
                // Not supported
            }
            if (tuple.grouping != null) {
                fmt.setGroupingSize(tuple.grouping);
            }
            if (tuple.grouping2 != null) {
                // Not supported
            }
            if (tuple.roundingMode != null) {
                // Not supported
            }
            if (tuple.currencyUsage != null) {
                // Not supported
            }
            if (tuple.minimumExponentDigits != null) {
                // Not supported
            }
            if (tuple.exponentSignAlwaysShown != null) {
                // Not supported
            }
            if (tuple.decimalSeparatorAlwaysShown != null) {
                fmt.setDecimalSeparatorAlwaysShown(tuple.decimalSeparatorAlwaysShown != 0);
            }
            if (tuple.padPosition != null) {
                // Not supported
            }
            if (tuple.positivePrefix != null) {
                fmt.setPositivePrefix(tuple.positivePrefix);
            }
            if (tuple.positiveSuffix != null) {
                fmt.setPositiveSuffix(tuple.positiveSuffix);
            }
            if (tuple.negativePrefix != null) {
                fmt.setNegativePrefix(tuple.negativePrefix);
            }
            if (tuple.negativeSuffix != null) {
                fmt.setNegativeSuffix(tuple.negativeSuffix);
            }
            if (tuple.signAlwaysShown != null) {
                // Not supported.
            }
            if (tuple.localizedPattern != null) {
                fmt.applyLocalizedPattern(tuple.localizedPattern);
            }

            // lenient parsing not supported by JDK
            if (tuple.parseIntegerOnly != null) {
                fmt.setParseIntegerOnly(tuple.parseIntegerOnly != 0);
            }
            if (tuple.parseCaseSensitive != null) {
                // Not supported.
            }
            if (tuple.decimalPatternMatchRequired != null) {
                // Oops, not supported
            }
            if (tuple.parseNoExponent != null) {
                // Oops, not supported for now
            }
        }
    };

    static void propertiesFromTuple(
            DataDrivenNumberFormatTestData tuple,
            DecimalFormatProperties properties) {
        if (tuple.minIntegerDigits != null) {
            properties.setMinimumIntegerDigits(tuple.minIntegerDigits);
        }
        if (tuple.maxIntegerDigits != null) {
            properties.setMaximumIntegerDigits(tuple.maxIntegerDigits);
        }
        if (tuple.minFractionDigits != null) {
            properties.setMinimumFractionDigits(tuple.minFractionDigits);
        }
        if (tuple.maxFractionDigits != null) {
            properties.setMaximumFractionDigits(tuple.maxFractionDigits);
        }
        if (tuple.currency != null) {
            properties.setCurrency(tuple.currency);
        }
        if (tuple.minGroupingDigits != null) {
            properties.setMinimumGroupingDigits(tuple.minGroupingDigits);
        }
        if (tuple.useSigDigits != null) {
            // TODO
        }
        if (tuple.minSigDigits != null) {
            properties.setMinimumSignificantDigits(tuple.minSigDigits);
        }
        if (tuple.maxSigDigits != null) {
            properties.setMaximumSignificantDigits(tuple.maxSigDigits);
        }
        if (tuple.useGrouping != null) {
            properties.setGroupingUsed(tuple.useGrouping > 0);
        }
        if (tuple.multiplier != null) {
            properties.setMultiplier(new BigDecimal(tuple.multiplier));
        }
        if (tuple.roundingIncrement != null) {
            properties.setRoundingIncrement(new BigDecimal(tuple.roundingIncrement.toString()));
        }
        if (tuple.formatWidth != null) {
            properties.setFormatWidth(tuple.formatWidth);
        }
        if (tuple.padCharacter != null && tuple.padCharacter.length() > 0) {
            properties.setPadString(tuple.padCharacter.toString());
        }
        if (tuple.useScientific != null) {
            properties.setMinimumExponentDigits(tuple.useScientific != 0 ? 1 : -1);
        }
        if (tuple.grouping != null) {
            properties.setGroupingSize(tuple.grouping);
        }
        if (tuple.grouping2 != null) {
            properties.setSecondaryGroupingSize(tuple.grouping2);
        }
        if (tuple.roundingMode != null) {
            properties.setRoundingMode(RoundingMode.valueOf(tuple.roundingMode));
        }
        if (tuple.currencyUsage != null) {
            properties.setCurrencyUsage(tuple.currencyUsage);
        }
        if (tuple.minimumExponentDigits != null) {
            properties.setMinimumExponentDigits(tuple.minimumExponentDigits.byteValue());
        }
        if (tuple.exponentSignAlwaysShown != null) {
            properties.setExponentSignAlwaysShown(tuple.exponentSignAlwaysShown != 0);
        }
        if (tuple.decimalSeparatorAlwaysShown != null) {
            properties.setDecimalSeparatorAlwaysShown(tuple.decimalSeparatorAlwaysShown != 0);
        }
        if (tuple.padPosition != null) {
            properties.setPadPosition(PadPosition.fromOld(tuple.padPosition));
        }
        if (tuple.positivePrefix != null) {
            properties.setPositivePrefix(tuple.positivePrefix);
        }
        if (tuple.positiveSuffix != null) {
            properties.setPositiveSuffix(tuple.positiveSuffix);
        }
        if (tuple.negativePrefix != null) {
            properties.setNegativePrefix(tuple.negativePrefix);
        }
        if (tuple.negativeSuffix != null) {
            properties.setNegativeSuffix(tuple.negativeSuffix);
        }
        if (tuple.signAlwaysShown != null) {
            properties.setSignAlwaysShown(tuple.signAlwaysShown != 0);
        }
        if (tuple.localizedPattern != null) {
            DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(tuple.locale);
            String converted = PatternStringUtils
                    .convertLocalized(tuple.localizedPattern, symbols, false);
            PatternStringParser.parseToExistingProperties(converted, properties);
        }
        if (tuple.lenient != null) {
            properties.setParseMode(tuple.lenient == 0 ? ParseMode.STRICT : ParseMode.LENIENT);
        }
        if (tuple.parseIntegerOnly != null) {
            properties.setParseIntegerOnly(tuple.parseIntegerOnly != 0);
        }
        if (tuple.parseCaseSensitive != null) {
            properties.setParseCaseSensitive(tuple.parseCaseSensitive != 0);
        }
        if (tuple.decimalPatternMatchRequired != null) {
            properties.setDecimalPatternMatchRequired(tuple.decimalPatternMatchRequired != 0);
        }
        if (tuple.parseNoExponent != null) {
            properties.setParseNoExponent(tuple.parseNoExponent != 0);
        }
    }

    /**
     * Same as ICU4J, but bypasses the DecimalFormat wrapper and goes directly to the
     * DecimalFormatProperties.
     */
    private DataDrivenNumberFormatTestUtility.CodeUnderTest ICU4J_Properties = new DataDrivenNumberFormatTestUtility.CodeUnderTest() {

        @Override
        public Character Id() {
            return 'P';
        }

        /**
         * Runs a single formatting test. On success, returns null. On failure, returns the error. This
         * implementation just returns null. Subclasses should override.
         *
         * @param tuple
         *            contains the parameters of the format test.
         */
        @Override
        public String format(DataDrivenNumberFormatTestData tuple) {
            String pattern = (tuple.pattern == null) ? "0" : tuple.pattern;
            ULocale locale = (tuple.locale == null) ? ULocale.ENGLISH : tuple.locale;
            DecimalFormatProperties properties = PatternStringParser.parseToProperties(pattern,
                    tuple.currency != null ? PatternStringParser.IGNORE_ROUNDING_ALWAYS
                            : PatternStringParser.IGNORE_ROUNDING_NEVER);
            propertiesFromTuple(tuple, properties);
            DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(locale);
            LocalizedNumberFormatter fmt = NumberFormatter.fromDecimalFormat(properties, symbols, null)
                    .locale(locale);
            Number number = toNumber(tuple.format);
            String expected = tuple.output;
            String actual = fmt.format(number).toString();
            if (!expected.equals(actual)) {
                return "Expected \"" + expected + "\", got \"" + actual + "\"";
            }
            return null;
        }

        /**
         * Runs a single toPattern test. On success, returns null. On failure, returns the error. This
         * implementation just returns null. Subclasses should override.
         *
         * @param tuple
         *            contains the parameters of the format test.
         */
        @Override
        public String toPattern(DataDrivenNumberFormatTestData tuple) {
            String pattern = (tuple.pattern == null) ? "0" : tuple.pattern;
            final DecimalFormatProperties properties;
            DecimalFormat df;
            try {
                properties = PatternStringParser.parseToProperties(pattern,
                        tuple.currency != null ? PatternStringParser.IGNORE_ROUNDING_ALWAYS
                                : PatternStringParser.IGNORE_ROUNDING_NEVER);
                propertiesFromTuple(tuple, properties);
                // TODO: Use PatternString.propertiesToString() directly. (How to deal with
                // CurrencyUsage?)
                df = new DecimalFormat();
                df.setProperties(new PropertySetter() {
                    @Override
                    public void set(DecimalFormatProperties props) {
                        props.copyFrom(properties);
                    }
                });
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
                return e.getLocalizedMessage();
            }

            if (tuple.toPattern != null) {
                String expected = tuple.toPattern;
                String actual = df.toPattern();
                if (!expected.equals(actual)) {
                    return "Expected toPattern='" + expected + "'; got '" + actual + "'";
                }
            }
            if (tuple.toLocalizedPattern != null) {
                String expected = tuple.toLocalizedPattern;
                String actual = PatternStringUtils.propertiesToPatternString(properties);
                if (!expected.equals(actual)) {
                    return "Expected toLocalizedPattern='" + expected + "'; got '" + actual + "'";
                }
            }
            return null;
        }

        @Override
        public String parse(DataDrivenNumberFormatTestData tuple) {
            String pattern = (tuple.pattern == null) ? "0" : tuple.pattern;
            DecimalFormatProperties properties;
            ParsePosition ppos = new ParsePosition(0);
            Number actual;
            try {
                properties = PatternStringParser.parseToProperties(pattern,
                        tuple.currency != null ? PatternStringParser.IGNORE_ROUNDING_ALWAYS
                                : PatternStringParser.IGNORE_ROUNDING_NEVER);
                propertiesFromTuple(tuple, properties);
                actual = NumberParserImpl.parseStatic(tuple.parse,
                        ppos,
                        properties,
                        DecimalFormatSymbols.getInstance(tuple.locale));
            } catch (IllegalArgumentException e) {
                return "parse exception: " + e.getMessage();
            }
            return compareParseResult(tuple.output, actual, ppos);
        }

        @Override
        public String parseCurrency(DataDrivenNumberFormatTestData tuple) {
            String pattern = (tuple.pattern == null) ? "0" : tuple.pattern;
            DecimalFormatProperties properties;
            ParsePosition ppos = new ParsePosition(0);
            CurrencyAmount actual;
            try {
                properties = PatternStringParser.parseToProperties(pattern,
                        tuple.currency != null ? PatternStringParser.IGNORE_ROUNDING_ALWAYS
                                : PatternStringParser.IGNORE_ROUNDING_NEVER);
                propertiesFromTuple(tuple, properties);
                actual = NumberParserImpl.parseStaticCurrency(tuple.parse,
                        ppos,
                        properties,
                        DecimalFormatSymbols.getInstance(tuple.locale));
            } catch (IllegalArgumentException e) {
                e.printStackTrace();
                return "parse exception: " + e.getMessage();
            }
            return compareParseCurrencyResult(tuple.output, tuple.outputCurrency, actual, ppos);
        }
    };

    @Test
    public void TestNoUnknownIDs() {
        DataDrivenNumberFormatTestUtility.checkNoUnknownIDs("numberformattestspecification.txt", "CHJKP");
    }

    @Test
    public void TestDataDrivenICU4J() {
        DataDrivenNumberFormatTestUtility
                .runFormatSuiteIncludingKnownFailures("numberformattestspecification.txt", ICU4J);
    }

    @Test
    public void TestDataDrivenJDK() {
        // #13373: Since not all JDK implementations are the same, test only whitelisted JDKs
        // with known behavior. The JDK version should be occasionally updated.
        org.junit.Assume.assumeTrue(TestUtil.getJavaRuntimeName() == TestUtil.JavaRuntimeName.OpenJDK
                && TestUtil.getJavaVersion() == 8);

        DataDrivenNumberFormatTestUtility
                .runFormatSuiteIncludingKnownFailures("numberformattestspecification.txt", JDK);
    }

    @Test
    public void TestDataDrivenICU4JProperties() {
        DataDrivenNumberFormatTestUtility
                .runFormatSuiteIncludingKnownFailures("numberformattestspecification.txt", ICU4J_Properties);
    }
}
