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