[apple/icu.git] / icuSources / test / intltest / dcfmapts.cpp

/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2013, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/

#include "unicode/utypes.h"

#if !UCONFIG_NO_FORMATTING

#include "dcfmapts.h"

#include "unicode/decimfmt.h"
#include "unicode/dcfmtsym.h"
#include "unicode/parseerr.h"
#include "unicode/currpinf.h"

// This is an API test, not a unit test.  It doesn't test very many cases, and doesn't
// try to test the full functionality.  It just calls each function in the class and
// verifies that it works on a basic level.

void IntlTestDecimalFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
{
    if (exec) logln((UnicodeString)"TestSuite DecimalFormatAPI");
    switch (index) {
        case 0: name = "DecimalFormat API test"; 
                if (exec) {
                    logln((UnicodeString)"DecimalFormat API test---"); logln((UnicodeString)"");
                    UErrorCode status = U_ZERO_ERROR;
                    Locale saveLocale;
                    Locale::setDefault(Locale::getEnglish(), status);
                    if(U_FAILURE(status)) {
                        errln((UnicodeString)"ERROR: Could not set default locale, test may not give correct results");
                    }
                    testAPI(/*par*/);
                    Locale::setDefault(saveLocale, status);
                }
                break;
        case 1: name = "Rounding test";
            if(exec) {
               logln((UnicodeString)"DecimalFormat Rounding test---");
               testRounding(/*par*/);
            }
            break;
        case 2: name = "Test6354";
            if(exec) {
               logln((UnicodeString)"DecimalFormat Rounding Increment test---");
               testRoundingInc(/*par*/);
            }
            break;
        case 3: name = "TestCurrencyPluralInfo";
            if(exec) {
               logln((UnicodeString)"CurrencyPluralInfo API test---");
               TestCurrencyPluralInfo();
            }
            break;
        case 4: name = "TestScale";
            if(exec) {
               logln((UnicodeString)"Scale test---");
               TestScale();
            }
            break;
        default: name = ""; break;
    }
}

/**
 * This test checks various generic API methods in DecimalFormat to achieve 100%
 * API coverage.
 */
void IntlTestDecimalFormatAPI::testAPI(/*char *par*/)
{
    UErrorCode status = U_ZERO_ERROR;

// ======= Test constructors

    logln((UnicodeString)"Testing DecimalFormat constructors");

    DecimalFormat def(status);
    if(U_FAILURE(status)) {
        errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
        return;
    }

    status = U_ZERO_ERROR;
    const UnicodeString pattern("#,##0.# FF");
    DecimalFormat pat(pattern, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern)");
        return;
    }

    status = U_ZERO_ERROR;
    DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getFrench(), status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: Could not create DecimalFormatSymbols (French)");
        return;
    }

    status = U_ZERO_ERROR;
    DecimalFormat cust1(pattern, symbols, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols*)");
    }

    status = U_ZERO_ERROR;
    DecimalFormat cust2(pattern, *symbols, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols)");
    }

    DecimalFormat copy(pat);

// ======= Test clone(), assignment, and equality

    logln((UnicodeString)"Testing clone(), assignment and equality operators");

    if( ! (copy == pat) || copy != pat) {
        errln((UnicodeString)"ERROR: Copy constructor or == failed");
    }

    copy = cust1;
    if(copy != cust1) {
        errln((UnicodeString)"ERROR: Assignment (or !=) failed");
    }

    Format *clone = def.clone();
    if( ! (*clone == def) ) {
        errln((UnicodeString)"ERROR: Clone() failed");
    }
    delete clone;

// ======= Test various format() methods

    logln((UnicodeString)"Testing various format() methods");

    double d = -10456.0037;
    int32_t l = 100000000;
    Formattable fD(d);
    Formattable fL(l);

    UnicodeString res1, res2, res3, res4;
    FieldPosition pos1(0), pos2(0), pos3(0), pos4(0);
    
    res1 = def.format(d, res1, pos1);
    logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1);

    res2 = pat.format(l, res2, pos2);
    logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2);

    status = U_ZERO_ERROR;
    res3 = cust1.format(fD, res3, pos3, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: format(Formattable [double]) failed");
    }
    logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res3);

    status = U_ZERO_ERROR;
    res4 = cust2.format(fL, res4, pos4, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: format(Formattable [long]) failed");
    }
    logln((UnicodeString) "" + fL.getLong() + " formatted to " + res4);

// ======= Test parse()

    logln((UnicodeString)"Testing parse()");

    UnicodeString text("-10,456.0037");
    Formattable result1, result2;
    ParsePosition pos(0);
    UnicodeString patt("#,##0.#");
    status = U_ZERO_ERROR;
    pat.applyPattern(patt, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: applyPattern() failed");
    }
    pat.parse(text, result1, pos);
    if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) {
        errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
    }
    logln(text + " parsed into " + (int32_t) result1.getDouble());

    status = U_ZERO_ERROR;
    pat.parse(text, result2, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: parse() failed");
    }
    if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) {
        errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
    }
    logln(text + " parsed into " + (int32_t) result2.getDouble());

// ======= Test getters and setters

    logln((UnicodeString)"Testing getters and setters");

    const DecimalFormatSymbols *syms = pat.getDecimalFormatSymbols();
    DecimalFormatSymbols *newSyms = new DecimalFormatSymbols(*syms);
    def.setDecimalFormatSymbols(*newSyms);
    def.adoptDecimalFormatSymbols(newSyms); // don't use newSyms after this
    if( *(pat.getDecimalFormatSymbols()) != *(def.getDecimalFormatSymbols())) {
        errln((UnicodeString)"ERROR: adopt or set DecimalFormatSymbols() failed");
    }

    UnicodeString posPrefix;
    pat.setPositivePrefix("+");
    posPrefix = pat.getPositivePrefix(posPrefix);
    logln((UnicodeString)"Positive prefix (should be +): " + posPrefix);
    if(posPrefix != "+") {
        errln((UnicodeString)"ERROR: setPositivePrefix() failed");
    }

    UnicodeString negPrefix;
    pat.setNegativePrefix("-");
    negPrefix = pat.getNegativePrefix(negPrefix);
    logln((UnicodeString)"Negative prefix (should be -): " + negPrefix);
    if(negPrefix != "-") {
        errln((UnicodeString)"ERROR: setNegativePrefix() failed");
    }

    UnicodeString posSuffix;
    pat.setPositiveSuffix("_");
    posSuffix = pat.getPositiveSuffix(posSuffix);
    logln((UnicodeString)"Positive suffix (should be _): " + posSuffix);
    if(posSuffix != "_") {
        errln((UnicodeString)"ERROR: setPositiveSuffix() failed");
    }

    UnicodeString negSuffix;
    pat.setNegativeSuffix("~");
    negSuffix = pat.getNegativeSuffix(negSuffix);
    logln((UnicodeString)"Negative suffix (should be ~): " + negSuffix);
    if(negSuffix != "~") {
        errln((UnicodeString)"ERROR: setNegativeSuffix() failed");
    }

    int32_t multiplier = 0;
    pat.setMultiplier(8);
    multiplier = pat.getMultiplier();
    logln((UnicodeString)"Multiplier (should be 8): " + multiplier);
    if(multiplier != 8) {
        errln((UnicodeString)"ERROR: setMultiplier() failed");
    }

    int32_t groupingSize = 0;
    pat.setGroupingSize(2);
    groupingSize = pat.getGroupingSize();
    logln((UnicodeString)"Grouping size (should be 2): " + (int32_t) groupingSize);
    if(groupingSize != 2) {
        errln((UnicodeString)"ERROR: setGroupingSize() failed");
    }

    pat.setDecimalSeparatorAlwaysShown(TRUE);
    UBool tf = pat.isDecimalSeparatorAlwaysShown();
    logln((UnicodeString)"DecimalSeparatorIsAlwaysShown (should be TRUE) is " + (UnicodeString) (tf ? "TRUE" : "FALSE"));
    if(tf != TRUE) {
        errln((UnicodeString)"ERROR: setDecimalSeparatorAlwaysShown() failed");
    }
    // Added by Ken Liu testing set/isExponentSignAlwaysShown
    pat.setExponentSignAlwaysShown(TRUE);
    UBool esas = pat.isExponentSignAlwaysShown();
    logln((UnicodeString)"ExponentSignAlwaysShown (should be TRUE) is " + (UnicodeString) (esas ? "TRUE" : "FALSE"));
    if(esas != TRUE) {
        errln((UnicodeString)"ERROR: ExponentSignAlwaysShown() failed");
    }

    // Added by Ken Liu testing set/isScientificNotation
    pat.setScientificNotation(TRUE);
    UBool sn = pat.isScientificNotation();
    logln((UnicodeString)"isScientificNotation (should be TRUE) is " + (UnicodeString) (sn ? "TRUE" : "FALSE"));
    if(sn != TRUE) {
        errln((UnicodeString)"ERROR: setScientificNotation() failed");
    }
    
    // Added by Ken Liu testing set/getMinimumExponentDigits
    int8_t MinimumExponentDigits = 0;
    pat.setMinimumExponentDigits(2);
    MinimumExponentDigits = pat.getMinimumExponentDigits();
    logln((UnicodeString)"MinimumExponentDigits (should be 2) is " + (int8_t) MinimumExponentDigits);
    if(MinimumExponentDigits != 2) {
        errln((UnicodeString)"ERROR: setMinimumExponentDigits() failed");
    }

    // Added by Ken Liu testing set/getRoundingIncrement
    double RoundingIncrement = 0.0;
    pat.setRoundingIncrement(2.0);
    RoundingIncrement = pat.getRoundingIncrement();
    logln((UnicodeString)"RoundingIncrement (should be 2.0) is " + (double) RoundingIncrement);
    if(RoundingIncrement != 2.0) {
        errln((UnicodeString)"ERROR: setRoundingIncrement() failed");
    }
    //end of Ken's Adding

    UnicodeString funkyPat;
    funkyPat = pat.toPattern(funkyPat);
    logln((UnicodeString)"Pattern is " + funkyPat);

    UnicodeString locPat;
    locPat = pat.toLocalizedPattern(locPat);
    logln((UnicodeString)"Localized pattern is " + locPat);

// ======= Test applyPattern()

    logln((UnicodeString)"Testing applyPattern()");

    UnicodeString p1("#,##0.0#;(#,##0.0#)");
    logln((UnicodeString)"Applying pattern " + p1);
    status = U_ZERO_ERROR;
    pat.applyPattern(p1, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
    }
    UnicodeString s2;
    s2 = pat.toPattern(s2);
    logln((UnicodeString)"Extracted pattern is " + s2);
    if(s2 != p1) {
        errln((UnicodeString)"ERROR: toPattern() result did not match pattern applied");
    }

    if(pat.getSecondaryGroupingSize() != 0) {
        errln("FAIL: Secondary Grouping Size should be 0, not %d\n", pat.getSecondaryGroupingSize());
    }

    if(pat.getGroupingSize() != 3) {
        errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
    }

    UnicodeString p2("#,##,##0.0# FF;(#,##,##0.0# FF)");
    logln((UnicodeString)"Applying pattern " + p2);
    status = U_ZERO_ERROR;
    pat.applyLocalizedPattern(p2, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
    }
    UnicodeString s3;
    s3 = pat.toLocalizedPattern(s3);
    logln((UnicodeString)"Extracted pattern is " + s3);
    if(s3 != p2) {
        errln((UnicodeString)"ERROR: toLocalizedPattern() result did not match pattern applied");
    }

    status = U_ZERO_ERROR;
    UParseError pe;
    pat.applyLocalizedPattern(p2, pe, status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: applyPattern((with ParseError)) failed with " + (int32_t) status);
    }
    UnicodeString s4;
    s4 = pat.toLocalizedPattern(s3);
    logln((UnicodeString)"Extracted pattern is " + s4);
    if(s4 != p2) {
        errln((UnicodeString)"ERROR: toLocalizedPattern(with ParseErr) result did not match pattern applied");
    }

    if(pat.getSecondaryGroupingSize() != 2) {
        errln("FAIL: Secondary Grouping Size should be 2, not %d\n", pat.getSecondaryGroupingSize());
    }

    if(pat.getGroupingSize() != 3) {
        errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
    }

// ======= Test getStaticClassID()

    logln((UnicodeString)"Testing getStaticClassID()");

    status = U_ZERO_ERROR;
    NumberFormat *test = new DecimalFormat(status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: Couldn't create a DecimalFormat");
    }

    if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) {
        errln((UnicodeString)"ERROR: getDynamicClassID() didn't return the expected value");
    }

    delete test;
}

void IntlTestDecimalFormatAPI::TestCurrencyPluralInfo(){
    UErrorCode status = U_ZERO_ERROR;

    CurrencyPluralInfo *cpi = new CurrencyPluralInfo(status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: CurrencyPluralInfo(UErrorCode) could not be created");
    }

    CurrencyPluralInfo cpi1 = *cpi;

    if(cpi->getDynamicClassID() != CurrencyPluralInfo::getStaticClassID()){
        errln((UnicodeString)"ERROR: CurrencyPluralInfo::getDynamicClassID() didn't return the expected value");
    }

    cpi->setCurrencyPluralPattern("","",status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: CurrencyPluralInfo::setCurrencyPluralPattern");
    }

    cpi->setLocale(Locale::getCanada(), status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: CurrencyPluralInfo::setLocale");
    }
    
    cpi->setPluralRules("",status);
    if(U_FAILURE(status)) {
        errln((UnicodeString)"ERROR: CurrencyPluralInfo::setPluralRules");
    }

    DecimalFormat *df = new DecimalFormat(status);
    if(U_FAILURE(status)) {
        errcheckln(status, "ERROR: Could not create DecimalFormat - %s", u_errorName(status));
    }

    df->adoptCurrencyPluralInfo(cpi);

    df->getCurrencyPluralInfo();

    df->setCurrencyPluralInfo(cpi1);

    delete df;
}

void IntlTestDecimalFormatAPI::testRounding(/*char *par*/)
{
    UErrorCode status = U_ZERO_ERROR;
    double Roundingnumber = 2.55;
    double Roundingnumber1 = -2.55;
                      //+2.55 results   -2.55 results
    double result[]={   3.0,            -2.0,    //  kRoundCeiling  0,
                        2.0,            -3.0,    //  kRoundFloor    1,
                        2.0,            -2.0,    //  kRoundDown     2,
                        3.0,            -3.0,    //  kRoundUp       3,
                        3.0,            -3.0,    //  kRoundHalfEven 4,
                        3.0,            -3.0,    //  kRoundHalfDown 5,
                        3.0,            -3.0     //  kRoundHalfUp   6 
    };
    DecimalFormat pat(status);
    if(U_FAILURE(status)) {
      errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
      return;
    }
    uint16_t mode;
    uint16_t i=0;
    UnicodeString message;
    UnicodeString resultStr;
    for(mode=0;mode < 7;mode++){
        pat.setRoundingMode((DecimalFormat::ERoundingMode)mode);
        if(pat.getRoundingMode() != (DecimalFormat::ERoundingMode)mode){
            errln((UnicodeString)"SetRoundingMode or GetRoundingMode failed for mode=" + mode);
        }


        //for +2.55 with RoundingIncrement=1.0
        pat.setRoundingIncrement(1.0);
        pat.format(Roundingnumber, resultStr);
        message= (UnicodeString)"Round() failed:  round(" + (double)Roundingnumber + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=1.0==>");
        verify(message, resultStr, result[i++]);
        message.remove();
        resultStr.remove();

        //for -2.55 with RoundingIncrement=1.0
        pat.format(Roundingnumber1, resultStr);
        message= (UnicodeString)"Round() failed:  round(" + (double)Roundingnumber1 + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=1.0==>");
        verify(message, resultStr, result[i++]);
        message.remove();
        resultStr.remove();
    }

}
void IntlTestDecimalFormatAPI::verify(const UnicodeString& message, const UnicodeString& got, double expected){
    logln((UnicodeString)message + got + (UnicodeString)" Expected : " + expected);
    UnicodeString expectedStr("");
    expectedStr=expectedStr + expected;
    if(got != expectedStr ) {
            errln((UnicodeString)"ERROR: " + message + got + (UnicodeString)"  Expected : " + expectedStr);
        }
}

void IntlTestDecimalFormatAPI::verifyString(const UnicodeString& message, const UnicodeString& got, UnicodeString& expected){
    logln((UnicodeString)message + got + (UnicodeString)" Expected : " + expected);
    if(got != expected ) {
            errln((UnicodeString)"ERROR: " + message + got + (UnicodeString)"  Expected : " + expected);
        }
}

void IntlTestDecimalFormatAPI::testRoundingInc(/*char *par*/)
{
    UErrorCode status = U_ZERO_ERROR;
    DecimalFormat pat(UnicodeString("#,##0.00"),status);
    if(U_FAILURE(status)) {
      errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
      return;
    }

    // get default rounding increment
    double roundingInc = pat.getRoundingIncrement();
    if (roundingInc != 0.0) {
      errln((UnicodeString)"ERROR: Rounding increment not zero");
      return;
    }

    // With rounding now being handled by decNumber, we no longer 
    // set a rounding increment to enable non-default mode rounding,
    // checking of which was the original point of this test.

    // set rounding mode with zero increment.  Rounding 
    // increment should not be set by this operation
    pat.setRoundingMode((DecimalFormat::ERoundingMode)0);
    roundingInc = pat.getRoundingIncrement();
    if (roundingInc != 0.0) {
      errln((UnicodeString)"ERROR: Rounding increment not zero after setRoundingMode");
      return;
    }
}

void IntlTestDecimalFormatAPI::TestScale()
{
    typedef struct TestData {
        double inputValue;
        int inputScale;
        char *expectedOutput;
    } TestData;

    static TestData testData[] = {
        { 100.0, 3,  "100,000" },
        { 10034.0, -2, "100.34" },
        { 0.86, -3, "0.0009" },
        { -0.000455, 1, "-0%" },
        { -0.000555, 1, "-1%" },
        { 0.000455, 1, "0%" },
        { 0.000555, 1, "1%" },
    };

    UErrorCode status = U_ZERO_ERROR;
    DecimalFormat pat(status);
    if(U_FAILURE(status)) {
      errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
      return;
    }

    UnicodeString message;
    UnicodeString resultStr;
    UnicodeString exp;
    UnicodeString percentPattern("#,##0%");
    pat.setMaximumFractionDigits(4);

    for(int32_t i=0;i < sizeof(testData)/sizeof(testData[0]);i++) {
        if ( i > 2 ) {
            pat.applyPattern(percentPattern,status);
        }
        pat.setAttribute(UNUM_SCALE,testData[i].inputScale,status);
        pat.format(testData[i].inputValue, resultStr);
        message = UnicodeString("Unexpected output for ") + testData[i].inputValue + UnicodeString(" and scale ") + testData[i].inputScale + UnicodeString(". Got: ");
        exp = testData[i].expectedOutput;
        verifyString(message, resultStr, exp);
        message.remove();
        resultStr.remove();
        exp.remove();
    }
}
#endif /* #if !UCONFIG_NO_FORMATTING */
Commit	Line	Data
b75a7d8f A	1	/********************************************************************
b75a7d8f A	2	* COPYRIGHT:
51004dcb	3	* Copyright (c) 1997-2013, International Business Machines Corporation and
b75a7d8f A	4	* others. All Rights Reserved.
	5	********************************************************************/
	6
	7	#include "unicode/utypes.h"
	8
	9	#if !UCONFIG_NO_FORMATTING
	10
	11	#include "dcfmapts.h"
	12
	13	#include "unicode/decimfmt.h"
	14	#include "unicode/dcfmtsym.h"
	15	#include "unicode/parseerr.h"
729e4ab9	16	#include "unicode/currpinf.h"
b75a7d8f A	17
	18	// This is an API test, not a unit test. It doesn't test very many cases, and doesn't
	19	// try to test the full functionality. It just calls each function in the class and
	20	// verifies that it works on a basic level.
	21
	22	void IntlTestDecimalFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /par/ )
	23	{
	24	if (exec) logln((UnicodeString)"TestSuite DecimalFormatAPI");
	25	switch (index) {
	26	case 0: name = "DecimalFormat API test";
	27	if (exec) {
	28	logln((UnicodeString)"DecimalFormat API test---"); logln((UnicodeString)"");
	29	UErrorCode status = U_ZERO_ERROR;
73c04bcf	30	Locale saveLocale;
b75a7d8f A	31	Locale::setDefault(Locale::getEnglish(), status);
	32	if(U_FAILURE(status)) {
	33	errln((UnicodeString)"ERROR: Could not set default locale, test may not give correct results");
	34	}
	35	testAPI(/par/);
73c04bcf	36	Locale::setDefault(saveLocale, status);
b75a7d8f A	37	}
	38	break;
	39	case 1: name = "Rounding test";
	40	if(exec) {
	41	logln((UnicodeString)"DecimalFormat Rounding test---");
	42	testRounding(/par/);
	43	}
	44	break;
729e4ab9 A	45	case 2: name = "Test6354";
	46	if(exec) {
	47	logln((UnicodeString)"DecimalFormat Rounding Increment test---");
	48	testRoundingInc(/par/);
	49	}
	50	break;
	51	case 3: name = "TestCurrencyPluralInfo";
	52	if(exec) {
	53	logln((UnicodeString)"CurrencyPluralInfo API test---");
	54	TestCurrencyPluralInfo();
	55	}
	56	break;
51004dcb A	57	case 4: name = "TestScale";
	58	if(exec) {
	59	logln((UnicodeString)"Scale test---");
	60	TestScale();
	61	}
	62	break;
b75a7d8f A	63	default: name = ""; break;
	64	}
	65	}
	66
	67	/**
	68	* This test checks various generic API methods in DecimalFormat to achieve 100%
	69	* API coverage.
	70	*/
	71	void IntlTestDecimalFormatAPI::testAPI(/char par*/)
	72	{
	73	UErrorCode status = U_ZERO_ERROR;
	74
	75	// ======= Test constructors
	76
	77	logln((UnicodeString)"Testing DecimalFormat constructors");
	78
	79	DecimalFormat def(status);
	80	if(U_FAILURE(status)) {
729e4ab9	81	errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
b75a7d8f A	82	return;
	83	}
	84
	85	status = U_ZERO_ERROR;
	86	const UnicodeString pattern("#,##0.# FF");
	87	DecimalFormat pat(pattern, status);
	88	if(U_FAILURE(status)) {
	89	errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern)");
	90	return;
	91	}
	92
	93	status = U_ZERO_ERROR;
	94	DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getFrench(), status);
	95	if(U_FAILURE(status)) {
	96	errln((UnicodeString)"ERROR: Could not create DecimalFormatSymbols (French)");
	97	return;
	98	}
	99
	100	status = U_ZERO_ERROR;
	101	DecimalFormat cust1(pattern, symbols, status);
	102	if(U_FAILURE(status)) {
	103	errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols*)");
	104	}
	105
	106	status = U_ZERO_ERROR;
	107	DecimalFormat cust2(pattern, *symbols, status);
	108	if(U_FAILURE(status)) {
	109	errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols)");
	110	}
	111
	112	DecimalFormat copy(pat);
	113
	114	// ======= Test clone(), assignment, and equality
	115
	116	logln((UnicodeString)"Testing clone(), assignment and equality operators");
	117
	118	if( ! (copy == pat) \|\| copy != pat) {
	119	errln((UnicodeString)"ERROR: Copy constructor or == failed");
	120	}
	121
	122	copy = cust1;
	123	if(copy != cust1) {
	124	errln((UnicodeString)"ERROR: Assignment (or !=) failed");
	125	}
	126
	127	Format *clone = def.clone();
	128	if( ! (*clone == def) ) {
	129	errln((UnicodeString)"ERROR: Clone() failed");
	130	}
	131	delete clone;
	132
	133	// ======= Test various format() methods
	134
	135	logln((UnicodeString)"Testing various format() methods");
	136
	137	double d = -10456.0037;
	138	int32_t l = 100000000;
	139	Formattable fD(d);
	140	Formattable fL(l);
	141
	142	UnicodeString res1, res2, res3, res4;
	143	FieldPosition pos1(0), pos2(0), pos3(0), pos4(0);
	144
	145	res1 = def.format(d, res1, pos1);
146	logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1);
147
148	res2 = pat.format(l, res2, pos2);
149	logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2);
150
151	status = U_ZERO_ERROR;
152	res3 = cust1.format(fD, res3, pos3, status);
153	if(U_FAILURE(status)) {
154	errln((UnicodeString)"ERROR: format(Formattable [double]) failed");
155	}
156	logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res3);
157
158	status = U_ZERO_ERROR;
159	res4 = cust2.format(fL, res4, pos4, status);
160	if(U_FAILURE(status)) {
161	errln((UnicodeString)"ERROR: format(Formattable [long]) failed");
162	}
163	logln((UnicodeString) "" + fL.getLong() + " formatted to " + res4);
164
165	// ======= Test parse()
166
167	logln((UnicodeString)"Testing parse()");
168
169	UnicodeString text("-10,456.0037");
170	Formattable result1, result2;
171	ParsePosition pos(0);
172	UnicodeString patt("#,##0.#");
173	status = U_ZERO_ERROR;
174	pat.applyPattern(patt, status);
175	if(U_FAILURE(status)) {
176	errln((UnicodeString)"ERROR: applyPattern() failed");
177	}
178	pat.parse(text, result1, pos);
179	if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) {
180	errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
181	}
182	logln(text + " parsed into " + (int32_t) result1.getDouble());
183
184	status = U_ZERO_ERROR;
185	pat.parse(text, result2, status);
186	if(U_FAILURE(status)) {
187	errln((UnicodeString)"ERROR: parse() failed");
188	}
189	if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) {
190	errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
191	}
192	logln(text + " parsed into " + (int32_t) result2.getDouble());
193
194	// ======= Test getters and setters
195
196	logln((UnicodeString)"Testing getters and setters");
197
198	const DecimalFormatSymbols *syms = pat.getDecimalFormatSymbols();
199	DecimalFormatSymbols newSyms = new DecimalFormatSymbols(syms);
200	def.setDecimalFormatSymbols(*newSyms);
201	def.adoptDecimalFormatSymbols(newSyms); // don't use newSyms after this
202	if( (pat.getDecimalFormatSymbols()) != (def.getDecimalFormatSymbols())) {
203	errln((UnicodeString)"ERROR: adopt or set DecimalFormatSymbols() failed");
204	}
205
206	UnicodeString posPrefix;
207	pat.setPositivePrefix("+");
208	posPrefix = pat.getPositivePrefix(posPrefix);
209	logln((UnicodeString)"Positive prefix (should be +): " + posPrefix);
210	if(posPrefix != "+") {
211	errln((UnicodeString)"ERROR: setPositivePrefix() failed");
212	}
213
214	UnicodeString negPrefix;
215	pat.setNegativePrefix("-");
216	negPrefix = pat.getNegativePrefix(negPrefix);
217	logln((UnicodeString)"Negative prefix (should be -): " + negPrefix);
218	if(negPrefix != "-") {
219	errln((UnicodeString)"ERROR: setNegativePrefix() failed");
220	}
221
222	UnicodeString posSuffix;
223	pat.setPositiveSuffix("_");
224	posSuffix = pat.getPositiveSuffix(posSuffix);
225	logln((UnicodeString)"Positive suffix (should be _): " + posSuffix);
226	if(posSuffix != "_") {
227	errln((UnicodeString)"ERROR: setPositiveSuffix() failed");
228	}
229
230	UnicodeString negSuffix;
231	pat.setNegativeSuffix("~");
232	negSuffix = pat.getNegativeSuffix(negSuffix);
233	logln((UnicodeString)"Negative suffix (should be ~): " + negSuffix);
234	if(negSuffix != "~") {
235	errln((UnicodeString)"ERROR: setNegativeSuffix() failed");
236	}
237
238	int32_t multiplier = 0;
239	pat.setMultiplier(8);
240	multiplier = pat.getMultiplier();
241	logln((UnicodeString)"Multiplier (should be 8): " + multiplier);
242	if(multiplier != 8) {
243	errln((UnicodeString)"ERROR: setMultiplier() failed");
244	}
245
246	int32_t groupingSize = 0;
247	pat.setGroupingSize(2);
248	groupingSize = pat.getGroupingSize();
249	logln((UnicodeString)"Grouping size (should be 2): " + (int32_t) groupingSize);
250	if(groupingSize != 2) {
251	errln((UnicodeString)"ERROR: setGroupingSize() failed");
252	}
253
254	pat.setDecimalSeparatorAlwaysShown(TRUE);
255	UBool tf = pat.isDecimalSeparatorAlwaysShown();
256	logln((UnicodeString)"DecimalSeparatorIsAlwaysShown (should be TRUE) is " + (UnicodeString) (tf ? "TRUE" : "FALSE"));
257	if(tf != TRUE) {
258	errln((UnicodeString)"ERROR: setDecimalSeparatorAlwaysShown() failed");
259	}
260	// Added by Ken Liu testing set/isExponentSignAlwaysShown
261	pat.setExponentSignAlwaysShown(TRUE);
262	UBool esas = pat.isExponentSignAlwaysShown();
263	logln((UnicodeString)"ExponentSignAlwaysShown (should be TRUE) is " + (UnicodeString) (esas ? "TRUE" : "FALSE"));
264	if(esas != TRUE) {
265	errln((UnicodeString)"ERROR: ExponentSignAlwaysShown() failed");
266	}
267
268	// Added by Ken Liu testing set/isScientificNotation
269	pat.setScientificNotation(TRUE);
270	UBool sn = pat.isScientificNotation();
271	logln((UnicodeString)"isScientificNotation (should be TRUE) is " + (UnicodeString) (sn ? "TRUE" : "FALSE"));
272	if(sn != TRUE) {
273	errln((UnicodeString)"ERROR: setScientificNotation() failed");
274	}
275
276	// Added by Ken Liu testing set/getMinimumExponentDigits
277	int8_t MinimumExponentDigits = 0;
278	pat.setMinimumExponentDigits(2);
279	MinimumExponentDigits = pat.getMinimumExponentDigits();
280	logln((UnicodeString)"MinimumExponentDigits (should be 2) is " + (int8_t) MinimumExponentDigits);
281	if(MinimumExponentDigits != 2) {
282	errln((UnicodeString)"ERROR: setMinimumExponentDigits() failed");
283	}
284
285	// Added by Ken Liu testing set/getRoundingIncrement
286	double RoundingIncrement = 0.0;
287	pat.setRoundingIncrement(2.0);
288	RoundingIncrement = pat.getRoundingIncrement();
289	logln((UnicodeString)"RoundingIncrement (should be 2.0) is " + (double) RoundingIncrement);
290	if(RoundingIncrement != 2.0) {
291	errln((UnicodeString)"ERROR: setRoundingIncrement() failed");
292	}
293	//end of Ken's Adding
294
295	UnicodeString funkyPat;
296	funkyPat = pat.toPattern(funkyPat);
297	logln((UnicodeString)"Pattern is " + funkyPat);
298
299	UnicodeString locPat;
300	locPat = pat.toLocalizedPattern(locPat);
301	logln((UnicodeString)"Localized pattern is " + locPat);
302
303	// ======= Test applyPattern()
304
305	logln((UnicodeString)"Testing applyPattern()");
306
307	UnicodeString p1("#,##0.0#;(#,##0.0#)");
308	logln((UnicodeString)"Applying pattern " + p1);
309	status = U_ZERO_ERROR;
310	pat.applyPattern(p1, status);
311	if(U_FAILURE(status)) {
312	errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
313	}
314	UnicodeString s2;
315	s2 = pat.toPattern(s2);
316	logln((UnicodeString)"Extracted pattern is " + s2);
317	if(s2 != p1) {
318	errln((UnicodeString)"ERROR: toPattern() result did not match pattern applied");
319	}
320
321	if(pat.getSecondaryGroupingSize() != 0) {
322	errln("FAIL: Secondary Grouping Size should be 0, not %d\n", pat.getSecondaryGroupingSize());
323	}
324
325	if(pat.getGroupingSize() != 3) {
326	errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
327	}
328
329	UnicodeString p2("#,##,##0.0# FF;(#,##,##0.0# FF)");
330	logln((UnicodeString)"Applying pattern " + p2);
331	status = U_ZERO_ERROR;
332	pat.applyLocalizedPattern(p2, status);
333	if(U_FAILURE(status)) {
334	errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
335	}
336	UnicodeString s3;
337	s3 = pat.toLocalizedPattern(s3);
338	logln((UnicodeString)"Extracted pattern is " + s3);
339	if(s3 != p2) {
340	errln((UnicodeString)"ERROR: toLocalizedPattern() result did not match pattern applied");
341	}
342
343	status = U_ZERO_ERROR;
344	UParseError pe;
345	pat.applyLocalizedPattern(p2, pe, status);
346	if(U_FAILURE(status)) {
347	errln((UnicodeString)"ERROR: applyPattern((with ParseError)) failed with " + (int32_t) status);
348	}
349	UnicodeString s4;
350	s4 = pat.toLocalizedPattern(s3);
351	logln((UnicodeString)"Extracted pattern is " + s4);
352	if(s4 != p2) {
353	errln((UnicodeString)"ERROR: toLocalizedPattern(with ParseErr) result did not match pattern applied");
354	}
355
356	if(pat.getSecondaryGroupingSize() != 2) {
357	errln("FAIL: Secondary Grouping Size should be 2, not %d\n", pat.getSecondaryGroupingSize());
358	}
359
360	if(pat.getGroupingSize() != 3) {
361	errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
362	}
363
364	// ======= Test getStaticClassID()
365
366	logln((UnicodeString)"Testing getStaticClassID()");
367
368	status = U_ZERO_ERROR;
369	NumberFormat *test = new DecimalFormat(status);
370	if(U_FAILURE(status)) {
371	errln((UnicodeString)"ERROR: Couldn't create a DecimalFormat");
372	}
373
374	if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) {
375	errln((UnicodeString)"ERROR: getDynamicClassID() didn't return the expected value");
376	}
377
378	delete test;
379	}
380
729e4ab9 A	381	void IntlTestDecimalFormatAPI::TestCurrencyPluralInfo(){
	382	UErrorCode status = U_ZERO_ERROR;
	383
	384	CurrencyPluralInfo *cpi = new CurrencyPluralInfo(status);
	385	if(U_FAILURE(status)) {
	386	errln((UnicodeString)"ERROR: CurrencyPluralInfo(UErrorCode) could not be created");
	387	}
	388
	389	CurrencyPluralInfo cpi1 = *cpi;
	390
	391	if(cpi->getDynamicClassID() != CurrencyPluralInfo::getStaticClassID()){
	392	errln((UnicodeString)"ERROR: CurrencyPluralInfo::getDynamicClassID() didn't return the expected value");
	393	}
	394
	395	cpi->setCurrencyPluralPattern("","",status);
	396	if(U_FAILURE(status)) {
	397	errln((UnicodeString)"ERROR: CurrencyPluralInfo::setCurrencyPluralPattern");
	398	}
	399
	400	cpi->setLocale(Locale::getCanada(), status);
	401	if(U_FAILURE(status)) {
	402	errln((UnicodeString)"ERROR: CurrencyPluralInfo::setLocale");
	403	}
	404
	405	cpi->setPluralRules("",status);
	406	if(U_FAILURE(status)) {
	407	errln((UnicodeString)"ERROR: CurrencyPluralInfo::setPluralRules");
	408	}
	409
	410	DecimalFormat *df = new DecimalFormat(status);
	411	if(U_FAILURE(status)) {
	412	errcheckln(status, "ERROR: Could not create DecimalFormat - %s", u_errorName(status));
	413	}
	414
	415	df->adoptCurrencyPluralInfo(cpi);
	416
	417	df->getCurrencyPluralInfo();
	418
	419	df->setCurrencyPluralInfo(cpi1);
	420
	421	delete df;
	422	}
	423
b75a7d8f A	424	void IntlTestDecimalFormatAPI::testRounding(/char par*/)
	425	{
	426	UErrorCode status = U_ZERO_ERROR;
	427	double Roundingnumber = 2.55;
	428	double Roundingnumber1 = -2.55;
	429	//+2.55 results -2.55 results
	430	double result[]={ 3.0, -2.0, // kRoundCeiling 0,
	431	2.0, -3.0, // kRoundFloor 1,
	432	2.0, -2.0, // kRoundDown 2,
	433	3.0, -3.0, // kRoundUp 3,
	434	3.0, -3.0, // kRoundHalfEven 4,
	435	3.0, -3.0, // kRoundHalfDown 5,
	436	3.0, -3.0 // kRoundHalfUp 6
	437	};
	438	DecimalFormat pat(status);
	439	if(U_FAILURE(status)) {
729e4ab9	440	errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
b75a7d8f A	441	return;
	442	}
	443	uint16_t mode;
	444	uint16_t i=0;
	445	UnicodeString message;
	446	UnicodeString resultStr;
	447	for(mode=0;mode < 7;mode++){
	448	pat.setRoundingMode((DecimalFormat::ERoundingMode)mode);
	449	if(pat.getRoundingMode() != (DecimalFormat::ERoundingMode)mode){
	450	errln((UnicodeString)"SetRoundingMode or GetRoundingMode failed for mode=" + mode);
	451	}
	452
	453
	454	//for +2.55 with RoundingIncrement=1.0
	455	pat.setRoundingIncrement(1.0);
	456	pat.format(Roundingnumber, resultStr);
51004dcb	457	message= (UnicodeString)"Round() failed: round(" + (double)Roundingnumber + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=1.0==>");
b75a7d8f A	458	verify(message, resultStr, result[i++]);
	459	message.remove();
	460	resultStr.remove();
	461
	462	//for -2.55 with RoundingIncrement=1.0
	463	pat.format(Roundingnumber1, resultStr);
51004dcb	464	message= (UnicodeString)"Round() failed: round(" + (double)Roundingnumber1 + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=1.0==>");
b75a7d8f A	465	verify(message, resultStr, result[i++]);
	466	message.remove();
	467	resultStr.remove();
	468	}
	469
	470	}
	471	void IntlTestDecimalFormatAPI::verify(const UnicodeString& message, const UnicodeString& got, double expected){
	472	logln((UnicodeString)message + got + (UnicodeString)" Expected : " + expected);
	473	UnicodeString expectedStr("");
	474	expectedStr=expectedStr + expected;
	475	if(got != expectedStr ) {
51004dcb A	476	errln((UnicodeString)"ERROR: " + message + got + (UnicodeString)" Expected : " + expectedStr);
	477	}
	478	}
	479
	480	void IntlTestDecimalFormatAPI::verifyString(const UnicodeString& message, const UnicodeString& got, UnicodeString& expected){
	481	logln((UnicodeString)message + got + (UnicodeString)" Expected : " + expected);
	482	if(got != expected ) {
	483	errln((UnicodeString)"ERROR: " + message + got + (UnicodeString)" Expected : " + expected);
b75a7d8f A	484	}
	485	}
	486
729e4ab9 A	487	void IntlTestDecimalFormatAPI::testRoundingInc(/char par*/)
	488	{
	489	UErrorCode status = U_ZERO_ERROR;
	490	DecimalFormat pat(UnicodeString("#,##0.00"),status);
	491	if(U_FAILURE(status)) {
	492	errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
	493	return;
	494	}
	495
	496	// get default rounding increment
	497	double roundingInc = pat.getRoundingIncrement();
	498	if (roundingInc != 0.0) {
	499	errln((UnicodeString)"ERROR: Rounding increment not zero");
	500	return;
	501	}
	502
	503	// With rounding now being handled by decNumber, we no longer
	504	// set a rounding increment to enable non-default mode rounding,
	505	// checking of which was the original point of this test.
	506
	507	// set rounding mode with zero increment. Rounding
	508	// increment should not be set by this operation
	509	pat.setRoundingMode((DecimalFormat::ERoundingMode)0);
	510	roundingInc = pat.getRoundingIncrement();
	511	if (roundingInc != 0.0) {
	512	errln((UnicodeString)"ERROR: Rounding increment not zero after setRoundingMode");
	513	return;
	514	}
	515	}
	516
51004dcb A	517	void IntlTestDecimalFormatAPI::TestScale()
	518	{
	519	typedef struct TestData {
	520	double inputValue;
	521	int inputScale;
	522	char *expectedOutput;
	523	} TestData;
	524
	525	static TestData testData[] = {
	526	{ 100.0, 3, "100,000" },
	527	{ 10034.0, -2, "100.34" },
	528	{ 0.86, -3, "0.0009" },
	529	{ -0.000455, 1, "-0%" },
	530	{ -0.000555, 1, "-1%" },
	531	{ 0.000455, 1, "0%" },
	532	{ 0.000555, 1, "1%" },
	533	};
	534
	535	UErrorCode status = U_ZERO_ERROR;
	536	DecimalFormat pat(status);
	537	if(U_FAILURE(status)) {
	538	errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
	539	return;
	540	}
	541
	542	UnicodeString message;
	543	UnicodeString resultStr;
	544	UnicodeString exp;
	545	UnicodeString percentPattern("#,##0%");
	546	pat.setMaximumFractionDigits(4);
	547
	548	for(int32_t i=0;i < sizeof(testData)/sizeof(testData[0]);i++) {
	549	if ( i > 2 ) {
	550	pat.applyPattern(percentPattern,status);
	551	}
	552	pat.setAttribute(UNUM_SCALE,testData[i].inputScale,status);
	553	pat.format(testData[i].inputValue, resultStr);
	554	message = UnicodeString("Unexpected output for ") + testData[i].inputValue + UnicodeString(" and scale ") + testData[i].inputScale + UnicodeString(". Got: ");
	555	exp = testData[i].expectedOutput;
	556	verifyString(message, resultStr, exp);
	557	message.remove();
	558	resultStr.remove();
	559	exp.remove();
	560	}
	561	}
b75a7d8f	562	#endif /* #if !UCONFIG_NO_FORMATTING */