/*
*******************************************************************************
* Copyright (C) 2015, International Business Machines Corporation and         *
* others. All Rights Reserved.                                                *
*******************************************************************************
*
* File NUMBERFORMAT2TEST.CPP
*
*******************************************************************************
*/
#include "unicode/utypes.h"

#include "intltest.h"

#if !UCONFIG_NO_FORMATTING

#include "unicode/localpointer.h"
#include "unicode/plurrule.h"

#include "affixpatternparser.h"
#include "charstr.h"
#include "datadrivennumberformattestsuite.h"
#include "decimalformatpattern.h"
#include "digitaffixesandpadding.h"
#include "digitformatter.h"
#include "digitgrouping.h"
#include "digitinterval.h"
#include "digitlst.h"
#include "fphdlimp.h"
#include "plurrule_impl.h"
#include "precision.h"
#include "significantdigitinterval.h"
#include "smallintformatter.h"
#include "uassert.h"
#include "valueformatter.h"
#include "visibledigits.h"

struct NumberFormat2Test_Attributes {
    int32_t id;
    int32_t spos;
    int32_t epos;
};

class NumberFormat2Test_FieldPositionHandler : public FieldPositionHandler {
public:
NumberFormat2Test_Attributes attributes[100];
int32_t count;
UBool bRecording;


NumberFormat2Test_FieldPositionHandler() : count(0), bRecording(TRUE) { attributes[0].spos = -1; }
NumberFormat2Test_FieldPositionHandler(UBool recording) : count(0), bRecording(recording) { attributes[0].spos = -1; }
virtual ~NumberFormat2Test_FieldPositionHandler();
virtual void addAttribute(int32_t id, int32_t start, int32_t limit);
virtual void shiftLast(int32_t delta);
virtual UBool isRecording(void) const;
};
 
NumberFormat2Test_FieldPositionHandler::~NumberFormat2Test_FieldPositionHandler() {
}

void NumberFormat2Test_FieldPositionHandler::addAttribute(
        int32_t id, int32_t start, int32_t limit) {
    if (count == UPRV_LENGTHOF(attributes) - 1) {
        return;
    }
    attributes[count].id = id;
    attributes[count].spos = start;
    attributes[count].epos = limit;
    ++count;
    attributes[count].spos = -1;
}

void NumberFormat2Test_FieldPositionHandler::shiftLast(int32_t /* delta */) {
}

UBool NumberFormat2Test_FieldPositionHandler::isRecording() const {
    return bRecording;
}


class NumberFormat2Test : public IntlTest {
public:
    void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
private:
    void TestQuantize();
    void TestConvertScientificNotation();
    void TestLowerUpperExponent();
    void TestRounding();
    void TestRoundingIncrement();
    void TestDigitInterval();
    void TestGroupingUsed();
    void TestBenchmark();
    void TestBenchmark2();
    void TestSmallIntFormatter();
    void TestPositiveIntDigitFormatter();
    void TestDigitListInterval();
    void TestLargeIntValue();
    void TestIntInitVisibleDigits();
    void TestIntInitVisibleDigitsToDigitList();
    void TestDoubleInitVisibleDigits();
    void TestDoubleInitVisibleDigitsToDigitList();
    void TestDigitListInitVisibleDigits();
    void TestSpecialInitVisibleDigits();
    void TestVisibleDigitsWithExponent();
    void TestDigitAffixesAndPadding();
    void TestPluralsAndRounding();
    void TestPluralsAndRoundingScientific();
    void TestValueFormatterIsFastFormattable();
    void TestCurrencyAffixInfo();
    void TestAffixPattern();
    void TestAffixPatternAppend();
    void TestAffixPatternAppendAjoiningLiterals();
    void TestAffixPatternDoubleQuote();
    void TestAffixPatternParser();
    void TestPluralAffix();
    void TestDigitAffix();
    void TestDigitFormatterDefaultCtor();
    void TestDigitFormatterMonetary();
    void TestDigitFormatter();
    void TestSciFormatterDefaultCtor();
    void TestSciFormatter();
    void TestToPatternScientific11648();
    void verifyInterval(const DigitInterval &, int32_t minInclusive, int32_t maxExclusive);
    void verifyAffix(
            const UnicodeString &expected,
            const DigitAffix &affix,
            const NumberFormat2Test_Attributes *expectedAttributes);
    void verifyAffixesAndPadding(
            const UnicodeString &expected,
            const DigitAffixesAndPadding &aaf,
            DigitList &digits,
            const ValueFormatter &vf,
            const PluralRules *optPluralRules,
            const NumberFormat2Test_Attributes *expectedAttributes);
    void verifyAffixesAndPaddingInt32(
            const UnicodeString &expected,
            const DigitAffixesAndPadding &aaf,
            int32_t value,
            const ValueFormatter &vf,
            const PluralRules *optPluralRules,
            const NumberFormat2Test_Attributes *expectedAttributes);
    void verifyDigitList(
        const UnicodeString &expected,
        const DigitList &digits);
    void verifyVisibleDigits(
        const UnicodeString &expected,
        UBool bNegative,
        const VisibleDigits &digits);
    void verifyVisibleDigitsWithExponent(
        const UnicodeString &expected,
        UBool bNegative,
        const VisibleDigitsWithExponent &digits);
    void verifyDigitFormatter(
            const UnicodeString &expected,
            const DigitFormatter &formatter,
            const VisibleDigits &digits,
            const DigitGrouping &grouping,
            const DigitFormatterOptions &options,
            const NumberFormat2Test_Attributes *expectedAttributes);
    void verifySciFormatter(
            const UnicodeString &expected,
            const DigitFormatter &formatter,
            const VisibleDigitsWithExponent &digits,
            const SciFormatterOptions &options,
            const NumberFormat2Test_Attributes *expectedAttributes);
    void verifySmallIntFormatter(
            const UnicodeString &expected,
            int32_t positiveValue,
            int32_t minDigits,
            int32_t maxDigits);
    void verifyPositiveIntDigitFormatter(
            const UnicodeString &expected,
            const DigitFormatter &formatter,
            int32_t value,
            int32_t minDigits,
            int32_t maxDigits,
            const NumberFormat2Test_Attributes *expectedAttributes);
    void verifyAttributes(
            const NumberFormat2Test_Attributes *expected,
            const NumberFormat2Test_Attributes *actual);
    void verifyIntValue(
            int64_t expected, const VisibleDigits &digits);
    void verifySource(
            double expected, const VisibleDigits &digits);
};

void NumberFormat2Test::runIndexedTest(
        int32_t index, UBool exec, const char *&name, char *) {
    if (exec) {
        logln("TestSuite ScientificNumberFormatterTest: ");
    }
    TESTCASE_AUTO_BEGIN;
    TESTCASE_AUTO(TestQuantize);
    TESTCASE_AUTO(TestConvertScientificNotation);
    TESTCASE_AUTO(TestLowerUpperExponent);
    TESTCASE_AUTO(TestRounding);
    TESTCASE_AUTO(TestRoundingIncrement);
    TESTCASE_AUTO(TestDigitInterval);
    TESTCASE_AUTO(TestGroupingUsed);
    TESTCASE_AUTO(TestDigitListInterval);
    TESTCASE_AUTO(TestDigitFormatterDefaultCtor);
    TESTCASE_AUTO(TestDigitFormatterMonetary);
    TESTCASE_AUTO(TestDigitFormatter);
    TESTCASE_AUTO(TestSciFormatterDefaultCtor);
    TESTCASE_AUTO(TestSciFormatter);
    TESTCASE_AUTO(TestBenchmark);
    TESTCASE_AUTO(TestBenchmark2);
    TESTCASE_AUTO(TestSmallIntFormatter);
    TESTCASE_AUTO(TestPositiveIntDigitFormatter);
    TESTCASE_AUTO(TestCurrencyAffixInfo);
    TESTCASE_AUTO(TestAffixPattern);
    TESTCASE_AUTO(TestAffixPatternAppend);
    TESTCASE_AUTO(TestAffixPatternAppendAjoiningLiterals);
    TESTCASE_AUTO(TestAffixPatternDoubleQuote);
    TESTCASE_AUTO(TestAffixPatternParser);
    TESTCASE_AUTO(TestPluralAffix);
    TESTCASE_AUTO(TestDigitAffix);
    TESTCASE_AUTO(TestValueFormatterIsFastFormattable);
    TESTCASE_AUTO(TestLargeIntValue);
    TESTCASE_AUTO(TestIntInitVisibleDigits);
    TESTCASE_AUTO(TestIntInitVisibleDigitsToDigitList);
    TESTCASE_AUTO(TestDoubleInitVisibleDigits);
    TESTCASE_AUTO(TestDoubleInitVisibleDigitsToDigitList);
    TESTCASE_AUTO(TestDigitListInitVisibleDigits);
    TESTCASE_AUTO(TestSpecialInitVisibleDigits);
    TESTCASE_AUTO(TestVisibleDigitsWithExponent);
    TESTCASE_AUTO(TestDigitAffixesAndPadding);
    TESTCASE_AUTO(TestPluralsAndRounding);
    TESTCASE_AUTO(TestPluralsAndRoundingScientific);
    TESTCASE_AUTO(TestToPatternScientific11648);
 
    TESTCASE_AUTO_END;
}

void NumberFormat2Test::TestDigitInterval() {
    DigitInterval all;
    DigitInterval threeInts;
    DigitInterval fourFrac;
    threeInts.setIntDigitCount(3);
    fourFrac.setFracDigitCount(4);
    verifyInterval(all, INT32_MIN, INT32_MAX);
    verifyInterval(threeInts, INT32_MIN, 3);
    verifyInterval(fourFrac, -4, INT32_MAX);
    {
        DigitInterval result(threeInts);
        result.shrinkToFitWithin(fourFrac);
        verifyInterval(result, -4, 3);
        assertEquals("", 7, result.length());
    }
    {
        DigitInterval result(threeInts);
        result.expandToContain(fourFrac);
        verifyInterval(result, INT32_MIN, INT32_MAX);
    }
    {
        DigitInterval result(threeInts);
        result.setIntDigitCount(0);
        verifyInterval(result, INT32_MIN, 0);
        result.setIntDigitCount(-1);
        verifyInterval(result, INT32_MIN, INT32_MAX);
    }
    {
        DigitInterval result(fourFrac);
        result.setFracDigitCount(0);
        verifyInterval(result, 0, INT32_MAX);
        result.setFracDigitCount(-1);
        verifyInterval(result, INT32_MIN, INT32_MAX);
    }
    {
        DigitInterval result;
        result.setIntDigitCount(3);
        result.setFracDigitCount(1);
        result.expandToContainDigit(0);
        result.expandToContainDigit(-1);
        result.expandToContainDigit(2);
        verifyInterval(result, -1, 3);
        result.expandToContainDigit(3);
        verifyInterval(result, -1, 4);
        result.expandToContainDigit(-2);
        verifyInterval(result, -2, 4);
        result.expandToContainDigit(15);
        result.expandToContainDigit(-15);
        verifyInterval(result, -15, 16);
    }
    {
        DigitInterval result;
        result.setIntDigitCount(3);
        result.setFracDigitCount(1);
        assertTrue("", result.contains(2));
        assertTrue("", result.contains(-1));
        assertFalse("", result.contains(3));
        assertFalse("", result.contains(-2));
    }
}

void NumberFormat2Test::verifyInterval(
        const DigitInterval &interval,
        int32_t minInclusive, int32_t maxExclusive) {
    assertEquals("", minInclusive, interval.getLeastSignificantInclusive());
    assertEquals("", maxExclusive, interval.getMostSignificantExclusive());
    assertEquals("", maxExclusive, interval.getIntDigitCount());
}

void NumberFormat2Test::TestGroupingUsed() {
    {
        DigitGrouping grouping;
        assertFalse("", grouping.isGroupingUsed());
    }
    {
        DigitGrouping grouping;
        grouping.fGrouping = 2;
        assertTrue("", grouping.isGroupingUsed());
    }
}

void NumberFormat2Test::TestDigitListInterval() {
    DigitInterval result;
    DigitList digitList;
    {
        digitList.set(12345);
        verifyInterval(digitList.getSmallestInterval(result), 0, 5);
    }
    {
        digitList.set(1000.00);
        verifyInterval(digitList.getSmallestInterval(result), 0, 4);
    }
    {
        digitList.set(43.125);
        verifyInterval(digitList.getSmallestInterval(result), -3, 2);
    }
    {
        digitList.set(.0078125);
        verifyInterval(digitList.getSmallestInterval(result), -7, 0);
    }
    {
        digitList.set(1000.00);
        digitList.getSmallestInterval(result);
        result.expandToContainDigit(3);
        verifyInterval(result, 0, 4);
    }
    {
        digitList.set(1000.00);
        digitList.getSmallestInterval(result);
        result.expandToContainDigit(4);
        verifyInterval(result, 0, 5);
    }
    {
        digitList.set(1000.00);
        digitList.getSmallestInterval(result);
        result.expandToContainDigit(0);
        verifyInterval(result, 0, 4);
    }
    {
        digitList.set(1000.00);
        digitList.getSmallestInterval(result);
        result.expandToContainDigit(-1);
        verifyInterval(result, -1, 4);
    }
    {
        digitList.set(43.125);
        digitList.getSmallestInterval(result);
        result.expandToContainDigit(1);
        verifyInterval(result, -3, 2);
    }
    {
        digitList.set(43.125);
        digitList.getSmallestInterval(result);
        result.expandToContainDigit(2);
        verifyInterval(result, -3, 3);
    }
    {
        digitList.set(43.125);
        digitList.getSmallestInterval(result);
        result.expandToContainDigit(-3);
        verifyInterval(result, -3, 2);
    }
    {
        digitList.set(43.125);
        digitList.getSmallestInterval(result);
        result.expandToContainDigit(-4);
        verifyInterval(result, -4, 2);
    }
}

void NumberFormat2Test::TestQuantize() {
    DigitList quantity;
    quantity.set(0.00168);
    quantity.roundAtExponent(-5);
    DigitList digits;
    UErrorCode status = U_ZERO_ERROR;
    {
        digits.set(1);
        digits.quantize(quantity, status);
        verifyDigitList(".9996", digits);
    }
    {
        // round half even up
        digits.set(1.00044);
        digits.roundAtExponent(-5);
        digits.quantize(quantity, status);
        verifyDigitList("1.00128", digits);
    }
    {
        // round half down
        digits.set(0.99876);
        digits.roundAtExponent(-5);
        digits.quantize(quantity, status);
        verifyDigitList(".99792", digits);
    }
    assertSuccess("", status);
}

void NumberFormat2Test::TestConvertScientificNotation() {
    DigitList digits;
    {
        digits.set(186283);
        assertEquals("", 5, digits.toScientific(1, 1));
        verifyDigitList(
                "1.86283",
                digits);
    }
    {
        digits.set(186283);
        assertEquals("", 0, digits.toScientific(6, 1));
        verifyDigitList(
                "186283",
                digits);
    }
    {
        digits.set(186283);
        assertEquals("", -2, digits.toScientific(8, 1));
        verifyDigitList(
                "18628300",
                digits);
    }
    {
        digits.set(43561);
        assertEquals("", 6, digits.toScientific(-1, 3));
        verifyDigitList(
                ".043561",
                digits);
    }
    {
        digits.set(43561);
        assertEquals("", 3, digits.toScientific(0, 3));
        verifyDigitList(
                "43.561",
                digits);
    }
    {
        digits.set(43561);
        assertEquals("", 3, digits.toScientific(2, 3));
        verifyDigitList(
                "43.561",
                digits);
    }
    {
        digits.set(43561);
        assertEquals("", 0, digits.toScientific(3, 3));
        verifyDigitList(
                "43561",
                digits);
    }
    {
        digits.set(43561);
        assertEquals("", 0, digits.toScientific(5, 3));
        verifyDigitList(
                "43561",
                digits);
    }
    {
        digits.set(43561);
        assertEquals("", -3, digits.toScientific(6, 3));
        verifyDigitList(
                "43561000",
                digits);
    }
    {
        digits.set(43561);
        assertEquals("", -3, digits.toScientific(8, 3));
        verifyDigitList(
                "43561000",
                digits);
    }
    {
        digits.set(43561);
        assertEquals("", -6, digits.toScientific(9, 3));
        verifyDigitList(
                "43561000000",
                digits);
    }
}

void NumberFormat2Test::TestLowerUpperExponent() {
    DigitList digits;

    digits.set(98.7);
    assertEquals("", -1, digits.getLowerExponent());
    assertEquals("", 2, digits.getUpperExponent());
}

void NumberFormat2Test::TestRounding() {
    DigitList digits;
    uprv_decContextSetRounding(&digits.fContext, DEC_ROUND_CEILING);
    {
        // Round at very large exponent
        digits.set(789.123);
        digits.roundAtExponent(100);
        verifyDigitList(
                "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", // 100 0's after 1
                digits);
    }
    {
        // Round at very large exponent
        digits.set(789.123);
        digits.roundAtExponent(1);
        verifyDigitList(
                "790", // 100 0's after 1
                digits);
    }
    {
        // Round at positive exponent
        digits.set(789.123);
        digits.roundAtExponent(1);
        verifyDigitList("790", digits);
    }
    {
        // Round at zero exponent
        digits.set(788.123);
        digits.roundAtExponent(0);
        verifyDigitList("789", digits);
    }
    {
        // Round at negative exponent
        digits.set(789.123);
        digits.roundAtExponent(-2);
        verifyDigitList("789.13", digits);
    }
    {
        // Round to exponent of digits.
        digits.set(789.123);
        digits.roundAtExponent(-3);
        verifyDigitList("789.123", digits);
    }
    {
        // Round at large negative exponent
        digits.set(789.123);
        digits.roundAtExponent(-100);
        verifyDigitList("789.123", digits);
    }
    {
        // Round negative
        digits.set(-789.123);
        digits.roundAtExponent(-2);
        digits.setPositive(TRUE);
        verifyDigitList("789.12", digits);
    }
    {
        // Round to 1 significant digit
        digits.set(789.123);
        digits.roundAtExponent(INT32_MIN, 1);
        verifyDigitList("800", digits);
    }
    {
        // Round to 5 significant digit
        digits.set(789.123);
        digits.roundAtExponent(INT32_MIN, 5);
        verifyDigitList("789.13", digits);
    }
    {
        // Round to 6 significant digit
        digits.set(789.123);
        digits.roundAtExponent(INT32_MIN, 6);
        verifyDigitList("789.123", digits);
    }
    {
        // no-op
        digits.set(789.123);
        digits.roundAtExponent(INT32_MIN, INT32_MAX);
        verifyDigitList("789.123", digits);
    }
    {
        // Rounding at -1 produces fewer than 5 significant digits
        digits.set(789.123);
        digits.roundAtExponent(-1, 5);
        verifyDigitList("789.2", digits);
    }
    {
        // Rounding at -1 produces exactly 4 significant digits
        digits.set(789.123);
        digits.roundAtExponent(-1, 4);
        verifyDigitList("789.2", digits);
    }
    {
        // Rounding at -1 produces more than 3 significant digits
        digits.set(788.123);
        digits.roundAtExponent(-1, 3);
        verifyDigitList("789", digits);
    }
    {
        digits.set(123.456);
        digits.round(INT32_MAX);
        verifyDigitList("123.456", digits);
    }
    {
        digits.set(123.456);
        digits.round(1);
        verifyDigitList("200", digits);
    }
}
void NumberFormat2Test::TestBenchmark() {
/*
    UErrorCode status = U_ZERO_ERROR;
    Locale en("en");
    DecimalFormatSymbols *sym = new DecimalFormatSymbols(en, status);
    DecimalFormat2 fmt(en, "0.0000000", status);
    FieldPosition fpos(0);
    clock_t start = clock();
    for (int32_t i = 0; i < 100000; ++i) {
       UParseError perror;
       DecimalFormat2 fmt2("0.0000000", new DecimalFormatSymbols(*sym), perror, status);
//       UnicodeString append;
//       fmt.format(4.6692016, append, fpos, status);
    }
    errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC);
    assertSuccess("", status);
*/
}

void NumberFormat2Test::TestBenchmark2() {
/*
    UErrorCode status = U_ZERO_ERROR;
    Locale en("en");
    DecimalFormatSymbols *sym = new DecimalFormatSymbols(en, status);
    DecimalFormat fmt("0.0000000", sym, status);
    FieldPosition fpos(0);
    clock_t start = clock();
    for (int32_t i = 0; i < 100000; ++i) {
      UParseError perror;
      DecimalFormat fmt("0.0000000", new DecimalFormatSymbols(*sym), perror, status);
//        UnicodeString append;
//        fmt.format(4.6692016, append, fpos, status);
    }
    errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC);
    assertSuccess("", status);
*/
}

void NumberFormat2Test::TestSmallIntFormatter() {
    verifySmallIntFormatter("0", 7, 0, -2);
    verifySmallIntFormatter("7", 7, 1, -2);
    verifySmallIntFormatter("07", 7, 2, -2);
    verifySmallIntFormatter("07", 7, 2, 2);
    verifySmallIntFormatter("007", 7, 3, 4);
    verifySmallIntFormatter("7", 7, -1, 3);
    verifySmallIntFormatter("0", 0, -1, 3);
    verifySmallIntFormatter("057", 57, 3, 7);
    verifySmallIntFormatter("0057", 57, 4, 7);
    // too many digits for small int
    verifySmallIntFormatter("", 57, 5, 7);
    // too many digits for small int
    verifySmallIntFormatter("", 57, 5, 4);
    verifySmallIntFormatter("03", 3, 2, 3);
    verifySmallIntFormatter("32", 32, 2, 3);
    verifySmallIntFormatter("321", 321, 2, 3);
    verifySmallIntFormatter("219", 3219, 2, 3);
    verifySmallIntFormatter("4095", 4095, 2, 4);
    verifySmallIntFormatter("4095", 4095, 2, 5);
    verifySmallIntFormatter("", 4096, 2, 5);
}

void NumberFormat2Test::TestPositiveIntDigitFormatter() {
    DigitFormatter formatter;
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 4},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "0057",
                formatter,
                57,
                4,
                INT32_MAX,
                expectedAttributes);
    }
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 5},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "00057",
                formatter,
                57,
                5,
                INT32_MAX,
                expectedAttributes);
    }
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 5},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "01000",
                formatter,
                1000,
                5,
                INT32_MAX,
                expectedAttributes);
    }
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 3},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "100",
                formatter,
                100,
                0,
                INT32_MAX,
                expectedAttributes);
    }
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 10},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "2147483647",
                formatter,
                2147483647,
                5,
                INT32_MAX,
                expectedAttributes);
    }
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 12},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "002147483647",
                formatter,
                2147483647,
                12,
                INT32_MAX,
                expectedAttributes);
    }
    {
        // Test long digit string where we have to append one
        // character at a time.
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 40},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "0000000000000000000000000000002147483647",
                formatter,
                2147483647,
                40,
                INT32_MAX,
                expectedAttributes);
    }
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 4},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "6283",
                formatter,
                186283,
                2,
                4,
                expectedAttributes);
    }
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "0",
                formatter,
                186283,
                0,
                0,
                expectedAttributes);
    }
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {0, -1, 0}};
        verifyPositiveIntDigitFormatter(
                "3",
                formatter,
                186283,
                1,
                1,
                expectedAttributes);
    }
}


void NumberFormat2Test::TestDigitFormatterDefaultCtor() {
    DigitFormatter formatter;
    VisibleDigits digits;
    FixedPrecision precision;
    UErrorCode status = U_ZERO_ERROR;
    precision.initVisibleDigits(246.801, digits, status);
    assertSuccess("", status);
    DigitGrouping grouping;
    DigitFormatterOptions options;
    verifyDigitFormatter(
            "246.801",
            formatter,
            digits,
            grouping,
            options,
            NULL);
}

void NumberFormat2Test::TestDigitFormatterMonetary() {
    UErrorCode status = U_ZERO_ERROR;
    DecimalFormatSymbols symbols("en", status);
    if (!assertSuccess("", status)) {
        return;
    }
    symbols.setSymbol(
            DecimalFormatSymbols::kMonetarySeparatorSymbol,
            "decimal separator");
    symbols.setSymbol(
            DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol,
            "grouping separator");
    DigitFormatter formatter(symbols);
    VisibleDigits visibleDigits;
    DigitGrouping grouping;
    FixedPrecision precision;
    precision.initVisibleDigits(43560.02, visibleDigits, status);
    if (!assertSuccess("", status)) {
        return;
    }
    DigitFormatterOptions options;
    grouping.fGrouping = 3;
    {
        verifyDigitFormatter(
                "43,560.02",
                formatter,
                visibleDigits,
                grouping,
                options,
                NULL);
        formatter.setDecimalFormatSymbolsForMonetary(symbols);
        verifyDigitFormatter(
                "43grouping separator560decimal separator02",
                formatter,
                visibleDigits,
                grouping,
                options,
                NULL);
    }
}

void NumberFormat2Test::TestDigitFormatter() {
    UErrorCode status = U_ZERO_ERROR;
    DecimalFormatSymbols symbols("en", status);
    if (!assertSuccess("", status)) {
        return;
    }
    DigitFormatter formatter(symbols);
    DigitInterval interval;
    {
        VisibleDigits visibleDigits;
        DigitGrouping grouping;
        FixedPrecision precision;
        precision.initVisibleDigits((int64_t) 8192, visibleDigits, status);
        if (!assertSuccess("", status)) {
            return;
        }
        DigitFormatterOptions options;
        verifyDigitFormatter(
                "8192",
                formatter,
                visibleDigits,
                grouping,
                options,
                NULL);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 4},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 4, 5},
            {0, -1, 0}};
        options.fAlwaysShowDecimal = TRUE;
        verifyDigitFormatter(
                "8192.",
                formatter,
                visibleDigits,
                grouping,
                options,
                expectedAttributes);

        // Turn on grouping
        grouping.fGrouping = 3;
        options.fAlwaysShowDecimal = FALSE;
        verifyDigitFormatter(
                "8,192",
                formatter,
                visibleDigits,
                grouping,
                options,
                NULL);

        // turn on min grouping which will suppress grouping
        grouping.fMinGrouping = 2;
        verifyDigitFormatter(
                "8192",
                formatter,
                visibleDigits,
                grouping,
                options,
                NULL);

        // adding one more digit will enable grouping once again.
        precision.initVisibleDigits((int64_t) 43560, visibleDigits, status);
        if (!assertSuccess("", status)) {
            return;
        }
        verifyDigitFormatter(
                "43,560",
                formatter,
                visibleDigits,
                grouping,
                options,
                NULL);
    }
    {
        DigitGrouping grouping;
        FixedPrecision precision;
        VisibleDigits visibleDigits;
        precision.initVisibleDigits(
                31415926.0078125, visibleDigits, status);
        if (!assertSuccess("", status)) {
            return;
        }
        DigitFormatterOptions options;
        verifyDigitFormatter(
                "31415926.0078125",
                formatter,
                visibleDigits,
                grouping,
                options,
                NULL);

        // Turn on grouping with secondary.
        grouping.fGrouping = 2;
        grouping.fGrouping2 = 3;
        verifyDigitFormatter(
                "314,159,26.0078125",
                formatter,
                visibleDigits,
                grouping,
                options,
                NULL);

        // Pad with zeros by widening interval.
        precision.fMin.setIntDigitCount(9);
        precision.fMin.setFracDigitCount(10);
        precision.initVisibleDigits(
                31415926.0078125, visibleDigits, status);
        if (!assertSuccess("", status)) {
            return;
        }
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_GROUPING_SEPARATOR_FIELD, 1, 2},
            {UNUM_GROUPING_SEPARATOR_FIELD, 5, 6},
            {UNUM_GROUPING_SEPARATOR_FIELD, 9, 10},
            {UNUM_INTEGER_FIELD, 0, 12},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 12, 13},
            {UNUM_FRACTION_FIELD, 13, 23},
            {0, -1, 0}};
        verifyDigitFormatter(
                "0,314,159,26.0078125000",
                formatter,
                visibleDigits,
                grouping,
                options,
                expectedAttributes);
    }
    {
        DigitGrouping grouping;
        FixedPrecision precision;
        VisibleDigits visibleDigits;
        DigitFormatterOptions options;
        precision.fMax.setIntDigitCount(0);
        precision.fMax.setFracDigitCount(0);
        precision.initVisibleDigits(
                3125.0, visibleDigits, status);
        if (!assertSuccess("", status)) {
            return;
        }
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {0, -1, 0}};
        verifyDigitFormatter(
                "0",
                formatter,
                visibleDigits,
                grouping,
                options,
                expectedAttributes);
        NumberFormat2Test_Attributes expectedAttributesWithDecimal[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
            {0, -1, 0}};
        options.fAlwaysShowDecimal = TRUE;
        verifyDigitFormatter(
                "0.",
                formatter,
                visibleDigits,
                grouping,
                options,
                expectedAttributesWithDecimal);
    }
    {
        DigitGrouping grouping;
        FixedPrecision precision;
        VisibleDigits visibleDigits;
        DigitFormatterOptions options;
        precision.fMax.setIntDigitCount(1);
        precision.fMin.setFracDigitCount(1);
        precision.initVisibleDigits(
                3125.0, visibleDigits, status);
        if (!assertSuccess("", status)) {
            return;
        }
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
            {UNUM_FRACTION_FIELD, 2, 3},
            {0, -1, 0}};
        options.fAlwaysShowDecimal = TRUE;
        verifyDigitFormatter(
                "5.0",
                formatter,
                visibleDigits,
                grouping,
                options,
                expectedAttributes);
    }
}

void NumberFormat2Test::TestSciFormatterDefaultCtor() {
    DigitFormatter formatter;
    ScientificPrecision precision;
    VisibleDigitsWithExponent visibleDigits;
    UErrorCode status = U_ZERO_ERROR;
    precision.initVisibleDigitsWithExponent(
            6.02E23, visibleDigits, status);
    if (!assertSuccess("", status)) {
        return;
    }
    SciFormatterOptions options;
    verifySciFormatter(
            "6.02E23",
            formatter,
            visibleDigits,
            options,
            NULL);
    precision.initVisibleDigitsWithExponent(
            6.62E-34, visibleDigits, status);
    if (!assertSuccess("", status)) {
        return;
    }
    verifySciFormatter(
            "6.62E-34",
            formatter,
            visibleDigits,
            options,
            NULL);
}

void NumberFormat2Test::TestSciFormatter() {
    DigitFormatter formatter;
    ScientificPrecision precision;
    precision.fMantissa.fMin.setIntDigitCount(4);
    precision.fMantissa.fMax.setIntDigitCount(4);
    precision.fMantissa.fMin.setFracDigitCount(0);
    precision.fMantissa.fMax.setFracDigitCount(0);
    precision.fMinExponentDigits = 3;
    VisibleDigitsWithExponent visibleDigits;
    UErrorCode status = U_ZERO_ERROR;
    precision.initVisibleDigitsWithExponent(
            1.248E26, visibleDigits, status);
    if (!assertSuccess("", status)) {
        return;
    }
    SciFormatterOptions options;

    {
        options.fExponent.fAlwaysShowSign = TRUE;
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 4},
            {UNUM_EXPONENT_SYMBOL_FIELD, 4, 5},
            {UNUM_EXPONENT_SIGN_FIELD, 5, 6},
            {UNUM_EXPONENT_FIELD, 6, 9},
            {0, -1, 0}};
        verifySciFormatter(
                "1248E+023",
                formatter,
                visibleDigits,
                options,
                expectedAttributes);
    }
    {
        options.fMantissa.fAlwaysShowDecimal = TRUE;
        options.fExponent.fAlwaysShowSign = FALSE;
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 4},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 4, 5},
            {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6},
            {UNUM_EXPONENT_FIELD, 6, 9},
            {0, -1, 0}};
        verifySciFormatter(
                "1248.E023",
                formatter,
                visibleDigits,
                options,
                expectedAttributes);
    }
}

void NumberFormat2Test::TestValueFormatterIsFastFormattable() {
    UErrorCode status = U_ZERO_ERROR;
    DecimalFormatSymbols symbols("en", status);
    if (!assertSuccess("", status)) {
        return;
    }
    DigitFormatter formatter(symbols);
    DigitGrouping grouping;
    FixedPrecision precision;
    DigitFormatterOptions options;
    ValueFormatter vf;
    vf.prepareFixedDecimalFormatting(
            formatter, grouping, precision, options);
    assertTrue("", vf.isFastFormattable(0));
    assertTrue("", vf.isFastFormattable(35));
    assertTrue("", vf.isFastFormattable(-48));
    assertTrue("", vf.isFastFormattable(2147483647));
    assertTrue("", vf.isFastFormattable(-2147483647));
    assertFalse("", vf.isFastFormattable(-2147483648L));
    {
        DigitGrouping grouping;
        grouping.fGrouping = 3;
        ValueFormatter vf;
        vf.prepareFixedDecimalFormatting(
                formatter, grouping, precision, options);
        assertTrue("0", vf.isFastFormattable(0));
        assertTrue("62", vf.isFastFormattable(62));
        assertTrue("999", vf.isFastFormattable(999));
        assertFalse("1000", vf.isFastFormattable(1000));
        assertTrue("-1", vf.isFastFormattable(-1));
        assertTrue("-38", vf.isFastFormattable(-38));
        assertTrue("-999", vf.isFastFormattable(-999));
        assertFalse("-1000", vf.isFastFormattable(-1000));
        grouping.fMinGrouping = 2;
        assertTrue("-1000", vf.isFastFormattable(-1000));
        assertTrue("-4095", vf.isFastFormattable(-4095));
        assertTrue("4095", vf.isFastFormattable(4095));
        // We give up on acounting digits at 4096
        assertFalse("-4096", vf.isFastFormattable(-4096));
        assertFalse("4096", vf.isFastFormattable(4096));
    }
    {
        // grouping on but with max integer digits set.
        DigitGrouping grouping;
        grouping.fGrouping = 4;
        FixedPrecision precision;
        precision.fMax.setIntDigitCount(4);
        ValueFormatter vf;
        vf.prepareFixedDecimalFormatting(
                formatter, grouping, precision, options);
        assertTrue("-4096", vf.isFastFormattable(-4096));
        assertTrue("4096", vf.isFastFormattable(4096));
        assertTrue("-10000", vf.isFastFormattable(-10000));
        assertTrue("10000", vf.isFastFormattable(10000));
        assertTrue("-2147483647", vf.isFastFormattable(-2147483647));
        assertTrue("2147483647", vf.isFastFormattable(2147483647));

        precision.fMax.setIntDigitCount(5);
        assertFalse("-4096", vf.isFastFormattable(-4096));
        assertFalse("4096", vf.isFastFormattable(4096));

    }
    {
        // grouping on but with min integer digits set.
        DigitGrouping grouping;
        grouping.fGrouping = 3;
        FixedPrecision precision;
        precision.fMin.setIntDigitCount(3);
        ValueFormatter vf;
        vf.prepareFixedDecimalFormatting(
                formatter, grouping, precision, options);
        assertTrue("-999", vf.isFastFormattable(-999));
        assertTrue("999", vf.isFastFormattable(999));
        assertFalse("-1000", vf.isFastFormattable(-1000));
        assertFalse("1000", vf.isFastFormattable(1000));

        precision.fMin.setIntDigitCount(4);
        assertFalse("-999", vf.isFastFormattable(-999));
        assertFalse("999", vf.isFastFormattable(999));
        assertFalse("-2147483647", vf.isFastFormattable(-2147483647));
        assertFalse("2147483647", vf.isFastFormattable(2147483647));
    }
    {
        // options set.
        DigitFormatterOptions options;
        ValueFormatter vf;
        vf.prepareFixedDecimalFormatting(
                formatter, grouping, precision, options);
        assertTrue("5125", vf.isFastFormattable(5125));
        options.fAlwaysShowDecimal = TRUE;
        assertFalse("5125", vf.isFastFormattable(5125));
        options.fAlwaysShowDecimal = FALSE;
        assertTrue("5125", vf.isFastFormattable(5125));
    }
    {
        // test fraction digits
        FixedPrecision precision;
        ValueFormatter vf;
        vf.prepareFixedDecimalFormatting(
                formatter, grouping, precision, options);
        assertTrue("7127", vf.isFastFormattable(7127));
        precision.fMin.setFracDigitCount(1);
        assertFalse("7127", vf.isFastFormattable(7127));
    }
    {
        // test presence of significant digits
        FixedPrecision precision;
        ValueFormatter vf;
        vf.prepareFixedDecimalFormatting(
                formatter, grouping, precision, options);
        assertTrue("1049", vf.isFastFormattable(1049));
        precision.fSignificant.setMin(1);
        assertFalse("1049", vf.isFastFormattable(1049));
    }
    {
        // test presence of rounding increment
        FixedPrecision precision;
        ValueFormatter vf;
        vf.prepareFixedDecimalFormatting(
                formatter, grouping, precision, options);
        assertTrue("1099", vf.isFastFormattable(1099));
        precision.fRoundingIncrement.set(2.3);
        assertFalse("1099", vf.isFastFormattable(1099));
    }
    {
        // test scientific notation
        ScientificPrecision precision;
        SciFormatterOptions options;
        ValueFormatter vf;
        vf.prepareScientificFormatting(
                formatter, precision, options);
        assertFalse("1081", vf.isFastFormattable(1081));
    }
}

void NumberFormat2Test::TestDigitAffix() {
    DigitAffix affix;
    {
        affix.append("foo");
        affix.append("--", UNUM_SIGN_FIELD);
        affix.append("%", UNUM_PERCENT_FIELD);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 3, 5},
            {UNUM_PERCENT_FIELD, 5, 6},
            {0, -1, 0}};
        verifyAffix("foo--%", affix, expectedAttributes);
    }
    {
        affix.remove();
        affix.append("USD", UNUM_CURRENCY_FIELD);
        affix.append(" ");
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_CURRENCY_FIELD, 0, 3},
            {0, -1, 0}};
        verifyAffix("USD ", affix, expectedAttributes);
    }
    {
        affix.setTo("%%", UNUM_PERCENT_FIELD);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_PERCENT_FIELD, 0, 2},
            {0, -1, 0}};
        verifyAffix("%%", affix, expectedAttributes);
    }
}

void NumberFormat2Test::TestPluralAffix() {
    UErrorCode status = U_ZERO_ERROR;
    PluralAffix part;
    part.setVariant("one", "Dollar", status);
    part.setVariant("few", "DollarFew", status);
    part.setVariant("other", "Dollars", status);
    PluralAffix dollar(part);
    PluralAffix percent(part);
    part.remove();
    part.setVariant("one", "Percent", status);
    part.setVariant("many", "PercentMany", status);
    part.setVariant("other", "Percents", status);
    percent = part;
    part.remove();
    part.setVariant("one", "foo", status);

    PluralAffix pa;
    assertEquals("", "", pa.getOtherVariant().toString());
    pa.append(dollar, UNUM_CURRENCY_FIELD, status);
    pa.append(" and ");
    pa.append(percent, UNUM_PERCENT_FIELD, status);
    pa.append("-", UNUM_SIGN_FIELD);

    {
        // other
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_CURRENCY_FIELD, 0, 7},
            {UNUM_PERCENT_FIELD, 12, 20},
            {UNUM_SIGN_FIELD, 20, 21},
            {0, -1, 0}};
        verifyAffix(
                "Dollars and Percents-",
                pa.getByCategory("other"),
                expectedAttributes);
    }
    {
        // two which is same as other
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_CURRENCY_FIELD, 0, 7},
            {UNUM_PERCENT_FIELD, 12, 20},
            {UNUM_SIGN_FIELD, 20, 21},
            {0, -1, 0}};
        verifyAffix(
                "Dollars and Percents-",
                pa.getByCategory("two"),
                expectedAttributes);
    }
    {
        // bad which is same as other
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_CURRENCY_FIELD, 0, 7},
            {UNUM_PERCENT_FIELD, 12, 20},
            {UNUM_SIGN_FIELD, 20, 21},
            {0, -1, 0}};
        verifyAffix(
                "Dollars and Percents-",
                pa.getByCategory("bad"),
                expectedAttributes);
    }
    {
        // one
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_CURRENCY_FIELD, 0, 6},
            {UNUM_PERCENT_FIELD, 11, 18},
            {UNUM_SIGN_FIELD, 18, 19},
            {0, -1, 0}};
        verifyAffix(
                "Dollar and Percent-",
                pa.getByCategory("one"),
                expectedAttributes);
    }
    {
        // few
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_CURRENCY_FIELD, 0, 9},
            {UNUM_PERCENT_FIELD, 14, 22},
            {UNUM_SIGN_FIELD, 22, 23},
            {0, -1, 0}};
        verifyAffix(
                "DollarFew and Percents-",
                pa.getByCategory("few"),
                expectedAttributes);
    }
    {
        // many
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_CURRENCY_FIELD, 0, 7},
            {UNUM_PERCENT_FIELD, 12, 23},
            {UNUM_SIGN_FIELD, 23, 24},
            {0, -1, 0}};
        verifyAffix(
                "Dollars and PercentMany-",
                pa.getByCategory("many"),
                expectedAttributes);
    }
    assertTrue("", pa.hasMultipleVariants());
    pa.remove();
    pa.append("$$$", UNUM_CURRENCY_FIELD);
    assertFalse("", pa.hasMultipleVariants());
    
}

void NumberFormat2Test::TestCurrencyAffixInfo() {
    CurrencyAffixInfo info;
    assertTrue("", info.isDefault());
    UnicodeString expectedSymbol("\\u00a4");
    UnicodeString expectedSymbolIso("\\u00a4\\u00a4");
    UnicodeString expectedSymbols("\\u00a4\\u00a4\\u00a4");
    assertEquals("", expectedSymbol.unescape(), info.getSymbol());
    assertEquals("", expectedSymbolIso.unescape(), info.getISO());
    assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("one").toString());
    assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("other").toString());
    assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("two").toString());
    UErrorCode status = U_ZERO_ERROR;
    static UChar USD[] = {0x55, 0x53, 0x44, 0x0};
    LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
    if (!assertSuccess("", status)) {
        return;
    }
    info.set("en", rules.getAlias(), USD, status);
    assertEquals("", "$", info.getSymbol(), TRUE);
    assertEquals("", "USD", info.getISO(), TRUE);
    assertEquals("", "US dollar", info.getLong().getByCategory("one").toString(), TRUE);
    assertEquals("", "US dollars", info.getLong().getByCategory("other").toString(), TRUE);
    assertEquals("", "US dollars", info.getLong().getByCategory("two").toString(), TRUE);
    assertFalse("", info.isDefault());
    info.set(NULL, NULL, NULL, status);
    assertTrue("", info.isDefault());
    assertEquals("", expectedSymbol.unescape(), info.getSymbol());
    assertEquals("", expectedSymbolIso.unescape(), info.getISO());
    assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("one").toString());
    assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("other").toString());
    assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("two").toString());
    info.setSymbol("$");
    assertFalse("", info.isDefault());
    info.set(NULL, NULL, NULL, status);
    assertTrue("", info.isDefault());
    info.setISO("USD");
    assertFalse("", info.isDefault());
    assertSuccess("", status);
}

void NumberFormat2Test::TestAffixPattern() {
    static UChar chars[500];
    for (int32_t i = 0; i < UPRV_LENGTHOF(chars); ++i) {
        chars[i] = (UChar) (i + 1);
    }
    AffixPattern first;
    first.add(AffixPattern::kPercent);
    first.addLiteral(chars, 0, 200);
    first.addLiteral(chars, 200, 300);
    first.addCurrency(2);
    first.addLiteral(chars, 0, 256);
    AffixPattern second;
    second.add(AffixPattern::kPercent);
    second.addLiteral(chars, 0, 300);
    second.addLiteral(chars, 300, 200);
    second.addCurrency(2);
    second.addLiteral(chars, 0, 150);
    second.addLiteral(chars, 150, 106);
    assertTrue("", first.equals(second));
    AffixPatternIterator iter;
    second.remove();
    assertFalse("", second.iterator(iter).nextToken());
    assertTrue("", first.iterator(iter).nextToken());
    assertEquals("", AffixPattern::kPercent, iter.getTokenType());
    assertEquals("", 1, iter.getTokenLength());
    assertTrue("", iter.nextToken());
    UnicodeString str;
    assertEquals("", 500, iter.getLiteral(str).length());
    assertEquals("", AffixPattern::kLiteral, iter.getTokenType());
    assertEquals("", 500, iter.getTokenLength());
    assertTrue("", iter.nextToken());
    assertEquals("", AffixPattern::kCurrency, iter.getTokenType());
    assertEquals("", 2, iter.getTokenLength());
    assertTrue("", iter.nextToken());
    assertEquals("", 256, iter.getLiteral(str).length());
    assertEquals("", AffixPattern::kLiteral, iter.getTokenType());
    assertEquals("", 256, iter.getTokenLength());
    assertFalse("", iter.nextToken());
}

void NumberFormat2Test::TestAffixPatternDoubleQuote() {
    UnicodeString str("'Don''t'");
    AffixPattern expected;
    // Don't
    static UChar chars[] = {0x44, 0x6F, 0x6E, 0x27, 0x74};
    expected.addLiteral(chars, 0, UPRV_LENGTHOF(chars));
    AffixPattern actual;
    UErrorCode status = U_ZERO_ERROR;
    AffixPattern::parseUserAffixString(str, actual, status);
    assertTrue("", expected.equals(actual));
    UnicodeString formattedString;
    assertEquals("", "Don''t", actual.toUserString(formattedString));
    assertSuccess("", status);
}

void NumberFormat2Test::TestAffixPatternParser() {
    UErrorCode status = U_ZERO_ERROR;
    static UChar USD[] = {0x55, 0x53, 0x44, 0x0};
    LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
    DecimalFormatSymbols symbols("en", status);
    if (U_FAILURE(status)) {
        dataerrln("Error creating DecimalFormatSymbols - %s", u_errorName(status));
        return;
    }
    AffixPatternParser parser(symbols);
    CurrencyAffixInfo currencyAffixInfo;
    currencyAffixInfo.set("en", rules.getAlias(), USD, status);
    PluralAffix affix;
    UnicodeString str("'--y'''dz'%'\\u00a4\\u00a4\\u00a4\\u00a4 y '\\u00a4\\u00a4\\u00a4 or '\\u00a4\\u00a4 but '\\u00a4");
    str = str.unescape();
    assertSuccess("", status);
    AffixPattern affixPattern;
    parser.parse(
            AffixPattern::parseAffixString(str, affixPattern, status),
            currencyAffixInfo,
            affix,
            status);
    UnicodeString formattedStr;
    affixPattern.toString(formattedStr);
    UnicodeString expectedFormattedStr("'--y''dz'%'\\u00a4\\u00a4\\u00a4\\u00a4 y '\\u00a4\\u00a4\\u00a4 or '\\u00a4\\u00a4 but '\\u00a4");
    expectedFormattedStr = expectedFormattedStr.unescape();
    assertEquals("1", expectedFormattedStr, formattedStr);
    AffixPattern userAffixPattern;
    UnicodeString userStr("-'-'y'''d'z%\\u00a4\\u00a4\\u00a4'\\u00a4' y \\u00a4\\u00a4\\u00a4 or \\u00a4\\u00a4 but \\u00a4");
    userStr = userStr.unescape();
    AffixPattern::parseUserAffixString(userStr, userAffixPattern, status),
    assertTrue("", affixPattern.equals(userAffixPattern));
    AffixPattern userAffixPattern2;
    UnicodeString formattedUserStr;
    AffixPattern::parseUserAffixString(
            userAffixPattern.toUserString(formattedUserStr),
            userAffixPattern2,
            status);
    UnicodeString expectedFormattedUserStr(
            "-'-'y''dz%\\u00a4\\u00a4\\u00a4'\\u00a4' y \\u00a4\\u00a4\\u00a4 or \\u00a4\\u00a4 but \\u00a4");
    assertEquals("2", expectedFormattedUserStr.unescape(), formattedUserStr);
    assertTrue("", userAffixPattern2.equals(userAffixPattern));
    assertSuccess("", status);
    assertTrue("", affixPattern.usesCurrency());
    assertTrue("", affixPattern.usesPercent());
    assertFalse("", affixPattern.usesPermill());
    assertTrue("", affix.hasMultipleVariants());
    {
        // other
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 0, 1},
            {UNUM_PERCENT_FIELD, 6, 7},
            {UNUM_CURRENCY_FIELD, 7, 17},
            {UNUM_CURRENCY_FIELD, 21, 31},
            {UNUM_CURRENCY_FIELD, 35, 38},
            {UNUM_CURRENCY_FIELD, 43, 44},
            {0, -1, 0}};
        verifyAffix(
                "--y'dz%US dollars\\u00a4 y US dollars or USD but $",
                affix.getByCategory("other"),
                expectedAttributes);
    }
    {
        // one
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 0, 1},
            {UNUM_PERCENT_FIELD, 6, 7},
            {UNUM_CURRENCY_FIELD, 7, 16},
            {UNUM_CURRENCY_FIELD, 20, 29},
            {UNUM_CURRENCY_FIELD, 33, 36},
            {UNUM_CURRENCY_FIELD, 41, 42},
            {0, -1, 0}};
        verifyAffix(
                "--y'dz%US dollar\\u00a4 y US dollar or USD but $",
                affix.getByCategory("one"),
                expectedAttributes);
    }
    affix.remove();
    str = "%'-";
    affixPattern.remove();
    parser.parse(
            AffixPattern::parseAffixString(str, affixPattern, status),
            currencyAffixInfo,
            affix,
            status);
    assertSuccess("", status);
    assertFalse("", affixPattern.usesCurrency());
    assertFalse("", affixPattern.usesPercent());
    assertFalse("", affixPattern.usesPermill());
    assertFalse("", affix.hasMultipleVariants());
    {
        // other
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 1, 2},
            {0, -1, 0}};
        verifyAffix(
                "%-",
                affix.getByCategory("other"),
                expectedAttributes);
    }
    UnicodeString a4("\\u00a4");
    AffixPattern scratchPattern;
    AffixPattern::parseAffixString(a4.unescape(), scratchPattern, status);
    assertFalse("", scratchPattern.usesCurrency());

    // Test really long string > 256 chars.
    str = "'\\u2030012345678901234567890123456789012345678901234567890123456789"
          "012345678901234567890123456789012345678901234567890123456789"
          "012345678901234567890123456789012345678901234567890123456789"
          "012345678901234567890123456789012345678901234567890123456789"
          "012345678901234567890123456789012345678901234567890123456789";
    str = str.unescape();
    affixPattern.remove();
    affix.remove();
    parser.parse(
            AffixPattern::parseAffixString(str, affixPattern, status),
            currencyAffixInfo,
            affix,
            status);
    assertSuccess("", status);
    assertFalse("", affixPattern.usesCurrency());
    assertFalse("", affixPattern.usesPercent());
    assertTrue("", affixPattern.usesPermill());
    assertFalse("", affix.hasMultipleVariants());
    {
       UnicodeString expected =
           "\\u2030012345678901234567890123456789012345678901234567890123456789"
           "012345678901234567890123456789012345678901234567890123456789"
           "012345678901234567890123456789012345678901234567890123456789"
           "012345678901234567890123456789012345678901234567890123456789"
           "012345678901234567890123456789012345678901234567890123456789";
        expected = expected.unescape();
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_PERMILL_FIELD, 0, 1},
            {0, -1, 0}};
        verifyAffix(
                expected,
                affix.getOtherVariant(),
                expectedAttributes);
    }
}

void NumberFormat2Test::TestAffixPatternAppend() {
  AffixPattern pattern;
  UErrorCode status = U_ZERO_ERROR;
  UnicodeString patternStr("%\\u2030");
  AffixPattern::parseUserAffixString(
          patternStr.unescape(), pattern, status);

  AffixPattern appendPattern;
  UnicodeString appendPatternStr("-\\u00a4\\u00a4*");
  AffixPattern::parseUserAffixString(
          appendPatternStr.unescape(), appendPattern, status);

  AffixPattern expectedPattern;
  UnicodeString expectedPatternStr("%\\u2030-\\u00a4\\u00a4*");
  AffixPattern::parseUserAffixString(
          expectedPatternStr.unescape(), expectedPattern, status);
  
  assertTrue("", pattern.append(appendPattern).equals(expectedPattern));
  assertSuccess("", status);
}

void NumberFormat2Test::TestAffixPatternAppendAjoiningLiterals() {
  AffixPattern pattern;
  UErrorCode status = U_ZERO_ERROR;
  UnicodeString patternStr("%baaa");
  AffixPattern::parseUserAffixString(
          patternStr, pattern, status);

  AffixPattern appendPattern;
  UnicodeString appendPatternStr("caa%");
  AffixPattern::parseUserAffixString(
          appendPatternStr, appendPattern, status);

  AffixPattern expectedPattern;
  UnicodeString expectedPatternStr("%baaacaa%");
  AffixPattern::parseUserAffixString(
          expectedPatternStr, expectedPattern, status);
  
  assertTrue("", pattern.append(appendPattern).equals(expectedPattern));
  assertSuccess("", status);
}

void NumberFormat2Test::TestLargeIntValue() {
    VisibleDigits digits;
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;

        // Last 18 digits for int values.
        verifyIntValue(
                223372036854775807LL, 
                precision.initVisibleDigits(INT64_MAX, digits, status));
        assertSuccess("INT64_MAX", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setIntDigitCount(5);

        // Last 18 digits for int values.
        verifyIntValue(
                75807LL, 
                precision.initVisibleDigits(INT64_MAX, digits, status));
        verifySource(75807.0, digits);
        assertSuccess("75807", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;

        // Last 18 digits for int values.
        verifyIntValue(
                223372036854775808LL, 
                precision.initVisibleDigits(INT64_MIN, digits, status));
        assertSuccess("INT64_MIN", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setIntDigitCount(5);

        // Last 18 digits for int values.
        verifyIntValue(
                75808LL, 
                precision.initVisibleDigits(INT64_MIN, digits, status));
        verifySource(75808.0, digits);
        assertSuccess("75808", status);
    }
        
}

void NumberFormat2Test::TestIntInitVisibleDigits() {
    VisibleDigits digits;
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        verifyVisibleDigits(
                "13",
                FALSE,
                precision.initVisibleDigits((int64_t) 13LL, digits, status));
        assertSuccess("13", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        verifyVisibleDigits(
                "17",
                TRUE,
                precision.initVisibleDigits((int64_t) -17LL, digits, status));
        assertSuccess("-17", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        verifyVisibleDigits(
                "9223372036854775808",
                TRUE,
                precision.initVisibleDigits(INT64_MIN, digits, status));
        assertSuccess("-9223372036854775808", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        verifyVisibleDigits(
                "9223372036854775807",
                FALSE,
                precision.initVisibleDigits(INT64_MAX, digits, status));
        assertSuccess("9223372036854775807", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        verifyVisibleDigits(
                "31536000",
                TRUE,
                precision.initVisibleDigits((int64_t) -31536000LL, digits, status));
        assertSuccess("-31536000", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        verifyVisibleDigits(
                "0",
                FALSE,
                precision.initVisibleDigits((int64_t) 0LL, digits, status));
        assertSuccess("0", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMin.setIntDigitCount(4);
        precision.fMin.setFracDigitCount(2);
        verifyVisibleDigits(
                "0000.00",
                FALSE,
                precision.initVisibleDigits((int64_t) 0LL, digits, status));
        assertSuccess("0", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMin.setIntDigitCount(4);
        precision.fMin.setFracDigitCount(2);
        verifyVisibleDigits(
                "0057.00",
                FALSE,
                precision.initVisibleDigits((int64_t) 57LL, digits, status));
        assertSuccess("57", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMin.setIntDigitCount(4);
        precision.fMin.setFracDigitCount(2);
        verifyVisibleDigits(
                "0057.00",
                TRUE,
                precision.initVisibleDigits((int64_t) -57LL, digits, status));
        assertSuccess("-57", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setIntDigitCount(2);
        precision.fMin.setFracDigitCount(1);
        verifyVisibleDigits(
                "35.0",
                FALSE,
                precision.initVisibleDigits((int64_t) 235LL, digits, status));
        assertSuccess("235", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setIntDigitCount(2);
        precision.fMin.setFracDigitCount(1);
        precision.fFailIfOverMax = TRUE;
        precision.initVisibleDigits((int64_t) 239LL, digits, status);
        if (status != U_ILLEGAL_ARGUMENT_ERROR) {
            errln("239: Expected U_ILLEGAL_ARGUMENT_ERROR");
        }
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMin(5);
        verifyVisibleDigits(
                "153.00",
                FALSE,
                precision.initVisibleDigits((int64_t) 153LL, digits, status));
        assertSuccess("153", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMax(2);
        precision.fExactOnly = TRUE;
        precision.initVisibleDigits((int64_t) 154LL, digits, status);
        if (status != U_FORMAT_INEXACT_ERROR) {
            errln("154: Expected U_FORMAT_INEXACT_ERROR");
        }
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMax(5);
        verifyVisibleDigits(
                "150",
                FALSE,
                precision.initVisibleDigits((int64_t) 150LL, digits, status));
        assertSuccess("150", status);
    }
}

void NumberFormat2Test::TestIntInitVisibleDigitsToDigitList() {
    VisibleDigits digits;
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fRoundingIncrement.set(7.3);
        verifyVisibleDigits(
                "29.2",
                TRUE,
                precision.initVisibleDigits((int64_t) -30LL, digits, status));
        assertSuccess("-29.2", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fRoundingIncrement.set(7.3);
        precision.fRoundingMode = DecimalFormat::kRoundFloor;
        verifyVisibleDigits(
                "36.5",
                TRUE,
                precision.initVisibleDigits((int64_t) -30LL, digits, status));
        assertSuccess("-36.5", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMax(3);
        precision.fRoundingMode = DecimalFormat::kRoundCeiling;
        verifyVisibleDigits(
                "1390",
                FALSE,
                precision.initVisibleDigits((int64_t) 1381LL, digits, status));
        assertSuccess("1390", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMax(1);
        precision.fRoundingMode = DecimalFormat::kRoundFloor;
        verifyVisibleDigits(
                "2000",
                TRUE,
                precision.initVisibleDigits((int64_t) -1381LL, digits, status));
        assertSuccess("-2000", status);
    }
}

void NumberFormat2Test::TestDoubleInitVisibleDigits() {
    VisibleDigits digits;
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        verifyVisibleDigits(
                "2.05",
                FALSE,
                precision.initVisibleDigits(2.05, digits, status));
        assertSuccess("2.05", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        verifyVisibleDigits(
                "3547",
                FALSE,
                precision.initVisibleDigits(3547.0, digits, status));
        assertSuccess("3547", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setFracDigitCount(2);
        precision.fMax.setIntDigitCount(1);
        precision.fFailIfOverMax = TRUE;
        precision.fExactOnly = TRUE;
        verifyVisibleDigits(
                "2.05",
                TRUE,
                precision.initVisibleDigits(-2.05, digits, status));
        assertSuccess("-2.05", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setFracDigitCount(1);
        precision.fMax.setIntDigitCount(1);
        precision.fFailIfOverMax = TRUE;
        precision.fExactOnly = TRUE;
        precision.initVisibleDigits(-2.05, digits, status);
        if (status != U_FORMAT_INEXACT_ERROR) {
            errln("6245.3: Expected U_FORMAT_INEXACT_ERROR");
        }
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setFracDigitCount(2);
        precision.fMax.setIntDigitCount(0);
        precision.fFailIfOverMax = TRUE;
        precision.fExactOnly = TRUE;
        precision.initVisibleDigits(-2.05, digits, status);
        if (status != U_ILLEGAL_ARGUMENT_ERROR) {
            errln("-2.05: Expected U_ILLEGAL_ARGUMENT_ERROR");
        }
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMin.setIntDigitCount(5);
        precision.fMin.setFracDigitCount(2);
        precision.fExactOnly = TRUE;
        verifyVisibleDigits(
                "06245.30",
                FALSE,
                precision.initVisibleDigits(6245.3, digits, status));
        assertSuccess("06245.30", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMax(5);
        precision.fExactOnly = TRUE;
        verifyVisibleDigits(
                "6245.3",
                FALSE,
                precision.initVisibleDigits(6245.3, digits, status));
        assertSuccess("6245.3", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMax(4);
        precision.fExactOnly = TRUE;
        precision.initVisibleDigits(6245.3, digits, status);
        if (status != U_FORMAT_INEXACT_ERROR) {
            errln("6245.3: Expected U_FORMAT_INEXACT_ERROR");
        }
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setIntDigitCount(3);
        precision.fMin.setFracDigitCount(2);
        verifyVisibleDigits(
                "384.90",
                FALSE,
                precision.initVisibleDigits(2384.9, digits, status));
        assertSuccess("380.00", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setIntDigitCount(3);
        precision.fMin.setFracDigitCount(2);
        precision.fFailIfOverMax = TRUE;
        precision.initVisibleDigits(2384.9, digits, status);
        if (status != U_ILLEGAL_ARGUMENT_ERROR) {
            errln("2384.9: Expected U_ILLEGAL_ARGUMENT_ERROR");
        }
    }
}

void NumberFormat2Test::TestDoubleInitVisibleDigitsToDigitList() {
    VisibleDigits digits;
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        // 2.01 produces round off error when multiplied by powers of
        // 10 forcing the use of DigitList.
        verifyVisibleDigits(
                "2.01",
                TRUE,
                precision.initVisibleDigits(-2.01, digits, status));
        assertSuccess("-2.01", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMax(3);
        precision.fMin.setFracDigitCount(2);
        verifyVisibleDigits(
                "2380.00",
                FALSE,
                precision.initVisibleDigits(2385.0, digits, status));
        assertSuccess("2380.00", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setFracDigitCount(2);
        verifyVisibleDigits(
                "45.83",
                TRUE,
                precision.initVisibleDigits(-45.8251, digits, status));
        assertSuccess("45.83", status);
    }
}

void NumberFormat2Test::TestDigitListInitVisibleDigits() {
    VisibleDigits digits;
    DigitList dlist;
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fMax.setIntDigitCount(3);
        precision.fMin.setFracDigitCount(2);
        precision.fFailIfOverMax = TRUE;
        dlist.set(2384.9);
        precision.initVisibleDigits(dlist, digits, status);
        if (status != U_ILLEGAL_ARGUMENT_ERROR) {
            errln("2384.9: Expected U_ILLEGAL_ARGUMENT_ERROR");
        }
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMax(4);
        precision.fExactOnly = TRUE;
        dlist.set(6245.3);
        precision.initVisibleDigits(dlist, digits, status);
        if (status != U_FORMAT_INEXACT_ERROR) {
            errln("6245.3: Expected U_FORMAT_INEXACT_ERROR");
        }
    }
}

void NumberFormat2Test::TestSpecialInitVisibleDigits() {
    VisibleDigits digits;
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.fSignificant.setMax(3);
        precision.fMin.setFracDigitCount(2);
        precision.initVisibleDigits(-uprv_getInfinity(), digits, status);
        assertFalse("", digits.isNaN());
        assertTrue("", digits.isInfinite());
        assertTrue("", digits.isNegative());
        assertSuccess("-Inf", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.initVisibleDigits(uprv_getInfinity(), digits, status);
        assertFalse("", digits.isNaN());
        assertTrue("", digits.isInfinite());
        assertFalse("", digits.isNegative());
        assertSuccess("Inf", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        FixedPrecision precision;
        precision.initVisibleDigits(uprv_getNaN(), digits, status);
        assertTrue("", digits.isNaN());
        assertSuccess("Inf", status);
    }
}

void NumberFormat2Test::TestVisibleDigitsWithExponent() {
    VisibleDigitsWithExponent digits;
    {
        UErrorCode status = U_ZERO_ERROR;
        ScientificPrecision precision;
        precision.initVisibleDigitsWithExponent(389.256, digits, status);
        verifyVisibleDigitsWithExponent(
                "3.89256E2", FALSE, digits);
        assertSuccess("3.89256E2", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        ScientificPrecision precision;
        precision.initVisibleDigitsWithExponent(-389.256, digits, status);
        verifyVisibleDigitsWithExponent(
                "3.89256E2", TRUE, digits);
        assertSuccess("-3.89256E2", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        ScientificPrecision precision;
        precision.fMinExponentDigits = 3;
        precision.fMantissa.fMin.setIntDigitCount(1);
        precision.fMantissa.fMax.setIntDigitCount(3);
        precision.initVisibleDigitsWithExponent(12345.67, digits, status);
        verifyVisibleDigitsWithExponent(
                "12.34567E003", FALSE, digits);
        assertSuccess("12.34567E003", status);
    }
    {
        UErrorCode status = U_ZERO_ERROR;
        ScientificPrecision precision;
        precision.fMantissa.fRoundingIncrement.set(0.073);
        precision.fMantissa.fMin.setIntDigitCount(2);
        precision.fMantissa.fMax.setIntDigitCount(2);
        precision.initVisibleDigitsWithExponent(999.74, digits, status);
        verifyVisibleDigitsWithExponent(
                "10.001E2", FALSE, digits);
        assertSuccess("10.001E2", status);
    }
}

void NumberFormat2Test::TestDigitAffixesAndPadding() {
    UErrorCode status = U_ZERO_ERROR;
    DecimalFormatSymbols symbols("en", status);
    if (!assertSuccess("", status)) {
        return;
    }
    DigitFormatter formatter(symbols);
    DigitGrouping grouping;
    grouping.fGrouping = 3;
    FixedPrecision precision;
    DigitFormatterOptions options;
    options.fAlwaysShowDecimal = TRUE;
    ValueFormatter vf;
    vf.prepareFixedDecimalFormatting(
            formatter,
            grouping,
            precision,
            options);
    DigitAffixesAndPadding aap;
    aap.fPositivePrefix.append("(+", UNUM_SIGN_FIELD);
    aap.fPositiveSuffix.append("+)", UNUM_SIGN_FIELD);
    aap.fNegativePrefix.append("(-", UNUM_SIGN_FIELD);
    aap.fNegativeSuffix.append("-)", UNUM_SIGN_FIELD);
    aap.fWidth = 10;
    aap.fPadPosition = DigitAffixesAndPadding::kPadBeforePrefix;
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 4, 6},
            {UNUM_INTEGER_FIELD, 6, 7},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8},
            {UNUM_SIGN_FIELD, 8, 10},
            {0, -1, 0}};
        verifyAffixesAndPaddingInt32(
                "****(+3.+)",
                aap,
                3,
                vf,
                NULL,
                expectedAttributes);
    }
    aap.fPadPosition = DigitAffixesAndPadding::kPadAfterPrefix;
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 0, 2},
            {UNUM_INTEGER_FIELD, 6, 7},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8},
            {UNUM_SIGN_FIELD, 8, 10},
            {0, -1, 0}};
        verifyAffixesAndPaddingInt32(
                "(+****3.+)",
                aap,
                3,
                vf,
                NULL,
                expectedAttributes);
    }
    aap.fPadPosition = DigitAffixesAndPadding::kPadBeforeSuffix;
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 0, 2},
            {UNUM_INTEGER_FIELD, 2, 3},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4},
            {UNUM_SIGN_FIELD, 8, 10},
            {0, -1, 0}};
        verifyAffixesAndPaddingInt32(
                "(+3.****+)",
                aap,
                3,
                vf,
                NULL,
                expectedAttributes);
    }
    aap.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix;
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 0, 2},
            {UNUM_INTEGER_FIELD, 2, 3},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4},
            {UNUM_SIGN_FIELD, 4, 6},
            {0, -1, 0}};
        verifyAffixesAndPaddingInt32(
                "(+3.+)****",
                aap,
                3,
                vf,
                NULL,
                expectedAttributes);
    }
    aap.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix;
    {
        DigitList digits;
        digits.set(-1234.5);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 0, 2},
            {UNUM_GROUPING_SEPARATOR_FIELD, 3, 4},
            {UNUM_INTEGER_FIELD, 2, 7},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8},
            {UNUM_FRACTION_FIELD, 8, 9},
            {UNUM_SIGN_FIELD, 9, 11},
            {0, -1, 0}};
        verifyAffixesAndPadding(
                "(-1,234.5-)",
                aap,
                digits,
                vf,
                NULL,
                expectedAttributes);
    }
    assertFalse("", aap.needsPluralRules());

    aap.fWidth = 0;
    aap.fPositivePrefix.remove();
    aap.fPositiveSuffix.remove();
    aap.fNegativePrefix.remove();
    aap.fNegativeSuffix.remove();
    
    // Set up for plural currencies.
    aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD);
    {
        PluralAffix part;
        part.setVariant("one", " Dollar", status);
        part.setVariant("other", " Dollars", status);
        aap.fPositiveSuffix.append(part, UNUM_CURRENCY_FIELD, status);
    }
    aap.fNegativeSuffix = aap.fPositiveSuffix;
    
    LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
    if (!assertSuccess("", status)) {
        return;
    }

    // Exercise the fastrack path
    {
        options.fAlwaysShowDecimal = FALSE;
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 0, 1},
            {UNUM_INTEGER_FIELD, 1, 3},
            {UNUM_CURRENCY_FIELD, 3, 11},
            {0, -1, 0}};
        verifyAffixesAndPaddingInt32(
                "-45 Dollars",
                aap,
                -45,
                vf,
                NULL,
                expectedAttributes);
        options.fAlwaysShowDecimal = TRUE;
    }
    
    // Now test plurals
    assertTrue("", aap.needsPluralRules());
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
            {UNUM_CURRENCY_FIELD, 2, 9},
            {0, -1, 0}};
        verifyAffixesAndPaddingInt32(
                "1. Dollar",
                aap,
                1,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 0, 1},
            {UNUM_INTEGER_FIELD, 1, 2},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3},
            {UNUM_CURRENCY_FIELD, 3, 10},
            {0, -1, 0}};
        verifyAffixesAndPaddingInt32(
                "-1. Dollar",
                aap,
                -1,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
    precision.fMin.setFracDigitCount(2);
    {
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
            {UNUM_FRACTION_FIELD, 2, 4},
            {UNUM_CURRENCY_FIELD, 4, 12},
            {0, -1, 0}};
        verifyAffixesAndPaddingInt32(
                "1.00 Dollars",
                aap,
                1,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
}

void NumberFormat2Test::TestPluralsAndRounding() {
    UErrorCode status = U_ZERO_ERROR;
    DecimalFormatSymbols symbols("en", status);
    if (!assertSuccess("", status)) {
        return;
    }
    DigitFormatter formatter(symbols);
    DigitGrouping grouping;
    FixedPrecision precision;
    precision.fSignificant.setMax(3);
    DigitFormatterOptions options;
    ValueFormatter vf;
    vf.prepareFixedDecimalFormatting(
            formatter,
            grouping,
            precision,
            options);
    DigitList digits;
    DigitAffixesAndPadding aap;
    // Set up for plural currencies.
    aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD);
    {
        PluralAffix part;
        part.setVariant("one", " Dollar", status);
        part.setVariant("other", " Dollars", status);
        aap.fPositiveSuffix.append(part, UNUM_CURRENCY_FIELD, status);
    }
    aap.fNegativeSuffix = aap.fPositiveSuffix;
    aap.fWidth = 14;
    LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
    if (!assertSuccess("", status)) {
        return;
    }
    {
        digits.set(0.999);
        verifyAffixesAndPadding(
                "*0.999 Dollars",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
    {
        digits.set(0.9996);
        verifyAffixesAndPadding(
                "******1 Dollar",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
    {
        digits.set(1.004);
        verifyAffixesAndPadding(
                "******1 Dollar",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
    precision.fSignificant.setMin(2);
    {
        digits.set(0.9996);
        verifyAffixesAndPadding(
                "***1.0 Dollars",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
    {
        digits.set(1.004);
        verifyAffixesAndPadding(
                "***1.0 Dollars",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
    precision.fSignificant.setMin(0);
    {
        digits.set(-79.214);
        verifyAffixesAndPadding(
                "*-79.2 Dollars",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
    // No more sig digits just max fractions
    precision.fSignificant.setMax(0); 
    precision.fMax.setFracDigitCount(4);
    {
        digits.set(79.213562);
        verifyAffixesAndPadding(
                "79.2136 Dollars",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }

}


void NumberFormat2Test::TestPluralsAndRoundingScientific() {
    UErrorCode status = U_ZERO_ERROR;
    DecimalFormatSymbols symbols("en", status);
    if (!assertSuccess("", status)) {
        return;
    }
    DigitFormatter formatter(symbols);
    ScientificPrecision precision;
    precision.fMantissa.fSignificant.setMax(4);
    SciFormatterOptions options;
    ValueFormatter vf;
    vf.prepareScientificFormatting(
            formatter,
            precision,
            options);
    DigitList digits;
    DigitAffixesAndPadding aap;
    aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD);
    {
        PluralAffix part;
        part.setVariant("one", " Meter", status);
        part.setVariant("other", " Meters", status);
        aap.fPositiveSuffix.append(part, UNUM_FIELD_COUNT, status);
    }
    aap.fNegativeSuffix = aap.fPositiveSuffix;
    LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
    if (!assertSuccess("", status)) {
        return;
    }
    {
        digits.set(0.99996);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {UNUM_EXPONENT_SYMBOL_FIELD, 1, 2},
            {UNUM_EXPONENT_FIELD, 2, 3},
            {0, -1, 0}};
        verifyAffixesAndPadding(
                "1E0 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
    options.fMantissa.fAlwaysShowDecimal = TRUE;
    {
        digits.set(0.99996);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
            {UNUM_EXPONENT_SYMBOL_FIELD, 2, 3},
            {UNUM_EXPONENT_FIELD, 3, 4},
            {0, -1, 0}};
        verifyAffixesAndPadding(
                "1.E0 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
    {
        digits.set(-299792458);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_SIGN_FIELD, 0, 1},
            {UNUM_INTEGER_FIELD, 1, 2},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3},
            {UNUM_FRACTION_FIELD, 3, 6},
            {UNUM_EXPONENT_SYMBOL_FIELD, 6, 7},
            {UNUM_EXPONENT_FIELD, 7, 8},
            {0, -1, 0}};
        verifyAffixesAndPadding(
                "-2.998E8 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
    precision.fMantissa.fSignificant.setMin(4);
    options.fExponent.fAlwaysShowSign = TRUE;
    precision.fMinExponentDigits = 3;
    {
        digits.set(3);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
            {UNUM_FRACTION_FIELD, 2, 5},
            {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6},
            {UNUM_EXPONENT_SIGN_FIELD, 6, 7},
            {UNUM_EXPONENT_FIELD, 7, 10},
            {0, -1, 0}};
        verifyAffixesAndPadding(
                "3.000E+000 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
    precision.fMantissa.fMax.setIntDigitCount(3);
    {
        digits.set(0.00025001);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 3},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4},
            {UNUM_FRACTION_FIELD, 4, 5},
            {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6},
            {UNUM_EXPONENT_SIGN_FIELD, 6, 7},
            {UNUM_EXPONENT_FIELD, 7, 10},
            {0, -1, 0}};
        verifyAffixesAndPadding(
                "250.0E-006 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
    {
        digits.set(0.0000025001);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
            {UNUM_FRACTION_FIELD, 2, 5},
            {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6},
            {UNUM_EXPONENT_SIGN_FIELD, 6, 7},
            {UNUM_EXPONENT_FIELD, 7, 10},
            {0, -1, 0}};
        verifyAffixesAndPadding(
                "2.500E-006 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
    precision.fMantissa.fMax.setFracDigitCount(1);
    {
        digits.set(0.0000025499);
        NumberFormat2Test_Attributes expectedAttributes[] = {
            {UNUM_INTEGER_FIELD, 0, 1},
            {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
            {UNUM_FRACTION_FIELD, 2, 3},
            {UNUM_EXPONENT_SYMBOL_FIELD, 3, 4},
            {UNUM_EXPONENT_SIGN_FIELD, 4, 5},
            {UNUM_EXPONENT_FIELD, 5, 8},
            {0, -1, 0}};
        verifyAffixesAndPadding(
                "2.5E-006 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                expectedAttributes);
    }
    precision.fMantissa.fMax.setIntDigitCount(1);
    precision.fMantissa.fMax.setFracDigitCount(2);
    {
        digits.set(299792458);
        verifyAffixesAndPadding(
                "3.00E+008 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
    // clear significant digits
    precision.fMantissa.fSignificant.setMin(0);
    precision.fMantissa.fSignificant.setMax(0);

    // set int and fraction digits
    precision.fMantissa.fMin.setFracDigitCount(2);
    precision.fMantissa.fMax.setFracDigitCount(4);
    precision.fMantissa.fMin.setIntDigitCount(2);
    precision.fMantissa.fMax.setIntDigitCount(3);
    {
        digits.set(-0.0000025300001);
        verifyAffixesAndPadding(
                "-253.00E-008 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
    {
        digits.set(-0.0000025300006);
        verifyAffixesAndPadding(
                "-253.0001E-008 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
    {
        digits.set(-0.000025300006);
        verifyAffixesAndPadding(
                "-25.30E-006 Meters",
                aap,
                digits,
                vf,
                rules.getAlias(),
                NULL);
    }
}


void NumberFormat2Test::TestRoundingIncrement() {
    UErrorCode status = U_ZERO_ERROR;
    DecimalFormatSymbols symbols("en", status);
    if (U_FAILURE(status)) {
        dataerrln("Error creating DecimalFormatSymbols - %s", u_errorName(status));
        return;
    }
    DigitFormatter formatter(symbols);
    ScientificPrecision precision;
    SciFormatterOptions options;
    precision.fMantissa.fRoundingIncrement.set(0.25);
    precision.fMantissa.fSignificant.setMax(4);
    DigitGrouping grouping;
    ValueFormatter vf;

    // fixed
    vf.prepareFixedDecimalFormatting(
            formatter,
            grouping,
            precision.fMantissa,
            options.fMantissa);
    DigitList digits;
    DigitAffixesAndPadding aap;
    aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD);
    {
        digits.set(3.7);
        verifyAffixesAndPadding(
                "3.75",
                aap,
                digits,
                vf,
                NULL, NULL);
    }
    {
        digits.set(-7.4);
        verifyAffixesAndPadding(
                "-7.5",
                aap,
                digits,
                vf,
                NULL, NULL);
    }
    {
        digits.set(99.8);
        verifyAffixesAndPadding(
                "99.75",
                aap,
                digits,
                vf,
                NULL, NULL);
    }
    precision.fMantissa.fMin.setFracDigitCount(2);
    {
        digits.set(99.1);
        verifyAffixesAndPadding(
                "99.00",
                aap,
                digits,
                vf,
                NULL, NULL);
    }
    {
        digits.set(-639.65);
        verifyAffixesAndPadding(
                "-639.80",
                aap,
                digits,
                vf,
                NULL, NULL);
    }

    precision.fMantissa.fMin.setIntDigitCount(2);
    // Scientific notation
    vf.prepareScientificFormatting(
            formatter,
            precision,
            options);
    {
        digits.set(-6396.5);
        verifyAffixesAndPadding(
                "-64.00E2",
                aap,
                digits,
                vf,
                NULL, NULL);
    }
    {
        digits.set(-0.00092374);
        verifyAffixesAndPadding(
                "-92.25E-5",
                aap,
                digits,
                vf,
                NULL, NULL);
    }
    precision.fMantissa.fMax.setIntDigitCount(3);
    {
        digits.set(-0.00092374);
        verifyAffixesAndPadding(
                "-923.80E-6",
                aap,
                digits,
                vf,
                NULL, NULL);
    }
}

void NumberFormat2Test::TestToPatternScientific11648() {
/*
    UErrorCode status = U_ZERO_ERROR;
    Locale en("en");
    DecimalFormat2 fmt(en, "0.00", status);
    fmt.setScientificNotation(TRUE);
    UnicodeString pattern;
    // Fails, produces "0.00E"
    assertEquals("", "0.00E0", fmt.toPattern(pattern));
    DecimalFormat fmt2(pattern, status);
    // Fails, bad pattern.
    assertSuccess("", status);
*/
}

void NumberFormat2Test::verifyAffixesAndPadding(
        const UnicodeString &expected,
        const DigitAffixesAndPadding &aaf,
        DigitList &digits,
        const ValueFormatter &vf,
        const PluralRules *optPluralRules,
        const NumberFormat2Test_Attributes *expectedAttributes) {
    UnicodeString appendTo;
    NumberFormat2Test_FieldPositionHandler handler;
    UErrorCode status = U_ZERO_ERROR;
    assertEquals(
            "",
            expected,
            aaf.format(
                    digits,
                    vf,
                    handler,
                    optPluralRules,
                    appendTo,
                    status));
    if (!assertSuccess("", status)) {
        return;
    }
    if (expectedAttributes != NULL) {
        verifyAttributes(expectedAttributes, handler.attributes);
    }
}

void NumberFormat2Test::verifyAffixesAndPaddingInt32(
        const UnicodeString &expected,
        const DigitAffixesAndPadding &aaf,
        int32_t value,
        const ValueFormatter &vf,
        const PluralRules *optPluralRules,
        const NumberFormat2Test_Attributes *expectedAttributes) {
    UnicodeString appendTo;
    NumberFormat2Test_FieldPositionHandler handler;
    UErrorCode status = U_ZERO_ERROR;
    assertEquals(
            "",
            expected,
            aaf.formatInt32(
                    value,
                    vf,
                    handler,
                    optPluralRules,
                    appendTo,
                    status));
    if (!assertSuccess("", status)) {
        return;
    }
    if (expectedAttributes != NULL) {
        verifyAttributes(expectedAttributes, handler.attributes);
    }
    DigitList digits;
    digits.set(value);
    verifyAffixesAndPadding(
            expected, aaf, digits, vf, optPluralRules, expectedAttributes);
}

void NumberFormat2Test::verifyAffix(
        const UnicodeString &expected,
        const DigitAffix &affix,
        const NumberFormat2Test_Attributes *expectedAttributes) {
    UnicodeString appendTo;
    NumberFormat2Test_FieldPositionHandler handler;
    assertEquals(
            "",
            expected.unescape(),
            affix.format(handler, appendTo));
    if (expectedAttributes != NULL) {
        verifyAttributes(expectedAttributes, handler.attributes);
    }
}

// Right now only works for positive values.
void NumberFormat2Test::verifyDigitList(
        const UnicodeString &expected,
        const DigitList &digits) {
    DigitFormatter formatter;
    DigitGrouping grouping;
    VisibleDigits visibleDigits;
    FixedPrecision precision;
    precision.fMin.setIntDigitCount(0);
    DigitFormatterOptions options;
    UErrorCode status = U_ZERO_ERROR;
    DigitList dlCopy(digits);
    precision.initVisibleDigits(
            dlCopy, visibleDigits, status);
    if (!assertSuccess("", status)) {
        return;
    }
    verifyDigitFormatter(
            expected,
            formatter,
            visibleDigits,
            grouping,
            options,
            NULL);
}

void NumberFormat2Test::verifyVisibleDigits(
        const UnicodeString &expected,
        UBool bNegative,
        const VisibleDigits &digits) {
    DigitFormatter formatter;
    DigitGrouping grouping;
    DigitFormatterOptions options;
    verifyDigitFormatter(
            expected,
            formatter,
            digits,
            grouping,
            options,
            NULL);
    if (digits.isNegative() != bNegative) {
        errln(expected + ": Wrong sign.");
    }
    if (digits.isNaN() || digits.isInfinite()) {
        errln(expected + ": Require real value.");
    }
}

void NumberFormat2Test::verifyVisibleDigitsWithExponent(
        const UnicodeString &expected,
        UBool bNegative,
        const VisibleDigitsWithExponent &digits) {
    DigitFormatter formatter;
    SciFormatterOptions options;
    verifySciFormatter(
            expected,
            formatter,
            digits,
            options,
            NULL);
    if (digits.isNegative() != bNegative) {
        errln(expected + ": Wrong sign.");
    }
    if (digits.isNaN() || digits.isInfinite()) {
        errln(expected + ": Require real value.");
    }
}

void NumberFormat2Test::verifySciFormatter(
        const UnicodeString &expected,
        const DigitFormatter &formatter,
        const VisibleDigitsWithExponent &digits,
        const SciFormatterOptions &options,
        const NumberFormat2Test_Attributes *expectedAttributes) {
    assertEquals(
            "",
            expected.countChar32(),
            formatter.countChar32(digits, options));
    UnicodeString appendTo;
    NumberFormat2Test_FieldPositionHandler handler;
    assertEquals(
            "",
            expected,
            formatter.format(
                    digits,
                    options,
                    handler,
                    appendTo));
    if (expectedAttributes != NULL) {
        verifyAttributes(expectedAttributes, handler.attributes);
    }
}

void NumberFormat2Test::verifyPositiveIntDigitFormatter(
        const UnicodeString &expected,
        const DigitFormatter &formatter,
        int32_t value,
        int32_t minDigits,
        int32_t maxDigits,
        const NumberFormat2Test_Attributes *expectedAttributes) {
    IntDigitCountRange range(minDigits, maxDigits);
    UnicodeString appendTo;
    NumberFormat2Test_FieldPositionHandler handler;
    assertEquals(
            "",
            expected,
            formatter.formatPositiveInt32(
                    value,
                    range,
                    handler,
                    appendTo));
    if (expectedAttributes != NULL) {
        verifyAttributes(expectedAttributes, handler.attributes);
    }
}

void NumberFormat2Test::verifyDigitFormatter(
        const UnicodeString &expected,
        const DigitFormatter &formatter,
        const VisibleDigits &digits,
        const DigitGrouping &grouping,
        const DigitFormatterOptions &options,
        const NumberFormat2Test_Attributes *expectedAttributes) {
    assertEquals(
            "",
            expected.countChar32(),
            formatter.countChar32(digits, grouping, options));
    UnicodeString appendTo;
    NumberFormat2Test_FieldPositionHandler handler;
    assertEquals(
            "",
            expected,
            formatter.format(
                    digits,
                    grouping,
                    options,
                    handler,
                    appendTo));
    if (expectedAttributes != NULL) {
        verifyAttributes(expectedAttributes, handler.attributes);
    }
}

void NumberFormat2Test::verifySmallIntFormatter(
        const UnicodeString &expected,
        int32_t positiveValue,
        int32_t minDigits,
        int32_t maxDigits) {
    IntDigitCountRange range(minDigits, maxDigits);
    if (!SmallIntFormatter::canFormat(positiveValue, range)) {
        UnicodeString actual;
        assertEquals("", expected, actual);
        return;
    }
    UnicodeString actual;
    assertEquals("", expected, SmallIntFormatter::format(positiveValue, range, actual));
}

void NumberFormat2Test::verifyAttributes(
        const NumberFormat2Test_Attributes *expected,
        const NumberFormat2Test_Attributes *actual) {
    int32_t idx = 0;
    while (expected[idx].spos != -1 && actual[idx].spos != -1) {
        assertEquals("id", expected[idx].id, actual[idx].id);
        assertEquals("spos", expected[idx].spos, actual[idx].spos);
        assertEquals("epos", expected[idx].epos, actual[idx].epos);
        ++idx;
    }
    assertEquals(
            "expected and actual not same length",
            expected[idx].spos,
            actual[idx].spos);
}

void NumberFormat2Test::verifyIntValue(
        int64_t expected, const VisibleDigits &digits) {
    double unusedSource;
    int64_t intValue;
    int64_t unusedF;
    int64_t unusedT;
    int32_t unusedV;
    UBool unusedHasIntValue;
    digits.getFixedDecimal(
            unusedSource, intValue, unusedF,
            unusedT, unusedV, unusedHasIntValue);
    assertEquals("", expected, intValue);
}

void NumberFormat2Test::verifySource(
        double expected, const VisibleDigits &digits) {
    double source;
    int64_t unusedIntValue;
    int64_t unusedF;
    int64_t unusedT;
    int32_t unusedV;
    UBool unusedHasIntValue;
    digits.getFixedDecimal(
            source, unusedIntValue, unusedF,
            unusedT, unusedV, unusedHasIntValue);
    if (expected != source) {
        errln("Expected %f, got %f instead", expected, source);
    }
}

extern IntlTest *createNumberFormat2Test() {
    return new NumberFormat2Test();
}

#endif /* !UCONFIG_NO_FORMATTING */