src/third_party/icu/source/test/intltest/dcfmapts.cpp

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