blob: 25ef40644275e9b3e02a47403927a3a4966bbd84 [file] [log] [blame]
/************************************************************************
* 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_