Home | History | Annotate | Download | only in intltest
      1 //  2016 and later: Unicode, Inc. and others.
      2 // License & terms of use: http://www.unicode.org/copyright.html
      3 /*
      4 *******************************************************************************
      5 * Copyright (C) 2015, International Business Machines Corporation and         *
      6 * others. All Rights Reserved.                                                *
      7 *******************************************************************************
      8 *
      9 * File NUMBERFORMAT2TEST.CPP
     10 *
     11 *******************************************************************************
     12 */
     13 #include "unicode/utypes.h"
     14 
     15 #include "intltest.h"
     16 
     17 #if !UCONFIG_NO_FORMATTING
     18 
     19 #include "unicode/localpointer.h"
     20 #include "unicode/plurrule.h"
     21 
     22 #include "affixpatternparser.h"
     23 #include "charstr.h"
     24 #include "datadrivennumberformattestsuite.h"
     25 #include "decimalformatpattern.h"
     26 #include "digitaffixesandpadding.h"
     27 #include "digitformatter.h"
     28 #include "digitgrouping.h"
     29 #include "digitinterval.h"
     30 #include "digitlst.h"
     31 #include "fphdlimp.h"
     32 #include "plurrule_impl.h"
     33 #include "precision.h"
     34 #include "significantdigitinterval.h"
     35 #include "smallintformatter.h"
     36 #include "uassert.h"
     37 #include "valueformatter.h"
     38 #include "visibledigits.h"
     39 
     40 struct NumberFormat2Test_Attributes {
     41     int32_t id;
     42     int32_t spos;
     43     int32_t epos;
     44 };
     45 
     46 class NumberFormat2Test_FieldPositionHandler : public FieldPositionHandler {
     47 public:
     48 NumberFormat2Test_Attributes attributes[100];
     49 int32_t count;
     50 UBool bRecording;
     51 
     52 
     53 
     54 NumberFormat2Test_FieldPositionHandler() : count(0), bRecording(TRUE) { attributes[0].spos = -1; }
     55 NumberFormat2Test_FieldPositionHandler(UBool recording) : count(0), bRecording(recording) { attributes[0].spos = -1; }
     56 virtual ~NumberFormat2Test_FieldPositionHandler();
     57 virtual void addAttribute(int32_t id, int32_t start, int32_t limit);
     58 virtual void shiftLast(int32_t delta);
     59 virtual UBool isRecording(void) const;
     60 };
     61 
     62 NumberFormat2Test_FieldPositionHandler::~NumberFormat2Test_FieldPositionHandler() {
     63 }
     64 
     65 void NumberFormat2Test_FieldPositionHandler::addAttribute(
     66         int32_t id, int32_t start, int32_t limit) {
     67     if (count == UPRV_LENGTHOF(attributes) - 1) {
     68         return;
     69     }
     70     attributes[count].id = id;
     71     attributes[count].spos = start;
     72     attributes[count].epos = limit;
     73     ++count;
     74     attributes[count].spos = -1;
     75 }
     76 
     77 void NumberFormat2Test_FieldPositionHandler::shiftLast(int32_t /* delta */) {
     78 }
     79 
     80 UBool NumberFormat2Test_FieldPositionHandler::isRecording() const {
     81     return bRecording;
     82 }
     83 
     84 
     85 class NumberFormat2Test : public IntlTest {
     86 public:
     87     void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
     88 private:
     89     void TestQuantize();
     90     void TestConvertScientificNotation();
     91     void TestLowerUpperExponent();
     92     void TestRounding();
     93     void TestRoundingIncrement();
     94     void TestDigitInterval();
     95     void TestGroupingUsed();
     96     void TestBenchmark();
     97     void TestBenchmark2();
     98     void TestSmallIntFormatter();
     99     void TestPositiveIntDigitFormatter();
    100     void TestDigitListInterval();
    101     void TestLargeIntValue();
    102     void TestIntInitVisibleDigits();
    103     void TestIntInitVisibleDigitsToDigitList();
    104     void TestDoubleInitVisibleDigits();
    105     void TestDoubleInitVisibleDigitsToDigitList();
    106     void TestDigitListInitVisibleDigits();
    107     void TestSpecialInitVisibleDigits();
    108     void TestVisibleDigitsWithExponent();
    109     void TestDigitAffixesAndPadding();
    110     void TestPluralsAndRounding();
    111     void TestPluralsAndRoundingScientific();
    112     void TestValueFormatterIsFastFormattable();
    113     void TestCurrencyAffixInfo();
    114     void TestAffixPattern();
    115     void TestAffixPatternAppend();
    116     void TestAffixPatternAppendAjoiningLiterals();
    117     void TestAffixPatternDoubleQuote();
    118     void TestAffixPatternParser();
    119     void TestPluralAffix();
    120     void TestDigitAffix();
    121     void TestDigitFormatterDefaultCtor();
    122     void TestDigitFormatterMonetary();
    123     void TestDigitFormatter();
    124     void TestSciFormatterDefaultCtor();
    125     void TestSciFormatter();
    126     void TestToPatternScientific11648();
    127     void verifyInterval(const DigitInterval &, int32_t minInclusive, int32_t maxExclusive);
    128     void verifyAffix(
    129             const UnicodeString &expected,
    130             const DigitAffix &affix,
    131             const NumberFormat2Test_Attributes *expectedAttributes);
    132     void verifyAffixesAndPadding(
    133             const UnicodeString &expected,
    134             const DigitAffixesAndPadding &aaf,
    135             DigitList &digits,
    136             const ValueFormatter &vf,
    137             const PluralRules *optPluralRules,
    138             const NumberFormat2Test_Attributes *expectedAttributes);
    139     void verifyAffixesAndPaddingInt32(
    140             const UnicodeString &expected,
    141             const DigitAffixesAndPadding &aaf,
    142             int32_t value,
    143             const ValueFormatter &vf,
    144             const PluralRules *optPluralRules,
    145             const NumberFormat2Test_Attributes *expectedAttributes);
    146     void verifyDigitList(
    147         const UnicodeString &expected,
    148         const DigitList &digits);
    149     void verifyVisibleDigits(
    150         const UnicodeString &expected,
    151         UBool bNegative,
    152         const VisibleDigits &digits);
    153     void verifyVisibleDigitsWithExponent(
    154         const UnicodeString &expected,
    155         UBool bNegative,
    156         const VisibleDigitsWithExponent &digits);
    157     void verifyDigitFormatter(
    158             const UnicodeString &expected,
    159             const DigitFormatter &formatter,
    160             const VisibleDigits &digits,
    161             const DigitGrouping &grouping,
    162             const DigitFormatterOptions &options,
    163             const NumberFormat2Test_Attributes *expectedAttributes);
    164     void verifySciFormatter(
    165             const UnicodeString &expected,
    166             const DigitFormatter &formatter,
    167             const VisibleDigitsWithExponent &digits,
    168             const SciFormatterOptions &options,
    169             const NumberFormat2Test_Attributes *expectedAttributes);
    170     void verifySmallIntFormatter(
    171             const UnicodeString &expected,
    172             int32_t positiveValue,
    173             int32_t minDigits,
    174             int32_t maxDigits);
    175     void verifyPositiveIntDigitFormatter(
    176             const UnicodeString &expected,
    177             const DigitFormatter &formatter,
    178             int32_t value,
    179             int32_t minDigits,
    180             int32_t maxDigits,
    181             const NumberFormat2Test_Attributes *expectedAttributes);
    182     void verifyAttributes(
    183             const NumberFormat2Test_Attributes *expected,
    184             const NumberFormat2Test_Attributes *actual);
    185     void verifyIntValue(
    186             int64_t expected, const VisibleDigits &digits);
    187     void verifySource(
    188             double expected, const VisibleDigits &digits);
    189 };
    190 
    191 void NumberFormat2Test::runIndexedTest(
    192         int32_t index, UBool exec, const char *&name, char *) {
    193     if (exec) {
    194         logln("TestSuite ScientificNumberFormatterTest: ");
    195     }
    196     TESTCASE_AUTO_BEGIN;
    197     TESTCASE_AUTO(TestQuantize);
    198     TESTCASE_AUTO(TestConvertScientificNotation);
    199     TESTCASE_AUTO(TestLowerUpperExponent);
    200     TESTCASE_AUTO(TestRounding);
    201     TESTCASE_AUTO(TestRoundingIncrement);
    202     TESTCASE_AUTO(TestDigitInterval);
    203     TESTCASE_AUTO(TestGroupingUsed);
    204     TESTCASE_AUTO(TestDigitListInterval);
    205     TESTCASE_AUTO(TestDigitFormatterDefaultCtor);
    206     TESTCASE_AUTO(TestDigitFormatterMonetary);
    207     TESTCASE_AUTO(TestDigitFormatter);
    208     TESTCASE_AUTO(TestSciFormatterDefaultCtor);
    209     TESTCASE_AUTO(TestSciFormatter);
    210     TESTCASE_AUTO(TestBenchmark);
    211     TESTCASE_AUTO(TestBenchmark2);
    212     TESTCASE_AUTO(TestSmallIntFormatter);
    213     TESTCASE_AUTO(TestPositiveIntDigitFormatter);
    214     TESTCASE_AUTO(TestCurrencyAffixInfo);
    215     TESTCASE_AUTO(TestAffixPattern);
    216     TESTCASE_AUTO(TestAffixPatternAppend);
    217     TESTCASE_AUTO(TestAffixPatternAppendAjoiningLiterals);
    218     TESTCASE_AUTO(TestAffixPatternDoubleQuote);
    219     TESTCASE_AUTO(TestAffixPatternParser);
    220     TESTCASE_AUTO(TestPluralAffix);
    221     TESTCASE_AUTO(TestDigitAffix);
    222     TESTCASE_AUTO(TestValueFormatterIsFastFormattable);
    223     TESTCASE_AUTO(TestLargeIntValue);
    224     TESTCASE_AUTO(TestIntInitVisibleDigits);
    225     TESTCASE_AUTO(TestIntInitVisibleDigitsToDigitList);
    226     TESTCASE_AUTO(TestDoubleInitVisibleDigits);
    227     TESTCASE_AUTO(TestDoubleInitVisibleDigitsToDigitList);
    228     TESTCASE_AUTO(TestDigitListInitVisibleDigits);
    229     TESTCASE_AUTO(TestSpecialInitVisibleDigits);
    230     TESTCASE_AUTO(TestVisibleDigitsWithExponent);
    231     TESTCASE_AUTO(TestDigitAffixesAndPadding);
    232     TESTCASE_AUTO(TestPluralsAndRounding);
    233     TESTCASE_AUTO(TestPluralsAndRoundingScientific);
    234     TESTCASE_AUTO(TestToPatternScientific11648);
    235 
    236     TESTCASE_AUTO_END;
    237 }
    238 
    239 void NumberFormat2Test::TestDigitInterval() {
    240     DigitInterval all;
    241     DigitInterval threeInts;
    242     DigitInterval fourFrac;
    243     threeInts.setIntDigitCount(3);
    244     fourFrac.setFracDigitCount(4);
    245     verifyInterval(all, INT32_MIN, INT32_MAX);
    246     verifyInterval(threeInts, INT32_MIN, 3);
    247     verifyInterval(fourFrac, -4, INT32_MAX);
    248     {
    249         DigitInterval result(threeInts);
    250         result.shrinkToFitWithin(fourFrac);
    251         verifyInterval(result, -4, 3);
    252         assertEquals("", 7, result.length());
    253     }
    254     {
    255         DigitInterval result(threeInts);
    256         result.expandToContain(fourFrac);
    257         verifyInterval(result, INT32_MIN, INT32_MAX);
    258     }
    259     {
    260         DigitInterval result(threeInts);
    261         result.setIntDigitCount(0);
    262         verifyInterval(result, INT32_MIN, 0);
    263         result.setIntDigitCount(-1);
    264         verifyInterval(result, INT32_MIN, INT32_MAX);
    265     }
    266     {
    267         DigitInterval result(fourFrac);
    268         result.setFracDigitCount(0);
    269         verifyInterval(result, 0, INT32_MAX);
    270         result.setFracDigitCount(-1);
    271         verifyInterval(result, INT32_MIN, INT32_MAX);
    272     }
    273     {
    274         DigitInterval result;
    275         result.setIntDigitCount(3);
    276         result.setFracDigitCount(1);
    277         result.expandToContainDigit(0);
    278         result.expandToContainDigit(-1);
    279         result.expandToContainDigit(2);
    280         verifyInterval(result, -1, 3);
    281         result.expandToContainDigit(3);
    282         verifyInterval(result, -1, 4);
    283         result.expandToContainDigit(-2);
    284         verifyInterval(result, -2, 4);
    285         result.expandToContainDigit(15);
    286         result.expandToContainDigit(-15);
    287         verifyInterval(result, -15, 16);
    288     }
    289     {
    290         DigitInterval result;
    291         result.setIntDigitCount(3);
    292         result.setFracDigitCount(1);
    293         assertTrue("", result.contains(2));
    294         assertTrue("", result.contains(-1));
    295         assertFalse("", result.contains(3));
    296         assertFalse("", result.contains(-2));
    297     }
    298 }
    299 
    300 void NumberFormat2Test::verifyInterval(
    301         const DigitInterval &interval,
    302         int32_t minInclusive, int32_t maxExclusive) {
    303     assertEquals("", minInclusive, interval.getLeastSignificantInclusive());
    304     assertEquals("", maxExclusive, interval.getMostSignificantExclusive());
    305     assertEquals("", maxExclusive, interval.getIntDigitCount());
    306 }
    307 
    308 void NumberFormat2Test::TestGroupingUsed() {
    309     {
    310         DigitGrouping grouping;
    311         assertFalse("", grouping.isGroupingUsed());
    312     }
    313     {
    314         DigitGrouping grouping;
    315         grouping.fGrouping = 2;
    316         assertTrue("", grouping.isGroupingUsed());
    317     }
    318 }
    319 
    320 void NumberFormat2Test::TestDigitListInterval() {
    321     DigitInterval result;
    322     DigitList digitList;
    323     {
    324         digitList.set((int32_t)12345);
    325         verifyInterval(digitList.getSmallestInterval(result), 0, 5);
    326     }
    327     {
    328         digitList.set(1000.00);
    329         verifyInterval(digitList.getSmallestInterval(result), 0, 4);
    330     }
    331     {
    332         digitList.set(43.125);
    333         verifyInterval(digitList.getSmallestInterval(result), -3, 2);
    334     }
    335     {
    336         digitList.set(.0078125);
    337         verifyInterval(digitList.getSmallestInterval(result), -7, 0);
    338     }
    339     {
    340         digitList.set(1000.00);
    341         digitList.getSmallestInterval(result);
    342         result.expandToContainDigit(3);
    343         verifyInterval(result, 0, 4);
    344     }
    345     {
    346         digitList.set(1000.00);
    347         digitList.getSmallestInterval(result);
    348         result.expandToContainDigit(4);
    349         verifyInterval(result, 0, 5);
    350     }
    351     {
    352         digitList.set(1000.00);
    353         digitList.getSmallestInterval(result);
    354         result.expandToContainDigit(0);
    355         verifyInterval(result, 0, 4);
    356     }
    357     {
    358         digitList.set(1000.00);
    359         digitList.getSmallestInterval(result);
    360         result.expandToContainDigit(-1);
    361         verifyInterval(result, -1, 4);
    362     }
    363     {
    364         digitList.set(43.125);
    365         digitList.getSmallestInterval(result);
    366         result.expandToContainDigit(1);
    367         verifyInterval(result, -3, 2);
    368     }
    369     {
    370         digitList.set(43.125);
    371         digitList.getSmallestInterval(result);
    372         result.expandToContainDigit(2);
    373         verifyInterval(result, -3, 3);
    374     }
    375     {
    376         digitList.set(43.125);
    377         digitList.getSmallestInterval(result);
    378         result.expandToContainDigit(-3);
    379         verifyInterval(result, -3, 2);
    380     }
    381     {
    382         digitList.set(43.125);
    383         digitList.getSmallestInterval(result);
    384         result.expandToContainDigit(-4);
    385         verifyInterval(result, -4, 2);
    386     }
    387 }
    388 
    389 void NumberFormat2Test::TestQuantize() {
    390     DigitList quantity;
    391     quantity.set(0.00168);
    392     quantity.roundAtExponent(-5);
    393     DigitList digits;
    394     UErrorCode status = U_ZERO_ERROR;
    395     {
    396         digits.set((int32_t)1);
    397         digits.quantize(quantity, status);
    398         verifyDigitList(".9996", digits);
    399     }
    400     {
    401         // round half even up
    402         digits.set(1.00044);
    403         digits.roundAtExponent(-5);
    404         digits.quantize(quantity, status);
    405         verifyDigitList("1.00128", digits);
    406     }
    407     {
    408         // round half down
    409         digits.set(0.99876);
    410         digits.roundAtExponent(-5);
    411         digits.quantize(quantity, status);
    412         verifyDigitList(".99792", digits);
    413     }
    414     assertSuccess("", status);
    415 }
    416 
    417 void NumberFormat2Test::TestConvertScientificNotation() {
    418     DigitList digits;
    419     {
    420         digits.set((int32_t)186283);
    421         assertEquals("", 5, digits.toScientific(1, 1));
    422         verifyDigitList(
    423                 "1.86283",
    424                 digits);
    425     }
    426     {
    427         digits.set((int32_t)186283);
    428         assertEquals("", 0, digits.toScientific(6, 1));
    429         verifyDigitList(
    430                 "186283",
    431                 digits);
    432     }
    433     {
    434         digits.set((int32_t)186283);
    435         assertEquals("", -2, digits.toScientific(8, 1));
    436         verifyDigitList(
    437                 "18628300",
    438                 digits);
    439     }
    440     {
    441         digits.set((int32_t)43561);
    442         assertEquals("", 6, digits.toScientific(-1, 3));
    443         verifyDigitList(
    444                 ".043561",
    445                 digits);
    446     }
    447     {
    448         digits.set((int32_t)43561);
    449         assertEquals("", 3, digits.toScientific(0, 3));
    450         verifyDigitList(
    451                 "43.561",
    452                 digits);
    453     }
    454     {
    455         digits.set((int32_t)43561);
    456         assertEquals("", 3, digits.toScientific(2, 3));
    457         verifyDigitList(
    458                 "43.561",
    459                 digits);
    460     }
    461     {
    462         digits.set((int32_t)43561);
    463         assertEquals("", 0, digits.toScientific(3, 3));
    464         verifyDigitList(
    465                 "43561",
    466                 digits);
    467     }
    468     {
    469         digits.set((int32_t)43561);
    470         assertEquals("", 0, digits.toScientific(5, 3));
    471         verifyDigitList(
    472                 "43561",
    473                 digits);
    474     }
    475     {
    476         digits.set((int32_t)43561);
    477         assertEquals("", -3, digits.toScientific(6, 3));
    478         verifyDigitList(
    479                 "43561000",
    480                 digits);
    481     }
    482     {
    483         digits.set((int32_t)43561);
    484         assertEquals("", -3, digits.toScientific(8, 3));
    485         verifyDigitList(
    486                 "43561000",
    487                 digits);
    488     }
    489     {
    490         digits.set((int32_t)43561);
    491         assertEquals("", -6, digits.toScientific(9, 3));
    492         verifyDigitList(
    493                 "43561000000",
    494                 digits);
    495     }
    496 }
    497 
    498 void NumberFormat2Test::TestLowerUpperExponent() {
    499     DigitList digits;
    500 
    501     digits.set(98.7);
    502     assertEquals("", -1, digits.getLowerExponent());
    503     assertEquals("", 2, digits.getUpperExponent());
    504 }
    505 
    506 void NumberFormat2Test::TestRounding() {
    507     DigitList digits;
    508     uprv_decContextSetRounding(&digits.fContext, DEC_ROUND_CEILING);
    509     {
    510         // Round at very large exponent
    511         digits.set(789.123);
    512         digits.roundAtExponent(100);
    513         verifyDigitList(
    514                 "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", // 100 0's after 1
    515                 digits);
    516     }
    517     {
    518         // Round at very large exponent
    519         digits.set(789.123);
    520         digits.roundAtExponent(1);
    521         verifyDigitList(
    522                 "790", // 100 0's after 1
    523                 digits);
    524     }
    525     {
    526         // Round at positive exponent
    527         digits.set(789.123);
    528         digits.roundAtExponent(1);
    529         verifyDigitList("790", digits);
    530     }
    531     {
    532         // Round at zero exponent
    533         digits.set(788.123);
    534         digits.roundAtExponent(0);
    535         verifyDigitList("789", digits);
    536     }
    537     {
    538         // Round at negative exponent
    539         digits.set(789.123);
    540         digits.roundAtExponent(-2);
    541         verifyDigitList("789.13", digits);
    542     }
    543     {
    544         // Round to exponent of digits.
    545         digits.set(789.123);
    546         digits.roundAtExponent(-3);
    547         verifyDigitList("789.123", digits);
    548     }
    549     {
    550         // Round at large negative exponent
    551         digits.set(789.123);
    552         digits.roundAtExponent(-100);
    553         verifyDigitList("789.123", digits);
    554     }
    555     {
    556         // Round negative
    557         digits.set(-789.123);
    558         digits.roundAtExponent(-2);
    559         digits.setPositive(TRUE);
    560         verifyDigitList("789.12", digits);
    561     }
    562     {
    563         // Round to 1 significant digit
    564         digits.set(789.123);
    565         digits.roundAtExponent(INT32_MIN, 1);
    566         verifyDigitList("800", digits);
    567     }
    568     {
    569         // Round to 5 significant digit
    570         digits.set(789.123);
    571         digits.roundAtExponent(INT32_MIN, 5);
    572         verifyDigitList("789.13", digits);
    573     }
    574     {
    575         // Round to 6 significant digit
    576         digits.set(789.123);
    577         digits.roundAtExponent(INT32_MIN, 6);
    578         verifyDigitList("789.123", digits);
    579     }
    580     {
    581         // no-op
    582         digits.set(789.123);
    583         digits.roundAtExponent(INT32_MIN, INT32_MAX);
    584         verifyDigitList("789.123", digits);
    585     }
    586     {
    587         // Rounding at -1 produces fewer than 5 significant digits
    588         digits.set(789.123);
    589         digits.roundAtExponent(-1, 5);
    590         verifyDigitList("789.2", digits);
    591     }
    592     {
    593         // Rounding at -1 produces exactly 4 significant digits
    594         digits.set(789.123);
    595         digits.roundAtExponent(-1, 4);
    596         verifyDigitList("789.2", digits);
    597     }
    598     {
    599         // Rounding at -1 produces more than 3 significant digits
    600         digits.set(788.123);
    601         digits.roundAtExponent(-1, 3);
    602         verifyDigitList("789", digits);
    603     }
    604     {
    605         digits.set(123.456);
    606         digits.round(INT32_MAX);
    607         verifyDigitList("123.456", digits);
    608     }
    609     {
    610         digits.set(123.456);
    611         digits.round(1);
    612         verifyDigitList("200", digits);
    613     }
    614 }
    615 void NumberFormat2Test::TestBenchmark() {
    616 /*
    617     UErrorCode status = U_ZERO_ERROR;
    618     Locale en("en");
    619     DecimalFormatSymbols *sym = new DecimalFormatSymbols(en, status);
    620     DecimalFormat2 fmt(en, "0.0000000", status);
    621     FieldPosition fpos(FieldPostion::DONT_CARE);
    622     clock_t start = clock();
    623     for (int32_t i = 0; i < 100000; ++i) {
    624        UParseError perror;
    625        DecimalFormat2 fmt2("0.0000000", new DecimalFormatSymbols(*sym), perror, status);
    626 //       UnicodeString append;
    627 //       fmt.format(4.6692016, append, fpos, status);
    628     }
    629     errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC);
    630     assertSuccess("", status);
    631 */
    632 }
    633 
    634 void NumberFormat2Test::TestBenchmark2() {
    635 /*
    636     UErrorCode status = U_ZERO_ERROR;
    637     Locale en("en");
    638     DecimalFormatSymbols *sym = new DecimalFormatSymbols(en, status);
    639     DecimalFormat fmt("0.0000000", sym, status);
    640     FieldPosition fpos(FieldPostion::DONT_CARE);
    641     clock_t start = clock();
    642     for (int32_t i = 0; i < 100000; ++i) {
    643       UParseError perror;
    644       DecimalFormat fmt("0.0000000", new DecimalFormatSymbols(*sym), perror, status);
    645 //        UnicodeString append;
    646 //        fmt.format(4.6692016, append, fpos, status);
    647     }
    648     errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC);
    649     assertSuccess("", status);
    650 */
    651 }
    652 
    653 void NumberFormat2Test::TestSmallIntFormatter() {
    654     verifySmallIntFormatter("0", 7, 0, -2);
    655     verifySmallIntFormatter("7", 7, 1, -2);
    656     verifySmallIntFormatter("07", 7, 2, -2);
    657     verifySmallIntFormatter("07", 7, 2, 2);
    658     verifySmallIntFormatter("007", 7, 3, 4);
    659     verifySmallIntFormatter("7", 7, -1, 3);
    660     verifySmallIntFormatter("0", 0, -1, 3);
    661     verifySmallIntFormatter("057", 57, 3, 7);
    662     verifySmallIntFormatter("0057", 57, 4, 7);
    663     // too many digits for small int
    664     verifySmallIntFormatter("", 57, 5, 7);
    665     // too many digits for small int
    666     verifySmallIntFormatter("", 57, 5, 4);
    667     verifySmallIntFormatter("03", 3, 2, 3);
    668     verifySmallIntFormatter("32", 32, 2, 3);
    669     verifySmallIntFormatter("321", 321, 2, 3);
    670     verifySmallIntFormatter("219", 3219, 2, 3);
    671     verifySmallIntFormatter("4095", 4095, 2, 4);
    672     verifySmallIntFormatter("4095", 4095, 2, 5);
    673     verifySmallIntFormatter("", 4096, 2, 5);
    674 }
    675 
    676 void NumberFormat2Test::TestPositiveIntDigitFormatter() {
    677     DigitFormatter formatter;
    678     {
    679         NumberFormat2Test_Attributes expectedAttributes[] = {
    680             {UNUM_INTEGER_FIELD, 0, 4},
    681             {0, -1, 0}};
    682         verifyPositiveIntDigitFormatter(
    683                 "0057",
    684                 formatter,
    685                 57,
    686                 4,
    687                 INT32_MAX,
    688                 expectedAttributes);
    689     }
    690     {
    691         NumberFormat2Test_Attributes expectedAttributes[] = {
    692             {UNUM_INTEGER_FIELD, 0, 5},
    693             {0, -1, 0}};
    694         verifyPositiveIntDigitFormatter(
    695                 "00057",
    696                 formatter,
    697                 57,
    698                 5,
    699                 INT32_MAX,
    700                 expectedAttributes);
    701     }
    702     {
    703         NumberFormat2Test_Attributes expectedAttributes[] = {
    704             {UNUM_INTEGER_FIELD, 0, 5},
    705             {0, -1, 0}};
    706         verifyPositiveIntDigitFormatter(
    707                 "01000",
    708                 formatter,
    709                 1000,
    710                 5,
    711                 INT32_MAX,
    712                 expectedAttributes);
    713     }
    714     {
    715         NumberFormat2Test_Attributes expectedAttributes[] = {
    716             {UNUM_INTEGER_FIELD, 0, 3},
    717             {0, -1, 0}};
    718         verifyPositiveIntDigitFormatter(
    719                 "100",
    720                 formatter,
    721                 100,
    722                 0,
    723                 INT32_MAX,
    724                 expectedAttributes);
    725     }
    726     {
    727         NumberFormat2Test_Attributes expectedAttributes[] = {
    728             {UNUM_INTEGER_FIELD, 0, 10},
    729             {0, -1, 0}};
    730         verifyPositiveIntDigitFormatter(
    731                 "2147483647",
    732                 formatter,
    733                 2147483647,
    734                 5,
    735                 INT32_MAX,
    736                 expectedAttributes);
    737     }
    738     {
    739         NumberFormat2Test_Attributes expectedAttributes[] = {
    740             {UNUM_INTEGER_FIELD, 0, 12},
    741             {0, -1, 0}};
    742         verifyPositiveIntDigitFormatter(
    743                 "002147483647",
    744                 formatter,
    745                 2147483647,
    746                 12,
    747                 INT32_MAX,
    748                 expectedAttributes);
    749     }
    750     {
    751         // Test long digit string where we have to append one
    752         // character at a time.
    753         NumberFormat2Test_Attributes expectedAttributes[] = {
    754             {UNUM_INTEGER_FIELD, 0, 40},
    755             {0, -1, 0}};
    756         verifyPositiveIntDigitFormatter(
    757                 "0000000000000000000000000000002147483647",
    758                 formatter,
    759                 2147483647,
    760                 40,
    761                 INT32_MAX,
    762                 expectedAttributes);
    763     }
    764     {
    765         NumberFormat2Test_Attributes expectedAttributes[] = {
    766             {UNUM_INTEGER_FIELD, 0, 4},
    767             {0, -1, 0}};
    768         verifyPositiveIntDigitFormatter(
    769                 "6283",
    770                 formatter,
    771                 186283,
    772                 2,
    773                 4,
    774                 expectedAttributes);
    775     }
    776     {
    777         NumberFormat2Test_Attributes expectedAttributes[] = {
    778             {UNUM_INTEGER_FIELD, 0, 1},
    779             {0, -1, 0}};
    780         verifyPositiveIntDigitFormatter(
    781                 "0",
    782                 formatter,
    783                 186283,
    784                 0,
    785                 0,
    786                 expectedAttributes);
    787     }
    788     {
    789         NumberFormat2Test_Attributes expectedAttributes[] = {
    790             {UNUM_INTEGER_FIELD, 0, 1},
    791             {0, -1, 0}};
    792         verifyPositiveIntDigitFormatter(
    793                 "3",
    794                 formatter,
    795                 186283,
    796                 1,
    797                 1,
    798                 expectedAttributes);
    799     }
    800 }
    801 
    802 
    803 void NumberFormat2Test::TestDigitFormatterDefaultCtor() {
    804     DigitFormatter formatter;
    805     VisibleDigits digits;
    806     FixedPrecision precision;
    807     UErrorCode status = U_ZERO_ERROR;
    808     precision.initVisibleDigits(246.801, digits, status);
    809     assertSuccess("", status);
    810     DigitGrouping grouping;
    811     DigitFormatterOptions options;
    812     verifyDigitFormatter(
    813             "246.801",
    814             formatter,
    815             digits,
    816             grouping,
    817             options,
    818             NULL);
    819 }
    820 
    821 void NumberFormat2Test::TestDigitFormatterMonetary() {
    822     UErrorCode status = U_ZERO_ERROR;
    823     DecimalFormatSymbols symbols("en", status);
    824     if (!assertSuccess("", status)) {
    825         return;
    826     }
    827     symbols.setSymbol(
    828             DecimalFormatSymbols::kMonetarySeparatorSymbol,
    829             "decimal separator");
    830     symbols.setSymbol(
    831             DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol,
    832             "grouping separator");
    833     DigitFormatter formatter(symbols);
    834     VisibleDigits visibleDigits;
    835     DigitGrouping grouping;
    836     FixedPrecision precision;
    837     precision.initVisibleDigits(43560.02, visibleDigits, status);
    838     if (!assertSuccess("", status)) {
    839         return;
    840     }
    841     DigitFormatterOptions options;
    842     grouping.fGrouping = 3;
    843     {
    844         verifyDigitFormatter(
    845                 "43,560.02",
    846                 formatter,
    847                 visibleDigits,
    848                 grouping,
    849                 options,
    850                 NULL);
    851         formatter.setDecimalFormatSymbolsForMonetary(symbols);
    852         verifyDigitFormatter(
    853                 "43grouping separator560decimal separator02",
    854                 formatter,
    855                 visibleDigits,
    856                 grouping,
    857                 options,
    858                 NULL);
    859     }
    860 }
    861 
    862 void NumberFormat2Test::TestDigitFormatter() {
    863     UErrorCode status = U_ZERO_ERROR;
    864     DecimalFormatSymbols symbols("en", status);
    865     if (!assertSuccess("", status)) {
    866         return;
    867     }
    868     DigitFormatter formatter(symbols);
    869     DigitInterval interval;
    870     {
    871         VisibleDigits visibleDigits;
    872         DigitGrouping grouping;
    873         FixedPrecision precision;
    874         precision.initVisibleDigits((int64_t) 8192, visibleDigits, status);
    875         if (!assertSuccess("", status)) {
    876             return;
    877         }
    878         DigitFormatterOptions options;
    879         verifyDigitFormatter(
    880                 "8192",
    881                 formatter,
    882                 visibleDigits,
    883                 grouping,
    884                 options,
    885                 NULL);
    886         NumberFormat2Test_Attributes expectedAttributes[] = {
    887             {UNUM_INTEGER_FIELD, 0, 4},
    888             {UNUM_DECIMAL_SEPARATOR_FIELD, 4, 5},
    889             {0, -1, 0}};
    890         options.fAlwaysShowDecimal = TRUE;
    891         verifyDigitFormatter(
    892                 "8192.",
    893                 formatter,
    894                 visibleDigits,
    895                 grouping,
    896                 options,
    897                 expectedAttributes);
    898 
    899         // Turn on grouping
    900         grouping.fGrouping = 3;
    901         options.fAlwaysShowDecimal = FALSE;
    902         verifyDigitFormatter(
    903                 "8,192",
    904                 formatter,
    905                 visibleDigits,
    906                 grouping,
    907                 options,
    908                 NULL);
    909 
    910         // turn on min grouping which will suppress grouping
    911         grouping.fMinGrouping = 2;
    912         verifyDigitFormatter(
    913                 "8192",
    914                 formatter,
    915                 visibleDigits,
    916                 grouping,
    917                 options,
    918                 NULL);
    919 
    920         // adding one more digit will enable grouping once again.
    921         precision.initVisibleDigits((int64_t) 43560, visibleDigits, status);
    922         if (!assertSuccess("", status)) {
    923             return;
    924         }
    925         verifyDigitFormatter(
    926                 "43,560",
    927                 formatter,
    928                 visibleDigits,
    929                 grouping,
    930                 options,
    931                 NULL);
    932     }
    933     {
    934         DigitGrouping grouping;
    935         FixedPrecision precision;
    936         VisibleDigits visibleDigits;
    937         precision.initVisibleDigits(
    938                 31415926.0078125, visibleDigits, status);
    939         if (!assertSuccess("", status)) {
    940             return;
    941         }
    942         DigitFormatterOptions options;
    943         verifyDigitFormatter(
    944                 "31415926.0078125",
    945                 formatter,
    946                 visibleDigits,
    947                 grouping,
    948                 options,
    949                 NULL);
    950 
    951         // Turn on grouping with secondary.
    952         grouping.fGrouping = 2;
    953         grouping.fGrouping2 = 3;
    954         verifyDigitFormatter(
    955                 "314,159,26.0078125",
    956                 formatter,
    957                 visibleDigits,
    958                 grouping,
    959                 options,
    960                 NULL);
    961 
    962         // Pad with zeros by widening interval.
    963         precision.fMin.setIntDigitCount(9);
    964         precision.fMin.setFracDigitCount(10);
    965         precision.initVisibleDigits(
    966                 31415926.0078125, visibleDigits, status);
    967         if (!assertSuccess("", status)) {
    968             return;
    969         }
    970         NumberFormat2Test_Attributes expectedAttributes[] = {
    971             {UNUM_GROUPING_SEPARATOR_FIELD, 1, 2},
    972             {UNUM_GROUPING_SEPARATOR_FIELD, 5, 6},
    973             {UNUM_GROUPING_SEPARATOR_FIELD, 9, 10},
    974             {UNUM_INTEGER_FIELD, 0, 12},
    975             {UNUM_DECIMAL_SEPARATOR_FIELD, 12, 13},
    976             {UNUM_FRACTION_FIELD, 13, 23},
    977             {0, -1, 0}};
    978         verifyDigitFormatter(
    979                 "0,314,159,26.0078125000",
    980                 formatter,
    981                 visibleDigits,
    982                 grouping,
    983                 options,
    984                 expectedAttributes);
    985     }
    986     {
    987         DigitGrouping grouping;
    988         FixedPrecision precision;
    989         VisibleDigits visibleDigits;
    990         DigitFormatterOptions options;
    991         precision.fMax.setIntDigitCount(0);
    992         precision.fMax.setFracDigitCount(0);
    993         precision.initVisibleDigits(
    994                 3125.0, visibleDigits, status);
    995         if (!assertSuccess("", status)) {
    996             return;
    997         }
    998         NumberFormat2Test_Attributes expectedAttributes[] = {
    999             {UNUM_INTEGER_FIELD, 0, 1},
   1000             {0, -1, 0}};
   1001         verifyDigitFormatter(
   1002                 "0",
   1003                 formatter,
   1004                 visibleDigits,
   1005                 grouping,
   1006                 options,
   1007                 expectedAttributes);
   1008         NumberFormat2Test_Attributes expectedAttributesWithDecimal[] = {
   1009             {UNUM_INTEGER_FIELD, 0, 1},
   1010             {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
   1011             {0, -1, 0}};
   1012         options.fAlwaysShowDecimal = TRUE;
   1013         verifyDigitFormatter(
   1014                 "0.",
   1015                 formatter,
   1016                 visibleDigits,
   1017                 grouping,
   1018                 options,
   1019                 expectedAttributesWithDecimal);
   1020     }
   1021     {
   1022         DigitGrouping grouping;
   1023         FixedPrecision precision;
   1024         VisibleDigits visibleDigits;
   1025         DigitFormatterOptions options;
   1026         precision.fMax.setIntDigitCount(1);
   1027         precision.fMin.setFracDigitCount(1);
   1028         precision.initVisibleDigits(
   1029                 3125.0, visibleDigits, status);
   1030         if (!assertSuccess("", status)) {
   1031             return;
   1032         }
   1033         NumberFormat2Test_Attributes expectedAttributes[] = {
   1034             {UNUM_INTEGER_FIELD, 0, 1},
   1035             {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
   1036             {UNUM_FRACTION_FIELD, 2, 3},
   1037             {0, -1, 0}};
   1038         options.fAlwaysShowDecimal = TRUE;
   1039         verifyDigitFormatter(
   1040                 "5.0",
   1041                 formatter,
   1042                 visibleDigits,
   1043                 grouping,
   1044                 options,
   1045                 expectedAttributes);
   1046     }
   1047 }
   1048 
   1049 void NumberFormat2Test::TestSciFormatterDefaultCtor() {
   1050     DigitFormatter formatter;
   1051     ScientificPrecision precision;
   1052     VisibleDigitsWithExponent visibleDigits;
   1053     UErrorCode status = U_ZERO_ERROR;
   1054     precision.initVisibleDigitsWithExponent(
   1055             6.02E23, visibleDigits, status);
   1056     if (!assertSuccess("", status)) {
   1057         return;
   1058     }
   1059     SciFormatterOptions options;
   1060     verifySciFormatter(
   1061             "6.02E23",
   1062             formatter,
   1063             visibleDigits,
   1064             options,
   1065             NULL);
   1066     precision.initVisibleDigitsWithExponent(
   1067             6.62E-34, visibleDigits, status);
   1068     if (!assertSuccess("", status)) {
   1069         return;
   1070     }
   1071     verifySciFormatter(
   1072             "6.62E-34",
   1073             formatter,
   1074             visibleDigits,
   1075             options,
   1076             NULL);
   1077 }
   1078 
   1079 void NumberFormat2Test::TestSciFormatter() {
   1080     DigitFormatter formatter;
   1081     ScientificPrecision precision;
   1082     precision.fMantissa.fMin.setIntDigitCount(4);
   1083     precision.fMantissa.fMax.setIntDigitCount(4);
   1084     precision.fMantissa.fMin.setFracDigitCount(0);
   1085     precision.fMantissa.fMax.setFracDigitCount(0);
   1086     precision.fMinExponentDigits = 3;
   1087     VisibleDigitsWithExponent visibleDigits;
   1088     UErrorCode status = U_ZERO_ERROR;
   1089     precision.initVisibleDigitsWithExponent(
   1090             1.248E26, visibleDigits, status);
   1091     if (!assertSuccess("", status)) {
   1092         return;
   1093     }
   1094     SciFormatterOptions options;
   1095 
   1096     {
   1097         options.fExponent.fAlwaysShowSign = TRUE;
   1098         NumberFormat2Test_Attributes expectedAttributes[] = {
   1099             {UNUM_INTEGER_FIELD, 0, 4},
   1100             {UNUM_EXPONENT_SYMBOL_FIELD, 4, 5},
   1101             {UNUM_EXPONENT_SIGN_FIELD, 5, 6},
   1102             {UNUM_EXPONENT_FIELD, 6, 9},
   1103             {0, -1, 0}};
   1104         verifySciFormatter(
   1105                 "1248E+023",
   1106                 formatter,
   1107                 visibleDigits,
   1108                 options,
   1109                 expectedAttributes);
   1110     }
   1111     {
   1112         options.fMantissa.fAlwaysShowDecimal = TRUE;
   1113         options.fExponent.fAlwaysShowSign = FALSE;
   1114         NumberFormat2Test_Attributes expectedAttributes[] = {
   1115             {UNUM_INTEGER_FIELD, 0, 4},
   1116             {UNUM_DECIMAL_SEPARATOR_FIELD, 4, 5},
   1117             {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6},
   1118             {UNUM_EXPONENT_FIELD, 6, 9},
   1119             {0, -1, 0}};
   1120         verifySciFormatter(
   1121                 "1248.E023",
   1122                 formatter,
   1123                 visibleDigits,
   1124                 options,
   1125                 expectedAttributes);
   1126     }
   1127 }
   1128 
   1129 void NumberFormat2Test::TestValueFormatterIsFastFormattable() {
   1130     UErrorCode status = U_ZERO_ERROR;
   1131     DecimalFormatSymbols symbols("en", status);
   1132     if (!assertSuccess("", status)) {
   1133         return;
   1134     }
   1135     DigitFormatter formatter(symbols);
   1136     DigitGrouping grouping;
   1137     FixedPrecision precision;
   1138     DigitFormatterOptions options;
   1139     ValueFormatter vf;
   1140     vf.prepareFixedDecimalFormatting(
   1141             formatter, grouping, precision, options);
   1142     assertTrue("", vf.isFastFormattable(0));
   1143     assertTrue("", vf.isFastFormattable(35));
   1144     assertTrue("", vf.isFastFormattable(-48));
   1145     assertTrue("", vf.isFastFormattable(2147483647));
   1146     assertTrue("", vf.isFastFormattable(-2147483647));
   1147     assertFalse("", vf.isFastFormattable(-2147483648L));
   1148     {
   1149         DigitGrouping grouping;
   1150         grouping.fGrouping = 3;
   1151         ValueFormatter vf;
   1152         vf.prepareFixedDecimalFormatting(
   1153                 formatter, grouping, precision, options);
   1154         assertTrue("0", vf.isFastFormattable(0));
   1155         assertTrue("62", vf.isFastFormattable(62));
   1156         assertTrue("999", vf.isFastFormattable(999));
   1157         assertFalse("1000", vf.isFastFormattable(1000));
   1158         assertTrue("-1", vf.isFastFormattable(-1));
   1159         assertTrue("-38", vf.isFastFormattable(-38));
   1160         assertTrue("-999", vf.isFastFormattable(-999));
   1161         assertFalse("-1000", vf.isFastFormattable(-1000));
   1162         grouping.fMinGrouping = 2;
   1163         assertTrue("-1000", vf.isFastFormattable(-1000));
   1164         assertTrue("-4095", vf.isFastFormattable(-4095));
   1165         assertTrue("4095", vf.isFastFormattable(4095));
   1166         // We give up on acounting digits at 4096
   1167         assertFalse("-4096", vf.isFastFormattable(-4096));
   1168         assertFalse("4096", vf.isFastFormattable(4096));
   1169     }
   1170     {
   1171         // grouping on but with max integer digits set.
   1172         DigitGrouping grouping;
   1173         grouping.fGrouping = 4;
   1174         FixedPrecision precision;
   1175         precision.fMax.setIntDigitCount(4);
   1176         ValueFormatter vf;
   1177         vf.prepareFixedDecimalFormatting(
   1178                 formatter, grouping, precision, options);
   1179         assertTrue("-4096", vf.isFastFormattable(-4096));
   1180         assertTrue("4096", vf.isFastFormattable(4096));
   1181         assertTrue("-10000", vf.isFastFormattable(-10000));
   1182         assertTrue("10000", vf.isFastFormattable(10000));
   1183         assertTrue("-2147483647", vf.isFastFormattable(-2147483647));
   1184         assertTrue("2147483647", vf.isFastFormattable(2147483647));
   1185 
   1186         precision.fMax.setIntDigitCount(5);
   1187         assertFalse("-4096", vf.isFastFormattable(-4096));
   1188         assertFalse("4096", vf.isFastFormattable(4096));
   1189 
   1190     }
   1191     {
   1192         // grouping on but with min integer digits set.
   1193         DigitGrouping grouping;
   1194         grouping.fGrouping = 3;
   1195         FixedPrecision precision;
   1196         precision.fMin.setIntDigitCount(3);
   1197         ValueFormatter vf;
   1198         vf.prepareFixedDecimalFormatting(
   1199                 formatter, grouping, precision, options);
   1200         assertTrue("-999", vf.isFastFormattable(-999));
   1201         assertTrue("999", vf.isFastFormattable(999));
   1202         assertFalse("-1000", vf.isFastFormattable(-1000));
   1203         assertFalse("1000", vf.isFastFormattable(1000));
   1204 
   1205         precision.fMin.setIntDigitCount(4);
   1206         assertFalse("-999", vf.isFastFormattable(-999));
   1207         assertFalse("999", vf.isFastFormattable(999));
   1208         assertFalse("-2147483647", vf.isFastFormattable(-2147483647));
   1209         assertFalse("2147483647", vf.isFastFormattable(2147483647));
   1210     }
   1211     {
   1212         // options set.
   1213         DigitFormatterOptions options;
   1214         ValueFormatter vf;
   1215         vf.prepareFixedDecimalFormatting(
   1216                 formatter, grouping, precision, options);
   1217         assertTrue("5125", vf.isFastFormattable(5125));
   1218         options.fAlwaysShowDecimal = TRUE;
   1219         assertFalse("5125", vf.isFastFormattable(5125));
   1220         options.fAlwaysShowDecimal = FALSE;
   1221         assertTrue("5125", vf.isFastFormattable(5125));
   1222     }
   1223     {
   1224         // test fraction digits
   1225         FixedPrecision precision;
   1226         ValueFormatter vf;
   1227         vf.prepareFixedDecimalFormatting(
   1228                 formatter, grouping, precision, options);
   1229         assertTrue("7127", vf.isFastFormattable(7127));
   1230         precision.fMin.setFracDigitCount(1);
   1231         assertFalse("7127", vf.isFastFormattable(7127));
   1232     }
   1233     {
   1234         // test presence of significant digits
   1235         FixedPrecision precision;
   1236         ValueFormatter vf;
   1237         vf.prepareFixedDecimalFormatting(
   1238                 formatter, grouping, precision, options);
   1239         assertTrue("1049", vf.isFastFormattable(1049));
   1240         precision.fSignificant.setMin(1);
   1241         assertFalse("1049", vf.isFastFormattable(1049));
   1242     }
   1243     {
   1244         // test presence of rounding increment
   1245         FixedPrecision precision;
   1246         ValueFormatter vf;
   1247         vf.prepareFixedDecimalFormatting(
   1248                 formatter, grouping, precision, options);
   1249         assertTrue("1099", vf.isFastFormattable(1099));
   1250         precision.fRoundingIncrement.set(2.3);
   1251         assertFalse("1099", vf.isFastFormattable(1099));
   1252     }
   1253     {
   1254         // test scientific notation
   1255         ScientificPrecision precision;
   1256         SciFormatterOptions options;
   1257         ValueFormatter vf;
   1258         vf.prepareScientificFormatting(
   1259                 formatter, precision, options);
   1260         assertFalse("1081", vf.isFastFormattable(1081));
   1261     }
   1262 }
   1263 
   1264 void NumberFormat2Test::TestDigitAffix() {
   1265     DigitAffix affix;
   1266     {
   1267         affix.append("foo");
   1268         affix.append("--", UNUM_SIGN_FIELD);
   1269         affix.append("%", UNUM_PERCENT_FIELD);
   1270         NumberFormat2Test_Attributes expectedAttributes[] = {
   1271             {UNUM_SIGN_FIELD, 3, 5},
   1272             {UNUM_PERCENT_FIELD, 5, 6},
   1273             {0, -1, 0}};
   1274         verifyAffix("foo--%", affix, expectedAttributes);
   1275     }
   1276     {
   1277         affix.remove();
   1278         affix.append("USD", UNUM_CURRENCY_FIELD);
   1279         affix.append(" ");
   1280         NumberFormat2Test_Attributes expectedAttributes[] = {
   1281             {UNUM_CURRENCY_FIELD, 0, 3},
   1282             {0, -1, 0}};
   1283         verifyAffix("USD ", affix, expectedAttributes);
   1284     }
   1285     {
   1286         affix.setTo("%%", UNUM_PERCENT_FIELD);
   1287         NumberFormat2Test_Attributes expectedAttributes[] = {
   1288             {UNUM_PERCENT_FIELD, 0, 2},
   1289             {0, -1, 0}};
   1290         verifyAffix("%%", affix, expectedAttributes);
   1291     }
   1292 }
   1293 
   1294 void NumberFormat2Test::TestPluralAffix() {
   1295     UErrorCode status = U_ZERO_ERROR;
   1296     PluralAffix part;
   1297     part.setVariant("one", "Dollar", status);
   1298     part.setVariant("few", "DollarFew", status);
   1299     part.setVariant("other", "Dollars", status);
   1300     PluralAffix dollar(part);
   1301     PluralAffix percent(part);
   1302     part.remove();
   1303     part.setVariant("one", "Percent", status);
   1304     part.setVariant("many", "PercentMany", status);
   1305     part.setVariant("other", "Percents", status);
   1306     percent = part;
   1307     part.remove();
   1308     part.setVariant("one", "foo", status);
   1309 
   1310     PluralAffix pa;
   1311     assertEquals("", "", pa.getOtherVariant().toString());
   1312     pa.append(dollar, UNUM_CURRENCY_FIELD, status);
   1313     pa.append(" and ");
   1314     pa.append(percent, UNUM_PERCENT_FIELD, status);
   1315     pa.append("-", UNUM_SIGN_FIELD);
   1316 
   1317     {
   1318         // other
   1319         NumberFormat2Test_Attributes expectedAttributes[] = {
   1320             {UNUM_CURRENCY_FIELD, 0, 7},
   1321             {UNUM_PERCENT_FIELD, 12, 20},
   1322             {UNUM_SIGN_FIELD, 20, 21},
   1323             {0, -1, 0}};
   1324         verifyAffix(
   1325                 "Dollars and Percents-",
   1326                 pa.getByCategory("other"),
   1327                 expectedAttributes);
   1328     }
   1329     {
   1330         // two which is same as other
   1331         NumberFormat2Test_Attributes expectedAttributes[] = {
   1332             {UNUM_CURRENCY_FIELD, 0, 7},
   1333             {UNUM_PERCENT_FIELD, 12, 20},
   1334             {UNUM_SIGN_FIELD, 20, 21},
   1335             {0, -1, 0}};
   1336         verifyAffix(
   1337                 "Dollars and Percents-",
   1338                 pa.getByCategory("two"),
   1339                 expectedAttributes);
   1340     }
   1341     {
   1342         // bad which is same as other
   1343         NumberFormat2Test_Attributes expectedAttributes[] = {
   1344             {UNUM_CURRENCY_FIELD, 0, 7},
   1345             {UNUM_PERCENT_FIELD, 12, 20},
   1346             {UNUM_SIGN_FIELD, 20, 21},
   1347             {0, -1, 0}};
   1348         verifyAffix(
   1349                 "Dollars and Percents-",
   1350                 pa.getByCategory("bad"),
   1351                 expectedAttributes);
   1352     }
   1353     {
   1354         // one
   1355         NumberFormat2Test_Attributes expectedAttributes[] = {
   1356             {UNUM_CURRENCY_FIELD, 0, 6},
   1357             {UNUM_PERCENT_FIELD, 11, 18},
   1358             {UNUM_SIGN_FIELD, 18, 19},
   1359             {0, -1, 0}};
   1360         verifyAffix(
   1361                 "Dollar and Percent-",
   1362                 pa.getByCategory("one"),
   1363                 expectedAttributes);
   1364     }
   1365     {
   1366         // few
   1367         NumberFormat2Test_Attributes expectedAttributes[] = {
   1368             {UNUM_CURRENCY_FIELD, 0, 9},
   1369             {UNUM_PERCENT_FIELD, 14, 22},
   1370             {UNUM_SIGN_FIELD, 22, 23},
   1371             {0, -1, 0}};
   1372         verifyAffix(
   1373                 "DollarFew and Percents-",
   1374                 pa.getByCategory("few"),
   1375                 expectedAttributes);
   1376     }
   1377     {
   1378         // many
   1379         NumberFormat2Test_Attributes expectedAttributes[] = {
   1380             {UNUM_CURRENCY_FIELD, 0, 7},
   1381             {UNUM_PERCENT_FIELD, 12, 23},
   1382             {UNUM_SIGN_FIELD, 23, 24},
   1383             {0, -1, 0}};
   1384         verifyAffix(
   1385                 "Dollars and PercentMany-",
   1386                 pa.getByCategory("many"),
   1387                 expectedAttributes);
   1388     }
   1389     assertTrue("", pa.hasMultipleVariants());
   1390     pa.remove();
   1391     pa.append("$$$", UNUM_CURRENCY_FIELD);
   1392     assertFalse("", pa.hasMultipleVariants());
   1393 
   1394 }
   1395 
   1396 void NumberFormat2Test::TestCurrencyAffixInfo() {
   1397     CurrencyAffixInfo info;
   1398     assertTrue("", info.isDefault());
   1399     UnicodeString expectedSymbol("\\u00a4");
   1400     UnicodeString expectedSymbolIso("\\u00a4\\u00a4");
   1401     UnicodeString expectedSymbols("\\u00a4\\u00a4\\u00a4");
   1402     assertEquals("", expectedSymbol.unescape(), info.getSymbol());
   1403     assertEquals("", expectedSymbolIso.unescape(), info.getISO());
   1404     assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("one").toString());
   1405     assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("other").toString());
   1406     assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("two").toString());
   1407     UErrorCode status = U_ZERO_ERROR;
   1408     static UChar USD[] = {0x55, 0x53, 0x44, 0x0};
   1409     LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
   1410     if (!assertSuccess("", status)) {
   1411         return;
   1412     }
   1413     info.set("en", rules.getAlias(), USD, status);
   1414     assertEquals("", "$", info.getSymbol(), TRUE);
   1415     assertEquals("", "USD", info.getISO(), TRUE);
   1416     assertEquals("", "US dollar", info.getLong().getByCategory("one").toString(), TRUE);
   1417     assertEquals("", "US dollars", info.getLong().getByCategory("other").toString(), TRUE);
   1418     assertEquals("", "US dollars", info.getLong().getByCategory("two").toString(), TRUE);
   1419     assertFalse("", info.isDefault());
   1420     info.set(NULL, NULL, NULL, status);
   1421     assertTrue("", info.isDefault());
   1422     assertEquals("", expectedSymbol.unescape(), info.getSymbol());
   1423     assertEquals("", expectedSymbolIso.unescape(), info.getISO());
   1424     assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("one").toString());
   1425     assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("other").toString());
   1426     assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("two").toString());
   1427     info.setSymbol("$");
   1428     assertFalse("", info.isDefault());
   1429     info.set(NULL, NULL, NULL, status);
   1430     assertTrue("", info.isDefault());
   1431     info.setISO("USD");
   1432     assertFalse("", info.isDefault());
   1433     assertSuccess("", status);
   1434 }
   1435 
   1436 void NumberFormat2Test::TestAffixPattern() {
   1437     static UChar chars[500];
   1438     for (int32_t i = 0; i < UPRV_LENGTHOF(chars); ++i) {
   1439         chars[i] = (UChar) (i + 1);
   1440     }
   1441     AffixPattern first;
   1442     first.add(AffixPattern::kPercent);
   1443     first.addLiteral(chars, 0, 200);
   1444     first.addLiteral(chars, 200, 300);
   1445     first.addCurrency(2);
   1446     first.addLiteral(chars, 0, 256);
   1447     AffixPattern second;
   1448     second.add(AffixPattern::kPercent);
   1449     second.addLiteral(chars, 0, 300);
   1450     second.addLiteral(chars, 300, 200);
   1451     second.addCurrency(2);
   1452     second.addLiteral(chars, 0, 150);
   1453     second.addLiteral(chars, 150, 106);
   1454     assertTrue("", first.equals(second));
   1455     AffixPatternIterator iter;
   1456     second.remove();
   1457     assertFalse("", second.iterator(iter).nextToken());
   1458     assertTrue("", first.iterator(iter).nextToken());
   1459     assertEquals("", (int32_t)AffixPattern::kPercent, iter.getTokenType());
   1460     assertEquals("", 1, iter.getTokenLength());
   1461     assertTrue("", iter.nextToken());
   1462     UnicodeString str;
   1463     assertEquals("", 500, iter.getLiteral(str).length());
   1464     assertEquals("", (int32_t)AffixPattern::kLiteral, iter.getTokenType());
   1465     assertEquals("", 500, iter.getTokenLength());
   1466     assertTrue("", iter.nextToken());
   1467     assertEquals("", (int32_t)AffixPattern::kCurrency, iter.getTokenType());
   1468     assertEquals("", 2, iter.getTokenLength());
   1469     assertTrue("", iter.nextToken());
   1470     assertEquals("", 256, iter.getLiteral(str).length());
   1471     assertEquals("", (int32_t)AffixPattern::kLiteral, iter.getTokenType());
   1472     assertEquals("", 256, iter.getTokenLength());
   1473     assertFalse("", iter.nextToken());
   1474 }
   1475 
   1476 void NumberFormat2Test::TestAffixPatternDoubleQuote() {
   1477     UnicodeString str("'Don''t'");
   1478     AffixPattern expected;
   1479     // Don't
   1480     static UChar chars[] = {0x44, 0x6F, 0x6E, 0x27, 0x74};
   1481     expected.addLiteral(chars, 0, UPRV_LENGTHOF(chars));
   1482     AffixPattern actual;
   1483     UErrorCode status = U_ZERO_ERROR;
   1484     AffixPattern::parseUserAffixString(str, actual, status);
   1485     assertTrue("", expected.equals(actual));
   1486     UnicodeString formattedString;
   1487     assertEquals("", "Don''t", actual.toUserString(formattedString));
   1488     assertSuccess("", status);
   1489 }
   1490 
   1491 void NumberFormat2Test::TestAffixPatternParser() {
   1492     UErrorCode status = U_ZERO_ERROR;
   1493     static UChar USD[] = {0x55, 0x53, 0x44, 0x0};
   1494     LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
   1495     DecimalFormatSymbols symbols("en", status);
   1496     if (U_FAILURE(status)) {
   1497         dataerrln("Error creating DecimalFormatSymbols - %s", u_errorName(status));
   1498         return;
   1499     }
   1500     AffixPatternParser parser(symbols);
   1501     CurrencyAffixInfo currencyAffixInfo;
   1502     currencyAffixInfo.set("en", rules.getAlias(), USD, status);
   1503     PluralAffix affix;
   1504     UnicodeString str("'--y'''dz'%'\\u00a4\\u00a4\\u00a4\\u00a4 y '\\u00a4\\u00a4\\u00a4 or '\\u00a4\\u00a4 but '\\u00a4");
   1505     str = str.unescape();
   1506     assertSuccess("", status);
   1507     AffixPattern affixPattern;
   1508     parser.parse(
   1509             AffixPattern::parseAffixString(str, affixPattern, status),
   1510             currencyAffixInfo,
   1511             affix,
   1512             status);
   1513     UnicodeString formattedStr;
   1514     affixPattern.toString(formattedStr);
   1515     UnicodeString expectedFormattedStr("'--y''dz'%'\\u00a4\\u00a4\\u00a4\\u00a4 y '\\u00a4\\u00a4\\u00a4 or '\\u00a4\\u00a4 but '\\u00a4");
   1516     expectedFormattedStr = expectedFormattedStr.unescape();
   1517     assertEquals("1", expectedFormattedStr, formattedStr);
   1518     AffixPattern userAffixPattern;
   1519     UnicodeString userStr("-'-'y'''d'z%\\u00a4\\u00a4\\u00a4'\\u00a4' y \\u00a4\\u00a4\\u00a4 or \\u00a4\\u00a4 but \\u00a4");
   1520     userStr = userStr.unescape();
   1521     AffixPattern::parseUserAffixString(userStr, userAffixPattern, status),
   1522     assertTrue("", affixPattern.equals(userAffixPattern));
   1523     AffixPattern userAffixPattern2;
   1524     UnicodeString formattedUserStr;
   1525     AffixPattern::parseUserAffixString(
   1526             userAffixPattern.toUserString(formattedUserStr),
   1527             userAffixPattern2,
   1528             status);
   1529     UnicodeString expectedFormattedUserStr(
   1530             "-'-'y''dz%\\u00a4\\u00a4\\u00a4'\\u00a4' y \\u00a4\\u00a4\\u00a4 or \\u00a4\\u00a4 but \\u00a4");
   1531     assertEquals("2", expectedFormattedUserStr.unescape(), formattedUserStr);
   1532     assertTrue("", userAffixPattern2.equals(userAffixPattern));
   1533     assertSuccess("", status);
   1534     assertTrue("", affixPattern.usesCurrency());
   1535     assertTrue("", affixPattern.usesPercent());
   1536     assertFalse("", affixPattern.usesPermill());
   1537     assertTrue("", affix.hasMultipleVariants());
   1538     {
   1539         // other
   1540         NumberFormat2Test_Attributes expectedAttributes[] = {
   1541             {UNUM_SIGN_FIELD, 0, 1},
   1542             {UNUM_PERCENT_FIELD, 6, 7},
   1543             {UNUM_CURRENCY_FIELD, 7, 17},
   1544             {UNUM_CURRENCY_FIELD, 21, 31},
   1545             {UNUM_CURRENCY_FIELD, 35, 38},
   1546             {UNUM_CURRENCY_FIELD, 43, 44},
   1547             {0, -1, 0}};
   1548         verifyAffix(
   1549                 "--y'dz%US dollars\\u00a4 y US dollars or USD but $",
   1550                 affix.getByCategory("other"),
   1551                 expectedAttributes);
   1552     }
   1553     {
   1554         // one
   1555         NumberFormat2Test_Attributes expectedAttributes[] = {
   1556             {UNUM_SIGN_FIELD, 0, 1},
   1557             {UNUM_PERCENT_FIELD, 6, 7},
   1558             {UNUM_CURRENCY_FIELD, 7, 16},
   1559             {UNUM_CURRENCY_FIELD, 20, 29},
   1560             {UNUM_CURRENCY_FIELD, 33, 36},
   1561             {UNUM_CURRENCY_FIELD, 41, 42},
   1562             {0, -1, 0}};
   1563         verifyAffix(
   1564                 "--y'dz%US dollar\\u00a4 y US dollar or USD but $",
   1565                 affix.getByCategory("one"),
   1566                 expectedAttributes);
   1567     }
   1568     affix.remove();
   1569     str = "%'-";
   1570     affixPattern.remove();
   1571     parser.parse(
   1572             AffixPattern::parseAffixString(str, affixPattern, status),
   1573             currencyAffixInfo,
   1574             affix,
   1575             status);
   1576     assertSuccess("", status);
   1577     assertFalse("", affixPattern.usesCurrency());
   1578     assertFalse("", affixPattern.usesPercent());
   1579     assertFalse("", affixPattern.usesPermill());
   1580     assertFalse("", affix.hasMultipleVariants());
   1581     {
   1582         // other
   1583         NumberFormat2Test_Attributes expectedAttributes[] = {
   1584             {UNUM_SIGN_FIELD, 1, 2},
   1585             {0, -1, 0}};
   1586         verifyAffix(
   1587                 "%-",
   1588                 affix.getByCategory("other"),
   1589                 expectedAttributes);
   1590     }
   1591     UnicodeString a4("\\u00a4");
   1592     AffixPattern scratchPattern;
   1593     AffixPattern::parseAffixString(a4.unescape(), scratchPattern, status);
   1594     assertFalse("", scratchPattern.usesCurrency());
   1595 
   1596     // Test really long string > 256 chars.
   1597     str = "'\\u2030012345678901234567890123456789012345678901234567890123456789"
   1598           "012345678901234567890123456789012345678901234567890123456789"
   1599           "012345678901234567890123456789012345678901234567890123456789"
   1600           "012345678901234567890123456789012345678901234567890123456789"
   1601           "012345678901234567890123456789012345678901234567890123456789";
   1602     str = str.unescape();
   1603     affixPattern.remove();
   1604     affix.remove();
   1605     parser.parse(
   1606             AffixPattern::parseAffixString(str, affixPattern, status),
   1607             currencyAffixInfo,
   1608             affix,
   1609             status);
   1610     assertSuccess("", status);
   1611     assertFalse("", affixPattern.usesCurrency());
   1612     assertFalse("", affixPattern.usesPercent());
   1613     assertTrue("", affixPattern.usesPermill());
   1614     assertFalse("", affix.hasMultipleVariants());
   1615     {
   1616        UnicodeString expected =
   1617            "\\u2030012345678901234567890123456789012345678901234567890123456789"
   1618            "012345678901234567890123456789012345678901234567890123456789"
   1619            "012345678901234567890123456789012345678901234567890123456789"
   1620            "012345678901234567890123456789012345678901234567890123456789"
   1621            "012345678901234567890123456789012345678901234567890123456789";
   1622         expected = expected.unescape();
   1623         NumberFormat2Test_Attributes expectedAttributes[] = {
   1624             {UNUM_PERMILL_FIELD, 0, 1},
   1625             {0, -1, 0}};
   1626         verifyAffix(
   1627                 expected,
   1628                 affix.getOtherVariant(),
   1629                 expectedAttributes);
   1630     }
   1631 }
   1632 
   1633 void NumberFormat2Test::TestAffixPatternAppend() {
   1634   AffixPattern pattern;
   1635   UErrorCode status = U_ZERO_ERROR;
   1636   UnicodeString patternStr("%\\u2030");
   1637   AffixPattern::parseUserAffixString(
   1638           patternStr.unescape(), pattern, status);
   1639 
   1640   AffixPattern appendPattern;
   1641   UnicodeString appendPatternStr("-\\u00a4\\u00a4*");
   1642   AffixPattern::parseUserAffixString(
   1643           appendPatternStr.unescape(), appendPattern, status);
   1644 
   1645   AffixPattern expectedPattern;
   1646   UnicodeString expectedPatternStr("%\\u2030-\\u00a4\\u00a4*");
   1647   AffixPattern::parseUserAffixString(
   1648           expectedPatternStr.unescape(), expectedPattern, status);
   1649 
   1650   assertTrue("", pattern.append(appendPattern).equals(expectedPattern));
   1651   assertSuccess("", status);
   1652 }
   1653 
   1654 void NumberFormat2Test::TestAffixPatternAppendAjoiningLiterals() {
   1655   AffixPattern pattern;
   1656   UErrorCode status = U_ZERO_ERROR;
   1657   UnicodeString patternStr("%baaa");
   1658   AffixPattern::parseUserAffixString(
   1659           patternStr, pattern, status);
   1660 
   1661   AffixPattern appendPattern;
   1662   UnicodeString appendPatternStr("caa%");
   1663   AffixPattern::parseUserAffixString(
   1664           appendPatternStr, appendPattern, status);
   1665 
   1666   AffixPattern expectedPattern;
   1667   UnicodeString expectedPatternStr("%baaacaa%");
   1668   AffixPattern::parseUserAffixString(
   1669           expectedPatternStr, expectedPattern, status);
   1670 
   1671   assertTrue("", pattern.append(appendPattern).equals(expectedPattern));
   1672   assertSuccess("", status);
   1673 }
   1674 
   1675 void NumberFormat2Test::TestLargeIntValue() {
   1676     VisibleDigits digits;
   1677     {
   1678         UErrorCode status = U_ZERO_ERROR;
   1679         FixedPrecision precision;
   1680 
   1681         // Last 18 digits for int values.
   1682         verifyIntValue(
   1683                 223372036854775807LL,
   1684                 precision.initVisibleDigits(U_INT64_MAX, digits, status));
   1685         assertSuccess("U_INT64_MAX", status);
   1686     }
   1687     {
   1688         UErrorCode status = U_ZERO_ERROR;
   1689         FixedPrecision precision;
   1690         precision.fMax.setIntDigitCount(5);
   1691 
   1692         // Last 18 digits for int values.
   1693         verifyIntValue(
   1694                 75807LL,
   1695                 precision.initVisibleDigits(U_INT64_MAX, digits, status));
   1696         verifySource(75807.0, digits);
   1697         assertSuccess("75807", status);
   1698     }
   1699     {
   1700         UErrorCode status = U_ZERO_ERROR;
   1701         FixedPrecision precision;
   1702 
   1703         // Last 18 digits for int values.
   1704         verifyIntValue(
   1705                 223372036854775808LL,
   1706                 precision.initVisibleDigits(U_INT64_MIN, digits, status));
   1707         assertSuccess("U_INT64_MIN", status);
   1708     }
   1709     {
   1710         UErrorCode status = U_ZERO_ERROR;
   1711         FixedPrecision precision;
   1712         precision.fMax.setIntDigitCount(5);
   1713 
   1714         // Last 18 digits for int values.
   1715         verifyIntValue(
   1716                 75808LL,
   1717                 precision.initVisibleDigits(U_INT64_MIN, digits, status));
   1718         verifySource(75808.0, digits);
   1719         assertSuccess("75808", status);
   1720     }
   1721 
   1722 }
   1723 
   1724 void NumberFormat2Test::TestIntInitVisibleDigits() {
   1725     VisibleDigits digits;
   1726     {
   1727         UErrorCode status = U_ZERO_ERROR;
   1728         FixedPrecision precision;
   1729         verifyVisibleDigits(
   1730                 "13",
   1731                 FALSE,
   1732                 precision.initVisibleDigits((int64_t) 13LL, digits, status));
   1733         assertSuccess("13", status);
   1734     }
   1735     {
   1736         UErrorCode status = U_ZERO_ERROR;
   1737         FixedPrecision precision;
   1738         verifyVisibleDigits(
   1739                 "17",
   1740                 TRUE,
   1741                 precision.initVisibleDigits((int64_t) -17LL, digits, status));
   1742         assertSuccess("-17", status);
   1743     }
   1744     {
   1745         UErrorCode status = U_ZERO_ERROR;
   1746         FixedPrecision precision;
   1747         verifyVisibleDigits(
   1748                 "9223372036854775808",
   1749                 TRUE,
   1750                 precision.initVisibleDigits(U_INT64_MIN, digits, status));
   1751         assertSuccess("-9223372036854775808", status);
   1752     }
   1753     {
   1754         UErrorCode status = U_ZERO_ERROR;
   1755         FixedPrecision precision;
   1756         verifyVisibleDigits(
   1757                 "9223372036854775807",
   1758                 FALSE,
   1759                 precision.initVisibleDigits(U_INT64_MAX, digits, status));
   1760         assertSuccess("9223372036854775807", status);
   1761     }
   1762     {
   1763         UErrorCode status = U_ZERO_ERROR;
   1764         FixedPrecision precision;
   1765         verifyVisibleDigits(
   1766                 "31536000",
   1767                 TRUE,
   1768                 precision.initVisibleDigits((int64_t) -31536000LL, digits, status));
   1769         assertSuccess("-31536000", status);
   1770     }
   1771     {
   1772         UErrorCode status = U_ZERO_ERROR;
   1773         FixedPrecision precision;
   1774         verifyVisibleDigits(
   1775                 "0",
   1776                 FALSE,
   1777                 precision.initVisibleDigits((int64_t) 0LL, digits, status));
   1778         assertSuccess("0", status);
   1779     }
   1780     {
   1781         UErrorCode status = U_ZERO_ERROR;
   1782         FixedPrecision precision;
   1783         precision.fMin.setIntDigitCount(4);
   1784         precision.fMin.setFracDigitCount(2);
   1785         verifyVisibleDigits(
   1786                 "0000.00",
   1787                 FALSE,
   1788                 precision.initVisibleDigits((int64_t) 0LL, digits, status));
   1789         assertSuccess("0", status);
   1790     }
   1791     {
   1792         UErrorCode status = U_ZERO_ERROR;
   1793         FixedPrecision precision;
   1794         precision.fMin.setIntDigitCount(4);
   1795         precision.fMin.setFracDigitCount(2);
   1796         verifyVisibleDigits(
   1797                 "0057.00",
   1798                 FALSE,
   1799                 precision.initVisibleDigits((int64_t) 57LL, digits, status));
   1800         assertSuccess("57", status);
   1801     }
   1802     {
   1803         UErrorCode status = U_ZERO_ERROR;
   1804         FixedPrecision precision;
   1805         precision.fMin.setIntDigitCount(4);
   1806         precision.fMin.setFracDigitCount(2);
   1807         verifyVisibleDigits(
   1808                 "0057.00",
   1809                 TRUE,
   1810                 precision.initVisibleDigits((int64_t) -57LL, digits, status));
   1811         assertSuccess("-57", status);
   1812     }
   1813     {
   1814         UErrorCode status = U_ZERO_ERROR;
   1815         FixedPrecision precision;
   1816         precision.fMax.setIntDigitCount(2);
   1817         precision.fMin.setFracDigitCount(1);
   1818         verifyVisibleDigits(
   1819                 "35.0",
   1820                 FALSE,
   1821                 precision.initVisibleDigits((int64_t) 235LL, digits, status));
   1822         assertSuccess("235", status);
   1823     }
   1824     {
   1825         UErrorCode status = U_ZERO_ERROR;
   1826         FixedPrecision precision;
   1827         precision.fMax.setIntDigitCount(2);
   1828         precision.fMin.setFracDigitCount(1);
   1829         precision.fFailIfOverMax = TRUE;
   1830         precision.initVisibleDigits((int64_t) 239LL, digits, status);
   1831         if (status != U_ILLEGAL_ARGUMENT_ERROR) {
   1832             errln("239: Expected U_ILLEGAL_ARGUMENT_ERROR");
   1833         }
   1834     }
   1835     {
   1836         UErrorCode status = U_ZERO_ERROR;
   1837         FixedPrecision precision;
   1838         precision.fSignificant.setMin(5);
   1839         verifyVisibleDigits(
   1840                 "153.00",
   1841                 FALSE,
   1842                 precision.initVisibleDigits((int64_t) 153LL, digits, status));
   1843         assertSuccess("153", status);
   1844     }
   1845     {
   1846         UErrorCode status = U_ZERO_ERROR;
   1847         FixedPrecision precision;
   1848         precision.fSignificant.setMax(2);
   1849         precision.fExactOnly = TRUE;
   1850         precision.initVisibleDigits((int64_t) 154LL, digits, status);
   1851         if (status != U_FORMAT_INEXACT_ERROR) {
   1852             errln("154: Expected U_FORMAT_INEXACT_ERROR");
   1853         }
   1854     }
   1855     {
   1856         UErrorCode status = U_ZERO_ERROR;
   1857         FixedPrecision precision;
   1858         precision.fSignificant.setMax(5);
   1859         verifyVisibleDigits(
   1860                 "150",
   1861                 FALSE,
   1862                 precision.initVisibleDigits((int64_t) 150LL, digits, status));
   1863         assertSuccess("150", status);
   1864     }
   1865 }
   1866 
   1867 void NumberFormat2Test::TestIntInitVisibleDigitsToDigitList() {
   1868     VisibleDigits digits;
   1869     {
   1870         UErrorCode status = U_ZERO_ERROR;
   1871         FixedPrecision precision;
   1872         precision.fRoundingIncrement.set(7.3);
   1873         verifyVisibleDigits(
   1874                 "29.2",
   1875                 TRUE,
   1876                 precision.initVisibleDigits((int64_t) -30LL, digits, status));
   1877         assertSuccess("-29.2", status);
   1878     }
   1879     {
   1880         UErrorCode status = U_ZERO_ERROR;
   1881         FixedPrecision precision;
   1882         precision.fRoundingIncrement.set(7.3);
   1883         precision.fRoundingMode = DecimalFormat::kRoundFloor;
   1884         verifyVisibleDigits(
   1885                 "36.5",
   1886                 TRUE,
   1887                 precision.initVisibleDigits((int64_t) -30LL, digits, status));
   1888         assertSuccess("-36.5", status);
   1889     }
   1890     {
   1891         UErrorCode status = U_ZERO_ERROR;
   1892         FixedPrecision precision;
   1893         precision.fSignificant.setMax(3);
   1894         precision.fRoundingMode = DecimalFormat::kRoundCeiling;
   1895         verifyVisibleDigits(
   1896                 "1390",
   1897                 FALSE,
   1898                 precision.initVisibleDigits((int64_t) 1381LL, digits, status));
   1899         assertSuccess("1390", status);
   1900     }
   1901     {
   1902         UErrorCode status = U_ZERO_ERROR;
   1903         FixedPrecision precision;
   1904         precision.fSignificant.setMax(1);
   1905         precision.fRoundingMode = DecimalFormat::kRoundFloor;
   1906         verifyVisibleDigits(
   1907                 "2000",
   1908                 TRUE,
   1909                 precision.initVisibleDigits((int64_t) -1381LL, digits, status));
   1910         assertSuccess("-2000", status);
   1911     }
   1912 }
   1913 
   1914 void NumberFormat2Test::TestDoubleInitVisibleDigits() {
   1915     VisibleDigits digits;
   1916     {
   1917         UErrorCode status = U_ZERO_ERROR;
   1918         FixedPrecision precision;
   1919         verifyVisibleDigits(
   1920                 "2.05",
   1921                 FALSE,
   1922                 precision.initVisibleDigits(2.05, digits, status));
   1923         assertSuccess("2.05", status);
   1924     }
   1925     {
   1926         UErrorCode status = U_ZERO_ERROR;
   1927         FixedPrecision precision;
   1928         verifyVisibleDigits(
   1929                 "3547",
   1930                 FALSE,
   1931                 precision.initVisibleDigits(3547.0, digits, status));
   1932         assertSuccess("3547", status);
   1933     }
   1934     {
   1935         UErrorCode status = U_ZERO_ERROR;
   1936         FixedPrecision precision;
   1937         precision.fMax.setFracDigitCount(2);
   1938         precision.fMax.setIntDigitCount(1);
   1939         precision.fFailIfOverMax = TRUE;
   1940         precision.fExactOnly = TRUE;
   1941         verifyVisibleDigits(
   1942                 "2.05",
   1943                 TRUE,
   1944                 precision.initVisibleDigits(-2.05, digits, status));
   1945         assertSuccess("-2.05", status);
   1946     }
   1947     {
   1948         UErrorCode status = U_ZERO_ERROR;
   1949         FixedPrecision precision;
   1950         precision.fMax.setFracDigitCount(1);
   1951         precision.fMax.setIntDigitCount(1);
   1952         precision.fFailIfOverMax = TRUE;
   1953         precision.fExactOnly = TRUE;
   1954         precision.initVisibleDigits(-2.05, digits, status);
   1955         if (status != U_FORMAT_INEXACT_ERROR) {
   1956             errln("6245.3: Expected U_FORMAT_INEXACT_ERROR");
   1957         }
   1958     }
   1959     {
   1960         UErrorCode status = U_ZERO_ERROR;
   1961         FixedPrecision precision;
   1962         precision.fMax.setFracDigitCount(2);
   1963         precision.fMax.setIntDigitCount(0);
   1964         precision.fFailIfOverMax = TRUE;
   1965         precision.fExactOnly = TRUE;
   1966         precision.initVisibleDigits(-2.05, digits, status);
   1967         if (status != U_ILLEGAL_ARGUMENT_ERROR) {
   1968             errln("-2.05: Expected U_ILLEGAL_ARGUMENT_ERROR");
   1969         }
   1970     }
   1971     {
   1972         UErrorCode status = U_ZERO_ERROR;
   1973         FixedPrecision precision;
   1974         precision.fMin.setIntDigitCount(5);
   1975         precision.fMin.setFracDigitCount(2);
   1976         precision.fExactOnly = TRUE;
   1977         verifyVisibleDigits(
   1978                 "06245.30",
   1979                 FALSE,
   1980                 precision.initVisibleDigits(6245.3, digits, status));
   1981         assertSuccess("06245.30", status);
   1982     }
   1983     {
   1984         UErrorCode status = U_ZERO_ERROR;
   1985         FixedPrecision precision;
   1986         precision.fSignificant.setMax(5);
   1987         precision.fExactOnly = TRUE;
   1988         verifyVisibleDigits(
   1989                 "6245.3",
   1990                 FALSE,
   1991                 precision.initVisibleDigits(6245.3, digits, status));
   1992         assertSuccess("6245.3", status);
   1993     }
   1994     {
   1995         UErrorCode status = U_ZERO_ERROR;
   1996         FixedPrecision precision;
   1997         precision.fSignificant.setMax(4);
   1998         precision.fExactOnly = TRUE;
   1999         precision.initVisibleDigits(6245.3, digits, status);
   2000         if (status != U_FORMAT_INEXACT_ERROR) {
   2001             errln("6245.3: Expected U_FORMAT_INEXACT_ERROR");
   2002         }
   2003     }
   2004     {
   2005         UErrorCode status = U_ZERO_ERROR;
   2006         FixedPrecision precision;
   2007         precision.fMax.setIntDigitCount(3);
   2008         precision.fMin.setFracDigitCount(2);
   2009         verifyVisibleDigits(
   2010                 "384.90",
   2011                 FALSE,
   2012                 precision.initVisibleDigits(2384.9, digits, status));
   2013         assertSuccess("380.00", status);
   2014     }
   2015     {
   2016         UErrorCode status = U_ZERO_ERROR;
   2017         FixedPrecision precision;
   2018         precision.fMax.setIntDigitCount(3);
   2019         precision.fMin.setFracDigitCount(2);
   2020         precision.fFailIfOverMax = TRUE;
   2021         precision.initVisibleDigits(2384.9, digits, status);
   2022         if (status != U_ILLEGAL_ARGUMENT_ERROR) {
   2023             errln("2384.9: Expected U_ILLEGAL_ARGUMENT_ERROR");
   2024         }
   2025     }
   2026 }
   2027 
   2028 void NumberFormat2Test::TestDoubleInitVisibleDigitsToDigitList() {
   2029     VisibleDigits digits;
   2030     {
   2031         UErrorCode status = U_ZERO_ERROR;
   2032         FixedPrecision precision;
   2033         // 2.01 produces round off error when multiplied by powers of
   2034         // 10 forcing the use of DigitList.
   2035         verifyVisibleDigits(
   2036                 "2.01",
   2037                 TRUE,
   2038                 precision.initVisibleDigits(-2.01, digits, status));
   2039         assertSuccess("-2.01", status);
   2040     }
   2041     {
   2042         UErrorCode status = U_ZERO_ERROR;
   2043         FixedPrecision precision;
   2044         precision.fSignificant.setMax(3);
   2045         precision.fMin.setFracDigitCount(2);
   2046         verifyVisibleDigits(
   2047                 "2380.00",
   2048                 FALSE,
   2049                 precision.initVisibleDigits(2385.0, digits, status));
   2050         assertSuccess("2380.00", status);
   2051     }
   2052     {
   2053         UErrorCode status = U_ZERO_ERROR;
   2054         FixedPrecision precision;
   2055         precision.fMax.setFracDigitCount(2);
   2056         verifyVisibleDigits(
   2057                 "45.83",
   2058                 TRUE,
   2059                 precision.initVisibleDigits(-45.8251, digits, status));
   2060         assertSuccess("45.83", status);
   2061     }
   2062 }
   2063 
   2064 void NumberFormat2Test::TestDigitListInitVisibleDigits() {
   2065     VisibleDigits digits;
   2066     DigitList dlist;
   2067     {
   2068         UErrorCode status = U_ZERO_ERROR;
   2069         FixedPrecision precision;
   2070         precision.fMax.setIntDigitCount(3);
   2071         precision.fMin.setFracDigitCount(2);
   2072         precision.fFailIfOverMax = TRUE;
   2073         dlist.set(2384.9);
   2074         precision.initVisibleDigits(dlist, digits, status);
   2075         if (status != U_ILLEGAL_ARGUMENT_ERROR) {
   2076             errln("2384.9: Expected U_ILLEGAL_ARGUMENT_ERROR");
   2077         }
   2078     }
   2079     {
   2080         UErrorCode status = U_ZERO_ERROR;
   2081         FixedPrecision precision;
   2082         precision.fSignificant.setMax(4);
   2083         precision.fExactOnly = TRUE;
   2084         dlist.set(6245.3);
   2085         precision.initVisibleDigits(dlist, digits, status);
   2086         if (status != U_FORMAT_INEXACT_ERROR) {
   2087             errln("6245.3: Expected U_FORMAT_INEXACT_ERROR");
   2088         }
   2089     }
   2090 }
   2091 
   2092 void NumberFormat2Test::TestSpecialInitVisibleDigits() {
   2093     VisibleDigits digits;
   2094     {
   2095         UErrorCode status = U_ZERO_ERROR;
   2096         FixedPrecision precision;
   2097         precision.fSignificant.setMax(3);
   2098         precision.fMin.setFracDigitCount(2);
   2099         precision.initVisibleDigits(-uprv_getInfinity(), digits, status);
   2100         assertFalse("", digits.isNaN());
   2101         assertTrue("", digits.isInfinite());
   2102         assertTrue("", digits.isNegative());
   2103         assertSuccess("-Inf", status);
   2104     }
   2105     {
   2106         UErrorCode status = U_ZERO_ERROR;
   2107         FixedPrecision precision;
   2108         precision.initVisibleDigits(uprv_getInfinity(), digits, status);
   2109         assertFalse("", digits.isNaN());
   2110         assertTrue("", digits.isInfinite());
   2111         assertFalse("", digits.isNegative());
   2112         assertSuccess("Inf", status);
   2113     }
   2114     {
   2115         UErrorCode status = U_ZERO_ERROR;
   2116         FixedPrecision precision;
   2117         precision.initVisibleDigits(uprv_getNaN(), digits, status);
   2118         assertTrue("", digits.isNaN());
   2119         assertSuccess("Inf", status);
   2120     }
   2121 }
   2122 
   2123 void NumberFormat2Test::TestVisibleDigitsWithExponent() {
   2124     VisibleDigitsWithExponent digits;
   2125     {
   2126         UErrorCode status = U_ZERO_ERROR;
   2127         ScientificPrecision precision;
   2128         precision.initVisibleDigitsWithExponent(389.256, digits, status);
   2129         verifyVisibleDigitsWithExponent(
   2130                 "3.89256E2", FALSE, digits);
   2131         assertSuccess("3.89256E2", status);
   2132     }
   2133     {
   2134         UErrorCode status = U_ZERO_ERROR;
   2135         ScientificPrecision precision;
   2136         precision.initVisibleDigitsWithExponent(-389.256, digits, status);
   2137         verifyVisibleDigitsWithExponent(
   2138                 "3.89256E2", TRUE, digits);
   2139         assertSuccess("-3.89256E2", status);
   2140     }
   2141     {
   2142         UErrorCode status = U_ZERO_ERROR;
   2143         ScientificPrecision precision;
   2144         precision.fMinExponentDigits = 3;
   2145         precision.fMantissa.fMin.setIntDigitCount(1);
   2146         precision.fMantissa.fMax.setIntDigitCount(3);
   2147         precision.initVisibleDigitsWithExponent(12345.67, digits, status);
   2148         verifyVisibleDigitsWithExponent(
   2149                 "12.34567E003", FALSE, digits);
   2150         assertSuccess("12.34567E003", status);
   2151     }
   2152     {
   2153         UErrorCode status = U_ZERO_ERROR;
   2154         ScientificPrecision precision;
   2155         precision.fMantissa.fRoundingIncrement.set(0.073);
   2156         precision.fMantissa.fMin.setIntDigitCount(2);
   2157         precision.fMantissa.fMax.setIntDigitCount(2);
   2158         precision.initVisibleDigitsWithExponent(999.74, digits, status);
   2159         verifyVisibleDigitsWithExponent(
   2160                 "10.001E2", FALSE, digits);
   2161         assertSuccess("10.001E2", status);
   2162     }
   2163 }
   2164 
   2165 void NumberFormat2Test::TestDigitAffixesAndPadding() {
   2166     UErrorCode status = U_ZERO_ERROR;
   2167     DecimalFormatSymbols symbols("en", status);
   2168     if (!assertSuccess("", status)) {
   2169         return;
   2170     }
   2171     DigitFormatter formatter(symbols);
   2172     DigitGrouping grouping;
   2173     grouping.fGrouping = 3;
   2174     FixedPrecision precision;
   2175     DigitFormatterOptions options;
   2176     options.fAlwaysShowDecimal = TRUE;
   2177     ValueFormatter vf;
   2178     vf.prepareFixedDecimalFormatting(
   2179             formatter,
   2180             grouping,
   2181             precision,
   2182             options);
   2183     DigitAffixesAndPadding aap;
   2184     aap.fPositivePrefix.append("(+", UNUM_SIGN_FIELD);
   2185     aap.fPositiveSuffix.append("+)", UNUM_SIGN_FIELD);
   2186     aap.fNegativePrefix.append("(-", UNUM_SIGN_FIELD);
   2187     aap.fNegativeSuffix.append("-)", UNUM_SIGN_FIELD);
   2188     aap.fWidth = 10;
   2189     aap.fPadPosition = DigitAffixesAndPadding::kPadBeforePrefix;
   2190     {
   2191         NumberFormat2Test_Attributes expectedAttributes[] = {
   2192             {UNUM_SIGN_FIELD, 4, 6},
   2193             {UNUM_INTEGER_FIELD, 6, 7},
   2194             {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8},
   2195             {UNUM_SIGN_FIELD, 8, 10},
   2196             {0, -1, 0}};
   2197         verifyAffixesAndPaddingInt32(
   2198                 "****(+3.+)",
   2199                 aap,
   2200                 3,
   2201                 vf,
   2202                 NULL,
   2203                 expectedAttributes);
   2204     }
   2205     aap.fPadPosition = DigitAffixesAndPadding::kPadAfterPrefix;
   2206     {
   2207         NumberFormat2Test_Attributes expectedAttributes[] = {
   2208             {UNUM_SIGN_FIELD, 0, 2},
   2209             {UNUM_INTEGER_FIELD, 6, 7},
   2210             {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8},
   2211             {UNUM_SIGN_FIELD, 8, 10},
   2212             {0, -1, 0}};
   2213         verifyAffixesAndPaddingInt32(
   2214                 "(+****3.+)",
   2215                 aap,
   2216                 3,
   2217                 vf,
   2218                 NULL,
   2219                 expectedAttributes);
   2220     }
   2221     aap.fPadPosition = DigitAffixesAndPadding::kPadBeforeSuffix;
   2222     {
   2223         NumberFormat2Test_Attributes expectedAttributes[] = {
   2224             {UNUM_SIGN_FIELD, 0, 2},
   2225             {UNUM_INTEGER_FIELD, 2, 3},
   2226             {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4},
   2227             {UNUM_SIGN_FIELD, 8, 10},
   2228             {0, -1, 0}};
   2229         verifyAffixesAndPaddingInt32(
   2230                 "(+3.****+)",
   2231                 aap,
   2232                 3,
   2233                 vf,
   2234                 NULL,
   2235                 expectedAttributes);
   2236     }
   2237     aap.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix;
   2238     {
   2239         NumberFormat2Test_Attributes expectedAttributes[] = {
   2240             {UNUM_SIGN_FIELD, 0, 2},
   2241             {UNUM_INTEGER_FIELD, 2, 3},
   2242             {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4},
   2243             {UNUM_SIGN_FIELD, 4, 6},
   2244             {0, -1, 0}};
   2245         verifyAffixesAndPaddingInt32(
   2246                 "(+3.+)****",
   2247                 aap,
   2248                 3,
   2249                 vf,
   2250                 NULL,
   2251                 expectedAttributes);
   2252     }
   2253     aap.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix;
   2254     {
   2255         DigitList digits;
   2256         digits.set(-1234.5);
   2257         NumberFormat2Test_Attributes expectedAttributes[] = {
   2258             {UNUM_SIGN_FIELD, 0, 2},
   2259             {UNUM_GROUPING_SEPARATOR_FIELD, 3, 4},
   2260             {UNUM_INTEGER_FIELD, 2, 7},
   2261             {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8},
   2262             {UNUM_FRACTION_FIELD, 8, 9},
   2263             {UNUM_SIGN_FIELD, 9, 11},
   2264             {0, -1, 0}};
   2265         verifyAffixesAndPadding(
   2266                 "(-1,234.5-)",
   2267                 aap,
   2268                 digits,
   2269                 vf,
   2270                 NULL,
   2271                 expectedAttributes);
   2272     }
   2273     assertFalse("", aap.needsPluralRules());
   2274 
   2275     aap.fWidth = 0;
   2276     aap.fPositivePrefix.remove();
   2277     aap.fPositiveSuffix.remove();
   2278     aap.fNegativePrefix.remove();
   2279     aap.fNegativeSuffix.remove();
   2280 
   2281     // Set up for plural currencies.
   2282     aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD);
   2283     {
   2284         PluralAffix part;
   2285         part.setVariant("one", " Dollar", status);
   2286         part.setVariant("other", " Dollars", status);
   2287         aap.fPositiveSuffix.append(part, UNUM_CURRENCY_FIELD, status);
   2288     }
   2289     aap.fNegativeSuffix = aap.fPositiveSuffix;
   2290 
   2291     LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
   2292     if (!assertSuccess("", status)) {
   2293         return;
   2294     }
   2295 
   2296     // Exercise the fastrack path
   2297     {
   2298         options.fAlwaysShowDecimal = FALSE;
   2299         NumberFormat2Test_Attributes expectedAttributes[] = {
   2300             {UNUM_SIGN_FIELD, 0, 1},
   2301             {UNUM_INTEGER_FIELD, 1, 3},
   2302             {UNUM_CURRENCY_FIELD, 3, 11},
   2303             {0, -1, 0}};
   2304         verifyAffixesAndPaddingInt32(
   2305                 "-45 Dollars",
   2306                 aap,
   2307                 -45,
   2308                 vf,
   2309                 NULL,
   2310                 expectedAttributes);
   2311         options.fAlwaysShowDecimal = TRUE;
   2312     }
   2313 
   2314     // Now test plurals
   2315     assertTrue("", aap.needsPluralRules());
   2316     {
   2317         NumberFormat2Test_Attributes expectedAttributes[] = {
   2318             {UNUM_INTEGER_FIELD, 0, 1},
   2319             {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
   2320             {UNUM_CURRENCY_FIELD, 2, 9},
   2321             {0, -1, 0}};
   2322         verifyAffixesAndPaddingInt32(
   2323                 "1. Dollar",
   2324                 aap,
   2325                 1,
   2326                 vf,
   2327                 rules.getAlias(),
   2328                 expectedAttributes);
   2329     }
   2330     {
   2331         NumberFormat2Test_Attributes expectedAttributes[] = {
   2332             {UNUM_SIGN_FIELD, 0, 1},
   2333             {UNUM_INTEGER_FIELD, 1, 2},
   2334             {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3},
   2335             {UNUM_CURRENCY_FIELD, 3, 10},
   2336             {0, -1, 0}};
   2337         verifyAffixesAndPaddingInt32(
   2338                 "-1. Dollar",
   2339                 aap,
   2340                 -1,
   2341                 vf,
   2342                 rules.getAlias(),
   2343                 expectedAttributes);
   2344     }
   2345     precision.fMin.setFracDigitCount(2);
   2346     {
   2347         NumberFormat2Test_Attributes expectedAttributes[] = {
   2348             {UNUM_INTEGER_FIELD, 0, 1},
   2349             {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
   2350             {UNUM_FRACTION_FIELD, 2, 4},
   2351             {UNUM_CURRENCY_FIELD, 4, 12},
   2352             {0, -1, 0}};
   2353         verifyAffixesAndPaddingInt32(
   2354                 "1.00 Dollars",
   2355                 aap,
   2356                 1,
   2357                 vf,
   2358                 rules.getAlias(),
   2359                 expectedAttributes);
   2360     }
   2361 }
   2362 
   2363 void NumberFormat2Test::TestPluralsAndRounding() {
   2364     UErrorCode status = U_ZERO_ERROR;
   2365     DecimalFormatSymbols symbols("en", status);
   2366     if (!assertSuccess("", status)) {
   2367         return;
   2368     }
   2369     DigitFormatter formatter(symbols);
   2370     DigitGrouping grouping;
   2371     FixedPrecision precision;
   2372     precision.fSignificant.setMax(3);
   2373     DigitFormatterOptions options;
   2374     ValueFormatter vf;
   2375     vf.prepareFixedDecimalFormatting(
   2376             formatter,
   2377             grouping,
   2378             precision,
   2379             options);
   2380     DigitList digits;
   2381     DigitAffixesAndPadding aap;
   2382     // Set up for plural currencies.
   2383     aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD);
   2384     {
   2385         PluralAffix part;
   2386         part.setVariant("one", " Dollar", status);
   2387         part.setVariant("other", " Dollars", status);
   2388         aap.fPositiveSuffix.append(part, UNUM_CURRENCY_FIELD, status);
   2389     }
   2390     aap.fNegativeSuffix = aap.fPositiveSuffix;
   2391     aap.fWidth = 14;
   2392     LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
   2393     if (!assertSuccess("", status)) {
   2394         return;
   2395     }
   2396     {
   2397         digits.set(0.999);
   2398         verifyAffixesAndPadding(
   2399                 "*0.999 Dollars",
   2400                 aap,
   2401                 digits,
   2402                 vf,
   2403                 rules.getAlias(),
   2404                 NULL);
   2405     }
   2406     {
   2407         digits.set(0.9996);
   2408         verifyAffixesAndPadding(
   2409                 "******1 Dollar",
   2410                 aap,
   2411                 digits,
   2412                 vf,
   2413                 rules.getAlias(),
   2414                 NULL);
   2415     }
   2416     {
   2417         digits.set(1.004);
   2418         verifyAffixesAndPadding(
   2419                 "******1 Dollar",
   2420                 aap,
   2421                 digits,
   2422                 vf,
   2423                 rules.getAlias(),
   2424                 NULL);
   2425     }
   2426     precision.fSignificant.setMin(2);
   2427     {
   2428         digits.set(0.9996);
   2429         verifyAffixesAndPadding(
   2430                 "***1.0 Dollars",
   2431                 aap,
   2432                 digits,
   2433                 vf,
   2434                 rules.getAlias(),
   2435                 NULL);
   2436     }
   2437     {
   2438         digits.set(1.004);
   2439         verifyAffixesAndPadding(
   2440                 "***1.0 Dollars",
   2441                 aap,
   2442                 digits,
   2443                 vf,
   2444                 rules.getAlias(),
   2445                 NULL);
   2446     }
   2447     precision.fSignificant.setMin(0);
   2448     {
   2449         digits.set(-79.214);
   2450         verifyAffixesAndPadding(
   2451                 "*-79.2 Dollars",
   2452                 aap,
   2453                 digits,
   2454                 vf,
   2455                 rules.getAlias(),
   2456                 NULL);
   2457     }
   2458     // No more sig digits just max fractions
   2459     precision.fSignificant.setMax(0);
   2460     precision.fMax.setFracDigitCount(4);
   2461     {
   2462         digits.set(79.213562);
   2463         verifyAffixesAndPadding(
   2464                 "79.2136 Dollars",
   2465                 aap,
   2466                 digits,
   2467                 vf,
   2468                 rules.getAlias(),
   2469                 NULL);
   2470     }
   2471 
   2472 }
   2473 
   2474 
   2475 void NumberFormat2Test::TestPluralsAndRoundingScientific() {
   2476     UErrorCode status = U_ZERO_ERROR;
   2477     DecimalFormatSymbols symbols("en", status);
   2478     if (!assertSuccess("", status)) {
   2479         return;
   2480     }
   2481     DigitFormatter formatter(symbols);
   2482     ScientificPrecision precision;
   2483     precision.fMantissa.fSignificant.setMax(4);
   2484     SciFormatterOptions options;
   2485     ValueFormatter vf;
   2486     vf.prepareScientificFormatting(
   2487             formatter,
   2488             precision,
   2489             options);
   2490     DigitList digits;
   2491     DigitAffixesAndPadding aap;
   2492     aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD);
   2493     {
   2494         PluralAffix part;
   2495         part.setVariant("one", " Meter", status);
   2496         part.setVariant("other", " Meters", status);
   2497         aap.fPositiveSuffix.append(part, UNUM_FIELD_COUNT, status);
   2498     }
   2499     aap.fNegativeSuffix = aap.fPositiveSuffix;
   2500     LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status));
   2501     if (!assertSuccess("", status)) {
   2502         return;
   2503     }
   2504     {
   2505         digits.set(0.99996);
   2506         NumberFormat2Test_Attributes expectedAttributes[] = {
   2507             {UNUM_INTEGER_FIELD, 0, 1},
   2508             {UNUM_EXPONENT_SYMBOL_FIELD, 1, 2},
   2509             {UNUM_EXPONENT_FIELD, 2, 3},
   2510             {0, -1, 0}};
   2511         verifyAffixesAndPadding(
   2512                 "1E0 Meters",
   2513                 aap,
   2514                 digits,
   2515                 vf,
   2516                 rules.getAlias(),
   2517                 expectedAttributes);
   2518     }
   2519     options.fMantissa.fAlwaysShowDecimal = TRUE;
   2520     {
   2521         digits.set(0.99996);
   2522         NumberFormat2Test_Attributes expectedAttributes[] = {
   2523             {UNUM_INTEGER_FIELD, 0, 1},
   2524             {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
   2525             {UNUM_EXPONENT_SYMBOL_FIELD, 2, 3},
   2526             {UNUM_EXPONENT_FIELD, 3, 4},
   2527             {0, -1, 0}};
   2528         verifyAffixesAndPadding(
   2529                 "1.E0 Meters",
   2530                 aap,
   2531                 digits,
   2532                 vf,
   2533                 rules.getAlias(),
   2534                 expectedAttributes);
   2535     }
   2536     {
   2537         digits.set(-299792458.0);
   2538         NumberFormat2Test_Attributes expectedAttributes[] = {
   2539             {UNUM_SIGN_FIELD, 0, 1},
   2540             {UNUM_INTEGER_FIELD, 1, 2},
   2541             {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3},
   2542             {UNUM_FRACTION_FIELD, 3, 6},
   2543             {UNUM_EXPONENT_SYMBOL_FIELD, 6, 7},
   2544             {UNUM_EXPONENT_FIELD, 7, 8},
   2545             {0, -1, 0}};
   2546         verifyAffixesAndPadding(
   2547                 "-2.998E8 Meters",
   2548                 aap,
   2549                 digits,
   2550                 vf,
   2551                 rules.getAlias(),
   2552                 expectedAttributes);
   2553     }
   2554     precision.fMantissa.fSignificant.setMin(4);
   2555     options.fExponent.fAlwaysShowSign = TRUE;
   2556     precision.fMinExponentDigits = 3;
   2557     {
   2558         digits.set(3.0);
   2559         NumberFormat2Test_Attributes expectedAttributes[] = {
   2560             {UNUM_INTEGER_FIELD, 0, 1},
   2561             {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
   2562             {UNUM_FRACTION_FIELD, 2, 5},
   2563             {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6},
   2564             {UNUM_EXPONENT_SIGN_FIELD, 6, 7},
   2565             {UNUM_EXPONENT_FIELD, 7, 10},
   2566             {0, -1, 0}};
   2567         verifyAffixesAndPadding(
   2568                 "3.000E+000 Meters",
   2569                 aap,
   2570                 digits,
   2571                 vf,
   2572                 rules.getAlias(),
   2573                 expectedAttributes);
   2574     }
   2575     precision.fMantissa.fMax.setIntDigitCount(3);
   2576     {
   2577         digits.set(0.00025001);
   2578         NumberFormat2Test_Attributes expectedAttributes[] = {
   2579             {UNUM_INTEGER_FIELD, 0, 3},
   2580             {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4},
   2581             {UNUM_FRACTION_FIELD, 4, 5},
   2582             {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6},
   2583             {UNUM_EXPONENT_SIGN_FIELD, 6, 7},
   2584             {UNUM_EXPONENT_FIELD, 7, 10},
   2585             {0, -1, 0}};
   2586         verifyAffixesAndPadding(
   2587                 "250.0E-006 Meters",
   2588                 aap,
   2589                 digits,
   2590                 vf,
   2591                 rules.getAlias(),
   2592                 expectedAttributes);
   2593     }
   2594     {
   2595         digits.set(0.0000025001);
   2596         NumberFormat2Test_Attributes expectedAttributes[] = {
   2597             {UNUM_INTEGER_FIELD, 0, 1},
   2598             {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
   2599             {UNUM_FRACTION_FIELD, 2, 5},
   2600             {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6},
   2601             {UNUM_EXPONENT_SIGN_FIELD, 6, 7},
   2602             {UNUM_EXPONENT_FIELD, 7, 10},
   2603             {0, -1, 0}};
   2604         verifyAffixesAndPadding(
   2605                 "2.500E-006 Meters",
   2606                 aap,
   2607                 digits,
   2608                 vf,
   2609                 rules.getAlias(),
   2610                 expectedAttributes);
   2611     }
   2612     precision.fMantissa.fMax.setFracDigitCount(1);
   2613     {
   2614         digits.set(0.0000025499);
   2615         NumberFormat2Test_Attributes expectedAttributes[] = {
   2616             {UNUM_INTEGER_FIELD, 0, 1},
   2617             {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2},
   2618             {UNUM_FRACTION_FIELD, 2, 3},
   2619             {UNUM_EXPONENT_SYMBOL_FIELD, 3, 4},
   2620             {UNUM_EXPONENT_SIGN_FIELD, 4, 5},
   2621             {UNUM_EXPONENT_FIELD, 5, 8},
   2622             {0, -1, 0}};
   2623         verifyAffixesAndPadding(
   2624                 "2.5E-006 Meters",
   2625                 aap,
   2626                 digits,
   2627                 vf,
   2628                 rules.getAlias(),
   2629                 expectedAttributes);
   2630     }
   2631     precision.fMantissa.fMax.setIntDigitCount(1);
   2632     precision.fMantissa.fMax.setFracDigitCount(2);
   2633     {
   2634         digits.set((int32_t)299792458);
   2635         verifyAffixesAndPadding(
   2636                 "3.00E+008 Meters",
   2637                 aap,
   2638                 digits,
   2639                 vf,
   2640                 rules.getAlias(),
   2641                 NULL);
   2642     }
   2643     // clear significant digits
   2644     precision.fMantissa.fSignificant.setMin(0);
   2645     precision.fMantissa.fSignificant.setMax(0);
   2646 
   2647     // set int and fraction digits
   2648     precision.fMantissa.fMin.setFracDigitCount(2);
   2649     precision.fMantissa.fMax.setFracDigitCount(4);
   2650     precision.fMantissa.fMin.setIntDigitCount(2);
   2651     precision.fMantissa.fMax.setIntDigitCount(3);
   2652     {
   2653         digits.set(-0.0000025300001);
   2654         verifyAffixesAndPadding(
   2655                 "-253.00E-008 Meters",
   2656                 aap,
   2657                 digits,
   2658                 vf,
   2659                 rules.getAlias(),
   2660                 NULL);
   2661     }
   2662     {
   2663         digits.set(-0.0000025300006);
   2664         verifyAffixesAndPadding(
   2665                 "-253.0001E-008 Meters",
   2666                 aap,
   2667                 digits,
   2668                 vf,
   2669                 rules.getAlias(),
   2670                 NULL);
   2671     }
   2672     {
   2673         digits.set(-0.000025300006);
   2674         verifyAffixesAndPadding(
   2675                 "-25.30E-006 Meters",
   2676                 aap,
   2677                 digits,
   2678                 vf,
   2679                 rules.getAlias(),
   2680                 NULL);
   2681     }
   2682 }
   2683 
   2684 
   2685 void NumberFormat2Test::TestRoundingIncrement() {
   2686     UErrorCode status = U_ZERO_ERROR;
   2687     DecimalFormatSymbols symbols("en", status);
   2688     if (U_FAILURE(status)) {
   2689         dataerrln("Error creating DecimalFormatSymbols - %s", u_errorName(status));
   2690         return;
   2691     }
   2692     DigitFormatter formatter(symbols);
   2693     ScientificPrecision precision;
   2694     SciFormatterOptions options;
   2695     precision.fMantissa.fRoundingIncrement.set(0.25);
   2696     precision.fMantissa.fSignificant.setMax(4);
   2697     DigitGrouping grouping;
   2698     ValueFormatter vf;
   2699 
   2700     // fixed
   2701     vf.prepareFixedDecimalFormatting(
   2702             formatter,
   2703             grouping,
   2704             precision.fMantissa,
   2705             options.fMantissa);
   2706     DigitList digits;
   2707     DigitAffixesAndPadding aap;
   2708     aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD);
   2709     {
   2710         digits.set(3.7);
   2711         verifyAffixesAndPadding(
   2712                 "3.75",
   2713                 aap,
   2714                 digits,
   2715                 vf,
   2716                 NULL, NULL);
   2717     }
   2718     {
   2719         digits.set(-7.4);
   2720         verifyAffixesAndPadding(
   2721                 "-7.5",
   2722                 aap,
   2723                 digits,
   2724                 vf,
   2725                 NULL, NULL);
   2726     }
   2727     {
   2728         digits.set(99.8);
   2729         verifyAffixesAndPadding(
   2730                 "99.75",
   2731                 aap,
   2732                 digits,
   2733                 vf,
   2734                 NULL, NULL);
   2735     }
   2736     precision.fMantissa.fMin.setFracDigitCount(2);
   2737     {
   2738         digits.set(99.1);
   2739         verifyAffixesAndPadding(
   2740                 "99.00",
   2741                 aap,
   2742                 digits,
   2743                 vf,
   2744                 NULL, NULL);
   2745     }
   2746     {
   2747         digits.set(-639.65);
   2748         verifyAffixesAndPadding(
   2749                 "-639.80",
   2750                 aap,
   2751                 digits,
   2752                 vf,
   2753                 NULL, NULL);
   2754     }
   2755 
   2756     precision.fMantissa.fMin.setIntDigitCount(2);
   2757     // Scientific notation
   2758     vf.prepareScientificFormatting(
   2759             formatter,
   2760             precision,
   2761             options);
   2762     {
   2763         digits.set(-6396.5);
   2764         verifyAffixesAndPadding(
   2765                 "-64.00E2",
   2766                 aap,
   2767                 digits,
   2768                 vf,
   2769                 NULL, NULL);
   2770     }
   2771     {
   2772         digits.set(-0.00092374);
   2773         verifyAffixesAndPadding(
   2774                 "-92.25E-5",
   2775                 aap,
   2776                 digits,
   2777                 vf,
   2778                 NULL, NULL);
   2779     }
   2780     precision.fMantissa.fMax.setIntDigitCount(3);
   2781     {
   2782         digits.set(-0.00092374);
   2783         verifyAffixesAndPadding(
   2784                 "-923.80E-6",
   2785                 aap,
   2786                 digits,
   2787                 vf,
   2788                 NULL, NULL);
   2789     }
   2790 }
   2791 
   2792 void NumberFormat2Test::TestToPatternScientific11648() {
   2793 /*
   2794     UErrorCode status = U_ZERO_ERROR;
   2795     Locale en("en");
   2796     DecimalFormat2 fmt(en, "0.00", status);
   2797     fmt.setScientificNotation(TRUE);
   2798     UnicodeString pattern;
   2799     // Fails, produces "0.00E"
   2800     assertEquals("", "0.00E0", fmt.toPattern(pattern));
   2801     DecimalFormat fmt2(pattern, status);
   2802     // Fails, bad pattern.
   2803     assertSuccess("", status);
   2804 */
   2805 }
   2806 
   2807 void NumberFormat2Test::verifyAffixesAndPadding(
   2808         const UnicodeString &expected,
   2809         const DigitAffixesAndPadding &aaf,
   2810         DigitList &digits,
   2811         const ValueFormatter &vf,
   2812         const PluralRules *optPluralRules,
   2813         const NumberFormat2Test_Attributes *expectedAttributes) {
   2814     UnicodeString appendTo;
   2815     NumberFormat2Test_FieldPositionHandler handler;
   2816     UErrorCode status = U_ZERO_ERROR;
   2817     assertEquals(
   2818             "",
   2819             expected,
   2820             aaf.format(
   2821                     digits,
   2822                     vf,
   2823                     handler,
   2824                     optPluralRules,
   2825                     appendTo,
   2826                     status));
   2827     if (!assertSuccess("", status)) {
   2828         return;
   2829     }
   2830     if (expectedAttributes != NULL) {
   2831         verifyAttributes(expectedAttributes, handler.attributes);
   2832     }
   2833 }
   2834 
   2835 void NumberFormat2Test::verifyAffixesAndPaddingInt32(
   2836         const UnicodeString &expected,
   2837         const DigitAffixesAndPadding &aaf,
   2838         int32_t value,
   2839         const ValueFormatter &vf,
   2840         const PluralRules *optPluralRules,
   2841         const NumberFormat2Test_Attributes *expectedAttributes) {
   2842     UnicodeString appendTo;
   2843     NumberFormat2Test_FieldPositionHandler handler;
   2844     UErrorCode status = U_ZERO_ERROR;
   2845     assertEquals(
   2846             "",
   2847             expected,
   2848             aaf.formatInt32(
   2849                     value,
   2850                     vf,
   2851                     handler,
   2852                     optPluralRules,
   2853                     appendTo,
   2854                     status));
   2855     if (!assertSuccess("", status)) {
   2856         return;
   2857     }
   2858     if (expectedAttributes != NULL) {
   2859         verifyAttributes(expectedAttributes, handler.attributes);
   2860     }
   2861     DigitList digits;
   2862     digits.set(value);
   2863     verifyAffixesAndPadding(
   2864             expected, aaf, digits, vf, optPluralRules, expectedAttributes);
   2865 }
   2866 
   2867 void NumberFormat2Test::verifyAffix(
   2868         const UnicodeString &expected,
   2869         const DigitAffix &affix,
   2870         const NumberFormat2Test_Attributes *expectedAttributes) {
   2871     UnicodeString appendTo;
   2872     NumberFormat2Test_FieldPositionHandler handler;
   2873     assertEquals(
   2874             "",
   2875             expected.unescape(),
   2876             affix.format(handler, appendTo));
   2877     if (expectedAttributes != NULL) {
   2878         verifyAttributes(expectedAttributes, handler.attributes);
   2879     }
   2880 }
   2881 
   2882 // Right now only works for positive values.
   2883 void NumberFormat2Test::verifyDigitList(
   2884         const UnicodeString &expected,
   2885         const DigitList &digits) {
   2886     DigitFormatter formatter;
   2887     DigitGrouping grouping;
   2888     VisibleDigits visibleDigits;
   2889     FixedPrecision precision;
   2890     precision.fMin.setIntDigitCount(0);
   2891     DigitFormatterOptions options;
   2892     UErrorCode status = U_ZERO_ERROR;
   2893     DigitList dlCopy(digits);
   2894     precision.initVisibleDigits(
   2895             dlCopy, visibleDigits, status);
   2896     if (!assertSuccess("", status)) {
   2897         return;
   2898     }
   2899     verifyDigitFormatter(
   2900             expected,
   2901             formatter,
   2902             visibleDigits,
   2903             grouping,
   2904             options,
   2905             NULL);
   2906 }
   2907 
   2908 void NumberFormat2Test::verifyVisibleDigits(
   2909         const UnicodeString &expected,
   2910         UBool bNegative,
   2911         const VisibleDigits &digits) {
   2912     DigitFormatter formatter;
   2913     DigitGrouping grouping;
   2914     DigitFormatterOptions options;
   2915     verifyDigitFormatter(
   2916             expected,
   2917             formatter,
   2918             digits,
   2919             grouping,
   2920             options,
   2921             NULL);
   2922     if (digits.isNegative() != bNegative) {
   2923         errln(expected + ": Wrong sign.");
   2924     }
   2925     if (digits.isNaN() || digits.isInfinite()) {
   2926         errln(expected + ": Require real value.");
   2927     }
   2928 }
   2929 
   2930 void NumberFormat2Test::verifyVisibleDigitsWithExponent(
   2931         const UnicodeString &expected,
   2932         UBool bNegative,
   2933         const VisibleDigitsWithExponent &digits) {
   2934     DigitFormatter formatter;
   2935     SciFormatterOptions options;
   2936     verifySciFormatter(
   2937             expected,
   2938             formatter,
   2939             digits,
   2940             options,
   2941             NULL);
   2942     if (digits.isNegative() != bNegative) {
   2943         errln(expected + ": Wrong sign.");
   2944     }
   2945     if (digits.isNaN() || digits.isInfinite()) {
   2946         errln(expected + ": Require real value.");
   2947     }
   2948 }
   2949 
   2950 void NumberFormat2Test::verifySciFormatter(
   2951         const UnicodeString &expected,
   2952         const DigitFormatter &formatter,
   2953         const VisibleDigitsWithExponent &digits,
   2954         const SciFormatterOptions &options,
   2955         const NumberFormat2Test_Attributes *expectedAttributes) {
   2956     assertEquals(
   2957             "",
   2958             expected.countChar32(),
   2959             formatter.countChar32(digits, options));
   2960     UnicodeString appendTo;
   2961     NumberFormat2Test_FieldPositionHandler handler;
   2962     assertEquals(
   2963             "",
   2964             expected,
   2965             formatter.format(
   2966                     digits,
   2967                     options,
   2968                     handler,
   2969                     appendTo));
   2970     if (expectedAttributes != NULL) {
   2971         verifyAttributes(expectedAttributes, handler.attributes);
   2972     }
   2973 }
   2974 
   2975 void NumberFormat2Test::verifyPositiveIntDigitFormatter(
   2976         const UnicodeString &expected,
   2977         const DigitFormatter &formatter,
   2978         int32_t value,
   2979         int32_t minDigits,
   2980         int32_t maxDigits,
   2981         const NumberFormat2Test_Attributes *expectedAttributes) {
   2982     IntDigitCountRange range(minDigits, maxDigits);
   2983     UnicodeString appendTo;
   2984     NumberFormat2Test_FieldPositionHandler handler;
   2985     assertEquals(
   2986             "",
   2987             expected,
   2988             formatter.formatPositiveInt32(
   2989                     value,
   2990                     range,
   2991                     handler,
   2992                     appendTo));
   2993     if (expectedAttributes != NULL) {
   2994         verifyAttributes(expectedAttributes, handler.attributes);
   2995     }
   2996 }
   2997 
   2998 void NumberFormat2Test::verifyDigitFormatter(
   2999         const UnicodeString &expected,
   3000         const DigitFormatter &formatter,
   3001         const VisibleDigits &digits,
   3002         const DigitGrouping &grouping,
   3003         const DigitFormatterOptions &options,
   3004         const NumberFormat2Test_Attributes *expectedAttributes) {
   3005     assertEquals(
   3006             "",
   3007             expected.countChar32(),
   3008             formatter.countChar32(digits, grouping, options));
   3009     UnicodeString appendTo;
   3010     NumberFormat2Test_FieldPositionHandler handler;
   3011     assertEquals(
   3012             "",
   3013             expected,
   3014             formatter.format(
   3015                     digits,
   3016                     grouping,
   3017                     options,
   3018                     handler,
   3019                     appendTo));
   3020     if (expectedAttributes != NULL) {
   3021         verifyAttributes(expectedAttributes, handler.attributes);
   3022     }
   3023 }
   3024 
   3025 void NumberFormat2Test::verifySmallIntFormatter(
   3026         const UnicodeString &expected,
   3027         int32_t positiveValue,
   3028         int32_t minDigits,
   3029         int32_t maxDigits) {
   3030     IntDigitCountRange range(minDigits, maxDigits);
   3031     if (!SmallIntFormatter::canFormat(positiveValue, range)) {
   3032         UnicodeString actual;
   3033         assertEquals("", expected, actual);
   3034         return;
   3035     }
   3036     UnicodeString actual;
   3037     assertEquals("", expected, SmallIntFormatter::format(positiveValue, range, actual));
   3038 }
   3039 
   3040 void NumberFormat2Test::verifyAttributes(
   3041         const NumberFormat2Test_Attributes *expected,
   3042         const NumberFormat2Test_Attributes *actual) {
   3043     int32_t idx = 0;
   3044     while (expected[idx].spos != -1 && actual[idx].spos != -1) {
   3045         assertEquals("id", expected[idx].id, actual[idx].id);
   3046         assertEquals("spos", expected[idx].spos, actual[idx].spos);
   3047         assertEquals("epos", expected[idx].epos, actual[idx].epos);
   3048         ++idx;
   3049     }
   3050     assertEquals(
   3051             "expected and actual not same length",
   3052             expected[idx].spos,
   3053             actual[idx].spos);
   3054 }
   3055 
   3056 void NumberFormat2Test::verifyIntValue(
   3057         int64_t expected, const VisibleDigits &digits) {
   3058     double unusedSource;
   3059     int64_t intValue;
   3060     int64_t unusedF;
   3061     int64_t unusedT;
   3062     int32_t unusedV;
   3063     UBool unusedHasIntValue;
   3064     digits.getFixedDecimal(
   3065             unusedSource, intValue, unusedF,
   3066             unusedT, unusedV, unusedHasIntValue);
   3067     assertEquals("", expected, intValue);
   3068 }
   3069 
   3070 void NumberFormat2Test::verifySource(
   3071         double expected, const VisibleDigits &digits) {
   3072     double source;
   3073     int64_t unusedIntValue;
   3074     int64_t unusedF;
   3075     int64_t unusedT;
   3076     int32_t unusedV;
   3077     UBool unusedHasIntValue;
   3078     digits.getFixedDecimal(
   3079             source, unusedIntValue, unusedF,
   3080             unusedT, unusedV, unusedHasIntValue);
   3081     if (expected != source) {
   3082         errln("Expected %f, got %f instead", expected, source);
   3083     }
   3084 }
   3085 
   3086 extern IntlTest *createNumberFormat2Test() {
   3087     return new NumberFormat2Test();
   3088 }
   3089 
   3090 #endif /* !UCONFIG_NO_FORMATTING */
   3091