You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1389 lines
53 KiB
1389 lines
53 KiB
// © 2016 and later: Unicode, Inc. and others.
|
|
// License & terms of use: http://www.unicode.org/copyright.html
|
|
/********************************************************************
|
|
* COPYRIGHT:
|
|
* Copyright (c) 1997-2015, International Business Machines Corporation and
|
|
* others. All Rights Reserved.
|
|
********************************************************************/
|
|
|
|
#include "unicode/utypes.h"
|
|
|
|
#if !UCONFIG_NO_FORMATTING
|
|
|
|
#include "dcfmapts.h"
|
|
|
|
#include "unicode/currpinf.h"
|
|
#include "unicode/dcfmtsym.h"
|
|
#include "unicode/decimfmt.h"
|
|
#include "unicode/fmtable.h"
|
|
#include "unicode/localpointer.h"
|
|
#include "unicode/parseerr.h"
|
|
#include "unicode/stringpiece.h"
|
|
|
|
#include "putilimp.h"
|
|
#include "plurrule_impl.h"
|
|
#include "number_decimalquantity.h"
|
|
|
|
#include <stdio.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;
|
|
case 5: name = "TestFixedDecimal";
|
|
if(exec) {
|
|
logln((UnicodeString)"TestFixedDecimal ---");
|
|
TestFixedDecimal();
|
|
}
|
|
break;
|
|
case 6: name = "TestBadFastpath";
|
|
if(exec) {
|
|
logln((UnicodeString)"TestBadFastpath ---");
|
|
TestBadFastpath();
|
|
}
|
|
break;
|
|
case 7: name = "TestRequiredDecimalPoint";
|
|
if(exec) {
|
|
logln((UnicodeString)"TestRequiredDecimalPoint ---");
|
|
TestRequiredDecimalPoint();
|
|
}
|
|
break;
|
|
case 8: name = "testErrorCode";
|
|
if(exec) {
|
|
logln((UnicodeString)"testErrorCode ---");
|
|
testErrorCode();
|
|
}
|
|
break;
|
|
case 9: name = "testInvalidObject";
|
|
if(exec) {
|
|
logln((UnicodeString) "testInvalidObject ---");
|
|
testInvalidObject();
|
|
}
|
|
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;
|
|
}
|
|
|
|
// bug 10864
|
|
status = U_ZERO_ERROR;
|
|
DecimalFormat noGrouping("###0.##", status);
|
|
assertEquals("Grouping size should be 0 for no grouping.", 0, noGrouping.getGroupingSize());
|
|
noGrouping.setGroupingUsed(TRUE);
|
|
assertEquals("Grouping size should still be 0.", 0, noGrouping.getGroupingSize());
|
|
// end bug 10864
|
|
|
|
// bug 13442 comment 14
|
|
status = U_ZERO_ERROR;
|
|
{
|
|
DecimalFormat df("0", {"en", status}, status);
|
|
UnicodeString result;
|
|
assertEquals("pat 0: ", 0, df.getGroupingSize());
|
|
assertEquals("pat 0: ", (UBool) FALSE, (UBool) df.isGroupingUsed());
|
|
df.setGroupingUsed(false);
|
|
assertEquals("pat 0 then disabled: ", 0, df.getGroupingSize());
|
|
assertEquals("pat 0 then disabled: ", u"1111", df.format(1111, result.remove()));
|
|
df.setGroupingUsed(true);
|
|
assertEquals("pat 0 then enabled: ", 0, df.getGroupingSize());
|
|
assertEquals("pat 0 then enabled: ", u"1111", df.format(1111, result.remove()));
|
|
}
|
|
{
|
|
DecimalFormat df("#,##0", {"en", status}, status);
|
|
UnicodeString result;
|
|
assertEquals("pat #,##0: ", 3, df.getGroupingSize());
|
|
assertEquals("pat #,##0: ", (UBool) TRUE, (UBool) df.isGroupingUsed());
|
|
df.setGroupingUsed(false);
|
|
assertEquals("pat #,##0 then disabled: ", 3, df.getGroupingSize());
|
|
assertEquals("pat #,##0 then disabled: ", u"1111", df.format(1111, result.remove()));
|
|
df.setGroupingUsed(true);
|
|
assertEquals("pat #,##0 then enabled: ", 3, df.getGroupingSize());
|
|
assertEquals("pat #,##0 then enabled: ", u"1,111", df.format(1111, result.remove()));
|
|
}
|
|
// end bug 13442 comment 14
|
|
|
|
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(FieldPosition::DONT_CARE), pos2(FieldPosition::DONT_CARE), pos3(FieldPosition::DONT_CARE), pos4(FieldPosition::DONT_CARE);
|
|
|
|
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()");
|
|
pat = DecimalFormat(status); // reset
|
|
|
|
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);
|
|
assertEquals("toPattern() result did not match pattern applied", p1, s2);
|
|
|
|
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);
|
|
assertEquals("toLocalizedPattern() result did not match pattern applied", p2, s3);
|
|
|
|
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);
|
|
assertEquals("toLocalizedPattern(with ParseErr) result did not match pattern applied", p2, s4);
|
|
|
|
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;
|
|
|
|
LocalPointer<CurrencyPluralInfo>cpi(new CurrencyPluralInfo(status), status);
|
|
if(U_FAILURE(status)) {
|
|
errln((UnicodeString)"ERROR: CurrencyPluralInfo(UErrorCode) could not be created");
|
|
return;
|
|
}
|
|
|
|
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");
|
|
}
|
|
|
|
LocalPointer<DecimalFormat>df(new DecimalFormat(status));
|
|
if(U_FAILURE(status)) {
|
|
errcheckln(status, "ERROR: Could not create DecimalFormat - %s", u_errorName(status));
|
|
return;
|
|
}
|
|
|
|
df->adoptCurrencyPluralInfo(cpi.orphan());
|
|
|
|
df->getCurrencyPluralInfo();
|
|
|
|
df->setCurrencyPluralInfo(cpi1);
|
|
|
|
}
|
|
|
|
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(" + (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(" + (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;
|
|
const 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 < UPRV_LENGTHOF(testData); i++) {
|
|
if ( i > 2 ) {
|
|
pat.applyPattern(percentPattern,status);
|
|
}
|
|
// Test both the attribute and the setter
|
|
if (i % 2 == 0) {
|
|
pat.setAttribute(UNUM_SCALE, testData[i].inputScale,status);
|
|
assertEquals("", testData[i].inputScale, pat.getMultiplierScale());
|
|
} else {
|
|
pat.setMultiplierScale(testData[i].inputScale);
|
|
assertEquals("", testData[i].inputScale, pat.getAttribute(UNUM_SCALE, 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();
|
|
}
|
|
}
|
|
|
|
|
|
#define ASSERT_EQUAL(expect, actual) UPRV_BLOCK_MACRO_BEGIN { \
|
|
/* ICU-20080: Use temporary variables to avoid strange compiler behaviour \
|
|
(with the nice side-effect of avoiding repeated function calls too). */ \
|
|
auto lhs = (expect); \
|
|
auto rhs = (actual); \
|
|
char tmp[200]; \
|
|
sprintf(tmp, "(%g==%g)", (double)lhs, (double)rhs); \
|
|
assertTrue(tmp, (lhs==rhs), FALSE, TRUE, __FILE__, __LINE__); \
|
|
} UPRV_BLOCK_MACRO_END
|
|
|
|
#if defined(_MSC_VER)
|
|
// Ignore the noisy warning 4805 (comparisons between int and bool) in the function below as we use the ICU TRUE/FALSE macros
|
|
// which are int values, whereas some of the DecimalQuantity methods return C++ bools.
|
|
#pragma warning(push)
|
|
#pragma warning(disable: 4805)
|
|
#endif
|
|
void IntlTestDecimalFormatAPI::TestFixedDecimal() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
LocalPointer<DecimalFormat> df(new DecimalFormat("###", status), status);
|
|
assertSuccess(WHERE, status);
|
|
if (status == U_MISSING_RESOURCE_ERROR) {
|
|
return;
|
|
}
|
|
number::impl::DecimalQuantity fd;
|
|
df->formatToDecimalQuantity(44, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(44, fd.getPluralOperand(PLURAL_OPERAND_N));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df->formatToDecimalQuantity(-44, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(44, fd.getPluralOperand(PLURAL_OPERAND_N));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(TRUE, fd.isNegative());
|
|
|
|
df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.00##", status), status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(123.456, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(3, fd.getPluralOperand(PLURAL_OPERAND_V)); // v
|
|
ASSERT_EQUAL(456, fd.getPluralOperand(PLURAL_OPERAND_F)); // f
|
|
ASSERT_EQUAL(456, fd.getPluralOperand(PLURAL_OPERAND_T)); // t
|
|
ASSERT_EQUAL(123, fd.getPluralOperand(PLURAL_OPERAND_I)); // i
|
|
ASSERT_EQUAL(123.456, fd.getPluralOperand(PLURAL_OPERAND_N)); // n
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df->formatToDecimalQuantity(-123.456, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(3, fd.getPluralOperand(PLURAL_OPERAND_V)); // v
|
|
ASSERT_EQUAL(456, fd.getPluralOperand(PLURAL_OPERAND_F)); // f
|
|
ASSERT_EQUAL(456, fd.getPluralOperand(PLURAL_OPERAND_T)); // t
|
|
ASSERT_EQUAL(123, fd.getPluralOperand(PLURAL_OPERAND_I)); // i
|
|
ASSERT_EQUAL(123.456, fd.getPluralOperand(PLURAL_OPERAND_N)); // n
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(TRUE, fd.isNegative());
|
|
|
|
// test max int digits
|
|
df->setMaximumIntegerDigits(2);
|
|
df->formatToDecimalQuantity(123.456, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(3, fd.getPluralOperand(PLURAL_OPERAND_V)); // v
|
|
ASSERT_EQUAL(456, fd.getPluralOperand(PLURAL_OPERAND_F)); // f
|
|
ASSERT_EQUAL(456, fd.getPluralOperand(PLURAL_OPERAND_T)); // t
|
|
ASSERT_EQUAL(23, fd.getPluralOperand(PLURAL_OPERAND_I)); // i
|
|
ASSERT_EQUAL(23.456, fd.getPluralOperand(PLURAL_OPERAND_N)); // n
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df->formatToDecimalQuantity(-123.456, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(3, fd.getPluralOperand(PLURAL_OPERAND_V)); // v
|
|
ASSERT_EQUAL(456, fd.getPluralOperand(PLURAL_OPERAND_F)); // f
|
|
ASSERT_EQUAL(456, fd.getPluralOperand(PLURAL_OPERAND_T)); // t
|
|
ASSERT_EQUAL(23, fd.getPluralOperand(PLURAL_OPERAND_I)); // i
|
|
ASSERT_EQUAL(23.456, fd.getPluralOperand(PLURAL_OPERAND_N)); // n
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(TRUE, fd.isNegative());
|
|
|
|
// test max fraction digits
|
|
df->setMaximumIntegerDigits(2000000000);
|
|
df->setMaximumFractionDigits(2);
|
|
df->formatToDecimalQuantity(123.456, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V)); // v
|
|
ASSERT_EQUAL(46, fd.getPluralOperand(PLURAL_OPERAND_F)); // f
|
|
ASSERT_EQUAL(46, fd.getPluralOperand(PLURAL_OPERAND_T)); // t
|
|
ASSERT_EQUAL(123, fd.getPluralOperand(PLURAL_OPERAND_I)); // i
|
|
ASSERT_EQUAL(123.46, fd.getPluralOperand(PLURAL_OPERAND_N)); // n
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df->formatToDecimalQuantity(-123.456, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V)); // v
|
|
ASSERT_EQUAL(46, fd.getPluralOperand(PLURAL_OPERAND_F)); // f
|
|
ASSERT_EQUAL(46, fd.getPluralOperand(PLURAL_OPERAND_T)); // t
|
|
ASSERT_EQUAL(123, fd.getPluralOperand(PLURAL_OPERAND_I)); // i
|
|
ASSERT_EQUAL(123.46, fd.getPluralOperand(PLURAL_OPERAND_N)); // n
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(TRUE, fd.isNegative());
|
|
|
|
// test esoteric rounding
|
|
df->setMaximumFractionDigits(6);
|
|
df->setRoundingIncrement(7.3);
|
|
|
|
df->formatToDecimalQuantity(30.0, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V)); // v
|
|
ASSERT_EQUAL(20, fd.getPluralOperand(PLURAL_OPERAND_F)); // f
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_T)); // t
|
|
ASSERT_EQUAL(29, fd.getPluralOperand(PLURAL_OPERAND_I)); // i
|
|
ASSERT_EQUAL(29.2, fd.getPluralOperand(PLURAL_OPERAND_N)); // n
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df->formatToDecimalQuantity(-30.0, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V)); // v
|
|
ASSERT_EQUAL(20, fd.getPluralOperand(PLURAL_OPERAND_F)); // f
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_T)); // t
|
|
ASSERT_EQUAL(29, fd.getPluralOperand(PLURAL_OPERAND_I)); // i
|
|
ASSERT_EQUAL(29.2, fd.getPluralOperand(PLURAL_OPERAND_N)); // n
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(TRUE, fd.isNegative());
|
|
|
|
df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###", status), status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(123.456, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(123, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(TRUE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(123.01, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(1, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(123, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(TRUE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(123.06, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(1, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(1, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(1, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(123, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status); // Significant Digits
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(123, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(123, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(TRUE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status); // Significant Digits
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(1.23, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(4, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(2300, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(23, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(1, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
df->formatToDecimalQuantity(uprv_getInfinity(), fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(TRUE, fd.isNaN() || fd.isInfinite());
|
|
df->formatToDecimalQuantity(0.0, fd, status);
|
|
ASSERT_EQUAL(FALSE, fd.isNaN() || fd.isInfinite());
|
|
df->formatToDecimalQuantity(uprv_getNaN(), fd, status);
|
|
ASSERT_EQUAL(TRUE, fd.isNaN() || fd.isInfinite());
|
|
assertSuccess(WHERE, status);
|
|
|
|
// Test Big Decimal input.
|
|
// 22 digits before and after decimal, will exceed the precision of a double
|
|
// and force DecimalFormat::getFixedDecimal() to work with a digit list.
|
|
df.adoptInsteadAndCheckErrorCode(
|
|
new DecimalFormat("#####################0.00####################", status), status);
|
|
assertSuccess(WHERE, status);
|
|
Formattable fable("12.34", status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(34, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(34, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(12, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
fable.setDecimalNumber("12.3456789012345678900123456789", status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(22, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(3456789012345678900LL, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(34567890123456789LL, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(12, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
// On field overflow, Integer part is truncated on the left, fraction part on the right.
|
|
fable.setDecimalNumber("123456789012345678901234567890.123456789012345678901234567890", status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(22, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(1234567890123456789LL, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(1234567890123456789LL, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(345678901234567890LL, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
// Digits way to the right of the decimal but within the format's precision aren't truncated
|
|
fable.setDecimalNumber("1.0000000000000000000012", status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(22, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(12, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(12, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(1, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
// Digits beyond the precision of the format are rounded away
|
|
fable.setDecimalNumber("1.000000000000000000000012", status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(1, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(TRUE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
// Negative numbers come through
|
|
fable.setDecimalNumber("-1.0000000000000000000012", status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(22, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(12, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(12, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(1, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(TRUE, fd.isNegative());
|
|
|
|
// MinFractionDigits from format larger than from number.
|
|
fable.setDecimalNumber("1000000000000000000000.3", status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(30, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(3, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
fable.setDecimalNumber("1000000000000000050000.3", status);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(30, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(3, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(50000LL, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(FALSE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
// Test some int64_t values that are out of the range of a double
|
|
fable.setInt64(4503599627370496LL);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(4503599627370496LL, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(TRUE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
fable.setInt64(4503599627370497LL);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
ASSERT_EQUAL(4503599627370497LL, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(TRUE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
fable.setInt64(9223372036854775807LL);
|
|
assertSuccess(WHERE, status);
|
|
df->formatToDecimalQuantity(fable, fd, status);
|
|
assertSuccess(WHERE, status);
|
|
ASSERT_EQUAL(2, fd.getPluralOperand(PLURAL_OPERAND_V));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_F));
|
|
ASSERT_EQUAL(0, fd.getPluralOperand(PLURAL_OPERAND_T));
|
|
// note: going through DigitList path to FixedDecimal, which is trimming
|
|
// int64_t fields to 18 digits. See ticket Ticket #10374
|
|
ASSERT_EQUAL(223372036854775807LL, fd.getPluralOperand(PLURAL_OPERAND_I));
|
|
ASSERT_EQUAL(TRUE, fd.hasIntegerValue());
|
|
ASSERT_EQUAL(FALSE, fd.isNegative());
|
|
|
|
}
|
|
#if defined(_MSC_VER)
|
|
// Re-enable 4805 warnings (comparisons between int and bool).
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
void IntlTestDecimalFormatAPI::TestBadFastpath() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
|
|
LocalPointer<DecimalFormat> df(new DecimalFormat("###", status), status);
|
|
if (U_FAILURE(status)) {
|
|
dataerrln("Error creating new DecimalFormat - %s", u_errorName(status));
|
|
return;
|
|
}
|
|
|
|
UnicodeString fmt;
|
|
fmt.remove();
|
|
assertEquals("Format 1234", "1234", df->format((int32_t)1234, fmt));
|
|
df->setGroupingUsed(FALSE);
|
|
fmt.remove();
|
|
assertEquals("Format 1234", "1234", df->format((int32_t)1234, fmt));
|
|
df->setGroupingUsed(TRUE);
|
|
df->setGroupingSize(3);
|
|
fmt.remove();
|
|
assertEquals("Format 1234 w/ grouping", "1,234", df->format((int32_t)1234, fmt));
|
|
}
|
|
|
|
void IntlTestDecimalFormatAPI::TestRequiredDecimalPoint() {
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
UnicodeString text("99");
|
|
Formattable result1;
|
|
UnicodeString pat1("##.0000");
|
|
UnicodeString pat2("00.0");
|
|
|
|
LocalPointer<DecimalFormat> df(new DecimalFormat(pat1, status), status);
|
|
if (U_FAILURE(status)) {
|
|
dataerrln("Error creating new DecimalFormat - %s", u_errorName(status));
|
|
return;
|
|
}
|
|
|
|
status = U_ZERO_ERROR;
|
|
df->applyPattern(pat1, status);
|
|
if(U_FAILURE(status)) {
|
|
errln((UnicodeString)"ERROR: applyPattern() failed");
|
|
}
|
|
df->parse(text, result1, status);
|
|
if(U_FAILURE(status)) {
|
|
errln((UnicodeString)"ERROR: parse() failed");
|
|
}
|
|
df->setDecimalPatternMatchRequired(TRUE);
|
|
df->parse(text, result1, status);
|
|
if(U_SUCCESS(status)) {
|
|
errln((UnicodeString)"ERROR: unexpected parse()");
|
|
}
|
|
|
|
|
|
status = U_ZERO_ERROR;
|
|
df->applyPattern(pat2, status);
|
|
df->setDecimalPatternMatchRequired(FALSE);
|
|
if(U_FAILURE(status)) {
|
|
errln((UnicodeString)"ERROR: applyPattern(2) failed");
|
|
}
|
|
df->parse(text, result1, status);
|
|
if(U_FAILURE(status)) {
|
|
errln((UnicodeString)"ERROR: parse(2) failed - " + u_errorName(status));
|
|
}
|
|
df->setDecimalPatternMatchRequired(TRUE);
|
|
df->parse(text, result1, status);
|
|
if(U_SUCCESS(status)) {
|
|
errln((UnicodeString)"ERROR: unexpected parse(2)");
|
|
}
|
|
}
|
|
|
|
void IntlTestDecimalFormatAPI::testErrorCode() {
|
|
// Try each DecimalFormat constructor with an errorCode set on input,
|
|
// Verify no crashes or leaks, and that the errorCode is not altered.
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const UnicodeString pattern(u"0.###E0");
|
|
UParseError pe;
|
|
DecimalFormatSymbols symbols(Locale::getUS(), status);
|
|
assertSuccess(WHERE, status);
|
|
|
|
{
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat df(status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
}
|
|
{
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat df(pattern, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
}
|
|
{
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat df(pattern, new DecimalFormatSymbols(symbols), status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
}
|
|
{
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat df(pattern, new DecimalFormatSymbols(symbols), UNUM_DECIMAL_COMPACT_LONG, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
}
|
|
{
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat df(pattern, new DecimalFormatSymbols(symbols), pe, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
}
|
|
{
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat df(pattern, symbols ,status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
}
|
|
|
|
// Try each DecimalFormat method with an error code parameter, verifying that
|
|
// an input error is not altered, and that no segmentation faults occur.
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat dfBogus(status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_ZERO_ERROR;
|
|
DecimalFormat dfGood(pattern, new DecimalFormatSymbols(symbols), status);
|
|
assertSuccess(WHERE, status);
|
|
|
|
for (DecimalFormat *df: {&dfBogus, &dfGood}) {
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->setAttribute(UNUM_PARSE_INT_ONLY, 0, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->getAttribute(UNUM_MAX_FRACTION_DIGITS, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
UnicodeString dest;
|
|
FieldPosition fp;
|
|
df->format(1.2, dest, fp, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->format(1.2, dest, nullptr, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->format((int32_t)666, dest, nullptr, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->format((int64_t)666, dest, nullptr, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->format(StringPiece("3.1415926535897932384626"), dest, nullptr, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->applyPattern(pattern, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->applyLocalizedPattern(pattern, pe, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->applyLocalizedPattern(pattern, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->setCurrency(u"USD", status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
df->setCurrencyUsage(UCURR_USAGE_CASH, &status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
}
|
|
}
|
|
|
|
void IntlTestDecimalFormatAPI::testInvalidObject() {
|
|
{
|
|
UErrorCode status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat dfBogus(status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_ZERO_ERROR;
|
|
DecimalFormat dfGood(status);
|
|
assertSuccess(WHERE, status);
|
|
|
|
// An invalid object should not be equal to a valid object.
|
|
// This also tests that no segmentation fault occurs in the comparison operator due
|
|
// to any dangling/nullptr pointers. (ICU-20381).
|
|
assertTrue(WHERE, dfGood != dfBogus);
|
|
|
|
status = U_MEMORY_ALLOCATION_ERROR;
|
|
DecimalFormat dfBogus2(status);
|
|
assertEquals(WHERE, U_MEMORY_ALLOCATION_ERROR, status);
|
|
|
|
// Two invalid objects should not be equal.
|
|
// (Also verify that nullptr isn't t dereferenced in the comparision operator.)
|
|
assertTrue(WHERE, dfBogus != dfBogus2);
|
|
|
|
// Verify the comparison operator works for two valid objects.
|
|
status = U_ZERO_ERROR;
|
|
DecimalFormat dfGood2(status);
|
|
assertSuccess(WHERE, status);
|
|
assertTrue(WHERE, dfGood == dfGood2);
|
|
|
|
// Verify that the assignment operator sets the object to an invalid state, and
|
|
// that no segmentation fault occurs due to any dangling/nullptr pointers.
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat dfAssignmentBogus = DecimalFormat(status);
|
|
// Verify comparison for the assigned object.
|
|
assertTrue(WHERE, dfAssignmentBogus != dfGood);
|
|
assertTrue(WHERE, dfAssignmentBogus != dfGood2);
|
|
assertTrue(WHERE, dfAssignmentBogus != dfBogus);
|
|
|
|
// Verify that cloning our original invalid object gives nullptr.
|
|
auto dfBogusClone = dfBogus.clone();
|
|
assertTrue(WHERE, dfBogusClone == nullptr);
|
|
// Verify that cloning our assigned invalid object gives nullptr.
|
|
auto dfBogusClone2 = dfAssignmentBogus.clone();
|
|
assertTrue(WHERE, dfBogusClone2 == nullptr);
|
|
|
|
// Verify copy constructing from an invalid object is also invalid.
|
|
DecimalFormat dfCopy(dfBogus);
|
|
assertTrue(WHERE, dfCopy != dfGood);
|
|
assertTrue(WHERE, dfCopy != dfGood2);
|
|
assertTrue(WHERE, dfCopy != dfBogus);
|
|
DecimalFormat dfCopyAssign = dfBogus;
|
|
assertTrue(WHERE, dfCopyAssign != dfGood);
|
|
assertTrue(WHERE, dfCopyAssign != dfGood2);
|
|
assertTrue(WHERE, dfCopyAssign != dfBogus);
|
|
auto dfBogusCopyClone1 = dfCopy.clone();
|
|
auto dfBogusCopyClone2 = dfCopyAssign.clone();
|
|
assertTrue(WHERE, dfBogusCopyClone1 == nullptr);
|
|
assertTrue(WHERE, dfBogusCopyClone2 == nullptr);
|
|
}
|
|
|
|
{
|
|
// Try each DecimalFormat class method that lacks an error code parameter, verifying
|
|
// we don't crash (segmentation fault) on invalid objects.
|
|
|
|
UErrorCode status = U_ZERO_ERROR;
|
|
const UnicodeString pattern(u"0.###E0");
|
|
UParseError pe;
|
|
DecimalFormatSymbols symbols(Locale::getUS(), status);
|
|
assertSuccess(WHERE, status);
|
|
CurrencyPluralInfo currencyPI(status);
|
|
assertSuccess(WHERE, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat dfBogus1(status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat dfBogus2(pattern, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat dfBogus3(pattern, new DecimalFormatSymbols(symbols), status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat dfBogus4(pattern, new DecimalFormatSymbols(symbols), UNumberFormatStyle::UNUM_CURRENCY, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
status = U_INTERNAL_PROGRAM_ERROR;
|
|
DecimalFormat dfBogus5(pattern, new DecimalFormatSymbols(symbols), pe, status);
|
|
assertEquals(WHERE, U_INTERNAL_PROGRAM_ERROR, status);
|
|
|
|
for (DecimalFormat *df : {&dfBogus1, &dfBogus2, &dfBogus3, &dfBogus4, &dfBogus5})
|
|
{
|
|
df->setGroupingUsed(true);
|
|
|
|
df->setParseIntegerOnly(false);
|
|
|
|
df->setLenient(true);
|
|
|
|
auto dfClone = df->clone();
|
|
assertTrue(WHERE, dfClone == nullptr);
|
|
|
|
UnicodeString dest;
|
|
FieldPosition fp;
|
|
df->format(1.2, dest, fp);
|
|
df->format(static_cast<int32_t>(1234), dest, fp);
|
|
df->format(static_cast<int64_t>(1234), dest, fp);
|
|
|
|
UnicodeString text("-1,234.00");
|
|
Formattable result;
|
|
ParsePosition pos(0);
|
|
df->parse(text, result, pos);
|
|
|
|
CurrencyAmount* ca = df->parseCurrency(text, pos);
|
|
assertTrue(WHERE, ca == nullptr);
|
|
|
|
const DecimalFormatSymbols* dfs = df->getDecimalFormatSymbols();
|
|
assertTrue(WHERE, dfs == nullptr);
|
|
|
|
df->adoptDecimalFormatSymbols(nullptr);
|
|
|
|
df->setDecimalFormatSymbols(symbols);
|
|
|
|
const CurrencyPluralInfo* cpi = df->getCurrencyPluralInfo();
|
|
assertTrue(WHERE, cpi == nullptr);
|
|
|
|
df->adoptCurrencyPluralInfo(nullptr);
|
|
|
|
df->setCurrencyPluralInfo(currencyPI);
|
|
|
|
UnicodeString prefix("-123");
|
|
df->getPositivePrefix(dest);
|
|
df->setPositivePrefix(prefix);
|
|
df->getNegativePrefix(dest);
|
|
df->setNegativePrefix(prefix);
|
|
df->getPositiveSuffix(dest);
|
|
df->setPositiveSuffix(prefix);
|
|
df->getNegativeSuffix(dest);
|
|
df->setNegativeSuffix(prefix);
|
|
|
|
df->isSignAlwaysShown();
|
|
|
|
df->setSignAlwaysShown(true);
|
|
|
|
df->getMultiplier();
|
|
df->setMultiplier(10);
|
|
|
|
df->getMultiplierScale();
|
|
df->setMultiplierScale(2);
|
|
|
|
df->getRoundingIncrement();
|
|
df->setRoundingIncrement(1.2);
|
|
|
|
df->getRoundingMode();
|
|
df->setRoundingMode(DecimalFormat::ERoundingMode::kRoundDown);
|
|
|
|
df->getFormatWidth();
|
|
df->setFormatWidth(0);
|
|
|
|
UnicodeString pad(" ");
|
|
df->getPadCharacterString();
|
|
df->setPadCharacter(pad);
|
|
|
|
df->getPadPosition();
|
|
df->setPadPosition(DecimalFormat::EPadPosition::kPadBeforePrefix);
|
|
|
|
df->isScientificNotation();
|
|
df->setScientificNotation(false);
|
|
|
|
df->getMinimumExponentDigits();
|
|
df->setMinimumExponentDigits(1);
|
|
|
|
df->isExponentSignAlwaysShown();
|
|
df->setExponentSignAlwaysShown(true);
|
|
|
|
df->getGroupingSize();
|
|
df->setGroupingSize(3);
|
|
|
|
df->getSecondaryGroupingSize();
|
|
df->setSecondaryGroupingSize(-1);
|
|
|
|
df->getMinimumGroupingDigits();
|
|
df->setMinimumGroupingDigits(-1);
|
|
|
|
df->isDecimalSeparatorAlwaysShown();
|
|
df->setDecimalSeparatorAlwaysShown(true);
|
|
|
|
df->isDecimalPatternMatchRequired();
|
|
df->setDecimalPatternMatchRequired(false);
|
|
|
|
df->isParseNoExponent();
|
|
df->setParseNoExponent(true);
|
|
|
|
df->isParseCaseSensitive();
|
|
df->setParseCaseSensitive(false);
|
|
|
|
df->isFormatFailIfMoreThanMaxDigits();
|
|
df->setFormatFailIfMoreThanMaxDigits(true);
|
|
|
|
df->toPattern(dest);
|
|
df->toLocalizedPattern(dest);
|
|
|
|
df->setMaximumIntegerDigits(10);
|
|
df->setMinimumIntegerDigits(0);
|
|
|
|
df->setMaximumFractionDigits(2);
|
|
df->setMinimumFractionDigits(0);
|
|
|
|
df->getMinimumSignificantDigits();
|
|
df->setMinimumSignificantDigits(0);
|
|
|
|
df->getMaximumSignificantDigits();
|
|
df->setMaximumSignificantDigits(5);
|
|
|
|
df->areSignificantDigitsUsed();
|
|
df->setSignificantDigitsUsed(true);
|
|
|
|
df->setCurrency(u"USD");
|
|
|
|
df->getCurrencyUsage();
|
|
|
|
const number::LocalizedNumberFormatter* lnf = df->toNumberFormatter(status);
|
|
assertEquals("toNumberFormatter should return nullptr",
|
|
(int64_t) nullptr, (int64_t) lnf);
|
|
|
|
// Should not crash when chaining to error code enabled methods on the LNF
|
|
lnf->formatInt(1, status);
|
|
lnf->formatDouble(1.0, status);
|
|
lnf->formatDecimal("1", status);
|
|
lnf->toFormat(status);
|
|
lnf->toSkeleton(status);
|
|
lnf->copyErrorTo(status);
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
#endif /* #if !UCONFIG_NO_FORMATTING */
|