icuSources/test/intltest/dcfmapts.cpp

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