icuSources/test/intltest/dcfmapts.cpp

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /********************************************************************
   4  * COPYRIGHT:
   5  * Copyright (c) 1997-2015, International Business Machines Corporation and
   6  * others. All Rights Reserved.
   7  ********************************************************************/
   8
   9 #include "unicode/utypes.h"
  10
  11 #if !UCONFIG_NO_FORMATTING
  12
  13 #include "dcfmapts.h"
  14
  15 #include "unicode/currpinf.h"
  16 #include "unicode/dcfmtsym.h"
  17 #include "unicode/decimfmt.h"
  18 #include "unicode/fmtable.h"
  19 #include "unicode/localpointer.h"
  20 #include "unicode/parseerr.h"
  21 #include "unicode/stringpiece.h"
  22
  23 #include "putilimp.h"
  24 #include "plurrule_impl.h"
  25 #include <stdio.h>
  26
  27 // This is an API test, not a unit test.  It doesn't test very many cases, and doesn't
  28 // try to test the full functionality.  It just calls each function in the class and
  29 // verifies that it works on a basic level.
  30
  31 void IntlTestDecimalFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  32 {
  33     if (exec) logln((UnicodeString)"TestSuite DecimalFormatAPI");
  34     switch (index) {
  35         case 0: name = "DecimalFormat API test";
  36                 if (exec) {
  37                     logln((UnicodeString)"DecimalFormat API test---"); logln((UnicodeString)"");
  38                     UErrorCode status = U_ZERO_ERROR;
  39                     Locale saveLocale;
  40                     Locale::setDefault(Locale::getEnglish(), status);
  41                     if(U_FAILURE(status)) {
  42                         errln((UnicodeString)"ERROR: Could not set default locale, test may not give correct results");
  43                     }
  44                     testAPI(/*par*/);
  45                     Locale::setDefault(saveLocale, status);
  46                 }
  47                 break;
  48         case 1: name = "Rounding test";
  49             if(exec) {
  50                logln((UnicodeString)"DecimalFormat Rounding test---");
  51                testRounding(/*par*/);
  52             }
  53             break;
  54         case 2: name = "Test6354";
  55             if(exec) {
  56                logln((UnicodeString)"DecimalFormat Rounding Increment test---");
  57                testRoundingInc(/*par*/);
  58             }
  59             break;
  60         case 3: name = "TestCurrencyPluralInfo";
  61             if(exec) {
  62                logln((UnicodeString)"CurrencyPluralInfo API test---");
  63                TestCurrencyPluralInfo();
  64             }
  65             break;
  66         case 4: name = "TestScale";
  67             if(exec) {
  68                logln((UnicodeString)"Scale test---");
  69                TestScale();
  70             }
  71             break;
  72          case 5: name = "TestFixedDecimal";
  73             if(exec) {
  74                logln((UnicodeString)"TestFixedDecimal ---");
  75                TestFixedDecimal();
  76             }
  77             break;
  78          case 6: name = "TestBadFastpath";
  79             if(exec) {
  80                logln((UnicodeString)"TestBadFastpath ---");
  81                TestBadFastpath();
  82             }
  83             break;
  84          case 7: name = "TestRequiredDecimalPoint";
  85             if(exec) {
  86                logln((UnicodeString)"TestRequiredDecimalPoint ---");
  87                TestRequiredDecimalPoint();
  88             }
  89             break;
  90        default: name = ""; break;
  91     }
  92 }
  93
  94 /**
  95  * This test checks various generic API methods in DecimalFormat to achieve 100%
  96  * API coverage.
  97  */
  98 void IntlTestDecimalFormatAPI::testAPI(/*char *par*/)
  99 {
 100     UErrorCode status = U_ZERO_ERROR;
 101
 102 // ======= Test constructors
 103
 104     logln((UnicodeString)"Testing DecimalFormat constructors");
 105
 106     DecimalFormat def(status);
 107     if(U_FAILURE(status)) {
 108         errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
 109         return;
 110     }
 111
 112     // bug 10864
 113     status = U_ZERO_ERROR;
 114     DecimalFormat noGrouping("###0.##", status);
 115     if (noGrouping.getGroupingSize() != 0) {
 116       errln("Grouping size should be 0 for no grouping.");
 117     }
 118     noGrouping.setGroupingUsed(TRUE);
 119     if (noGrouping.getGroupingSize() != 0) {
 120       errln("Grouping size should still be 0.");
 121     }
 122     // end bug 10864
 123
 124     status = U_ZERO_ERROR;
 125     const UnicodeString pattern("#,##0.# FF");
 126     DecimalFormat pat(pattern, status);
 127     if(U_FAILURE(status)) {
 128         errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern)");
 129         return;
 130     }
 131
 132     status = U_ZERO_ERROR;
 133     DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getFrench(), status);
 134     if(U_FAILURE(status)) {
 135         errln((UnicodeString)"ERROR: Could not create DecimalFormatSymbols (French)");
 136         return;
 137     }
 138
 139     status = U_ZERO_ERROR;
 140     DecimalFormat cust1(pattern, symbols, status);
 141     if(U_FAILURE(status)) {
 142         errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols*)");
 143     }
 144
 145     status = U_ZERO_ERROR;
 146     DecimalFormat cust2(pattern, *symbols, status);
 147     if(U_FAILURE(status)) {
 148         errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols)");
 149     }
 150
 151     DecimalFormat copy(pat);
 152
 153 // ======= Test clone(), assignment, and equality
 154
 155     logln((UnicodeString)"Testing clone(), assignment and equality operators");
 156
 157     if( ! (copy == pat) || copy != pat) {
 158         errln((UnicodeString)"ERROR: Copy constructor or == failed");
 159     }
 160
 161     copy = cust1;
 162     if(copy != cust1) {
 163         errln((UnicodeString)"ERROR: Assignment (or !=) failed");
 164     }
 165
 166     Format *clone = def.clone();
 167     if( ! (*clone == def) ) {
 168         errln((UnicodeString)"ERROR: Clone() failed");
 169     }
 170     delete clone;
 171
 172 // ======= Test various format() methods
 173
 174     logln((UnicodeString)"Testing various format() methods");
 175
 176     double d = -10456.0037;
 177     int32_t l = 100000000;
 178     Formattable fD(d);
 179     Formattable fL(l);
 180
 181     UnicodeString res1, res2, res3, res4;
 182     FieldPosition pos1(FieldPosition::DONT_CARE), pos2(FieldPosition::DONT_CARE), pos3(FieldPosition::DONT_CARE), pos4(FieldPosition::DONT_CARE);
 183
 184     res1 = def.format(d, res1, pos1);
 185     logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1);
 186
 187     res2 = pat.format(l, res2, pos2);
 188     logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2);
 189
 190     status = U_ZERO_ERROR;
 191     res3 = cust1.format(fD, res3, pos3, status);
 192     if(U_FAILURE(status)) {
 193         errln((UnicodeString)"ERROR: format(Formattable [double]) failed");
 194     }
 195     logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res3);
 196
 197     status = U_ZERO_ERROR;
 198     res4 = cust2.format(fL, res4, pos4, status);
 199     if(U_FAILURE(status)) {
 200         errln((UnicodeString)"ERROR: format(Formattable [long]) failed");
 201     }
 202     logln((UnicodeString) "" + fL.getLong() + " formatted to " + res4);
 203
 204 // ======= Test parse()
 205
 206     logln((UnicodeString)"Testing parse()");
 207
 208     UnicodeString text("-10,456.0037");
 209     Formattable result1, result2;
 210     ParsePosition pos(0);
 211     UnicodeString patt("#,##0.#");
 212     status = U_ZERO_ERROR;
 213     pat.applyPattern(patt, status);
 214     if(U_FAILURE(status)) {
 215         errln((UnicodeString)"ERROR: applyPattern() failed");
 216     }
 217     pat.parse(text, result1, pos);
 218     if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) {
 219         errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
 220     }
 221     logln(text + " parsed into " + (int32_t) result1.getDouble());
 222
 223     status = U_ZERO_ERROR;
 224     pat.parse(text, result2, status);
 225     if(U_FAILURE(status)) {
 226         errln((UnicodeString)"ERROR: parse() failed");
 227     }
 228     if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) {
 229         errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
 230     }
 231     logln(text + " parsed into " + (int32_t) result2.getDouble());
 232
 233 // ======= Test getters and setters
 234
 235     logln((UnicodeString)"Testing getters and setters");
 236
 237     const DecimalFormatSymbols *syms = pat.getDecimalFormatSymbols();
 238     DecimalFormatSymbols *newSyms = new DecimalFormatSymbols(*syms);
 239     def.setDecimalFormatSymbols(*newSyms);
 240     def.adoptDecimalFormatSymbols(newSyms); // don't use newSyms after this
 241     if( *(pat.getDecimalFormatSymbols()) != *(def.getDecimalFormatSymbols())) {
 242         errln((UnicodeString)"ERROR: adopt or set DecimalFormatSymbols() failed");
 243     }
 244
 245     UnicodeString posPrefix;
 246     pat.setPositivePrefix("+");
 247     posPrefix = pat.getPositivePrefix(posPrefix);
 248     logln((UnicodeString)"Positive prefix (should be +): " + posPrefix);
 249     if(posPrefix != "+") {
 250         errln((UnicodeString)"ERROR: setPositivePrefix() failed");
 251     }
 252
 253     UnicodeString negPrefix;
 254     pat.setNegativePrefix("-");
 255     negPrefix = pat.getNegativePrefix(negPrefix);
 256     logln((UnicodeString)"Negative prefix (should be -): " + negPrefix);
 257     if(negPrefix != "-") {
 258         errln((UnicodeString)"ERROR: setNegativePrefix() failed");
 259     }
 260
 261     UnicodeString posSuffix;
 262     pat.setPositiveSuffix("_");
 263     posSuffix = pat.getPositiveSuffix(posSuffix);
 264     logln((UnicodeString)"Positive suffix (should be _): " + posSuffix);
 265     if(posSuffix != "_") {
 266         errln((UnicodeString)"ERROR: setPositiveSuffix() failed");
 267     }
 268
 269     UnicodeString negSuffix;
 270     pat.setNegativeSuffix("~");
 271     negSuffix = pat.getNegativeSuffix(negSuffix);
 272     logln((UnicodeString)"Negative suffix (should be ~): " + negSuffix);
 273     if(negSuffix != "~") {
 274         errln((UnicodeString)"ERROR: setNegativeSuffix() failed");
 275     }
 276
 277     int32_t multiplier = 0;
 278     pat.setMultiplier(8);
 279     multiplier = pat.getMultiplier();
 280     logln((UnicodeString)"Multiplier (should be 8): " + multiplier);
 281     if(multiplier != 8) {
 282         errln((UnicodeString)"ERROR: setMultiplier() failed");
 283     }
 284
 285     int32_t groupingSize = 0;
 286     pat.setGroupingSize(2);
 287     groupingSize = pat.getGroupingSize();
 288     logln((UnicodeString)"Grouping size (should be 2): " + (int32_t) groupingSize);
 289     if(groupingSize != 2) {
 290         errln((UnicodeString)"ERROR: setGroupingSize() failed");
 291     }
 292
 293     pat.setDecimalSeparatorAlwaysShown(TRUE);
 294     UBool tf = pat.isDecimalSeparatorAlwaysShown();
 295     logln((UnicodeString)"DecimalSeparatorIsAlwaysShown (should be TRUE) is " + (UnicodeString) (tf ? "TRUE" : "FALSE"));
 296     if(tf != TRUE) {
 297         errln((UnicodeString)"ERROR: setDecimalSeparatorAlwaysShown() failed");
 298     }
 299     // Added by Ken Liu testing set/isExponentSignAlwaysShown
 300     pat.setExponentSignAlwaysShown(TRUE);
 301     UBool esas = pat.isExponentSignAlwaysShown();
 302     logln((UnicodeString)"ExponentSignAlwaysShown (should be TRUE) is " + (UnicodeString) (esas ? "TRUE" : "FALSE"));
 303     if(esas != TRUE) {
 304         errln((UnicodeString)"ERROR: ExponentSignAlwaysShown() failed");
 305     }
 306
 307     // Added by Ken Liu testing set/isScientificNotation
 308     pat.setScientificNotation(TRUE);
 309     UBool sn = pat.isScientificNotation();
 310     logln((UnicodeString)"isScientificNotation (should be TRUE) is " + (UnicodeString) (sn ? "TRUE" : "FALSE"));
 311     if(sn != TRUE) {
 312         errln((UnicodeString)"ERROR: setScientificNotation() failed");
 313     }
 314
 315     // Added by Ken Liu testing set/getMinimumExponentDigits
 316     int8_t MinimumExponentDigits = 0;
 317     pat.setMinimumExponentDigits(2);
 318     MinimumExponentDigits = pat.getMinimumExponentDigits();
 319     logln((UnicodeString)"MinimumExponentDigits (should be 2) is " + (int8_t) MinimumExponentDigits);
 320     if(MinimumExponentDigits != 2) {
 321         errln((UnicodeString)"ERROR: setMinimumExponentDigits() failed");
 322     }
 323
 324     // Added by Ken Liu testing set/getRoundingIncrement
 325     double RoundingIncrement = 0.0;
 326     pat.setRoundingIncrement(2.0);
 327     RoundingIncrement = pat.getRoundingIncrement();
 328     logln((UnicodeString)"RoundingIncrement (should be 2.0) is " + (double) RoundingIncrement);
 329     if(RoundingIncrement != 2.0) {
 330         errln((UnicodeString)"ERROR: setRoundingIncrement() failed");
 331     }
 332     //end of Ken's Adding
 333
 334     UnicodeString funkyPat;
 335     funkyPat = pat.toPattern(funkyPat);
 336     logln((UnicodeString)"Pattern is " + funkyPat);
 337
 338     UnicodeString locPat;
 339     locPat = pat.toLocalizedPattern(locPat);
 340     logln((UnicodeString)"Localized pattern is " + locPat);
 341
 342 // ======= Test applyPattern()
 343
 344     logln((UnicodeString)"Testing applyPattern()");
 345
 346     UnicodeString p1("#,##0.0#;(#,##0.0#)");
 347     logln((UnicodeString)"Applying pattern " + p1);
 348     status = U_ZERO_ERROR;
 349     pat.applyPattern(p1, status);
 350     if(U_FAILURE(status)) {
 351         errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
 352     }
 353     UnicodeString s2;
 354     s2 = pat.toPattern(s2);
 355     logln((UnicodeString)"Extracted pattern is " + s2);
 356     if(s2 != p1) {
 357         errln((UnicodeString)"ERROR: toPattern() result did not match pattern applied");
 358     }
 359
 360     if(pat.getSecondaryGroupingSize() != 0) {
 361         errln("FAIL: Secondary Grouping Size should be 0, not %d\n", pat.getSecondaryGroupingSize());
 362     }
 363
 364     if(pat.getGroupingSize() != 3) {
 365         errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
 366     }
 367
 368     UnicodeString p2("#,##,##0.0# FF;(#,##,##0.0# FF)");
 369     logln((UnicodeString)"Applying pattern " + p2);
 370     status = U_ZERO_ERROR;
 371     pat.applyLocalizedPattern(p2, status);
 372     if(U_FAILURE(status)) {
 373         errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
 374     }
 375     UnicodeString s3;
 376     s3 = pat.toLocalizedPattern(s3);
 377     logln((UnicodeString)"Extracted pattern is " + s3);
 378     if(s3 != p2) {
 379         errln((UnicodeString)"ERROR: toLocalizedPattern() result did not match pattern applied");
 380     }
 381
 382     status = U_ZERO_ERROR;
 383     UParseError pe;
 384     pat.applyLocalizedPattern(p2, pe, status);
 385     if(U_FAILURE(status)) {
 386         errln((UnicodeString)"ERROR: applyPattern((with ParseError)) failed with " + (int32_t) status);
 387     }
 388     UnicodeString s4;
 389     s4 = pat.toLocalizedPattern(s3);
 390     logln((UnicodeString)"Extracted pattern is " + s4);
 391     if(s4 != p2) {
 392         errln((UnicodeString)"ERROR: toLocalizedPattern(with ParseErr) result did not match pattern applied");
 393     }
 394
 395     if(pat.getSecondaryGroupingSize() != 2) {
 396         errln("FAIL: Secondary Grouping Size should be 2, not %d\n", pat.getSecondaryGroupingSize());
 397     }
 398
 399     if(pat.getGroupingSize() != 3) {
 400         errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
 401     }
 402
 403 // ======= Test getStaticClassID()
 404
 405     logln((UnicodeString)"Testing getStaticClassID()");
 406
 407     status = U_ZERO_ERROR;
 408     NumberFormat *test = new DecimalFormat(status);
 409     if(U_FAILURE(status)) {
 410         errln((UnicodeString)"ERROR: Couldn't create a DecimalFormat");
 411     }
 412
 413     if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) {
 414         errln((UnicodeString)"ERROR: getDynamicClassID() didn't return the expected value");
 415     }
 416
 417     delete test;
 418 }
 419
 420 void IntlTestDecimalFormatAPI::TestCurrencyPluralInfo(){
 421     UErrorCode status = U_ZERO_ERROR;
 422
 423     CurrencyPluralInfo *cpi = new CurrencyPluralInfo(status);
 424     if(U_FAILURE(status)) {
 425         errln((UnicodeString)"ERROR: CurrencyPluralInfo(UErrorCode) could not be created");
 426     }
 427
 428     CurrencyPluralInfo cpi1 = *cpi;
 429
 430     if(cpi->getDynamicClassID() != CurrencyPluralInfo::getStaticClassID()){
 431         errln((UnicodeString)"ERROR: CurrencyPluralInfo::getDynamicClassID() didn't return the expected value");
 432     }
 433
 434     cpi->setCurrencyPluralPattern("","",status);
 435     if(U_FAILURE(status)) {
 436         errln((UnicodeString)"ERROR: CurrencyPluralInfo::setCurrencyPluralPattern");
 437     }
 438
 439     cpi->setLocale(Locale::getCanada(), status);
 440     if(U_FAILURE(status)) {
 441         errln((UnicodeString)"ERROR: CurrencyPluralInfo::setLocale");
 442     }
 443
 444     cpi->setPluralRules("",status);
 445     if(U_FAILURE(status)) {
 446         errln((UnicodeString)"ERROR: CurrencyPluralInfo::setPluralRules");
 447     }
 448
 449     DecimalFormat *df = new DecimalFormat(status);
 450     if(U_FAILURE(status)) {
 451         errcheckln(status, "ERROR: Could not create DecimalFormat - %s", u_errorName(status));
 452         return;
 453     }
 454
 455     df->adoptCurrencyPluralInfo(cpi);
 456
 457     df->getCurrencyPluralInfo();
 458
 459     df->setCurrencyPluralInfo(cpi1);
 460
 461     delete df;
 462 }
 463
 464 void IntlTestDecimalFormatAPI::testRounding(/*char *par*/)
 465 {
 466     UErrorCode status = U_ZERO_ERROR;
 467     double Roundingnumber = 2.55;
 468     double Roundingnumber1 = -2.55;
 469                       //+2.55 results   -2.55 results
 470     double result[]={   3.0,            -2.0,    //  kRoundCeiling  0,
 471                         2.0,            -3.0,    //  kRoundFloor    1,
 472                         2.0,            -2.0,    //  kRoundDown     2,
 473                         3.0,            -3.0,    //  kRoundUp       3,
 474                         3.0,            -3.0,    //  kRoundHalfEven 4,
 475                         3.0,            -3.0,    //  kRoundHalfDown 5,
 476                         3.0,            -3.0     //  kRoundHalfUp   6
 477     };
 478     DecimalFormat pat(status);
 479     if(U_FAILURE(status)) {
 480       errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
 481       return;
 482     }
 483     uint16_t mode;
 484     uint16_t i=0;
 485     UnicodeString message;
 486     UnicodeString resultStr;
 487     for(mode=0;mode < 7;mode++){
 488         pat.setRoundingMode((DecimalFormat::ERoundingMode)mode);
 489         if(pat.getRoundingMode() != (DecimalFormat::ERoundingMode)mode){
 490             errln((UnicodeString)"SetRoundingMode or GetRoundingMode failed for mode=" + mode);
 491         }
 492
 493
 494         //for +2.55 with RoundingIncrement=1.0
 495         pat.setRoundingIncrement(1.0);
 496         pat.format(Roundingnumber, resultStr);
 497         message= (UnicodeString)"Round() failed:  round(" + (double)Roundingnumber + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=1.0==>");
 498         verify(message, resultStr, result[i++]);
 499         message.remove();
 500         resultStr.remove();
 501
 502         //for -2.55 with RoundingIncrement=1.0
 503         pat.format(Roundingnumber1, resultStr);
 504         message= (UnicodeString)"Round() failed:  round(" + (double)Roundingnumber1 + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=1.0==>");
 505         verify(message, resultStr, result[i++]);
 506         message.remove();
 507         resultStr.remove();
 508     }
 509
 510 }
 511 void IntlTestDecimalFormatAPI::verify(const UnicodeString& message, const UnicodeString& got, double expected){
 512     logln((UnicodeString)message + got + (UnicodeString)" Expected : " + expected);
 513     UnicodeString expectedStr("");
 514     expectedStr=expectedStr + expected;
 515     if(got != expectedStr ) {
 516             errln((UnicodeString)"ERROR: " + message + got + (UnicodeString)"  Expected : " + expectedStr);
 517         }
 518 }
 519
 520 void IntlTestDecimalFormatAPI::verifyString(const UnicodeString& message, const UnicodeString& got, UnicodeString& expected){
 521     logln((UnicodeString)message + got + (UnicodeString)" Expected : " + expected);
 522     if(got != expected ) {
 523             errln((UnicodeString)"ERROR: " + message + got + (UnicodeString)"  Expected : " + expected);
 524         }
 525 }
 526
 527 void IntlTestDecimalFormatAPI::testRoundingInc(/*char *par*/)
 528 {
 529     UErrorCode status = U_ZERO_ERROR;
 530     DecimalFormat pat(UnicodeString("#,##0.00"),status);
 531     if(U_FAILURE(status)) {
 532       errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
 533       return;
 534     }
 535
 536     // get default rounding increment
 537     double roundingInc = pat.getRoundingIncrement();
 538     if (roundingInc != 0.0) {
 539       errln((UnicodeString)"ERROR: Rounding increment not zero");
 540       return;
 541     }
 542
 543     // With rounding now being handled by decNumber, we no longer
 544     // set a rounding increment to enable non-default mode rounding,
 545     // checking of which was the original point of this test.
 546
 547     // set rounding mode with zero increment.  Rounding
 548     // increment should not be set by this operation
 549     pat.setRoundingMode((DecimalFormat::ERoundingMode)0);
 550     roundingInc = pat.getRoundingIncrement();
 551     if (roundingInc != 0.0) {
 552       errln((UnicodeString)"ERROR: Rounding increment not zero after setRoundingMode");
 553       return;
 554     }
 555 }
 556
 557 void IntlTestDecimalFormatAPI::TestScale()
 558 {
 559     typedef struct TestData {
 560         double inputValue;
 561         int inputScale;
 562         const char *expectedOutput;
 563     } TestData;
 564
 565     static TestData testData[] = {
 566         { 100.0, 3,  "100,000" },
 567         { 10034.0, -2, "100.34" },
 568         { 0.86, -3, "0.0009" },
 569         { -0.000455, 1, "-0%" },
 570         { -0.000555, 1, "-1%" },
 571         { 0.000455, 1, "0%" },
 572         { 0.000555, 1, "1%" },
 573     };
 574
 575     UErrorCode status = U_ZERO_ERROR;
 576     DecimalFormat pat(status);
 577     if(U_FAILURE(status)) {
 578       errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
 579       return;
 580     }
 581
 582     UnicodeString message;
 583     UnicodeString resultStr;
 584     UnicodeString exp;
 585     UnicodeString percentPattern("#,##0%");
 586     pat.setMaximumFractionDigits(4);
 587
 588     for(int32_t i=0; i < UPRV_LENGTHOF(testData); i++) {
 589         if ( i > 2 ) {
 590             pat.applyPattern(percentPattern,status);
 591         }
 592         pat.setAttribute(UNUM_SCALE,testData[i].inputScale,status);
 593         pat.format(testData[i].inputValue, resultStr);
 594         message = UnicodeString("Unexpected output for ") + testData[i].inputValue + UnicodeString(" and scale ") +
 595                   testData[i].inputScale + UnicodeString(". Got: ");
 596         exp = testData[i].expectedOutput;
 597         verifyString(message, resultStr, exp);
 598         message.remove();
 599         resultStr.remove();
 600         exp.remove();
 601     }
 602 }
 603
 604
 605 #define ASSERT_EQUAL(expect, actual) { char tmp[200]; sprintf(tmp, "(%g==%g)", (double)(expect), (double)(actual)); \
 606     assertTrue(tmp, ((expect)==(actual)), FALSE, TRUE, __FILE__, __LINE__); }
 607
 608 void IntlTestDecimalFormatAPI::TestFixedDecimal() {
 609     UErrorCode status = U_ZERO_ERROR;
 610
 611     LocalPointer<DecimalFormat> df(new DecimalFormat("###", status), status);
 612     TEST_ASSERT_STATUS(status);
 613     if (status == U_MISSING_RESOURCE_ERROR) {
 614         return;
 615     }
 616     FixedDecimal fd = df->getFixedDecimal(44, status);
 617     TEST_ASSERT_STATUS(status);
 618     ASSERT_EQUAL(44, fd.source);
 619     ASSERT_EQUAL(0, fd.visibleDecimalDigitCount);
 620     ASSERT_EQUAL(FALSE, fd.isNegative);
 621
 622     fd = df->getFixedDecimal(-44, status);
 623     TEST_ASSERT_STATUS(status);
 624     ASSERT_EQUAL(44, fd.source);
 625     ASSERT_EQUAL(0, fd.visibleDecimalDigitCount);
 626     ASSERT_EQUAL(TRUE, fd.isNegative);
 627
 628     df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.00##", status), status);
 629     TEST_ASSERT_STATUS(status);
 630     fd = df->getFixedDecimal(123.456, status);
 631     TEST_ASSERT_STATUS(status);
 632     ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v
 633     ASSERT_EQUAL(456, fd.decimalDigits); // f
 634     ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t
 635     ASSERT_EQUAL(123, fd.intValue); // i
 636     ASSERT_EQUAL(123.456, fd.source); // n
 637     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 638     ASSERT_EQUAL(FALSE, fd.isNegative);
 639
 640     fd = df->getFixedDecimal(-123.456, status);
 641     TEST_ASSERT_STATUS(status);
 642     ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v
 643     ASSERT_EQUAL(456, fd.decimalDigits); // f
 644     ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t
 645     ASSERT_EQUAL(123, fd.intValue); // i
 646     ASSERT_EQUAL(123.456, fd.source); // n
 647     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 648     ASSERT_EQUAL(TRUE, fd.isNegative);
 649
 650     // test max int digits
 651     df->setMaximumIntegerDigits(2);
 652     fd = df->getFixedDecimal(123.456, status);
 653     TEST_ASSERT_STATUS(status);
 654     ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v
 655     ASSERT_EQUAL(456, fd.decimalDigits); // f
 656     ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t
 657     ASSERT_EQUAL(23, fd.intValue); // i
 658     ASSERT_EQUAL(23.456, fd.source); // n
 659     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 660     ASSERT_EQUAL(FALSE, fd.isNegative);
 661
 662     fd = df->getFixedDecimal(-123.456, status);
 663     TEST_ASSERT_STATUS(status);
 664     ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v
 665     ASSERT_EQUAL(456, fd.decimalDigits); // f
 666     ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t
 667     ASSERT_EQUAL(23, fd.intValue); // i
 668     ASSERT_EQUAL(23.456, fd.source); // n
 669     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 670     ASSERT_EQUAL(TRUE, fd.isNegative);
 671
 672     // test max fraction digits
 673     df->setMaximumIntegerDigits(2000000000);
 674     df->setMaximumFractionDigits(2);
 675     fd = df->getFixedDecimal(123.456, status);
 676     TEST_ASSERT_STATUS(status);
 677     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v
 678     ASSERT_EQUAL(46, fd.decimalDigits); // f
 679     ASSERT_EQUAL(46, fd.decimalDigitsWithoutTrailingZeros); // t
 680     ASSERT_EQUAL(123, fd.intValue); // i
 681     ASSERT_EQUAL(123.46, fd.source); // n
 682     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 683     ASSERT_EQUAL(FALSE, fd.isNegative);
 684
 685     fd = df->getFixedDecimal(-123.456, status);
 686     TEST_ASSERT_STATUS(status);
 687     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v
 688     ASSERT_EQUAL(46, fd.decimalDigits); // f
 689     ASSERT_EQUAL(46, fd.decimalDigitsWithoutTrailingZeros); // t
 690     ASSERT_EQUAL(123, fd.intValue); // i
 691     ASSERT_EQUAL(123.46, fd.source); // n
 692     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 693     ASSERT_EQUAL(TRUE, fd.isNegative);
 694
 695     // test esoteric rounding
 696     df->setMaximumFractionDigits(6);
 697     df->setRoundingIncrement(7.3);
 698
 699     fd = df->getFixedDecimal(30.0, status);
 700     TEST_ASSERT_STATUS(status);
 701     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v
 702     ASSERT_EQUAL(20, fd.decimalDigits); // f
 703     ASSERT_EQUAL(2, fd.decimalDigitsWithoutTrailingZeros); // t
 704     ASSERT_EQUAL(29, fd.intValue); // i
 705     ASSERT_EQUAL(29.2, fd.source); // n
 706     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 707     ASSERT_EQUAL(FALSE, fd.isNegative);
 708
 709     fd = df->getFixedDecimal(-30.0, status);
 710     TEST_ASSERT_STATUS(status);
 711     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v
 712     ASSERT_EQUAL(20, fd.decimalDigits); // f
 713     ASSERT_EQUAL(2, fd.decimalDigitsWithoutTrailingZeros); // t
 714     ASSERT_EQUAL(29, fd.intValue); // i
 715     ASSERT_EQUAL(29.2, fd.source); // n
 716     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 717     ASSERT_EQUAL(TRUE, fd.isNegative);
 718
 719     df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###", status), status);
 720     TEST_ASSERT_STATUS(status);
 721     fd = df->getFixedDecimal(123.456, status);
 722     TEST_ASSERT_STATUS(status);
 723     ASSERT_EQUAL(0, fd.visibleDecimalDigitCount);
 724     ASSERT_EQUAL(0, fd.decimalDigits);
 725     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
 726     ASSERT_EQUAL(123, fd.intValue);
 727     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
 728     ASSERT_EQUAL(FALSE, fd.isNegative);
 729
 730     df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status);
 731     TEST_ASSERT_STATUS(status);
 732     fd = df->getFixedDecimal(123.01, status);
 733     TEST_ASSERT_STATUS(status);
 734     ASSERT_EQUAL(1, fd.visibleDecimalDigitCount);
 735     ASSERT_EQUAL(0, fd.decimalDigits);
 736     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
 737     ASSERT_EQUAL(123, fd.intValue);
 738     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
 739     ASSERT_EQUAL(FALSE, fd.isNegative);
 740
 741     df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status);
 742     TEST_ASSERT_STATUS(status);
 743     fd = df->getFixedDecimal(123.06, status);
 744     TEST_ASSERT_STATUS(status);
 745     ASSERT_EQUAL(1, fd.visibleDecimalDigitCount);
 746     ASSERT_EQUAL(1, fd.decimalDigits);
 747     ASSERT_EQUAL(1, fd.decimalDigitsWithoutTrailingZeros);
 748     ASSERT_EQUAL(123, fd.intValue);
 749     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 750     ASSERT_EQUAL(FALSE, fd.isNegative);
 751
 752     df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status);  // Significant Digits
 753     TEST_ASSERT_STATUS(status);
 754     fd = df->getFixedDecimal(123, status);
 755     TEST_ASSERT_STATUS(status);
 756     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
 757     ASSERT_EQUAL(0, fd.decimalDigits);
 758     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
 759     ASSERT_EQUAL(123, fd.intValue);
 760     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
 761     ASSERT_EQUAL(FALSE, fd.isNegative);
 762
 763     df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status);  // Significant Digits
 764     TEST_ASSERT_STATUS(status);
 765     fd = df->getFixedDecimal(1.23, status);
 766     TEST_ASSERT_STATUS(status);
 767     ASSERT_EQUAL(4, fd.visibleDecimalDigitCount);
 768     ASSERT_EQUAL(2300, fd.decimalDigits);
 769     ASSERT_EQUAL(23, fd.decimalDigitsWithoutTrailingZeros);
 770     ASSERT_EQUAL(1, fd.intValue);
 771     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 772     ASSERT_EQUAL(FALSE, fd.isNegative);
 773
 774     fd = df->getFixedDecimal(uprv_getInfinity(), status);
 775     TEST_ASSERT_STATUS(status);
 776     ASSERT_EQUAL(TRUE, fd.isNanOrInfinity);
 777     fd = df->getFixedDecimal(0.0, status);
 778     ASSERT_EQUAL(FALSE, fd.isNanOrInfinity);
 779     fd = df->getFixedDecimal(uprv_getNaN(), status);
 780     ASSERT_EQUAL(TRUE, fd.isNanOrInfinity);
 781     TEST_ASSERT_STATUS(status);
 782
 783     // Test Big Decimal input.
 784     // 22 digits before and after decimal, will exceed the precision of a double
 785     //    and force DecimalFormat::getFixedDecimal() to work with a digit list.
 786     df.adoptInsteadAndCheckErrorCode(
 787         new DecimalFormat("#####################0.00####################", status), status);
 788     TEST_ASSERT_STATUS(status);
 789     Formattable fable("12.34", status);
 790     TEST_ASSERT_STATUS(status);
 791     fd = df->getFixedDecimal(fable, status);
 792     TEST_ASSERT_STATUS(status);
 793     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
 794     ASSERT_EQUAL(34, fd.decimalDigits);
 795     ASSERT_EQUAL(34, fd.decimalDigitsWithoutTrailingZeros);
 796     ASSERT_EQUAL(12, fd.intValue);
 797     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 798     ASSERT_EQUAL(FALSE, fd.isNegative);
 799
 800     fable.setDecimalNumber("12.345678901234567890123456789", status);
 801     TEST_ASSERT_STATUS(status);
 802     fd = df->getFixedDecimal(fable, status);
 803     TEST_ASSERT_STATUS(status);
 804     ASSERT_EQUAL(22, fd.visibleDecimalDigitCount);
 805     ASSERT_EQUAL(345678901234567890LL, fd.decimalDigits);
 806     ASSERT_EQUAL(34567890123456789LL, fd.decimalDigitsWithoutTrailingZeros);
 807     ASSERT_EQUAL(12, fd.intValue);
 808     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 809     ASSERT_EQUAL(FALSE, fd.isNegative);
 810
 811     // On field overflow, Integer part is truncated on the left, fraction part on the right.
 812     fable.setDecimalNumber("123456789012345678901234567890.123456789012345678901234567890", status);
 813     TEST_ASSERT_STATUS(status);
 814     fd = df->getFixedDecimal(fable, status);
 815     TEST_ASSERT_STATUS(status);
 816     ASSERT_EQUAL(22, fd.visibleDecimalDigitCount);
 817     ASSERT_EQUAL(123456789012345678LL, fd.decimalDigits);
 818     ASSERT_EQUAL(123456789012345678LL, fd.decimalDigitsWithoutTrailingZeros);
 819     ASSERT_EQUAL(345678901234567890LL, fd.intValue);
 820     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 821     ASSERT_EQUAL(FALSE, fd.isNegative);
 822
 823     // Digits way to the right of the decimal but within the format's precision aren't truncated
 824     fable.setDecimalNumber("1.0000000000000000000012", status);
 825     TEST_ASSERT_STATUS(status);
 826     fd = df->getFixedDecimal(fable, status);
 827     TEST_ASSERT_STATUS(status);
 828     ASSERT_EQUAL(22, fd.visibleDecimalDigitCount);
 829     ASSERT_EQUAL(12, fd.decimalDigits);
 830     ASSERT_EQUAL(12, fd.decimalDigitsWithoutTrailingZeros);
 831     ASSERT_EQUAL(1, fd.intValue);
 832     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 833     ASSERT_EQUAL(FALSE, fd.isNegative);
 834
 835     // Digits beyond the precision of the format are rounded away
 836     fable.setDecimalNumber("1.000000000000000000000012", status);
 837     TEST_ASSERT_STATUS(status);
 838     fd = df->getFixedDecimal(fable, status);
 839     TEST_ASSERT_STATUS(status);
 840     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
 841     ASSERT_EQUAL(0, fd.decimalDigits);
 842     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
 843     ASSERT_EQUAL(1, fd.intValue);
 844     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
 845     ASSERT_EQUAL(FALSE, fd.isNegative);
 846
 847     // Negative numbers come through
 848     fable.setDecimalNumber("-1.0000000000000000000012", status);
 849     TEST_ASSERT_STATUS(status);
 850     fd = df->getFixedDecimal(fable, status);
 851     TEST_ASSERT_STATUS(status);
 852     ASSERT_EQUAL(22, fd.visibleDecimalDigitCount);
 853     ASSERT_EQUAL(12, fd.decimalDigits);
 854     ASSERT_EQUAL(12, fd.decimalDigitsWithoutTrailingZeros);
 855     ASSERT_EQUAL(1, fd.intValue);
 856     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 857     ASSERT_EQUAL(TRUE, fd.isNegative);
 858
 859     // MinFractionDigits from format larger than from number.
 860     fable.setDecimalNumber("1000000000000000000000.3", status);
 861     TEST_ASSERT_STATUS(status);
 862     fd = df->getFixedDecimal(fable, status);
 863     TEST_ASSERT_STATUS(status);
 864     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
 865     ASSERT_EQUAL(30, fd.decimalDigits);
 866     ASSERT_EQUAL(3, fd.decimalDigitsWithoutTrailingZeros);
 867     ASSERT_EQUAL(100000000000000000LL, fd.intValue);
 868     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 869     ASSERT_EQUAL(FALSE, fd.isNegative);
 870
 871     fable.setDecimalNumber("1000000000000000050000.3", status);
 872     TEST_ASSERT_STATUS(status);
 873     fd = df->getFixedDecimal(fable, status);
 874     TEST_ASSERT_STATUS(status);
 875     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
 876     ASSERT_EQUAL(30, fd.decimalDigits);
 877     ASSERT_EQUAL(3, fd.decimalDigitsWithoutTrailingZeros);
 878     ASSERT_EQUAL(50000LL, fd.intValue);
 879     ASSERT_EQUAL(FALSE, fd.hasIntegerValue);
 880     ASSERT_EQUAL(FALSE, fd.isNegative);
 881
 882     // Test some int64_t values that are out of the range of a double
 883     fable.setInt64(4503599627370496LL);
 884     TEST_ASSERT_STATUS(status);
 885     fd = df->getFixedDecimal(fable, status);
 886     TEST_ASSERT_STATUS(status);
 887     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
 888     ASSERT_EQUAL(0, fd.decimalDigits);
 889     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
 890     ASSERT_EQUAL(4503599627370496LL, fd.intValue);
 891     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
 892     ASSERT_EQUAL(FALSE, fd.isNegative);
 893
 894     fable.setInt64(4503599627370497LL);
 895     TEST_ASSERT_STATUS(status);
 896     fd = df->getFixedDecimal(fable, status);
 897     TEST_ASSERT_STATUS(status);
 898     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
 899     ASSERT_EQUAL(0, fd.decimalDigits);
 900     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
 901     ASSERT_EQUAL(4503599627370497LL, fd.intValue);
 902     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
 903     ASSERT_EQUAL(FALSE, fd.isNegative);
 904
 905     fable.setInt64(9223372036854775807LL);
 906     TEST_ASSERT_STATUS(status);
 907     fd = df->getFixedDecimal(fable, status);
 908     TEST_ASSERT_STATUS(status);
 909     ASSERT_EQUAL(2, fd.visibleDecimalDigitCount);
 910     ASSERT_EQUAL(0, fd.decimalDigits);
 911     ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros);
 912     // note: going through DigitList path to FixedDecimal, which is trimming
 913     //       int64_t fields to 18 digits. See ticket Ticket #10374
 914     // ASSERT_EQUAL(223372036854775807LL, fd.intValue);
 915     if (!(fd.intValue == 223372036854775807LL || fd.intValue == 9223372036854775807LL)) {
 916         dataerrln("File %s, Line %d, fd.intValue = %lld", __FILE__, __LINE__, fd.intValue);
 917     }
 918     ASSERT_EQUAL(TRUE, fd.hasIntegerValue);
 919     ASSERT_EQUAL(FALSE, fd.isNegative);
 920
 921 }
 922
 923 void IntlTestDecimalFormatAPI::TestBadFastpath() {
 924     UErrorCode status = U_ZERO_ERROR;
 925
 926     LocalPointer<DecimalFormat> df(new DecimalFormat("###", status), status);
 927     if (U_FAILURE(status)) {
 928         dataerrln("Error creating new DecimalFormat - %s", u_errorName(status));
 929         return;
 930     }
 931
 932     UnicodeString fmt;
 933     fmt.remove();
 934     assertEquals("Format 1234", "1234", df->format((int32_t)1234, fmt));
 935     df->setGroupingUsed(FALSE);
 936     fmt.remove();
 937     assertEquals("Format 1234", "1234", df->format((int32_t)1234, fmt));
 938     df->setGroupingUsed(TRUE);
 939     df->setGroupingSize(3);
 940     fmt.remove();
 941     assertEquals("Format 1234 w/ grouping", "1,234", df->format((int32_t)1234, fmt));
 942 }
 943
 944 void IntlTestDecimalFormatAPI::TestRequiredDecimalPoint() {
 945     UErrorCode status = U_ZERO_ERROR;
 946     UnicodeString text("99");
 947     Formattable result1;
 948     UnicodeString pat1("##.0000");
 949     UnicodeString pat2("00.0");
 950
 951     LocalPointer<DecimalFormat> df(new DecimalFormat(pat1, status), status);
 952     if (U_FAILURE(status)) {
 953         dataerrln("Error creating new DecimalFormat - %s", u_errorName(status));
 954         return;
 955     }
 956
 957     status = U_ZERO_ERROR;
 958     df->applyPattern(pat1, status);
 959     if(U_FAILURE(status)) {
 960         errln((UnicodeString)"ERROR: applyPattern() failed");
 961     }
 962     df->parse(text, result1, status);
 963     if(U_FAILURE(status)) {
 964         errln((UnicodeString)"ERROR: parse() failed");
 965     }
 966     df->setDecimalPatternMatchRequired(TRUE);
 967     df->parse(text, result1, status);
 968     if(U_SUCCESS(status)) {
 969         errln((UnicodeString)"ERROR: unexpected parse()");
 970     }
 971
 972
 973     status = U_ZERO_ERROR;
 974     df->applyPattern(pat2, status);
 975     df->setDecimalPatternMatchRequired(FALSE);
 976     if(U_FAILURE(status)) {
 977         errln((UnicodeString)"ERROR: applyPattern(2) failed");
 978     }
 979     df->parse(text, result1, status);
 980     if(U_FAILURE(status)) {
 981         errln((UnicodeString)"ERROR: parse(2) failed - " + u_errorName(status));
 982     }
 983     df->setDecimalPatternMatchRequired(TRUE);
 984     df->parse(text, result1, status);
 985     if(U_SUCCESS(status)) {
 986         errln((UnicodeString)"ERROR: unexpected parse(2)");
 987     }
 988 }
 989
 990 #endif /* #if !UCONFIG_NO_FORMATTING */