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