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
40struct NumberFormat2Test_Attributes {
41    int32_t id;
42    int32_t spos;
43    int32_t epos;
44};
45
46class NumberFormat2Test_FieldPositionHandler : public FieldPositionHandler {
47public:
48NumberFormat2Test_Attributes attributes[100];
49int32_t count;
50UBool bRecording;
51
52
53
54NumberFormat2Test_FieldPositionHandler() : count(0), bRecording(TRUE) { attributes[0].spos = -1; }
55NumberFormat2Test_FieldPositionHandler(UBool recording) : count(0), bRecording(recording) { attributes[0].spos = -1; }
56virtual ~NumberFormat2Test_FieldPositionHandler();
57virtual void addAttribute(int32_t id, int32_t start, int32_t limit);
58virtual void shiftLast(int32_t delta);
59virtual UBool isRecording(void) const;
60};
61
62NumberFormat2Test_FieldPositionHandler::~NumberFormat2Test_FieldPositionHandler() {
63}
64
65void 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
77void NumberFormat2Test_FieldPositionHandler::shiftLast(int32_t /* delta */) {
78}
79
80UBool NumberFormat2Test_FieldPositionHandler::isRecording() const {
81    return bRecording;
82}
83
84
85class NumberFormat2Test : public IntlTest {
86public:
87    void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0);
88private:
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
191void 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
239void 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
300void 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
308void 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
320void 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
389void 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
417void 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
498void NumberFormat2Test::TestLowerUpperExponent() {
499    DigitList digits;
500
501    digits.set(98.7);
502    assertEquals("", -1, digits.getLowerExponent());
503    assertEquals("", 2, digits.getUpperExponent());
504}
505
506void 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}
615void 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
634void 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
653void 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
676void 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
803void 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
821void 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
862void 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
1049void 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
1079void 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
1129void 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
1264void 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
1294void 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
1396void 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
1436void 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
1476void 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
1491void 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
1633void 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
1654void 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
1675void 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
1724void 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
1867void 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
1914void 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
2028void 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
2064void 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
2092void 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
2123void 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
2165void 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
2363void 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
2475void 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
2685void 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
2792void 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
2807void 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
2835void 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
2867void 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.
2883void 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
2908void 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
2930void 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
2950void 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
2975void 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
2998void 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
3025void 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
3040void 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
3056void 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
3070void 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
3086extern IntlTest *createNumberFormat2Test() {
3087    return new NumberFormat2Test();
3088}
3089
3090#endif /* !UCONFIG_NO_FORMATTING */
3091