icuSources/test/intltest/dcfmapts.cpp

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