icuSources/test/intltest/dcfmapts.cpp

   1 /********************************************************************
   2  * COPYRIGHT:
   3  * Copyright (c) 1997-2010, 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/decimfmt.h"
  14 #include "unicode/dcfmtsym.h"
  15 #include "unicode/parseerr.h"
  16 #include "unicode/currpinf.h"
  17
  18 // This is an API test, not a unit test.  It doesn't test very many cases, and doesn't
  19 // try to test the full functionality.  It just calls each function in the class and
  20 // verifies that it works on a basic level.
  21
  22 void IntlTestDecimalFormatAPI::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ )
  23 {
  24     if (exec) logln((UnicodeString)"TestSuite DecimalFormatAPI");
  25     switch (index) {
  26         case 0: name = "DecimalFormat API test";
  27                 if (exec) {
  28                     logln((UnicodeString)"DecimalFormat API test---"); logln((UnicodeString)"");
  29                     UErrorCode status = U_ZERO_ERROR;
  30                     Locale saveLocale;
  31                     Locale::setDefault(Locale::getEnglish(), status);
  32                     if(U_FAILURE(status)) {
  33                         errln((UnicodeString)"ERROR: Could not set default locale, test may not give correct results");
  34                     }
  35                     testAPI(/*par*/);
  36                     Locale::setDefault(saveLocale, status);
  37                 }
  38                 break;
  39         case 1: name = "Rounding test";
  40             if(exec) {
  41                logln((UnicodeString)"DecimalFormat Rounding test---");
  42                testRounding(/*par*/);
  43             }
  44             break;
  45         case 2: name = "Test6354";
  46             if(exec) {
  47                logln((UnicodeString)"DecimalFormat Rounding Increment test---");
  48                testRoundingInc(/*par*/);
  49             }
  50             break;
  51         case 3: name = "TestCurrencyPluralInfo";
  52             if(exec) {
  53                logln((UnicodeString)"CurrencyPluralInfo API test---");
  54                TestCurrencyPluralInfo();
  55             }
  56             break;
  57         default: name = ""; break;
  58     }
  59 }
  60
  61 /**
  62  * This test checks various generic API methods in DecimalFormat to achieve 100%
  63  * API coverage.
  64  */
  65 void IntlTestDecimalFormatAPI::testAPI(/*char *par*/)
  66 {
  67     UErrorCode status = U_ZERO_ERROR;
  68
  69 // ======= Test constructors
  70
  71     logln((UnicodeString)"Testing DecimalFormat constructors");
  72
  73     DecimalFormat def(status);
  74     if(U_FAILURE(status)) {
  75         errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
  76         return;
  77     }
  78
  79     status = U_ZERO_ERROR;
  80     const UnicodeString pattern("#,##0.# FF");
  81     DecimalFormat pat(pattern, status);
  82     if(U_FAILURE(status)) {
  83         errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern)");
  84         return;
  85     }
  86
  87     status = U_ZERO_ERROR;
  88     DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getFrench(), status);
  89     if(U_FAILURE(status)) {
  90         errln((UnicodeString)"ERROR: Could not create DecimalFormatSymbols (French)");
  91         return;
  92     }
  93
  94     status = U_ZERO_ERROR;
  95     DecimalFormat cust1(pattern, symbols, status);
  96     if(U_FAILURE(status)) {
  97         errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols*)");
  98     }
  99
 100     status = U_ZERO_ERROR;
 101     DecimalFormat cust2(pattern, *symbols, status);
 102     if(U_FAILURE(status)) {
 103         errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols)");
 104     }
 105
 106     DecimalFormat copy(pat);
 107
 108 // ======= Test clone(), assignment, and equality
 109
 110     logln((UnicodeString)"Testing clone(), assignment and equality operators");
 111
 112     if( ! (copy == pat) || copy != pat) {
 113         errln((UnicodeString)"ERROR: Copy constructor or == failed");
 114     }
 115
 116     copy = cust1;
 117     if(copy != cust1) {
 118         errln((UnicodeString)"ERROR: Assignment (or !=) failed");
 119     }
 120
 121     Format *clone = def.clone();
 122     if( ! (*clone == def) ) {
 123         errln((UnicodeString)"ERROR: Clone() failed");
 124     }
 125     delete clone;
 126
 127 // ======= Test various format() methods
 128
 129     logln((UnicodeString)"Testing various format() methods");
 130
 131     double d = -10456.0037;
 132     int32_t l = 100000000;
 133     Formattable fD(d);
 134     Formattable fL(l);
 135
 136     UnicodeString res1, res2, res3, res4;
 137     FieldPosition pos1(0), pos2(0), pos3(0), pos4(0);
 138
 139     res1 = def.format(d, res1, pos1);
 140     logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1);
 141
 142     res2 = pat.format(l, res2, pos2);
 143     logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2);
 144
 145     status = U_ZERO_ERROR;
 146     res3 = cust1.format(fD, res3, pos3, status);
 147     if(U_FAILURE(status)) {
 148         errln((UnicodeString)"ERROR: format(Formattable [double]) failed");
 149     }
 150     logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res3);
 151
 152     status = U_ZERO_ERROR;
 153     res4 = cust2.format(fL, res4, pos4, status);
 154     if(U_FAILURE(status)) {
 155         errln((UnicodeString)"ERROR: format(Formattable [long]) failed");
 156     }
 157     logln((UnicodeString) "" + fL.getLong() + " formatted to " + res4);
 158
 159 // ======= Test parse()
 160
 161     logln((UnicodeString)"Testing parse()");
 162
 163     UnicodeString text("-10,456.0037");
 164     Formattable result1, result2;
 165     ParsePosition pos(0);
 166     UnicodeString patt("#,##0.#");
 167     status = U_ZERO_ERROR;
 168     pat.applyPattern(patt, status);
 169     if(U_FAILURE(status)) {
 170         errln((UnicodeString)"ERROR: applyPattern() failed");
 171     }
 172     pat.parse(text, result1, pos);
 173     if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) {
 174         errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
 175     }
 176     logln(text + " parsed into " + (int32_t) result1.getDouble());
 177
 178     status = U_ZERO_ERROR;
 179     pat.parse(text, result2, status);
 180     if(U_FAILURE(status)) {
 181         errln((UnicodeString)"ERROR: parse() failed");
 182     }
 183     if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) {
 184         errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text);
 185     }
 186     logln(text + " parsed into " + (int32_t) result2.getDouble());
 187
 188 // ======= Test getters and setters
 189
 190     logln((UnicodeString)"Testing getters and setters");
 191
 192     const DecimalFormatSymbols *syms = pat.getDecimalFormatSymbols();
 193     DecimalFormatSymbols *newSyms = new DecimalFormatSymbols(*syms);
 194     def.setDecimalFormatSymbols(*newSyms);
 195     def.adoptDecimalFormatSymbols(newSyms); // don't use newSyms after this
 196     if( *(pat.getDecimalFormatSymbols()) != *(def.getDecimalFormatSymbols())) {
 197         errln((UnicodeString)"ERROR: adopt or set DecimalFormatSymbols() failed");
 198     }
 199
 200     UnicodeString posPrefix;
 201     pat.setPositivePrefix("+");
 202     posPrefix = pat.getPositivePrefix(posPrefix);
 203     logln((UnicodeString)"Positive prefix (should be +): " + posPrefix);
 204     if(posPrefix != "+") {
 205         errln((UnicodeString)"ERROR: setPositivePrefix() failed");
 206     }
 207
 208     UnicodeString negPrefix;
 209     pat.setNegativePrefix("-");
 210     negPrefix = pat.getNegativePrefix(negPrefix);
 211     logln((UnicodeString)"Negative prefix (should be -): " + negPrefix);
 212     if(negPrefix != "-") {
 213         errln((UnicodeString)"ERROR: setNegativePrefix() failed");
 214     }
 215
 216     UnicodeString posSuffix;
 217     pat.setPositiveSuffix("_");
 218     posSuffix = pat.getPositiveSuffix(posSuffix);
 219     logln((UnicodeString)"Positive suffix (should be _): " + posSuffix);
 220     if(posSuffix != "_") {
 221         errln((UnicodeString)"ERROR: setPositiveSuffix() failed");
 222     }
 223
 224     UnicodeString negSuffix;
 225     pat.setNegativeSuffix("~");
 226     negSuffix = pat.getNegativeSuffix(negSuffix);
 227     logln((UnicodeString)"Negative suffix (should be ~): " + negSuffix);
 228     if(negSuffix != "~") {
 229         errln((UnicodeString)"ERROR: setNegativeSuffix() failed");
 230     }
 231
 232     int32_t multiplier = 0;
 233     pat.setMultiplier(8);
 234     multiplier = pat.getMultiplier();
 235     logln((UnicodeString)"Multiplier (should be 8): " + multiplier);
 236     if(multiplier != 8) {
 237         errln((UnicodeString)"ERROR: setMultiplier() failed");
 238     }
 239
 240     int32_t groupingSize = 0;
 241     pat.setGroupingSize(2);
 242     groupingSize = pat.getGroupingSize();
 243     logln((UnicodeString)"Grouping size (should be 2): " + (int32_t) groupingSize);
 244     if(groupingSize != 2) {
 245         errln((UnicodeString)"ERROR: setGroupingSize() failed");
 246     }
 247
 248     pat.setDecimalSeparatorAlwaysShown(TRUE);
 249     UBool tf = pat.isDecimalSeparatorAlwaysShown();
 250     logln((UnicodeString)"DecimalSeparatorIsAlwaysShown (should be TRUE) is " + (UnicodeString) (tf ? "TRUE" : "FALSE"));
 251     if(tf != TRUE) {
 252         errln((UnicodeString)"ERROR: setDecimalSeparatorAlwaysShown() failed");
 253     }
 254     // Added by Ken Liu testing set/isExponentSignAlwaysShown
 255     pat.setExponentSignAlwaysShown(TRUE);
 256     UBool esas = pat.isExponentSignAlwaysShown();
 257     logln((UnicodeString)"ExponentSignAlwaysShown (should be TRUE) is " + (UnicodeString) (esas ? "TRUE" : "FALSE"));
 258     if(esas != TRUE) {
 259         errln((UnicodeString)"ERROR: ExponentSignAlwaysShown() failed");
 260     }
 261
 262     // Added by Ken Liu testing set/isScientificNotation
 263     pat.setScientificNotation(TRUE);
 264     UBool sn = pat.isScientificNotation();
 265     logln((UnicodeString)"isScientificNotation (should be TRUE) is " + (UnicodeString) (sn ? "TRUE" : "FALSE"));
 266     if(sn != TRUE) {
 267         errln((UnicodeString)"ERROR: setScientificNotation() failed");
 268     }
 269
 270     // Added by Ken Liu testing set/getMinimumExponentDigits
 271     int8_t MinimumExponentDigits = 0;
 272     pat.setMinimumExponentDigits(2);
 273     MinimumExponentDigits = pat.getMinimumExponentDigits();
 274     logln((UnicodeString)"MinimumExponentDigits (should be 2) is " + (int8_t) MinimumExponentDigits);
 275     if(MinimumExponentDigits != 2) {
 276         errln((UnicodeString)"ERROR: setMinimumExponentDigits() failed");
 277     }
 278
 279     // Added by Ken Liu testing set/getRoundingIncrement
 280     double RoundingIncrement = 0.0;
 281     pat.setRoundingIncrement(2.0);
 282     RoundingIncrement = pat.getRoundingIncrement();
 283     logln((UnicodeString)"RoundingIncrement (should be 2.0) is " + (double) RoundingIncrement);
 284     if(RoundingIncrement != 2.0) {
 285         errln((UnicodeString)"ERROR: setRoundingIncrement() failed");
 286     }
 287     //end of Ken's Adding
 288
 289     UnicodeString funkyPat;
 290     funkyPat = pat.toPattern(funkyPat);
 291     logln((UnicodeString)"Pattern is " + funkyPat);
 292
 293     UnicodeString locPat;
 294     locPat = pat.toLocalizedPattern(locPat);
 295     logln((UnicodeString)"Localized pattern is " + locPat);
 296
 297 // ======= Test applyPattern()
 298
 299     logln((UnicodeString)"Testing applyPattern()");
 300
 301     UnicodeString p1("#,##0.0#;(#,##0.0#)");
 302     logln((UnicodeString)"Applying pattern " + p1);
 303     status = U_ZERO_ERROR;
 304     pat.applyPattern(p1, status);
 305     if(U_FAILURE(status)) {
 306         errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
 307     }
 308     UnicodeString s2;
 309     s2 = pat.toPattern(s2);
 310     logln((UnicodeString)"Extracted pattern is " + s2);
 311     if(s2 != p1) {
 312         errln((UnicodeString)"ERROR: toPattern() result did not match pattern applied");
 313     }
 314
 315     if(pat.getSecondaryGroupingSize() != 0) {
 316         errln("FAIL: Secondary Grouping Size should be 0, not %d\n", pat.getSecondaryGroupingSize());
 317     }
 318
 319     if(pat.getGroupingSize() != 3) {
 320         errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
 321     }
 322
 323     UnicodeString p2("#,##,##0.0# FF;(#,##,##0.0# FF)");
 324     logln((UnicodeString)"Applying pattern " + p2);
 325     status = U_ZERO_ERROR;
 326     pat.applyLocalizedPattern(p2, status);
 327     if(U_FAILURE(status)) {
 328         errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) status);
 329     }
 330     UnicodeString s3;
 331     s3 = pat.toLocalizedPattern(s3);
 332     logln((UnicodeString)"Extracted pattern is " + s3);
 333     if(s3 != p2) {
 334         errln((UnicodeString)"ERROR: toLocalizedPattern() result did not match pattern applied");
 335     }
 336
 337     status = U_ZERO_ERROR;
 338     UParseError pe;
 339     pat.applyLocalizedPattern(p2, pe, status);
 340     if(U_FAILURE(status)) {
 341         errln((UnicodeString)"ERROR: applyPattern((with ParseError)) failed with " + (int32_t) status);
 342     }
 343     UnicodeString s4;
 344     s4 = pat.toLocalizedPattern(s3);
 345     logln((UnicodeString)"Extracted pattern is " + s4);
 346     if(s4 != p2) {
 347         errln((UnicodeString)"ERROR: toLocalizedPattern(with ParseErr) result did not match pattern applied");
 348     }
 349
 350     if(pat.getSecondaryGroupingSize() != 2) {
 351         errln("FAIL: Secondary Grouping Size should be 2, not %d\n", pat.getSecondaryGroupingSize());
 352     }
 353
 354     if(pat.getGroupingSize() != 3) {
 355         errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupingSize());
 356     }
 357
 358 // ======= Test getStaticClassID()
 359
 360     logln((UnicodeString)"Testing getStaticClassID()");
 361
 362     status = U_ZERO_ERROR;
 363     NumberFormat *test = new DecimalFormat(status);
 364     if(U_FAILURE(status)) {
 365         errln((UnicodeString)"ERROR: Couldn't create a DecimalFormat");
 366     }
 367
 368     if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) {
 369         errln((UnicodeString)"ERROR: getDynamicClassID() didn't return the expected value");
 370     }
 371
 372     delete test;
 373 }
 374
 375 void IntlTestDecimalFormatAPI::TestCurrencyPluralInfo(){
 376     UErrorCode status = U_ZERO_ERROR;
 377
 378     CurrencyPluralInfo *cpi = new CurrencyPluralInfo(status);
 379     if(U_FAILURE(status)) {
 380         errln((UnicodeString)"ERROR: CurrencyPluralInfo(UErrorCode) could not be created");
 381     }
 382
 383     CurrencyPluralInfo cpi1 = *cpi;
 384
 385     if(cpi->getDynamicClassID() != CurrencyPluralInfo::getStaticClassID()){
 386         errln((UnicodeString)"ERROR: CurrencyPluralInfo::getDynamicClassID() didn't return the expected value");
 387     }
 388
 389     cpi->setCurrencyPluralPattern("","",status);
 390     if(U_FAILURE(status)) {
 391         errln((UnicodeString)"ERROR: CurrencyPluralInfo::setCurrencyPluralPattern");
 392     }
 393
 394     cpi->setLocale(Locale::getCanada(), status);
 395     if(U_FAILURE(status)) {
 396         errln((UnicodeString)"ERROR: CurrencyPluralInfo::setLocale");
 397     }
 398
 399     cpi->setPluralRules("",status);
 400     if(U_FAILURE(status)) {
 401         errln((UnicodeString)"ERROR: CurrencyPluralInfo::setPluralRules");
 402     }
 403
 404     DecimalFormat *df = new DecimalFormat(status);
 405     if(U_FAILURE(status)) {
 406         errcheckln(status, "ERROR: Could not create DecimalFormat - %s", u_errorName(status));
 407     }
 408
 409     df->adoptCurrencyPluralInfo(cpi);
 410
 411     df->getCurrencyPluralInfo();
 412
 413     df->setCurrencyPluralInfo(cpi1);
 414
 415     delete df;
 416 }
 417
 418 void IntlTestDecimalFormatAPI::testRounding(/*char *par*/)
 419 {
 420     UErrorCode status = U_ZERO_ERROR;
 421     double Roundingnumber = 2.55;
 422     double Roundingnumber1 = -2.55;
 423                       //+2.55 results   -2.55 results
 424     double result[]={   3.0,            -2.0,    //  kRoundCeiling  0,
 425                         2.0,            -3.0,    //  kRoundFloor    1,
 426                         2.0,            -2.0,    //  kRoundDown     2,
 427                         3.0,            -3.0,    //  kRoundUp       3,
 428                         3.0,            -3.0,    //  kRoundHalfEven 4,
 429                         3.0,            -3.0,    //  kRoundHalfDown 5,
 430                         3.0,            -3.0     //  kRoundHalfUp   6
 431     };
 432     DecimalFormat pat(status);
 433     if(U_FAILURE(status)) {
 434       errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
 435       return;
 436     }
 437     uint16_t mode;
 438     uint16_t i=0;
 439     UnicodeString message;
 440     UnicodeString resultStr;
 441     for(mode=0;mode < 7;mode++){
 442         pat.setRoundingMode((DecimalFormat::ERoundingMode)mode);
 443         if(pat.getRoundingMode() != (DecimalFormat::ERoundingMode)mode){
 444             errln((UnicodeString)"SetRoundingMode or GetRoundingMode failed for mode=" + mode);
 445         }
 446
 447
 448         //for +2.55 with RoundingIncrement=1.0
 449         pat.setRoundingIncrement(1.0);
 450         pat.format(Roundingnumber, resultStr);
 451         message= (UnicodeString)"round(" + (double)Roundingnumber + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=1.0==>");
 452         verify(message, resultStr, result[i++]);
 453         message.remove();
 454         resultStr.remove();
 455
 456         //for -2.55 with RoundingIncrement=1.0
 457         pat.format(Roundingnumber1, resultStr);
 458         message= (UnicodeString)"round(" + (double)Roundingnumber1 + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=1.0==>");
 459         verify(message, resultStr, result[i++]);
 460         message.remove();
 461         resultStr.remove();
 462     }
 463
 464 }
 465 void IntlTestDecimalFormatAPI::verify(const UnicodeString& message, const UnicodeString& got, double expected){
 466     logln((UnicodeString)message + got + (UnicodeString)" Expected : " + expected);
 467     UnicodeString expectedStr("");
 468     expectedStr=expectedStr + expected;
 469     if(got != expectedStr ) {
 470             errln((UnicodeString)"ERROR: Round() failed:  " + message + got + (UnicodeString)"  Expected : " + expectedStr);
 471         }
 472 }
 473
 474 void IntlTestDecimalFormatAPI::testRoundingInc(/*char *par*/)
 475 {
 476     UErrorCode status = U_ZERO_ERROR;
 477     DecimalFormat pat(UnicodeString("#,##0.00"),status);
 478     if(U_FAILURE(status)) {
 479       errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s", u_errorName(status));
 480       return;
 481     }
 482
 483     // get default rounding increment
 484     double roundingInc = pat.getRoundingIncrement();
 485     if (roundingInc != 0.0) {
 486       errln((UnicodeString)"ERROR: Rounding increment not zero");
 487       return;
 488     }
 489
 490     // With rounding now being handled by decNumber, we no longer
 491     // set a rounding increment to enable non-default mode rounding,
 492     // checking of which was the original point of this test.
 493
 494     // set rounding mode with zero increment.  Rounding
 495     // increment should not be set by this operation
 496     pat.setRoundingMode((DecimalFormat::ERoundingMode)0);
 497     roundingInc = pat.getRoundingIncrement();
 498     if (roundingInc != 0.0) {
 499       errln((UnicodeString)"ERROR: Rounding increment not zero after setRoundingMode");
 500       return;
 501     }
 502 }
 503
 504 #endif /* #if !UCONFIG_NO_FORMATTING */