icuSources/test/intltest/numfmtst.h

   1 // © 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  */
  28 struct 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  */
  38 class NumberFormatDataDrivenTest : public DataDrivenNumberFormatTestSuite {
  39   public:
  40     void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par );
  41     void TestNumberFormatTestTuple();
  42     void TestDataDrivenICU4C();
  43
  44   protected:
  45     UBool isFormatPass(
  46             const NumberFormatTestTuple &tuple,
  47             UnicodeString &appendErrorMessage,
  48             UErrorCode &status);
  49     UBool isToPatternPass(
  50             const NumberFormatTestTuple &tuple,
  51             UnicodeString &appendErrorMessage,
  52             UErrorCode &status);
  53     UBool isParsePass(
  54             const NumberFormatTestTuple &tuple,
  55             UnicodeString &appendErrorMessage,
  56             UErrorCode &status);
  57     UBool isParseCurrencyPass(
  58             const NumberFormatTestTuple &tuple,
  59             UnicodeString &appendErrorMessage,
  60             UErrorCode &status);
  61 };
  62
  63 /**
  64  * Performs various in-depth test on NumberFormat
  65  **/
  66 class NumberFormatTest: public CalendarTimeZoneTest {
  67
  68     // IntlTest override
  69     void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par );
  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 Test20484_NarrowSymbolFallback(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 TestEquality();
 235
 236     void TestCurrencyUsage();
 237
 238     void TestDoubleLimit11439();
 239     void TestFastPathConsistent11524();
 240     void TestGetAffixes();
 241     void TestToPatternScientific11648();
 242     void TestBenchmark();
 243     void TestCtorApplyPatternDifference();
 244     void TestFractionalDigitsForCurrency();
 245     void TestFormatCurrencyPlural();
 246     void Test11868();
 247     void Test11739_ParseLongCurrency();
 248     void Test13035_MultiCodePointPaddingInPattern();
 249     void Test13737_ParseScientificStrict();
 250     void Test10727_RoundingZero();
 251     void Test11376_getAndSetPositivePrefix();
 252     void Test11475_signRecognition();
 253     void Test11640_getAffixes();
 254     void Test11649_toPatternWithMultiCurrency();
 255     void Test13327_numberingSystemBufferOverflow();
 256     void Test13391_chakmaParsing();
 257
 258     void Test11735_ExceptionIssue();
 259     void Test11035_FormatCurrencyAmount();
 260     void Test11318_DoubleConversion();
 261     void TestParsePercentRegression();
 262     void TestMultiplierWithScale();
 263     void TestFastFormatInt32();
 264     void Test11646_Equality();
 265     void TestParseNaN();
 266     void TestFormatFailIfMoreThanMaxDigits();
 267     void TestParseCaseSensitive();
 268     void TestParseNoExponent();
 269     void TestSignAlwaysShown();
 270     void TestMinimumGroupingDigits();
 271     void Test11897_LocalizedPatternSeparator();
 272     void Test13055_PercentageRounding();
 273     void Test11839();
 274     void Test10354();
 275     void Test11645_ApplyPatternEquality();
 276     void Test12567();
 277     void Test11626_CustomizeCurrencyPluralInfo();
 278     void Test20073_StrictPercentParseErrorIndex();
 279     void Test13056_GroupingSize();
 280     void Test11025_CurrencyPadding();
 281     void Test11648_ExpDecFormatMalPattern();
 282     void Test11649_DecFmtCurrencies();
 283     void Test13148_ParseGroupingSeparators();
 284     void Test12753_PatternDecimalPoint();
 285     void Test11647_PatternCurrencySymbols();
 286     void Test11913_BigDecimal();
 287     void Test11020_RoundingInScientificNotation();
 288     void Test11640_TripleCurrencySymbol();
 289     void Test13763_FieldPositionIteratorOffset();
 290     void Test13777_ParseLongNameNonCurrencyMode();
 291     void Test13804_EmptyStringsWhenParsing();
 292     void Test20037_ScientificIntegerOverflow();
 293     void Test13840_ParseLongStringCrash();
 294     void Test13850_EmptyStringCurrency();
 295     void Test20348_CurrencyPrefixOverride();
 296     void Test20358_GroupingInPattern();
 297     void Test13731_DefaultCurrency();
 298     void Test20499_CurrencyVisibleDigitsPlural();
 299
 300  private:
 301     UBool testFormattableAsUFormattable(const char *file, int line, Formattable &f);
 302
 303     void expectParseCurrency(const NumberFormat &fmt, const UChar* currency, double amount, const char *text);
 304
 305     static UBool equalValue(const Formattable& a, const Formattable& b);
 306
 307     void expectPositions(FieldPositionIterator& iter, int32_t *values, int32_t tupleCount,
 308                          const UnicodeString& str);
 309
 310     void expectPosition(FieldPosition& pos, int32_t id, int32_t start, int32_t limit,
 311                         const UnicodeString& str);
 312
 313     void expect2(NumberFormat& fmt, const Formattable& n, const UnicodeString& str);
 314
 315     void expect3(NumberFormat& fmt, const Formattable& n, const UnicodeString& str);
 316
 317     void expect2(NumberFormat& fmt, const Formattable& n, const char* str) {
 318         expect2(fmt, n, UnicodeString(str, ""));
 319     }
 320
 321     void expect2(NumberFormat* fmt, const Formattable& n, const UnicodeString& str, UErrorCode ec);
 322
 323     void expect2(NumberFormat* fmt, const Formattable& n, const char* str, UErrorCode ec) {
 324         expect2(fmt, n, UnicodeString(str, ""), ec);
 325     }
 326
 327     void expect(NumberFormat& fmt, const UnicodeString& str, const Formattable& n);
 328
 329     void expect(NumberFormat& fmt, const char *str, const Formattable& n) {
 330         expect(fmt, UnicodeString(str, ""), n);
 331     }
 332
 333     void expect(NumberFormat& fmt, const Formattable& n,
 334                 const UnicodeString& exp, UBool rt=TRUE);
 335
 336     void expect(NumberFormat& fmt, const Formattable& n,
 337                 const char *exp, UBool rt=TRUE) {
 338         expect(fmt, n, UnicodeString(exp, ""), rt);
 339     }
 340
 341     void expect(NumberFormat* fmt, const Formattable& n,
 342                 const UnicodeString& exp, UBool rt, UErrorCode errorCode);
 343
 344     void expect(NumberFormat* fmt, const Formattable& n,
 345                 const char *exp, UBool rt, UErrorCode errorCode) {
 346         expect(fmt, n, UnicodeString(exp, ""), rt, errorCode);
 347     }
 348
 349     void expect(NumberFormat* fmt, const Formattable& n,
 350                 const UnicodeString& exp, UErrorCode errorCode) {
 351         expect(fmt, n, exp, TRUE, errorCode);
 352     }
 353
 354     void expect(NumberFormat* fmt, const Formattable& n,
 355                 const char *exp, UErrorCode errorCode) {
 356         expect(fmt, n, UnicodeString(exp, ""), TRUE, errorCode);
 357     }
 358
 359     void expectCurrency(NumberFormat& nf, const Locale& locale,
 360                         double value, const UnicodeString& string);
 361
 362     void expectPad(DecimalFormat& fmt, const UnicodeString& pat,
 363                    int32_t pos, int32_t width, UChar pad);
 364
 365     void expectPad(DecimalFormat& fmt, const char *pat,
 366                    int32_t pos, int32_t width, UChar pad) {
 367         expectPad(fmt, UnicodeString(pat, ""), pos, width, pad);
 368     }
 369
 370     void expectPad(DecimalFormat& fmt, const UnicodeString& pat,
 371                    int32_t pos, int32_t width, const UnicodeString& pad);
 372
 373     void expectPad(DecimalFormat& fmt, const char *pat,
 374                    int32_t pos, int32_t width, const UnicodeString& pad) {
 375         expectPad(fmt, UnicodeString(pat, ""), pos, width, pad);
 376     }
 377
 378     void expectPat(DecimalFormat& fmt, const UnicodeString& exp);
 379
 380     void expectPat(DecimalFormat& fmt, const char *exp) {
 381         expectPat(fmt, UnicodeString(exp, ""));
 382     }
 383
 384     void expectPad(DecimalFormat& fmt, const UnicodeString& pat,
 385                    int32_t pos);
 386
 387     void expectPad(DecimalFormat& fmt, const char *pat,
 388                    int32_t pos) {
 389         expectPad(fmt, pat, pos, 0, (UChar)0);
 390     }
 391
 392     void expect_rbnf(NumberFormat& fmt, const UnicodeString& str, const Formattable& n);
 393
 394     void expect_rbnf(NumberFormat& fmt, const Formattable& n,
 395                 const UnicodeString& exp, UBool rt=TRUE);
 396
 397     // internal utility routine
 398     static UnicodeString& escape(UnicodeString& s);
 399
 400     enum { ILLEGAL = -1 };
 401
 402     // internal subtest used by TestRounding487
 403     void roundingTest(NumberFormat& nf, double x, int32_t maxFractionDigits, const char* expected);
 404
 405     // internal rounding checking for TestRounding
 406     void checkRounding(DecimalFormat* df, double base, int iterations, double increment);
 407
 408     double checkRound(DecimalFormat* df, double iValue, double lastParsed);
 409
 410     void verifyRounding(
 411         DecimalFormat& format,
 412         const double *values,
 413         const char * const *expected,
 414         const DecimalFormat::ERoundingMode *roundingModes,
 415         const char * const *descriptions,
 416         int32_t valueSize,
 417         int32_t roundingModeSize);
 418
 419     void verifyFieldPositionIterator(
 420             NumberFormatTest_Attributes *expected,
 421             FieldPositionIterator &iter);
 422
 423 };
 424
 425 #endif /* #if !UCONFIG_NO_FORMATTING */
 426
 427 #endif // _NUMBERFORMATTEST_