blob: abd828d644bccdcdd597fd391e7315f400d65142 [file] [log] [blame]
Frank Tang3e05d9d2021-11-08 14:04:04 -08001// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/************************************************************************
4 * COPYRIGHT:
5 * Copyright (c) 1997-2016, International Business Machines Corporation
6 * and others. All Rights Reserved.
7 ************************************************************************/
8
9#ifndef _NUMBERFORMATTEST_
10#define _NUMBERFORMATTEST_
11
12#include "unicode/utypes.h"
13
14#if !UCONFIG_NO_FORMATTING
15
16#include "unicode/numfmt.h"
17#include "unicode/decimfmt.h"
18#include "caltztst.h"
19#include "datadrivennumberformattestsuite.h"
20
21/**
22 * Expected field positions from field position iterator. Tests should
23 * stack allocate an array of these making sure that the last element is
24 * {0, -1, 0} (The sentinel element indicating end of iterator). Then test
25 * should call verifyFieldPositionIterator() passing both this array of
26 * expected results and the field position iterator from the format method.
27 */
28struct NumberFormatTest_Attributes {
29 int32_t id;
30 int32_t spos;
31 int32_t epos;
32};
33
34
35/**
36 * Header for the data-driven test, powered by numberformattestspecification.txt
37 */
38class NumberFormatDataDrivenTest : public DataDrivenNumberFormatTestSuite {
39 public:
40 void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par ) override;
41 void TestNumberFormatTestTuple();
42 void TestDataDrivenICU4C();
43
44 protected:
45 UBool isFormatPass(
46 const NumberFormatTestTuple &tuple,
47 UnicodeString &appendErrorMessage,
48 UErrorCode &status) override;
49 UBool isToPatternPass(
50 const NumberFormatTestTuple &tuple,
51 UnicodeString &appendErrorMessage,
52 UErrorCode &status) override;
53 UBool isParsePass(
54 const NumberFormatTestTuple &tuple,
55 UnicodeString &appendErrorMessage,
56 UErrorCode &status) override;
57 UBool isParseCurrencyPass(
58 const NumberFormatTestTuple &tuple,
59 UnicodeString &appendErrorMessage,
60 UErrorCode &status) override;
61};
62
63/**
64 * Performs various in-depth test on NumberFormat
65 **/
66class NumberFormatTest: public CalendarTimeZoneTest {
67
68 // IntlTest override
69 void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par ) override;
70 public:
71
72 /**
73 * Test APIs (to increase code coverage)
74 */
75 void TestAPI(void);
76
77 void TestCoverage(void);
78 void TestLocalizedPatternSymbolCoverage();
79
80 /**
81 * Test the handling of quotes
82 **/
83 void TestQuotes(void);
84 /**
85 * Test patterns with exponential representation
86 **/
87 void TestExponential(void);
88 /**
89 * Test handling of patterns with currency symbols
90 **/
91 void TestCurrencySign(void);
92 /**
93 * Test different format patterns
94 **/
95 void TestPatterns(void);
96 /**
97 * API coverage for DigitList
98 **/
99 //void TestDigitList(void);
100
101 void Test20186_SpacesAroundSemicolon(void);
102
103 /**
104 * Test localized currency patterns.
105 */
106 void TestCurrency(void);
107
108 /**
109 * Test the Currency object handling, new as of ICU 2.2.
110 */
111 void TestCurrencyObject(void);
112
113 void TestCurrencyPatterns(void);
114
115 /**
116 * Do rudimentary testing of parsing.
117 */
118 void TestParse(void);
119 /**
120 * Test proper rounding by the format method.
121 */
122 void TestRounding487(void);
123
124 // New tests for alphaWorks upgrade
125 void TestExponent(void);
126
127 void TestScientific(void);
128
129 void TestScientific2(void);
130
131 void TestScientificGrouping(void);
132
133 void TestInt64(void);
134
135 void TestSurrogateSupport(void);
136
137 /**
138 * Test the functioning of the secondary grouping value.
139 */
140 void TestSecondaryGrouping(void);
141
142 void TestWhiteSpaceParsing(void);
143
144 void TestComplexCurrency(void);
145
146 void TestPad(void);
147 void TestPatterns2(void);
148
149 /**
150 * Test currency registration.
151 */
152 void TestRegCurrency(void);
153
154 void TestCurrencyNames(void);
155
156 void TestCurrencyVariants(void);
157
158 void TestCurrencyAmount(void);
159
160 void TestCurrencyUnit(void);
161
162 void TestSymbolsWithBadLocale(void);
163
164 void TestAdoptDecimalFormatSymbols(void);
165
166 void TestPerMill(void);
167
168 void TestIllegalPatterns(void);
169
170 void TestCases(void);
171
172 void TestJB3832(void);
173
174 void TestHost(void);
175
176 void TestHostClone(void);
177
178 void TestCurrencyFormat(void);
179
180 /* Port of ICU4J rounding test. */
181 void TestRounding(void);
182
183 void TestRoundingPattern(void);
184
185 void TestNonpositiveMultiplier(void);
186
187 void TestNumberingSystems();
188
189
190 void TestSpaceParsing();
191 void TestMultiCurrencySign();
192 void TestCurrencyFormatForMixParsing();
193 void TestMismatchedCurrencyFormatFail();
194 void TestDecimalFormatCurrencyParse();
195 void TestCurrencyIsoPluralFormat();
196 void TestCurrencyParsing();
197 void TestParseCurrencyInUCurr();
198 void TestFormatAttributes();
199 void TestFieldPositionIterator();
200
201 void TestLenientParse();
202
203 void TestDecimal();
204 void TestCurrencyFractionDigits();
205
206 void TestExponentParse();
207 void TestExplicitParents();
208 void TestAvailableNumberingSystems();
209 void Test9087();
210 void TestFormatFastpaths();
211
212 void TestFormattableSize();
213
214 void TestUFormattable();
215
216 void TestEnumSet();
217
218 void TestSignificantDigits();
219 void TestShowZero();
220
221 void TestCompatibleCurrencies();
222 void TestBug9936();
223 void TestParseNegativeWithFaLocale();
224 void TestParseNegativeWithAlternateMinusSign();
225
226 void TestCustomCurrencySignAndSeparator();
227
228 void TestParseSignsAndMarks();
229 void Test10419RoundingWith0FractionDigits();
230 void Test10468ApplyPattern();
231 void TestRoundingScientific10542();
232 void TestZeroScientific10547();
233 void TestAccountingCurrency();
234 void TestCurrencyFormatForMissingLocale();
235 void TestEquality();
236
237 void TestCurrencyUsage();
238
239 void TestDoubleLimit11439();
240 void TestFastPathConsistent11524();
241 void TestGetAffixes();
242 void TestToPatternScientific11648();
243 void TestBenchmark();
244 void TestCtorApplyPatternDifference();
245 void TestFractionalDigitsForCurrency();
246 void TestFormatCurrencyPlural();
247 void Test11868();
248 void Test11739_ParseLongCurrency();
249 void Test13035_MultiCodePointPaddingInPattern();
250 void Test13737_ParseScientificStrict();
251 void Test10727_RoundingZero();
252 void Test11376_getAndSetPositivePrefix();
253 void Test11475_signRecognition();
254 void Test11640_getAffixes();
255 void Test11649_toPatternWithMultiCurrency();
256 void Test13327_numberingSystemBufferOverflow();
257 void Test13391_chakmaParsing();
258
259 void Test11735_ExceptionIssue();
260 void Test11035_FormatCurrencyAmount();
261 void Test11318_DoubleConversion();
262 void TestParsePercentRegression();
263 void TestMultiplierWithScale();
264 void TestFastFormatInt32();
265 void Test11646_Equality();
266 void TestParseNaN();
267 void TestFormatFailIfMoreThanMaxDigits();
268 void TestParseCaseSensitive();
269 void TestParseNoExponent();
270 void TestSignAlwaysShown();
271 void TestMinimumGroupingDigits();
272 void Test11897_LocalizedPatternSeparator();
273 void Test13055_PercentageRounding();
274 void Test11839();
275 void Test10354();
276 void Test11645_ApplyPatternEquality();
277 void Test12567();
278 void Test11626_CustomizeCurrencyPluralInfo();
279 void Test20073_StrictPercentParseErrorIndex();
280 void Test13056_GroupingSize();
281 void Test11025_CurrencyPadding();
282 void Test11648_ExpDecFormatMalPattern();
283 void Test11649_DecFmtCurrencies();
284 void Test13148_ParseGroupingSeparators();
285 void Test12753_PatternDecimalPoint();
286 void Test11647_PatternCurrencySymbols();
287 void Test11913_BigDecimal();
288 void Test11020_RoundingInScientificNotation();
289 void Test11640_TripleCurrencySymbol();
290 void Test13763_FieldPositionIteratorOffset();
291 void Test13777_ParseLongNameNonCurrencyMode();
292 void Test13804_EmptyStringsWhenParsing();
293 void Test20037_ScientificIntegerOverflow();
294 void Test13840_ParseLongStringCrash();
295 void Test13850_EmptyStringCurrency();
296 void Test20348_CurrencyPrefixOverride();
297 void Test20956_MonetarySymbolGetters();
298 void Test20358_GroupingInPattern();
299 void Test13731_DefaultCurrency();
300 void Test20499_CurrencyVisibleDigitsPlural();
301 void Test13735_GroupingSizeGetter();
302 void Test13734_StrictFlexibleWhitespace();
303 void Test20961_CurrencyPluralPattern();
304 void Test21134_ToNumberFormatter();
305 void Test13733_StrictAndLenient();
306 void Test20425_IntegerIncrement();
307 void Test20425_FractionWithIntegerIncrement();
308 void Test21232_ParseTimeout();
309 void Test10997_FormatCurrency();
310 void Test21556_CurrencyAsDecimal();
311
312 private:
313 UBool testFormattableAsUFormattable(const char *file, int line, Formattable &f);
314
315 void expectParseCurrency(const NumberFormat &fmt, const UChar* currency, double amount, const char *text);
316
317 static UBool equalValue(const Formattable& a, const Formattable& b);
318
319 void expectPositions(FieldPositionIterator& iter, int32_t *values, int32_t tupleCount,
320 const UnicodeString& str);
321
322 void expectPosition(FieldPosition& pos, int32_t id, int32_t start, int32_t limit,
323 const UnicodeString& str);
324
325 void expect2(NumberFormat& fmt, const Formattable& n, const UnicodeString& str);
326
327 void expect3(NumberFormat& fmt, const Formattable& n, const UnicodeString& str);
328
329 void expect2(NumberFormat& fmt, const Formattable& n, const char* str) {
330 expect2(fmt, n, UnicodeString(str, ""));
331 }
332
333 void expect2(NumberFormat* fmt, const Formattable& n, const UnicodeString& str, UErrorCode ec);
334
335 void expect2(NumberFormat* fmt, const Formattable& n, const char* str, UErrorCode ec) {
336 expect2(fmt, n, UnicodeString(str, ""), ec);
337 }
338
339 void expect(NumberFormat& fmt, const UnicodeString& str, const Formattable& n);
340
341 void expect(NumberFormat& fmt, const char *str, const Formattable& n) {
342 expect(fmt, UnicodeString(str, ""), n);
343 }
344
345 void expect(NumberFormat& fmt, const Formattable& n,
346 const UnicodeString& exp, UBool rt=TRUE);
347
348 void expect(NumberFormat& fmt, const Formattable& n,
349 const char *exp, UBool rt=TRUE) {
350 expect(fmt, n, UnicodeString(exp, ""), rt);
351 }
352
353 void expect(NumberFormat* fmt, const Formattable& n,
354 const UnicodeString& exp, UBool rt, UErrorCode errorCode);
355
356 void expect(NumberFormat* fmt, const Formattable& n,
357 const char *exp, UBool rt, UErrorCode errorCode) {
358 expect(fmt, n, UnicodeString(exp, ""), rt, errorCode);
359 }
360
361 void expect(NumberFormat* fmt, const Formattable& n,
362 const UnicodeString& exp, UErrorCode errorCode) {
363 expect(fmt, n, exp, TRUE, errorCode);
364 }
365
366 void expect(NumberFormat* fmt, const Formattable& n,
367 const char *exp, UErrorCode errorCode) {
368 expect(fmt, n, UnicodeString(exp, ""), TRUE, errorCode);
369 }
370
371 void expectCurrency(NumberFormat& nf, const Locale& locale,
372 double value, const UnicodeString& string);
373
374 void expectPad(DecimalFormat& fmt, const UnicodeString& pat,
375 int32_t pos, int32_t width, UChar pad);
376
377 void expectPad(DecimalFormat& fmt, const char *pat,
378 int32_t pos, int32_t width, UChar pad) {
379 expectPad(fmt, UnicodeString(pat, ""), pos, width, pad);
380 }
381
382 void expectPad(DecimalFormat& fmt, const UnicodeString& pat,
383 int32_t pos, int32_t width, const UnicodeString& pad);
384
385 void expectPad(DecimalFormat& fmt, const char *pat,
386 int32_t pos, int32_t width, const UnicodeString& pad) {
387 expectPad(fmt, UnicodeString(pat, ""), pos, width, pad);
388 }
389
390 void expectPat(DecimalFormat& fmt, const UnicodeString& exp);
391
392 void expectPat(DecimalFormat& fmt, const char *exp) {
393 expectPat(fmt, UnicodeString(exp, ""));
394 }
395
396 void expectPad(DecimalFormat& fmt, const UnicodeString& pat,
397 int32_t pos);
398
399 void expectPad(DecimalFormat& fmt, const char *pat,
400 int32_t pos) {
401 expectPad(fmt, pat, pos, 0, (UChar)0);
402 }
403
404 void expect_rbnf(NumberFormat& fmt, const UnicodeString& str, const Formattable& n);
405
406 void expect_rbnf(NumberFormat& fmt, const Formattable& n,
407 const UnicodeString& exp, UBool rt=TRUE);
408
409 // internal utility routine
410 static UnicodeString& escape(UnicodeString& s);
411
412 enum { ILLEGAL = -1 };
413
414 // internal subtest used by TestRounding487
415 void roundingTest(NumberFormat& nf, double x, int32_t maxFractionDigits, const char* expected);
416
417 // internal rounding checking for TestRounding
418 void checkRounding(DecimalFormat* df, double base, int iterations, double increment);
419
420 double checkRound(DecimalFormat* df, double iValue, double lastParsed);
421
422 void verifyRounding(
423 DecimalFormat& format,
424 const double *values,
425 const char * const *expected,
426 const DecimalFormat::ERoundingMode *roundingModes,
427 const char * const *descriptions,
428 int32_t valueSize,
429 int32_t roundingModeSize);
430
431 void verifyFieldPositionIterator(
432 NumberFormatTest_Attributes *expected,
433 FieldPositionIterator &iter);
434
435};
436
437#endif /* #if !UCONFIG_NO_FORMATTING */
438
439#endif // _NUMBERFORMATTEST_