| /************************************************************************ |
| * COPYRIGHT: |
| * Copyright (c) 1997-2015, International Business Machines Corporation |
| * and others. All Rights Reserved. |
| ************************************************************************/ |
| |
| #ifndef _NUMBERFORMATTEST_ |
| #define _NUMBERFORMATTEST_ |
| |
| #include "unicode/utypes.h" |
| |
| #if !UCONFIG_NO_FORMATTING |
| |
| #include "unicode/numfmt.h" |
| #include "unicode/decimfmt.h" |
| #include "caltztst.h" |
| |
| /** |
| * Expected field positions from field position iterator. Tests should |
| * stack allocate an array of these making sure that the last element is |
| * {0, -1, 0} (The sentinel element indicating end of iterator). Then test |
| * should call verifyFieldPositionIterator() passing both this array of |
| * expected results and the field position iterator from the format method. |
| */ |
| struct NumberFormatTest_Attributes { |
| int32_t id; |
| int32_t spos; |
| int32_t epos; |
| }; |
| |
| /** |
| * Performs various in-depth test on NumberFormat |
| **/ |
| class NumberFormatTest: public CalendarTimeZoneTest { |
| |
| // IntlTest override |
| void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par ); |
| public: |
| |
| /** |
| * Test APIs (to increase code coverage) |
| */ |
| void TestAPI(void); |
| |
| void TestCoverage(void); |
| |
| /** |
| * Test the handling of quotes |
| **/ |
| void TestQuotes(void); |
| /** |
| * Test patterns with exponential representation |
| **/ |
| void TestExponential(void); |
| /** |
| * Test handling of patterns with currency symbols |
| **/ |
| void TestCurrencySign(void); |
| /** |
| * Test different format patterns |
| **/ |
| void TestPatterns(void); |
| /** |
| * API coverage for DigitList |
| **/ |
| //void TestDigitList(void); |
| |
| /** |
| * Test localized currency patterns. |
| */ |
| void TestCurrency(void); |
| |
| /** |
| * Test the Currency object handling, new as of ICU 2.2. |
| */ |
| void TestCurrencyObject(void); |
| |
| void TestCurrencyPatterns(void); |
| |
| /** |
| * Do rudimentary testing of parsing. |
| */ |
| void TestParse(void); |
| /** |
| * Test proper rounding by the format method. |
| */ |
| void TestRounding487(void); |
| |
| // New tests for alphaWorks upgrade |
| void TestExponent(void); |
| |
| void TestScientific(void); |
| |
| void TestScientific2(void); |
| |
| void TestScientificGrouping(void); |
| |
| void TestInt64(void); |
| |
| void TestSurrogateSupport(void); |
| |
| /** |
| * Test the functioning of the secondary grouping value. |
| */ |
| void TestSecondaryGrouping(void); |
| |
| void TestWhiteSpaceParsing(void); |
| |
| void TestComplexCurrency(void); |
| |
| void TestPad(void); |
| void TestPatterns2(void); |
| |
| /** |
| * Test currency registration. |
| */ |
| void TestRegCurrency(void); |
| |
| void TestCurrencyNames(void); |
| |
| void TestCurrencyAmount(void); |
| |
| void TestCurrencyUnit(void); |
| |
| void TestSymbolsWithBadLocale(void); |
| |
| void TestAdoptDecimalFormatSymbols(void); |
| |
| void TestPerMill(void); |
| |
| void TestIllegalPatterns(void); |
| |
| void TestCases(void); |
| |
| void TestJB3832(void); |
| |
| void TestHost(void); |
| |
| void TestHostClone(void); |
| |
| void TestCurrencyFormat(void); |
| |
| /* Port of ICU4J rounding test. */ |
| void TestRounding(void); |
| |
| void TestRoundingPattern(void); |
| |
| void TestNonpositiveMultiplier(void); |
| |
| void TestNumberingSystems(); |
| |
| |
| void TestSpaceParsing(); |
| void TestMultiCurrencySign(); |
| void TestCurrencyFormatForMixParsing(); |
| void TestDecimalFormatCurrencyParse(); |
| void TestCurrencyIsoPluralFormat(); |
| void TestCurrencyParsing(); |
| void TestParseCurrencyInUCurr(); |
| void TestFormatAttributes(); |
| void TestFieldPositionIterator(); |
| |
| void TestLenientParse(); |
| |
| void TestDecimal(); |
| void TestCurrencyFractionDigits(); |
| |
| void TestExponentParse(); |
| void TestExplicitParents(); |
| void TestAvailableNumberingSystems(); |
| void Test9087(); |
| void TestFormatFastpaths(); |
| |
| void TestFormattableSize(); |
| |
| void TestUFormattable(); |
| |
| void TestEnumSet(); |
| |
| void TestSignificantDigits(); |
| void TestShowZero(); |
| |
| void TestCompatibleCurrencies(); |
| void TestBug9936(); |
| void TestParseNegativeWithFaLocale(); |
| void TestParseNegativeWithAlternateMinusSign(); |
| |
| void TestCustomCurrencySignAndSeparator(); |
| |
| void TestParseSignsAndMarks(); |
| void Test10419RoundingWith0FractionDigits(); |
| void Test10468ApplyPattern(); |
| void TestRoundingScientific10542(); |
| void TestZeroScientific10547(); |
| void TestAccountingCurrency(); |
| void TestEquality(); |
| |
| void TestCurrencyUsage(); |
| void TestNumberFormatTestTuple(); |
| void TestDataDriven(); |
| |
| void TestDoubleLimit11439(); |
| void TestFastPathConsistent11524(); |
| void TestGetAffixes(); |
| void TestToPatternScientific11648(); |
| void TestBenchmark(); |
| void TestCtorApplyPatternDifference(); |
| void TestFractionalDigitsForCurrency(); |
| void TestFormatCurrencyPlural(); |
| void Test11868(); |
| void Test10727_RoundingZero(); |
| void Test11376_getAndSetPositivePrefix(); |
| void Test11475_signRecognition(); |
| void Test11640_getAffixes(); |
| void Test11649_toPatternWithMultiCurrency(); |
| |
| private: |
| UBool testFormattableAsUFormattable(const char *file, int line, Formattable &f); |
| |
| void expectParseCurrency(const NumberFormat &fmt, const UChar* currency, double amount, const char *text); |
| |
| static UBool equalValue(const Formattable& a, const Formattable& b); |
| |
| void expectPositions(FieldPositionIterator& iter, int32_t *values, int32_t tupleCount, |
| const UnicodeString& str); |
| |
| void expectPosition(FieldPosition& pos, int32_t id, int32_t start, int32_t limit, |
| const UnicodeString& str); |
| |
| void expect2(NumberFormat& fmt, const Formattable& n, const UnicodeString& str); |
| |
| void expect3(NumberFormat& fmt, const Formattable& n, const UnicodeString& str); |
| |
| void expect2(NumberFormat& fmt, const Formattable& n, const char* str) { |
| expect2(fmt, n, UnicodeString(str, "")); |
| } |
| |
| void expect2(NumberFormat* fmt, const Formattable& n, const UnicodeString& str, UErrorCode ec); |
| |
| void expect2(NumberFormat* fmt, const Formattable& n, const char* str, UErrorCode ec) { |
| expect2(fmt, n, UnicodeString(str, ""), ec); |
| } |
| |
| void expect(NumberFormat& fmt, const UnicodeString& str, const Formattable& n); |
| |
| void expect(NumberFormat& fmt, const char *str, const Formattable& n) { |
| expect(fmt, UnicodeString(str, ""), n); |
| } |
| |
| void expect(NumberFormat& fmt, const Formattable& n, |
| const UnicodeString& exp, UBool rt=TRUE); |
| |
| void expect(NumberFormat& fmt, const Formattable& n, |
| const char *exp, UBool rt=TRUE) { |
| expect(fmt, n, UnicodeString(exp, ""), rt); |
| } |
| |
| void expect(NumberFormat* fmt, const Formattable& n, |
| const UnicodeString& exp, UBool rt, UErrorCode errorCode); |
| |
| void expect(NumberFormat* fmt, const Formattable& n, |
| const char *exp, UBool rt, UErrorCode errorCode) { |
| expect(fmt, n, UnicodeString(exp, ""), rt, errorCode); |
| } |
| |
| void expect(NumberFormat* fmt, const Formattable& n, |
| const UnicodeString& exp, UErrorCode errorCode) { |
| expect(fmt, n, exp, TRUE, errorCode); |
| } |
| |
| void expect(NumberFormat* fmt, const Formattable& n, |
| const char *exp, UErrorCode errorCode) { |
| expect(fmt, n, UnicodeString(exp, ""), TRUE, errorCode); |
| } |
| |
| void expectCurrency(NumberFormat& nf, const Locale& locale, |
| double value, const UnicodeString& string); |
| |
| void expectPad(DecimalFormat& fmt, const UnicodeString& pat, |
| int32_t pos, int32_t width, UChar pad); |
| |
| void expectPad(DecimalFormat& fmt, const char *pat, |
| int32_t pos, int32_t width, UChar pad) { |
| expectPad(fmt, UnicodeString(pat, ""), pos, width, pad); |
| } |
| |
| void expectPad(DecimalFormat& fmt, const UnicodeString& pat, |
| int32_t pos, int32_t width, const UnicodeString& pad); |
| |
| void expectPad(DecimalFormat& fmt, const char *pat, |
| int32_t pos, int32_t width, const UnicodeString& pad) { |
| expectPad(fmt, UnicodeString(pat, ""), pos, width, pad); |
| } |
| |
| void expectPat(DecimalFormat& fmt, const UnicodeString& exp); |
| |
| void expectPat(DecimalFormat& fmt, const char *exp) { |
| expectPat(fmt, UnicodeString(exp, "")); |
| } |
| |
| void expectPad(DecimalFormat& fmt, const UnicodeString& pat, |
| int32_t pos); |
| |
| void expectPad(DecimalFormat& fmt, const char *pat, |
| int32_t pos) { |
| expectPad(fmt, pat, pos, 0, (UChar)0); |
| } |
| |
| void expect_rbnf(NumberFormat& fmt, const UnicodeString& str, const Formattable& n); |
| |
| void expect_rbnf(NumberFormat& fmt, const Formattable& n, |
| const UnicodeString& exp, UBool rt=TRUE); |
| |
| // internal utility routine |
| static UnicodeString& escape(UnicodeString& s); |
| |
| enum { ILLEGAL = -1 }; |
| |
| // internal subtest used by TestRounding487 |
| void roundingTest(NumberFormat& nf, double x, int32_t maxFractionDigits, const char* expected); |
| |
| // internal rounding checking for TestRounding |
| void checkRounding(DecimalFormat* df, double base, int iterations, double increment); |
| |
| double checkRound(DecimalFormat* df, double iValue, double lastParsed); |
| |
| void verifyRounding( |
| DecimalFormat& format, |
| const double *values, |
| const char * const *expected, |
| const DecimalFormat::ERoundingMode *roundingModes, |
| const char * const *descriptions, |
| int32_t valueSize, |
| int32_t roundingModeSize); |
| |
| void verifyFieldPositionIterator( |
| NumberFormatTest_Attributes *expected, |
| FieldPositionIterator &iter); |
| |
| }; |
| |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |
| |
| #endif // _NUMBERFORMATTEST_ |
