1/************************************************************************
2 * COPYRIGHT:
3 * Copyright (c) 1997-2015, International Business Machines Corporation
4 * and others. All Rights Reserved.
5 ************************************************************************/
6
7#ifndef _NUMBERFORMATTEST_
8#define _NUMBERFORMATTEST_
9
10#include "unicode/utypes.h"
11
12#if !UCONFIG_NO_FORMATTING
13
14#include "unicode/numfmt.h"
15#include "unicode/decimfmt.h"
16#include "caltztst.h"
17
18/**
19 * Performs various in-depth test on NumberFormat
20 **/
21class NumberFormatTest: public CalendarTimeZoneTest {
22
23    // IntlTest override
24    void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par );
25 public:
26
27    /**
28     * Test APIs (to increase code coverage)
29     */
30    void TestAPI(void);
31
32    void TestCoverage(void);
33
34    /**
35     * Test the handling of quotes
36     **/
37    void TestQuotes(void);
38    /**
39     * Test patterns with exponential representation
40     **/
41    void TestExponential(void);
42    /**
43     * Test handling of patterns with currency symbols
44     **/
45    void TestCurrencySign(void);
46    /**
47     * Test different format patterns
48     **/
49    void TestPatterns(void);
50    /**
51     * API coverage for DigitList
52     **/
53    //void TestDigitList(void);
54
55    /**
56     * Test localized currency patterns.
57     */
58    void TestCurrency(void);
59
60    /**
61     * Test the Currency object handling, new as of ICU 2.2.
62     */
63    void TestCurrencyObject(void);
64
65    void TestCurrencyPatterns(void);
66
67    /**
68     * Do rudimentary testing of parsing.
69     */
70    void TestParse(void);
71    /**
72     * Test proper rounding by the format method.
73     */
74    void TestRounding487(void);
75
76    // New tests for alphaWorks upgrade
77    void TestExponent(void);
78
79    void TestScientific(void);
80
81    void TestScientific2(void);
82
83    void TestScientificGrouping(void);
84
85    void TestInt64(void);
86
87    void TestSurrogateSupport(void);
88
89    /**
90     * Test the functioning of the secondary grouping value.
91     */
92    void TestSecondaryGrouping(void);
93
94    void TestWhiteSpaceParsing(void);
95
96    void TestComplexCurrency(void);
97
98    void TestPad(void);
99    void TestPatterns2(void);
100
101    /**
102     * Test currency registration.
103     */
104    void TestRegCurrency(void);
105
106    void TestCurrencyNames(void);
107
108    void TestCurrencyAmount(void);
109
110    void TestCurrencyUnit(void);
111
112    void TestSymbolsWithBadLocale(void);
113
114    void TestAdoptDecimalFormatSymbols(void);
115
116    void TestPerMill(void);
117
118    void TestIllegalPatterns(void);
119
120    void TestCases(void);
121
122    void TestJB3832(void);
123
124    void TestHost(void);
125
126    void TestHostClone(void);
127
128    void TestCurrencyFormat(void);
129
130    /* Port of ICU4J rounding test. */
131    void TestRounding(void);
132
133    void TestRoundingPattern(void);
134
135    void TestNonpositiveMultiplier(void);
136
137    void TestNumberingSystems();
138
139
140    void TestSpaceParsing();
141    void TestMultiCurrencySign();
142    void TestCurrencyFormatForMixParsing();
143    void TestDecimalFormatCurrencyParse();
144    void TestCurrencyIsoPluralFormat();
145    void TestCurrencyParsing();
146    void TestParseCurrencyInUCurr();
147    void TestFormatAttributes();
148    void TestFieldPositionIterator();
149
150    void TestLenientParse();
151
152    void TestDecimal();
153    void TestCurrencyFractionDigits();
154
155    void TestExponentParse();
156    void TestExplicitParents();
157    void TestAvailableNumberingSystems();
158    void Test9087();
159    void TestFormatFastpaths();
160
161    void TestFormattableSize();
162
163    void TestUFormattable();
164
165    void TestEnumSet();
166
167    void TestSignificantDigits();
168    void TestShowZero();
169
170    void TestCompatibleCurrencies();
171    void TestBug9936();
172    void TestParseNegativeWithFaLocale();
173    void TestParseNegativeWithAlternateMinusSign();
174
175    void TestCustomCurrencySignAndSeparator();
176
177    void TestParseSignsAndMarks();
178    void Test10419RoundingWith0FractionDigits();
179    void Test10468ApplyPattern();
180    void TestRoundingScientific10542();
181    void TestZeroScientific10547();
182    void TestAccountingCurrency();
183    void TestEquality();
184
185    void TestCurrencyUsage();
186    void TestDoubleLimit11439();
187    void TestFastPathConsistent11524();
188
189 private:
190    UBool testFormattableAsUFormattable(const char *file, int line, Formattable &f);
191
192    void expectParseCurrency(const NumberFormat &fmt, const UChar* currency, double amount, const char *text);
193
194    static UBool equalValue(const Formattable& a, const Formattable& b);
195
196    void expectPositions(FieldPositionIterator& iter, int32_t *values, int32_t tupleCount,
197                         const UnicodeString& str);
198
199    void expectPosition(FieldPosition& pos, int32_t id, int32_t start, int32_t limit,
200                        const UnicodeString& str);
201
202    void expect2(NumberFormat& fmt, const Formattable& n, const UnicodeString& str);
203
204    void expect3(NumberFormat& fmt, const Formattable& n, const UnicodeString& str);
205
206    void expect2(NumberFormat& fmt, const Formattable& n, const char* str) {
207        expect2(fmt, n, UnicodeString(str, ""));
208    }
209
210    void expect2(NumberFormat* fmt, const Formattable& n, const UnicodeString& str, UErrorCode ec);
211
212    void expect2(NumberFormat* fmt, const Formattable& n, const char* str, UErrorCode ec) {
213        expect2(fmt, n, UnicodeString(str, ""), ec);
214    }
215
216    void expect(NumberFormat& fmt, const UnicodeString& str, const Formattable& n);
217
218    void expect(NumberFormat& fmt, const char *str, const Formattable& n) {
219        expect(fmt, UnicodeString(str, ""), n);
220    }
221
222    void expect(NumberFormat& fmt, const Formattable& n,
223                const UnicodeString& exp, UBool rt=TRUE);
224
225    void expect(NumberFormat& fmt, const Formattable& n,
226                const char *exp, UBool rt=TRUE) {
227        expect(fmt, n, UnicodeString(exp, ""), rt);
228    }
229
230    void expect(NumberFormat* fmt, const Formattable& n,
231                const UnicodeString& exp, UBool rt, UErrorCode errorCode);
232
233    void expect(NumberFormat* fmt, const Formattable& n,
234                const char *exp, UBool rt, UErrorCode errorCode) {
235        expect(fmt, n, UnicodeString(exp, ""), rt, errorCode);
236    }
237
238    void expect(NumberFormat* fmt, const Formattable& n,
239                const UnicodeString& exp, UErrorCode errorCode) {
240        expect(fmt, n, exp, TRUE, errorCode);
241    }
242
243    void expect(NumberFormat* fmt, const Formattable& n,
244                const char *exp, UErrorCode errorCode) {
245        expect(fmt, n, UnicodeString(exp, ""), TRUE, errorCode);
246    }
247
248    void expectCurrency(NumberFormat& nf, const Locale& locale,
249                        double value, const UnicodeString& string);
250
251    void expectPad(DecimalFormat& fmt, const UnicodeString& pat,
252                   int32_t pos, int32_t width, UChar pad);
253
254    void expectPad(DecimalFormat& fmt, const char *pat,
255                   int32_t pos, int32_t width, UChar pad) {
256        expectPad(fmt, UnicodeString(pat, ""), pos, width, pad);
257    }
258
259    void expectPad(DecimalFormat& fmt, const UnicodeString& pat,
260                   int32_t pos, int32_t width, const UnicodeString& pad);
261
262    void expectPad(DecimalFormat& fmt, const char *pat,
263                   int32_t pos, int32_t width, const UnicodeString& pad) {
264        expectPad(fmt, UnicodeString(pat, ""), pos, width, pad);
265    }
266
267    void expectPat(DecimalFormat& fmt, const UnicodeString& exp);
268
269    void expectPat(DecimalFormat& fmt, const char *exp) {
270        expectPat(fmt, UnicodeString(exp, ""));
271    }
272
273    void expectPad(DecimalFormat& fmt, const UnicodeString& pat,
274                   int32_t pos);
275
276    void expectPad(DecimalFormat& fmt, const char *pat,
277                   int32_t pos) {
278        expectPad(fmt, pat, pos, 0, (UChar)0);
279    }
280
281    void expect_rbnf(NumberFormat& fmt, const UnicodeString& str, const Formattable& n);
282
283    void expect_rbnf(NumberFormat& fmt, const Formattable& n,
284                const UnicodeString& exp, UBool rt=TRUE);
285
286    // internal utility routine
287    static UnicodeString& escape(UnicodeString& s);
288
289    enum { ILLEGAL = -1 };
290
291    // internal subtest used by TestRounding487
292    void roundingTest(NumberFormat& nf, double x, int32_t maxFractionDigits, const char* expected);
293
294    // internal rounding checking for TestRounding
295    void checkRounding(DecimalFormat* df, double base, int iterations, double increment);
296
297    double checkRound(DecimalFormat* df, double iValue, double lastParsed);
298
299    void verifyRounding(
300        DecimalFormat& format,
301        const double *values,
302        const char * const *expected,
303        const DecimalFormat::ERoundingMode *roundingModes,
304        const char * const *descriptions,
305        int32_t valueSize,
306        int32_t roundingModeSize);
307
308};
309
310#endif /* #if !UCONFIG_NO_FORMATTING */
311
312#endif // _NUMBERFORMATTEST_
313