[apple/icu.git] / icuSources / test / intltest / numfmtst.h

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/************************************************************************
 * COPYRIGHT:
 * Copyright (c) 1997-2016, 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"
#include "datadrivennumberformattestsuite.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;
};


/**
 * Header for the data-driven test, powered by numberformattestspecification.txt
 */
class NumberFormatDataDrivenTest : public DataDrivenNumberFormatTestSuite {
  public:
    void runIndexedTest( int32_t index, UBool exec, const char* &name, char* par );
    void TestNumberFormatTestTuple();
    void TestDataDrivenICU4C();

  protected:
    UBool isFormatPass(
            const NumberFormatTestTuple &tuple,
            UnicodeString &appendErrorMessage,
            UErrorCode &status);
    UBool isToPatternPass(
            const NumberFormatTestTuple &tuple,
            UnicodeString &appendErrorMessage,
            UErrorCode &status);
    UBool isParsePass(
            const NumberFormatTestTuple &tuple,
            UnicodeString &appendErrorMessage,
            UErrorCode &status);
    UBool isParseCurrencyPass(
            const NumberFormatTestTuple &tuple,
            UnicodeString &appendErrorMessage,
            UErrorCode &status);
};

/**
 * 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);
    void TestLocalizedPatternSymbolCoverage();

    /**
     * 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);

    void Test20186_SpacesAroundSemicolon(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 Test20484_NarrowSymbolFallback(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 TestMismatchedCurrencyFormatFail();
    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 TestDoubleLimit11439();
    void TestFastPathConsistent11524();
    void TestGetAffixes();
    void TestToPatternScientific11648();
    void TestBenchmark();
    void TestCtorApplyPatternDifference();
    void TestFractionalDigitsForCurrency();
    void TestFormatCurrencyPlural();
    void Test11868();
    void Test11739_ParseLongCurrency();
    void Test13035_MultiCodePointPaddingInPattern();
    void Test13737_ParseScientificStrict();
    void Test10727_RoundingZero();
    void Test11376_getAndSetPositivePrefix();
    void Test11475_signRecognition();
    void Test11640_getAffixes();
    void Test11649_toPatternWithMultiCurrency();
    void Test13327_numberingSystemBufferOverflow();
    void Test13391_chakmaParsing();

    void Test11735_ExceptionIssue();
    void Test11035_FormatCurrencyAmount();
    void Test11318_DoubleConversion();
    void TestParsePercentRegression();
    void TestMultiplierWithScale();
    void TestFastFormatInt32();
    void Test11646_Equality();
    void TestParseNaN();
    void TestFormatFailIfMoreThanMaxDigits();
    void TestParseCaseSensitive();
    void TestParseNoExponent();
    void TestSignAlwaysShown();
    void TestMinimumGroupingDigits();
    void Test11897_LocalizedPatternSeparator();
    void Test13055_PercentageRounding();
    void Test11839();
    void Test10354();
    void Test11645_ApplyPatternEquality();
    void Test12567();
    void Test11626_CustomizeCurrencyPluralInfo();
    void Test20073_StrictPercentParseErrorIndex();
    void Test13056_GroupingSize();
    void Test11025_CurrencyPadding();
    void Test11648_ExpDecFormatMalPattern();
    void Test11649_DecFmtCurrencies();
    void Test13148_ParseGroupingSeparators();
    void Test12753_PatternDecimalPoint();
    void Test11647_PatternCurrencySymbols();
    void Test11913_BigDecimal();
    void Test11020_RoundingInScientificNotation();
    void Test11640_TripleCurrencySymbol();
    void Test13763_FieldPositionIteratorOffset();
    void Test13777_ParseLongNameNonCurrencyMode();
    void Test13804_EmptyStringsWhenParsing();
    void Test20037_ScientificIntegerOverflow();
    void Test13840_ParseLongStringCrash();
    void Test13850_EmptyStringCurrency();
    void Test20348_CurrencyPrefixOverride();
    void Test20358_GroupingInPattern();
    void Test13731_DefaultCurrency();
    void Test20499_CurrencyVisibleDigitsPlural();

 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_
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
729e4ab9 A	3	/************************************************************************
729e4ab9 A	4	* COPYRIGHT:
2ca993e8	5	* Copyright (c) 1997-2016, International Business Machines Corporation
729e4ab9 A	6	* and others. All Rights Reserved.
	7	************************************************************************/
	8
b75a7d8f A	9	#ifndef _NUMBERFORMATTEST_
	10	#define _NUMBERFORMATTEST_
	11
	12	#include "unicode/utypes.h"
	13
	14	#if !UCONFIG_NO_FORMATTING
	15
	16	#include "unicode/numfmt.h"
729e4ab9	17	#include "unicode/decimfmt.h"
b75a7d8f	18	#include "caltztst.h"
0f5d89e8	19	#include "datadrivennumberformattestsuite.h"
b75a7d8f	20
2ca993e8 A	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
0f5d89e8 A	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
b75a7d8f A	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)
729e4ab9	74	*/
b75a7d8f	75	void TestAPI(void);
73c04bcf A	76
73c04bcf A	77	void TestCoverage(void);
0f5d89e8	78	void TestLocalizedPatternSymbolCoverage();
73c04bcf	79
b75a7d8f A	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	**/
46f4442e	99	//void TestDigitList(void);
729e4ab9	100
3d1f044b A	101	void Test20186_SpacesAroundSemicolon(void);
3d1f044b A	102
b75a7d8f A	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
374ca955 A	129	void TestScientific2(void);
	130
	131	void TestScientificGrouping(void);
	132
	133	void TestInt64(void);
	134
b75a7d8f A	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);
729e4ab9	143
b75a7d8f	144	void TestComplexCurrency(void);
729e4ab9	145
b75a7d8f A	146	void TestPad(void);
	147	void TestPatterns2(void);
	148
	149	/**
	150	* Test currency registration.
	151	*/
	152	void TestRegCurrency(void);
	153
374ca955 A	154	void TestCurrencyNames(void);
374ca955 A	155
3d1f044b A	156	void Test20484_NarrowSymbolFallback(void);
3d1f044b A	157
73c04bcf A	158	void TestCurrencyAmount(void);
	159
	160	void TestCurrencyUnit(void);
	161
b75a7d8f A	162	void TestSymbolsWithBadLocale(void);
	163
	164	void TestAdoptDecimalFormatSymbols(void);
	165
374ca955 A	166	void TestPerMill(void);
	167
	168	void TestIllegalPatterns(void);
729e4ab9	169
374ca955 A	170	void TestCases(void);
374ca955 A	171
73c04bcf A	172	void TestJB3832(void);
	173
	174	void TestHost(void);
	175
46f4442e A	176	void TestHostClone(void);
46f4442e A	177
73c04bcf	178	void TestCurrencyFormat(void);
729e4ab9	179
46f4442e A	180	/* Port of ICU4J rounding test. */
	181	void TestRounding(void);
	182
4388f060 A	183	void TestRoundingPattern(void);
4388f060 A	184
46f4442e	185	void TestNonpositiveMultiplier(void);
729e4ab9 A	186
	187	void TestNumberingSystems();
	188
	189
	190	void TestSpaceParsing();
	191	void TestMultiCurrencySign();
	192	void TestCurrencyFormatForMixParsing();
0f5d89e8	193	void TestMismatchedCurrencyFormatFail();
729e4ab9 A	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();
4388f060 A	207	void TestExplicitParents();
	208	void TestAvailableNumberingSystems();
	209	void Test9087();
51004dcb	210	void TestFormatFastpaths();
4388f060	211
51004dcb A	212	void TestFormattableSize();
51004dcb A	213
57a6839d A	214	void TestUFormattable();
57a6839d A	215
51004dcb	216	void TestEnumSet();
729e4ab9	217
57a6839d A	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
b331163b	236	void TestCurrencyUsage();
2ca993e8	237
b331163b A	238	void TestDoubleLimit11439();
b331163b A	239	void TestFastPathConsistent11524();
2ca993e8 A	240	void TestGetAffixes();
	241	void TestToPatternScientific11648();
	242	void TestBenchmark();
	243	void TestCtorApplyPatternDifference();
	244	void TestFractionalDigitsForCurrency();
	245	void TestFormatCurrencyPlural();
	246	void Test11868();
0f5d89e8 A	247	void Test11739_ParseLongCurrency();
	248	void Test13035_MultiCodePointPaddingInPattern();
	249	void Test13737_ParseScientificStrict();
2ca993e8 A	250	void Test10727_RoundingZero();
	251	void Test11376_getAndSetPositivePrefix();
	252	void Test11475_signRecognition();
	253	void Test11640_getAffixes();
	254	void Test11649_toPatternWithMultiCurrency();
0f5d89e8 A	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();
3d1f044b A	266	void TestFormatFailIfMoreThanMaxDigits();
	267	void TestParseCaseSensitive();
	268	void TestParseNoExponent();
	269	void TestSignAlwaysShown();
	270	void TestMinimumGroupingDigits();
0f5d89e8 A	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();
3d1f044b	278	void Test20073_StrictPercentParseErrorIndex();
0f5d89e8 A	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();
3d1f044b	292	void Test20037_ScientificIntegerOverflow();
0f5d89e8	293	void Test13840_ParseLongStringCrash();
3d1f044b A	294	void Test13850_EmptyStringCurrency();
	295	void Test20348_CurrencyPrefixOverride();
	296	void Test20358_GroupingInPattern();
	297	void Test13731_DefaultCurrency();
	298	void Test20499_CurrencyVisibleDigitsPlural();
b331163b	299
b75a7d8f	300	private:
57a6839d A	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);
b75a7d8f A	304
	305	static UBool equalValue(const Formattable& a, const Formattable& b);
	306
729e4ab9 A	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
b75a7d8f A	313	void expect2(NumberFormat& fmt, const Formattable& n, const UnicodeString& str);
b75a7d8f A	314
729e4ab9 A	315	void expect3(NumberFormat& fmt, const Formattable& n, const UnicodeString& str);
729e4ab9 A	316
b75a7d8f A	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,
57a6839d A	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	}
b75a7d8f A	353
	354	void expect(NumberFormat* fmt, const Formattable& n,
	355	const char *exp, UErrorCode errorCode) {
57a6839d	356	expect(fmt, n, UnicodeString(exp, ""), TRUE, errorCode);
b75a7d8f A	357	}
	358
	359	void expectCurrency(NumberFormat& nf, const Locale& locale,
	360	double value, const UnicodeString& string);
	361
b75a7d8f A	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
73c04bcf A	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
729e4ab9 A	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
b75a7d8f A	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);
729e4ab9	404
46f4442e A	405	// internal rounding checking for TestRounding
46f4442e A	406	void checkRounding(DecimalFormat* df, double base, int iterations, double increment);
729e4ab9	407
46f4442e	408	double checkRound(DecimalFormat* df, double iValue, double lastParsed);
57a6839d A	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
2ca993e8 A	419	void verifyFieldPositionIterator(
	420	NumberFormatTest_Attributes *expected,
	421	FieldPositionIterator &iter);
	422
b75a7d8f A	423	};
	424
	425	#endif /* #if !UCONFIG_NO_FORMATTING */
729e4ab9	426
b75a7d8f	427	#endif // _NUMBERFORMATTEST_