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