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