1 // Copyright (C) 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /******************************************************************** 4 * COPYRIGHT: 5 * Copyright (c) 1997-2016, International Business Machines Corporation and 6 * others. All Rights Reserved. 7 ********************************************************************/ 8 /* Modification History: 9 * Date Name Description 10 * 07/15/99 helena Ported to HPUX 10/11 CC. 11 */ 12 13 #include "unicode/utypes.h" 14 15 #if !UCONFIG_NO_FORMATTING 16 17 #include "numfmtst.h" 18 #include "unicode/dcfmtsym.h" 19 #include "unicode/decimfmt.h" 20 #include "unicode/localpointer.h" 21 #include "unicode/ucurr.h" 22 #include "unicode/ustring.h" 23 #include "unicode/measfmt.h" 24 #include "unicode/curramt.h" 25 #include "digitlst.h" 26 #include "textfile.h" 27 #include "tokiter.h" 28 #include "charstr.h" 29 #include "putilimp.h" 30 #include "winnmtst.h" 31 #include <float.h> 32 #include <string.h> 33 #include <stdlib.h> 34 #include "cmemory.h" 35 #include "cstring.h" 36 #include "unicode/numsys.h" 37 #include "fmtableimp.h" 38 #include "numberformattesttuple.h" 39 #include "datadrivennumberformattestsuite.h" 40 #include "unicode/msgfmt.h" 41 42 class NumberFormatTestDataDriven : public DataDrivenNumberFormatTestSuite { 43 protected: 44 UBool isFormatPass( 45 const NumberFormatTestTuple &tuple, 46 UnicodeString &appendErrorMessage, 47 UErrorCode &status); 48 UBool isToPatternPass( 49 const NumberFormatTestTuple &tuple, 50 UnicodeString &appendErrorMessage, 51 UErrorCode &status); 52 UBool isParsePass( 53 const NumberFormatTestTuple &tuple, 54 UnicodeString &appendErrorMessage, 55 UErrorCode &status); 56 UBool isParseCurrencyPass( 57 const NumberFormatTestTuple &tuple, 58 UnicodeString &appendErrorMessage, 59 UErrorCode &status); 60 }; 61 62 static DigitList &strToDigitList( 63 const UnicodeString &str, 64 DigitList &digitList, 65 UErrorCode &status) { 66 if (U_FAILURE(status)) { 67 return digitList; 68 } 69 if (str == "NaN") { 70 digitList.set(uprv_getNaN()); 71 return digitList; 72 } 73 if (str == "-Inf") { 74 digitList.set(-1*uprv_getInfinity()); 75 return digitList; 76 } 77 if (str == "Inf") { 78 digitList.set(uprv_getInfinity()); 79 return digitList; 80 } 81 CharString formatValue; 82 formatValue.appendInvariantChars(str, status); 83 digitList.set(StringPiece(formatValue.data()), status, 0); 84 return digitList; 85 } 86 87 static UnicodeString &format( 88 const DecimalFormat &fmt, 89 const DigitList &digitList, 90 UnicodeString &appendTo, 91 UErrorCode &status) { 92 if (U_FAILURE(status)) { 93 return appendTo; 94 } 95 FieldPosition fpos(FieldPosition::DONT_CARE); 96 return fmt.format(digitList, appendTo, fpos, status); 97 } 98 99 template<class T> 100 static UnicodeString &format( 101 const DecimalFormat &fmt, 102 T value, 103 UnicodeString &appendTo, 104 UErrorCode &status) { 105 if (U_FAILURE(status)) { 106 return appendTo; 107 } 108 FieldPosition fpos(FieldPosition::DONT_CARE); 109 return fmt.format(value, appendTo, fpos, status); 110 } 111 112 static void adjustDecimalFormat( 113 const NumberFormatTestTuple &tuple, 114 DecimalFormat &fmt, 115 UnicodeString &appendErrorMessage) { 116 if (tuple.minIntegerDigitsFlag) { 117 fmt.setMinimumIntegerDigits(tuple.minIntegerDigits); 118 } 119 if (tuple.maxIntegerDigitsFlag) { 120 fmt.setMaximumIntegerDigits(tuple.maxIntegerDigits); 121 } 122 if (tuple.minFractionDigitsFlag) { 123 fmt.setMinimumFractionDigits(tuple.minFractionDigits); 124 } 125 if (tuple.maxFractionDigitsFlag) { 126 fmt.setMaximumFractionDigits(tuple.maxFractionDigits); 127 } 128 if (tuple.currencyFlag) { 129 UErrorCode status = U_ZERO_ERROR; 130 UnicodeString currency(tuple.currency); 131 const UChar *terminatedCurrency = currency.getTerminatedBuffer(); 132 fmt.setCurrency(terminatedCurrency, status); 133 if (U_FAILURE(status)) { 134 appendErrorMessage.append("Error setting currency."); 135 } 136 } 137 if (tuple.minGroupingDigitsFlag) { 138 fmt.setMinimumGroupingDigits(tuple.minGroupingDigits); 139 } 140 if (tuple.useSigDigitsFlag) { 141 fmt.setSignificantDigitsUsed(tuple.useSigDigits != 0); 142 } 143 if (tuple.minSigDigitsFlag) { 144 fmt.setMinimumSignificantDigits(tuple.minSigDigits); 145 } 146 if (tuple.maxSigDigitsFlag) { 147 fmt.setMaximumSignificantDigits(tuple.maxSigDigits); 148 } 149 if (tuple.useGroupingFlag) { 150 fmt.setGroupingUsed(tuple.useGrouping != 0); 151 } 152 if (tuple.multiplierFlag) { 153 fmt.setMultiplier(tuple.multiplier); 154 } 155 if (tuple.roundingIncrementFlag) { 156 fmt.setRoundingIncrement(tuple.roundingIncrement); 157 } 158 if (tuple.formatWidthFlag) { 159 fmt.setFormatWidth(tuple.formatWidth); 160 } 161 if (tuple.padCharacterFlag) { 162 fmt.setPadCharacter(tuple.padCharacter); 163 } 164 if (tuple.useScientificFlag) { 165 fmt.setScientificNotation(tuple.useScientific != 0); 166 } 167 if (tuple.groupingFlag) { 168 fmt.setGroupingSize(tuple.grouping); 169 } 170 if (tuple.grouping2Flag) { 171 fmt.setSecondaryGroupingSize(tuple.grouping2); 172 } 173 if (tuple.roundingModeFlag) { 174 fmt.setRoundingMode(tuple.roundingMode); 175 } 176 if (tuple.currencyUsageFlag) { 177 UErrorCode status = U_ZERO_ERROR; 178 fmt.setCurrencyUsage(tuple.currencyUsage, &status); 179 if (U_FAILURE(status)) { 180 appendErrorMessage.append("CurrencyUsage: error setting."); 181 } 182 } 183 if (tuple.minimumExponentDigitsFlag) { 184 fmt.setMinimumExponentDigits(tuple.minimumExponentDigits); 185 } 186 if (tuple.exponentSignAlwaysShownFlag) { 187 fmt.setExponentSignAlwaysShown(tuple.exponentSignAlwaysShown != 0); 188 } 189 if (tuple.decimalSeparatorAlwaysShownFlag) { 190 fmt.setDecimalSeparatorAlwaysShown( 191 tuple.decimalSeparatorAlwaysShown != 0); 192 } 193 if (tuple.padPositionFlag) { 194 fmt.setPadPosition(tuple.padPosition); 195 } 196 if (tuple.positivePrefixFlag) { 197 fmt.setPositivePrefix(tuple.positivePrefix); 198 } 199 if (tuple.positiveSuffixFlag) { 200 fmt.setPositiveSuffix(tuple.positiveSuffix); 201 } 202 if (tuple.negativePrefixFlag) { 203 fmt.setNegativePrefix(tuple.negativePrefix); 204 } 205 if (tuple.negativeSuffixFlag) { 206 fmt.setNegativeSuffix(tuple.negativeSuffix); 207 } 208 if (tuple.localizedPatternFlag) { 209 UErrorCode status = U_ZERO_ERROR; 210 fmt.applyLocalizedPattern(tuple.localizedPattern, status); 211 if (U_FAILURE(status)) { 212 appendErrorMessage.append("Error setting localized pattern."); 213 } 214 } 215 fmt.setLenient(NFTT_GET_FIELD(tuple, lenient, 1) != 0); 216 if (tuple.parseIntegerOnlyFlag) { 217 fmt.setParseIntegerOnly(tuple.parseIntegerOnly != 0); 218 } 219 if (tuple.decimalPatternMatchRequiredFlag) { 220 fmt.setDecimalPatternMatchRequired( 221 tuple.decimalPatternMatchRequired != 0); 222 } 223 if (tuple.parseNoExponentFlag) { 224 UErrorCode status = U_ZERO_ERROR; 225 fmt.setAttribute( 226 UNUM_PARSE_NO_EXPONENT, 227 tuple.parseNoExponent, 228 status); 229 if (U_FAILURE(status)) { 230 appendErrorMessage.append("Error setting parse no exponent flag."); 231 } 232 } 233 } 234 235 static DecimalFormat *newDecimalFormat( 236 const Locale &locale, 237 const UnicodeString &pattern, 238 UErrorCode &status) { 239 if (U_FAILURE(status)) { 240 return NULL; 241 } 242 LocalPointer<DecimalFormatSymbols> symbols( 243 new DecimalFormatSymbols(locale, status), status); 244 if (U_FAILURE(status)) { 245 return NULL; 246 } 247 UParseError perror; 248 LocalPointer<DecimalFormat> result(new DecimalFormat( 249 pattern, symbols.getAlias(), perror, status), status); 250 if (!result.isNull()) { 251 symbols.orphan(); 252 } 253 if (U_FAILURE(status)) { 254 return NULL; 255 } 256 return result.orphan(); 257 } 258 259 static DecimalFormat *newDecimalFormat( 260 const NumberFormatTestTuple &tuple, 261 UErrorCode &status) { 262 if (U_FAILURE(status)) { 263 return NULL; 264 } 265 Locale en("en"); 266 return newDecimalFormat( 267 NFTT_GET_FIELD(tuple, locale, en), 268 NFTT_GET_FIELD(tuple, pattern, "0"), 269 status); 270 } 271 272 UBool NumberFormatTestDataDriven::isFormatPass( 273 const NumberFormatTestTuple &tuple, 274 UnicodeString &appendErrorMessage, 275 UErrorCode &status) { 276 if (U_FAILURE(status)) { 277 return FALSE; 278 } 279 LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status)); 280 if (U_FAILURE(status)) { 281 appendErrorMessage.append("Error creating DecimalFormat."); 282 return FALSE; 283 } 284 adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage); 285 if (appendErrorMessage.length() > 0) { 286 return FALSE; 287 } 288 DigitList digitList; 289 strToDigitList(tuple.format, digitList, status); 290 { 291 UnicodeString appendTo; 292 format(*fmtPtr, digitList, appendTo, status); 293 if (U_FAILURE(status)) { 294 appendErrorMessage.append("Error formatting."); 295 return FALSE; 296 } 297 if (appendTo != tuple.output) { 298 appendErrorMessage.append( 299 UnicodeString("Expected: ") + tuple.output + ", got: " + appendTo); 300 return FALSE; 301 } 302 } 303 double doubleVal = digitList.getDouble(); 304 { 305 UnicodeString appendTo; 306 format(*fmtPtr, doubleVal, appendTo, status); 307 if (U_FAILURE(status)) { 308 appendErrorMessage.append("Error formatting."); 309 return FALSE; 310 } 311 if (appendTo != tuple.output) { 312 appendErrorMessage.append( 313 UnicodeString("double Expected: ") + tuple.output + ", got: " + appendTo); 314 return FALSE; 315 } 316 } 317 if (!uprv_isNaN(doubleVal) && !uprv_isInfinite(doubleVal) && doubleVal == uprv_floor(doubleVal)) { 318 int64_t intVal = digitList.getInt64(); 319 { 320 UnicodeString appendTo; 321 format(*fmtPtr, intVal, appendTo, status); 322 if (U_FAILURE(status)) { 323 appendErrorMessage.append("Error formatting."); 324 return FALSE; 325 } 326 if (appendTo != tuple.output) { 327 appendErrorMessage.append( 328 UnicodeString("int64 Expected: ") + tuple.output + ", got: " + appendTo); 329 return FALSE; 330 } 331 } 332 } 333 return TRUE; 334 } 335 336 UBool NumberFormatTestDataDriven::isToPatternPass( 337 const NumberFormatTestTuple &tuple, 338 UnicodeString &appendErrorMessage, 339 UErrorCode &status) { 340 if (U_FAILURE(status)) { 341 return FALSE; 342 } 343 LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status)); 344 if (U_FAILURE(status)) { 345 appendErrorMessage.append("Error creating DecimalFormat."); 346 return FALSE; 347 } 348 adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage); 349 if (appendErrorMessage.length() > 0) { 350 return FALSE; 351 } 352 if (tuple.toPatternFlag) { 353 UnicodeString actual; 354 fmtPtr->toPattern(actual); 355 if (actual != tuple.toPattern) { 356 appendErrorMessage.append( 357 UnicodeString("Expected: ") + tuple.toPattern + ", got: " + actual + ". "); 358 } 359 } 360 if (tuple.toLocalizedPatternFlag) { 361 UnicodeString actual; 362 fmtPtr->toLocalizedPattern(actual); 363 if (actual != tuple.toLocalizedPattern) { 364 appendErrorMessage.append( 365 UnicodeString("Expected: ") + tuple.toLocalizedPattern + ", got: " + actual + ". "); 366 } 367 } 368 return appendErrorMessage.length() == 0; 369 } 370 371 UBool NumberFormatTestDataDriven::isParsePass( 372 const NumberFormatTestTuple &tuple, 373 UnicodeString &appendErrorMessage, 374 UErrorCode &status) { 375 if (U_FAILURE(status)) { 376 return FALSE; 377 } 378 LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status)); 379 if (U_FAILURE(status)) { 380 appendErrorMessage.append("Error creating DecimalFormat."); 381 return FALSE; 382 } 383 adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage); 384 if (appendErrorMessage.length() > 0) { 385 return FALSE; 386 } 387 Formattable result; 388 ParsePosition ppos; 389 fmtPtr->parse(tuple.parse, result, ppos); 390 if (ppos.getIndex() == 0) { 391 if (tuple.output != "fail") { 392 appendErrorMessage.append("Parse failed but was expected to succeed."); 393 return FALSE; 394 } 395 return TRUE; 396 } 397 UnicodeString resultStr(UnicodeString::fromUTF8(result.getDecimalNumber(status))); 398 if (tuple.output == "fail") { 399 appendErrorMessage.append(UnicodeString("Parse succeeded: ") + resultStr + ", but was expected to fail."); 400 return FALSE; 401 } 402 DigitList expected; 403 strToDigitList(tuple.output, expected, status); 404 if (U_FAILURE(status)) { 405 appendErrorMessage.append("Error parsing."); 406 return FALSE; 407 } 408 if (expected != *result.getDigitList()) { 409 appendErrorMessage.append( 410 UnicodeString("Expected: ") + tuple.output + ", got: " + resultStr + ". "); 411 return FALSE; 412 } 413 return TRUE; 414 } 415 416 UBool NumberFormatTestDataDriven::isParseCurrencyPass( 417 const NumberFormatTestTuple &tuple, 418 UnicodeString &appendErrorMessage, 419 UErrorCode &status) { 420 if (U_FAILURE(status)) { 421 return FALSE; 422 } 423 LocalPointer<DecimalFormat> fmtPtr(newDecimalFormat(tuple, status)); 424 if (U_FAILURE(status)) { 425 appendErrorMessage.append("Error creating DecimalFormat."); 426 return FALSE; 427 } 428 adjustDecimalFormat(tuple, *fmtPtr, appendErrorMessage); 429 if (appendErrorMessage.length() > 0) { 430 return FALSE; 431 } 432 ParsePosition ppos; 433 LocalPointer<CurrencyAmount> currAmt( 434 fmtPtr->parseCurrency(tuple.parse, ppos)); 435 if (ppos.getIndex() == 0) { 436 if (tuple.output != "fail") { 437 appendErrorMessage.append("Parse failed but was expected to succeed."); 438 return FALSE; 439 } 440 return TRUE; 441 } 442 UnicodeString currStr(currAmt->getISOCurrency()); 443 Formattable resultFormattable(currAmt->getNumber()); 444 UnicodeString resultStr(UnicodeString::fromUTF8(resultFormattable.getDecimalNumber(status))); 445 if (tuple.output == "fail") { 446 appendErrorMessage.append(UnicodeString("Parse succeeded: ") + resultStr + ", but was expected to fail."); 447 return FALSE; 448 } 449 DigitList expected; 450 strToDigitList(tuple.output, expected, status); 451 if (U_FAILURE(status)) { 452 appendErrorMessage.append("Error parsing."); 453 return FALSE; 454 } 455 if (expected != *currAmt->getNumber().getDigitList()) { 456 appendErrorMessage.append( 457 UnicodeString("Expected: ") + tuple.output + ", got: " + resultStr + ". "); 458 return FALSE; 459 } 460 if (currStr != tuple.outputCurrency) { 461 appendErrorMessage.append(UnicodeString( 462 "Expected currency: ") + tuple.outputCurrency + ", got: " + currStr + ". "); 463 return FALSE; 464 } 465 return TRUE; 466 } 467 468 //#define NUMFMTST_CACHE_DEBUG 1 469 #include "stdio.h" /* for sprintf */ 470 // #include "iostream" // for cout 471 472 //#define NUMFMTST_DEBUG 1 473 474 static const UChar EUR[] = {69,85,82,0}; // "EUR" 475 static const UChar ISO_CURRENCY_USD[] = {0x55, 0x53, 0x44, 0}; // "USD" 476 477 478 // ***************************************************************************** 479 // class NumberFormatTest 480 // ***************************************************************************** 481 482 #define CHECK(status,str) if (U_FAILURE(status)) { errcheckln(status, UnicodeString("FAIL: ") + str + " - " + u_errorName(status)); return; } 483 #define CHECK_DATA(status,str) if (U_FAILURE(status)) { dataerrln(UnicodeString("FAIL: ") + str + " - " + u_errorName(status)); return; } 484 485 void NumberFormatTest::runIndexedTest( int32_t index, UBool exec, const char* &name, char* /*par*/ ) 486 { 487 TESTCASE_AUTO_BEGIN; 488 TESTCASE_AUTO(TestCurrencySign); 489 TESTCASE_AUTO(TestCurrency); 490 TESTCASE_AUTO(TestParse); 491 TESTCASE_AUTO(TestRounding487); 492 TESTCASE_AUTO(TestQuotes); 493 TESTCASE_AUTO(TestExponential); 494 TESTCASE_AUTO(TestPatterns); 495 496 // Upgrade to alphaWorks - liu 5/99 497 TESTCASE_AUTO(TestExponent); 498 TESTCASE_AUTO(TestScientific); 499 TESTCASE_AUTO(TestPad); 500 TESTCASE_AUTO(TestPatterns2); 501 TESTCASE_AUTO(TestSecondaryGrouping); 502 TESTCASE_AUTO(TestSurrogateSupport); 503 TESTCASE_AUTO(TestAPI); 504 505 TESTCASE_AUTO(TestCurrencyObject); 506 TESTCASE_AUTO(TestCurrencyPatterns); 507 //TESTCASE_AUTO(TestDigitList); 508 TESTCASE_AUTO(TestWhiteSpaceParsing); 509 TESTCASE_AUTO(TestComplexCurrency); // This test removed because CLDR no longer uses choice formats in currency symbols. 510 TESTCASE_AUTO(TestRegCurrency); 511 TESTCASE_AUTO(TestSymbolsWithBadLocale); 512 TESTCASE_AUTO(TestAdoptDecimalFormatSymbols); 513 514 TESTCASE_AUTO(TestScientific2); 515 TESTCASE_AUTO(TestScientificGrouping); 516 TESTCASE_AUTO(TestInt64); 517 518 TESTCASE_AUTO(TestPerMill); 519 TESTCASE_AUTO(TestIllegalPatterns); 520 TESTCASE_AUTO(TestCases); 521 522 TESTCASE_AUTO(TestCurrencyNames); 523 TESTCASE_AUTO(TestCurrencyAmount); 524 TESTCASE_AUTO(TestCurrencyUnit); 525 TESTCASE_AUTO(TestCoverage); 526 TESTCASE_AUTO(TestJB3832); 527 TESTCASE_AUTO(TestHost); 528 TESTCASE_AUTO(TestHostClone); 529 TESTCASE_AUTO(TestCurrencyFormat); 530 TESTCASE_AUTO(TestRounding); 531 TESTCASE_AUTO(TestNonpositiveMultiplier); 532 TESTCASE_AUTO(TestNumberingSystems); 533 TESTCASE_AUTO(TestSpaceParsing); 534 TESTCASE_AUTO(TestMultiCurrencySign); 535 TESTCASE_AUTO(TestCurrencyFormatForMixParsing); 536 TESTCASE_AUTO(TestDecimalFormatCurrencyParse); 537 TESTCASE_AUTO(TestCurrencyIsoPluralFormat); 538 TESTCASE_AUTO(TestCurrencyParsing); 539 TESTCASE_AUTO(TestParseCurrencyInUCurr); 540 TESTCASE_AUTO(TestFormatAttributes); 541 TESTCASE_AUTO(TestFieldPositionIterator); 542 TESTCASE_AUTO(TestDecimal); 543 TESTCASE_AUTO(TestCurrencyFractionDigits); 544 TESTCASE_AUTO(TestExponentParse); 545 TESTCASE_AUTO(TestExplicitParents); 546 TESTCASE_AUTO(TestLenientParse); 547 TESTCASE_AUTO(TestAvailableNumberingSystems); 548 TESTCASE_AUTO(TestRoundingPattern); 549 TESTCASE_AUTO(Test9087); 550 TESTCASE_AUTO(TestFormatFastpaths); 551 TESTCASE_AUTO(TestFormattableSize); 552 TESTCASE_AUTO(TestUFormattable); 553 TESTCASE_AUTO(TestSignificantDigits); 554 TESTCASE_AUTO(TestShowZero); 555 TESTCASE_AUTO(TestCompatibleCurrencies); 556 TESTCASE_AUTO(TestBug9936); 557 TESTCASE_AUTO(TestParseNegativeWithFaLocale); 558 TESTCASE_AUTO(TestParseNegativeWithAlternateMinusSign); 559 TESTCASE_AUTO(TestCustomCurrencySignAndSeparator); 560 TESTCASE_AUTO(TestParseSignsAndMarks); 561 TESTCASE_AUTO(Test10419RoundingWith0FractionDigits); 562 TESTCASE_AUTO(Test10468ApplyPattern); 563 TESTCASE_AUTO(TestRoundingScientific10542); 564 TESTCASE_AUTO(TestZeroScientific10547); 565 TESTCASE_AUTO(TestAccountingCurrency); 566 TESTCASE_AUTO(TestEquality); 567 TESTCASE_AUTO(TestCurrencyUsage); 568 TESTCASE_AUTO(TestNumberFormatTestTuple); 569 TESTCASE_AUTO(TestDataDriven); 570 TESTCASE_AUTO(TestDoubleLimit11439); 571 TESTCASE_AUTO(TestFastPathConsistent11524); 572 TESTCASE_AUTO(TestGetAffixes); 573 TESTCASE_AUTO(TestToPatternScientific11648); 574 TESTCASE_AUTO(TestBenchmark); 575 TESTCASE_AUTO(TestCtorApplyPatternDifference); 576 TESTCASE_AUTO(TestFractionalDigitsForCurrency); 577 TESTCASE_AUTO(TestFormatCurrencyPlural); 578 TESTCASE_AUTO(Test11868); 579 TESTCASE_AUTO(Test10727_RoundingZero); 580 TESTCASE_AUTO(Test11376_getAndSetPositivePrefix); 581 TESTCASE_AUTO(Test11475_signRecognition); 582 TESTCASE_AUTO(Test11640_getAffixes); 583 TESTCASE_AUTO(Test11649_toPatternWithMultiCurrency); 584 TESTCASE_AUTO_END; 585 } 586 587 // ------------------------------------- 588 589 // Test API (increase code coverage) 590 void 591 NumberFormatTest::TestAPI(void) 592 { 593 logln("Test API"); 594 UErrorCode status = U_ZERO_ERROR; 595 NumberFormat *test = NumberFormat::createInstance("root", status); 596 if(U_FAILURE(status)) { 597 dataerrln("unable to create format object - %s", u_errorName(status)); 598 } 599 if(test != NULL) { 600 test->setMinimumIntegerDigits(10); 601 test->setMaximumIntegerDigits(2); 602 603 test->setMinimumFractionDigits(10); 604 test->setMaximumFractionDigits(2); 605 606 UnicodeString result; 607 FieldPosition pos; 608 Formattable bla("Paja Patak"); // Donald Duck for non Serbian speakers 609 test->format(bla, result, pos, status); 610 if(U_SUCCESS(status)) { 611 errln("Yuck... Formatted a duck... As a number!"); 612 } else { 613 status = U_ZERO_ERROR; 614 } 615 616 result.remove(); 617 int64_t ll = 12; 618 test->format(ll, result); 619 if (result != "12.00"){ 620 errln("format int64_t error"); 621 } 622 623 ParsePosition ppos; 624 LocalPointer<CurrencyAmount> currAmt(test->parseCurrency("",ppos)); 625 // old test for (U_FAILURE(status)) was bogus here, method does not set status! 626 if (ppos.getIndex()) { 627 errln("Parsed empty string as currency"); 628 } 629 630 delete test; 631 } 632 } 633 634 class StubNumberFormat :public NumberFormat{ 635 public: 636 StubNumberFormat(){}; 637 virtual UnicodeString& format(double ,UnicodeString& appendTo,FieldPosition& ) const { 638 return appendTo; 639 } 640 virtual UnicodeString& format(int32_t ,UnicodeString& appendTo,FieldPosition& ) const { 641 return appendTo.append((UChar)0x0033); 642 } 643 virtual UnicodeString& format(int64_t number,UnicodeString& appendTo,FieldPosition& pos) const { 644 return NumberFormat::format(number, appendTo, pos); 645 } 646 virtual UnicodeString& format(const Formattable& , UnicodeString& appendTo, FieldPosition& , UErrorCode& ) const { 647 return appendTo; 648 } 649 virtual void parse(const UnicodeString& , 650 Formattable& , 651 ParsePosition& ) const {} 652 virtual void parse( const UnicodeString& , 653 Formattable& , 654 UErrorCode& ) const {} 655 virtual UClassID getDynamicClassID(void) const { 656 static char classID = 0; 657 return (UClassID)&classID; 658 } 659 virtual Format* clone() const {return NULL;} 660 }; 661 662 void 663 NumberFormatTest::TestCoverage(void){ 664 StubNumberFormat stub; 665 UnicodeString agent("agent"); 666 FieldPosition pos; 667 int64_t num = 4; 668 if (stub.format(num, agent, pos) != UnicodeString("agent3")){ 669 errln("NumberFormat::format(int64, UnicodString&, FieldPosition&) should delegate to (int32, ,)"); 670 }; 671 } 672 673 // Test various patterns 674 void 675 NumberFormatTest::TestPatterns(void) 676 { 677 UErrorCode status = U_ZERO_ERROR; 678 DecimalFormatSymbols sym(Locale::getUS(), status); 679 if (U_FAILURE(status)) { errcheckln(status, "FAIL: Could not construct DecimalFormatSymbols - %s", u_errorName(status)); return; } 680 681 const char* pat[] = { "#.#", "#.", ".#", "#" }; 682 int32_t pat_length = UPRV_LENGTHOF(pat); 683 const char* newpat[] = { "#0.#", "#0.", "#.0", "#" }; 684 const char* num[] = { "0", "0.", ".0", "0" }; 685 for (int32_t i=0; i<pat_length; ++i) 686 { 687 status = U_ZERO_ERROR; 688 DecimalFormat fmt(pat[i], sym, status); 689 if (U_FAILURE(status)) { errln((UnicodeString)"FAIL: DecimalFormat constructor failed for " + pat[i]); continue; } 690 UnicodeString newp; fmt.toPattern(newp); 691 if (!(newp == newpat[i])) 692 errln((UnicodeString)"FAIL: Pattern " + pat[i] + " should transmute to " + newpat[i] + 693 "; " + newp + " seen instead"); 694 695 UnicodeString s; (*(NumberFormat*)&fmt).format((int32_t)0, s); 696 if (!(s == num[i])) 697 { 698 errln((UnicodeString)"FAIL: Pattern " + pat[i] + " should format zero as " + num[i] + 699 "; " + s + " seen instead"); 700 logln((UnicodeString)"Min integer digits = " + fmt.getMinimumIntegerDigits()); 701 } 702 } 703 } 704 705 /* 706 icu_2_4::DigitList::operator== 0 0 2 icuuc24d.dll digitlst.cpp Doug 707 icu_2_4::DigitList::append 0 0 4 icuin24d.dll digitlst.h Doug 708 icu_2_4::DigitList::operator!= 0 0 1 icuuc24d.dll digitlst.h Doug 709 */ 710 /* 711 void 712 NumberFormatTest::TestDigitList(void) 713 { 714 // API coverage for DigitList 715 DigitList list1; 716 list1.append('1'); 717 list1.fDecimalAt = 1; 718 DigitList list2; 719 list2.set((int32_t)1); 720 if (list1 != list2) { 721 errln("digitlist append, operator!= or set failed "); 722 } 723 if (!(list1 == list2)) { 724 errln("digitlist append, operator== or set failed "); 725 } 726 } 727 */ 728 729 // ------------------------------------- 730 731 // Test exponential pattern 732 void 733 NumberFormatTest::TestExponential(void) 734 { 735 UErrorCode status = U_ZERO_ERROR; 736 DecimalFormatSymbols sym(Locale::getUS(), status); 737 if (U_FAILURE(status)) { errcheckln(status, "FAIL: Bad status returned by DecimalFormatSymbols ct - %s", u_errorName(status)); return; } 738 const char* pat[] = { "0.####E0", "00.000E00", "##0.######E000", "0.###E0;[0.###E0]" }; 739 int32_t pat_length = UPRV_LENGTHOF(pat); 740 741 // The following #if statements allow this test to be built and run on 742 // platforms that do not have standard IEEE numerics. For example, 743 // S/390 doubles have an exponent range of -78 to +75. For the 744 // following #if statements to work, float.h must define 745 // DBL_MAX_10_EXP to be a compile-time constant. 746 747 // This section may be expanded as needed. 748 749 #if DBL_MAX_10_EXP > 300 750 double val[] = { 0.01234, 123456789, 1.23e300, -3.141592653e-271 }; 751 int32_t val_length = UPRV_LENGTHOF(val); 752 const char* valFormat[] = 753 { 754 // 0.####E0 755 "1.234E-2", "1.2346E8", "1.23E300", "-3.1416E-271", 756 // 00.000E00 757 "12.340E-03", "12.346E07", "12.300E299", "-31.416E-272", 758 // ##0.######E000 759 "12.34E-003", "123.4568E006", "1.23E300", "-314.1593E-273", 760 // 0.###E0;[0.###E0] 761 "1.234E-2", "1.235E8", "1.23E300", "[3.142E-271]" 762 }; 763 double valParse[] = 764 { 765 0.01234, 123460000, 1.23E300, -3.1416E-271, 766 0.01234, 123460000, 1.23E300, -3.1416E-271, 767 0.01234, 123456800, 1.23E300, -3.141593E-271, 768 0.01234, 123500000, 1.23E300, -3.142E-271, 769 }; 770 #elif DBL_MAX_10_EXP > 70 771 double val[] = { 0.01234, 123456789, 1.23e70, -3.141592653e-71 }; 772 int32_t val_length = UPRV_LENGTHOF(val); 773 char* valFormat[] = 774 { 775 // 0.####E0 776 "1.234E-2", "1.2346E8", "1.23E70", "-3.1416E-71", 777 // 00.000E00 778 "12.340E-03", "12.346E07", "12.300E69", "-31.416E-72", 779 // ##0.######E000 780 "12.34E-003", "123.4568E006", "12.3E069", "-31.41593E-072", 781 // 0.###E0;[0.###E0] 782 "1.234E-2", "1.235E8", "1.23E70", "[3.142E-71]" 783 }; 784 double valParse[] = 785 { 786 0.01234, 123460000, 1.23E70, -3.1416E-71, 787 0.01234, 123460000, 1.23E70, -3.1416E-71, 788 0.01234, 123456800, 1.23E70, -3.141593E-71, 789 0.01234, 123500000, 1.23E70, -3.142E-71, 790 }; 791 #else 792 // Don't test double conversion 793 double* val = 0; 794 int32_t val_length = 0; 795 char** valFormat = 0; 796 double* valParse = 0; 797 logln("Warning: Skipping double conversion tests"); 798 #endif 799 800 int32_t lval[] = { 0, -1, 1, 123456789 }; 801 int32_t lval_length = UPRV_LENGTHOF(lval); 802 const char* lvalFormat[] = 803 { 804 // 0.####E0 805 "0E0", "-1E0", "1E0", "1.2346E8", 806 // 00.000E00 807 "00.000E00", "-10.000E-01", "10.000E-01", "12.346E07", 808 // ##0.######E000 809 "0E000", "-1E000", "1E000", "123.4568E006", 810 // 0.###E0;[0.###E0] 811 "0E0", "[1E0]", "1E0", "1.235E8" 812 }; 813 int32_t lvalParse[] = 814 { 815 0, -1, 1, 123460000, 816 0, -1, 1, 123460000, 817 0, -1, 1, 123456800, 818 0, -1, 1, 123500000, 819 }; 820 int32_t ival = 0, ilval = 0; 821 for (int32_t p=0; p<pat_length; ++p) 822 { 823 DecimalFormat fmt(pat[p], sym, status); 824 if (U_FAILURE(status)) { errln("FAIL: Bad status returned by DecimalFormat ct"); continue; } 825 UnicodeString pattern; 826 logln((UnicodeString)"Pattern \"" + pat[p] + "\" -toPattern-> \"" + 827 fmt.toPattern(pattern) + "\""); 828 int32_t v; 829 for (v=0; v<val_length; ++v) 830 { 831 UnicodeString s; (*(NumberFormat*)&fmt).format(val[v], s); 832 logln((UnicodeString)" " + val[v] + " -format-> " + s); 833 if (s != valFormat[v+ival]) 834 errln((UnicodeString)"FAIL: Expected " + valFormat[v+ival]); 835 836 ParsePosition pos(0); 837 Formattable af; 838 fmt.parse(s, af, pos); 839 double a; 840 UBool useEpsilon = FALSE; 841 if (af.getType() == Formattable::kLong) 842 a = af.getLong(); 843 else if (af.getType() == Formattable::kDouble) { 844 a = af.getDouble(); 845 #if U_PF_OS390 <= U_PLATFORM && U_PLATFORM <= U_PF_OS400 846 // S/390 will show a failure like this: 847 //| -3.141592652999999e-271 -format-> -3.1416E-271 848 //| -parse-> -3.1416e-271 849 //| FAIL: Expected -3.141599999999999e-271 850 // To compensate, we use an epsilon-based equality 851 // test on S/390 only. We don't want to do this in 852 // general because it's less exacting. 853 useEpsilon = TRUE; 854 #endif 855 } 856 else { 857 errln((UnicodeString)"FAIL: Non-numeric Formattable returned"); 858 continue; 859 } 860 if (pos.getIndex() == s.length()) 861 { 862 logln((UnicodeString)" -parse-> " + a); 863 // Use epsilon comparison as necessary 864 if ((useEpsilon && 865 (uprv_fabs(a - valParse[v+ival]) / a > (2*DBL_EPSILON))) || 866 (!useEpsilon && a != valParse[v+ival])) 867 { 868 errln((UnicodeString)"FAIL: Expected " + valParse[v+ival]); 869 } 870 } 871 else { 872 errln((UnicodeString)"FAIL: Partial parse (" + pos.getIndex() + " chars) -> " + a); 873 errln((UnicodeString)" should be (" + s.length() + " chars) -> " + valParse[v+ival]); 874 } 875 } 876 for (v=0; v<lval_length; ++v) 877 { 878 UnicodeString s; 879 (*(NumberFormat*)&fmt).format(lval[v], s); 880 logln((UnicodeString)" " + lval[v] + "L -format-> " + s); 881 if (s != lvalFormat[v+ilval]) 882 errln((UnicodeString)"ERROR: Expected " + lvalFormat[v+ilval] + " Got: " + s); 883 884 ParsePosition pos(0); 885 Formattable af; 886 fmt.parse(s, af, pos); 887 if (af.getType() == Formattable::kLong || 888 af.getType() == Formattable::kInt64) { 889 UErrorCode status = U_ZERO_ERROR; 890 int32_t a = af.getLong(status); 891 if (pos.getIndex() == s.length()) 892 { 893 logln((UnicodeString)" -parse-> " + a); 894 if (a != lvalParse[v+ilval]) 895 errln((UnicodeString)"FAIL: Expected " + lvalParse[v+ilval]); 896 } 897 else 898 errln((UnicodeString)"FAIL: Partial parse (" + pos.getIndex() + " chars) -> " + a); 899 } 900 else 901 errln((UnicodeString)"FAIL: Non-long Formattable returned for " + s 902 + " Double: " + af.getDouble() 903 + ", Long: " + af.getLong()); 904 } 905 ival += val_length; 906 ilval += lval_length; 907 } 908 } 909 910 void 911 NumberFormatTest::TestScientific2() { 912 // jb 2552 913 UErrorCode status = U_ZERO_ERROR; 914 DecimalFormat* fmt = (DecimalFormat*)NumberFormat::createCurrencyInstance("en_US", status); 915 if (U_SUCCESS(status)) { 916 double num = 12.34; 917 expect(*fmt, num, "$12.34"); 918 fmt->setScientificNotation(TRUE); 919 expect(*fmt, num, "$1.23E1"); 920 fmt->setScientificNotation(FALSE); 921 expect(*fmt, num, "$12.34"); 922 } 923 delete fmt; 924 } 925 926 void 927 NumberFormatTest::TestScientificGrouping() { 928 // jb 2552 929 UErrorCode status = U_ZERO_ERROR; 930 DecimalFormat fmt("##0.00E0",status); 931 if (U_SUCCESS(status)) { 932 expect(fmt, .01234, "12.3E-3"); 933 expect(fmt, .1234, "123E-3"); 934 expect(fmt, 1.234, "1.23E0"); 935 expect(fmt, 12.34, "12.3E0"); 936 expect(fmt, 123.4, "123E0"); 937 expect(fmt, 1234., "1.23E3"); 938 } 939 } 940 941 /*static void setFromString(DigitList& dl, const char* str) { 942 char c; 943 UBool decimalSet = FALSE; 944 dl.clear(); 945 while ((c = *str++)) { 946 if (c == '-') { 947 dl.fIsPositive = FALSE; 948 } else if (c == '+') { 949 dl.fIsPositive = TRUE; 950 } else if (c == '.') { 951 dl.fDecimalAt = dl.fCount; 952 decimalSet = TRUE; 953 } else { 954 dl.append(c); 955 } 956 } 957 if (!decimalSet) { 958 dl.fDecimalAt = dl.fCount; 959 } 960 }*/ 961 962 void 963 NumberFormatTest::TestInt64() { 964 UErrorCode status = U_ZERO_ERROR; 965 DecimalFormat fmt("#.#E0",status); 966 if (U_FAILURE(status)) { 967 dataerrln("Error creating DecimalFormat - %s", u_errorName(status)); 968 return; 969 } 970 fmt.setMaximumFractionDigits(20); 971 if (U_SUCCESS(status)) { 972 expect(fmt, (Formattable)(int64_t)0, "0E0"); 973 expect(fmt, (Formattable)(int64_t)-1, "-1E0"); 974 expect(fmt, (Formattable)(int64_t)1, "1E0"); 975 expect(fmt, (Formattable)(int64_t)2147483647, "2.147483647E9"); 976 expect(fmt, (Formattable)((int64_t)-2147483647-1), "-2.147483648E9"); 977 expect(fmt, (Formattable)(int64_t)U_INT64_MAX, "9.223372036854775807E18"); 978 expect(fmt, (Formattable)(int64_t)U_INT64_MIN, "-9.223372036854775808E18"); 979 } 980 981 // also test digitlist 982 /* int64_t int64max = U_INT64_MAX; 983 int64_t int64min = U_INT64_MIN; 984 const char* int64maxstr = "9223372036854775807"; 985 const char* int64minstr = "-9223372036854775808"; 986 UnicodeString fail("fail: "); 987 988 // test max int64 value 989 DigitList dl; 990 setFromString(dl, int64maxstr); 991 { 992 if (!dl.fitsIntoInt64(FALSE)) { 993 errln(fail + int64maxstr + " didn't fit"); 994 } 995 int64_t int64Value = dl.getInt64(); 996 if (int64Value != int64max) { 997 errln(fail + int64maxstr); 998 } 999 dl.set(int64Value); 1000 int64Value = dl.getInt64(); 1001 if (int64Value != int64max) { 1002 errln(fail + int64maxstr); 1003 } 1004 } 1005 // test negative of max int64 value (1 shy of min int64 value) 1006 dl.fIsPositive = FALSE; 1007 { 1008 if (!dl.fitsIntoInt64(FALSE)) { 1009 errln(fail + "-" + int64maxstr + " didn't fit"); 1010 } 1011 int64_t int64Value = dl.getInt64(); 1012 if (int64Value != -int64max) { 1013 errln(fail + "-" + int64maxstr); 1014 } 1015 dl.set(int64Value); 1016 int64Value = dl.getInt64(); 1017 if (int64Value != -int64max) { 1018 errln(fail + "-" + int64maxstr); 1019 } 1020 } 1021 // test min int64 value 1022 setFromString(dl, int64minstr); 1023 { 1024 if (!dl.fitsIntoInt64(FALSE)) { 1025 errln(fail + "-" + int64minstr + " didn't fit"); 1026 } 1027 int64_t int64Value = dl.getInt64(); 1028 if (int64Value != int64min) { 1029 errln(fail + int64minstr); 1030 } 1031 dl.set(int64Value); 1032 int64Value = dl.getInt64(); 1033 if (int64Value != int64min) { 1034 errln(fail + int64minstr); 1035 } 1036 } 1037 // test negative of min int 64 value (1 more than max int64 value) 1038 dl.fIsPositive = TRUE; // won't fit 1039 { 1040 if (dl.fitsIntoInt64(FALSE)) { 1041 errln(fail + "-(" + int64minstr + ") didn't fit"); 1042 } 1043 }*/ 1044 } 1045 1046 // ------------------------------------- 1047 1048 // Test the handling of quotes 1049 void 1050 NumberFormatTest::TestQuotes(void) 1051 { 1052 UErrorCode status = U_ZERO_ERROR; 1053 UnicodeString *pat; 1054 DecimalFormatSymbols *sym = new DecimalFormatSymbols(Locale::getUS(), status); 1055 if (U_FAILURE(status)) { 1056 errcheckln(status, "Fail to create DecimalFormatSymbols - %s", u_errorName(status)); 1057 delete sym; 1058 return; 1059 } 1060 pat = new UnicodeString("a'fo''o'b#"); 1061 DecimalFormat *fmt = new DecimalFormat(*pat, *sym, status); 1062 UnicodeString s; 1063 ((NumberFormat*)fmt)->format((int32_t)123, s); 1064 logln((UnicodeString)"Pattern \"" + *pat + "\""); 1065 logln((UnicodeString)" Format 123 -> " + escape(s)); 1066 if (!(s=="afo'ob123")) 1067 errln((UnicodeString)"FAIL: Expected afo'ob123"); 1068 1069 s.truncate(0); 1070 delete fmt; 1071 delete pat; 1072 1073 pat = new UnicodeString("a''b#"); 1074 fmt = new DecimalFormat(*pat, *sym, status); 1075 ((NumberFormat*)fmt)->format((int32_t)123, s); 1076 logln((UnicodeString)"Pattern \"" + *pat + "\""); 1077 logln((UnicodeString)" Format 123 -> " + escape(s)); 1078 if (!(s=="a'b123")) 1079 errln((UnicodeString)"FAIL: Expected a'b123"); 1080 delete fmt; 1081 delete pat; 1082 delete sym; 1083 } 1084 1085 /** 1086 * Test the handling of the currency symbol in patterns. 1087 */ 1088 void 1089 NumberFormatTest::TestCurrencySign(void) 1090 { 1091 UErrorCode status = U_ZERO_ERROR; 1092 DecimalFormatSymbols* sym = new DecimalFormatSymbols(Locale::getUS(), status); 1093 UnicodeString pat; 1094 UChar currency = 0x00A4; 1095 if (U_FAILURE(status)) { 1096 errcheckln(status, "Fail to create DecimalFormatSymbols - %s", u_errorName(status)); 1097 delete sym; 1098 return; 1099 } 1100 // "\xA4#,##0.00;-\xA4#,##0.00" 1101 pat.append(currency).append("#,##0.00;-"). 1102 append(currency).append("#,##0.00"); 1103 DecimalFormat *fmt = new DecimalFormat(pat, *sym, status); 1104 UnicodeString s; ((NumberFormat*)fmt)->format(1234.56, s); 1105 pat.truncate(0); 1106 logln((UnicodeString)"Pattern \"" + fmt->toPattern(pat) + "\""); 1107 logln((UnicodeString)" Format " + 1234.56 + " -> " + escape(s)); 1108 if (s != "$1,234.56") dataerrln((UnicodeString)"FAIL: Expected $1,234.56"); 1109 s.truncate(0); 1110 ((NumberFormat*)fmt)->format(- 1234.56, s); 1111 logln((UnicodeString)" Format " + (-1234.56) + " -> " + escape(s)); 1112 if (s != "-$1,234.56") dataerrln((UnicodeString)"FAIL: Expected -$1,234.56"); 1113 delete fmt; 1114 pat.truncate(0); 1115 // "\xA4\xA4 #,##0.00;\xA4\xA4 -#,##0.00" 1116 pat.append(currency).append(currency). 1117 append(" #,##0.00;"). 1118 append(currency).append(currency). 1119 append(" -#,##0.00"); 1120 fmt = new DecimalFormat(pat, *sym, status); 1121 s.truncate(0); 1122 ((NumberFormat*)fmt)->format(1234.56, s); 1123 logln((UnicodeString)"Pattern \"" + fmt->toPattern(pat) + "\""); 1124 logln((UnicodeString)" Format " + 1234.56 + " -> " + escape(s)); 1125 if (s != "USD 1,234.56") dataerrln((UnicodeString)"FAIL: Expected USD 1,234.56"); 1126 s.truncate(0); 1127 ((NumberFormat*)fmt)->format(-1234.56, s); 1128 logln((UnicodeString)" Format " + (-1234.56) + " -> " + escape(s)); 1129 if (s != "USD -1,234.56") dataerrln((UnicodeString)"FAIL: Expected USD -1,234.56"); 1130 delete fmt; 1131 delete sym; 1132 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: Status " + u_errorName(status)); 1133 } 1134 1135 // ------------------------------------- 1136 1137 static UChar toHexString(int32_t i) { return (UChar)(i + (i < 10 ? 0x30 : (0x41 - 10))); } 1138 1139 UnicodeString& 1140 NumberFormatTest::escape(UnicodeString& s) 1141 { 1142 UnicodeString buf; 1143 for (int32_t i=0; i<s.length(); ++i) 1144 { 1145 UChar c = s[(int32_t)i]; 1146 if (c <= (UChar)0x7F) buf += c; 1147 else { 1148 buf += (UChar)0x5c; buf += (UChar)0x55; 1149 buf += toHexString((c & 0xF000) >> 12); 1150 buf += toHexString((c & 0x0F00) >> 8); 1151 buf += toHexString((c & 0x00F0) >> 4); 1152 buf += toHexString(c & 0x000F); 1153 } 1154 } 1155 return (s = buf); 1156 } 1157 1158 1159 // ------------------------------------- 1160 static const char* testCases[][2]= { 1161 /* locale ID */ /* expected */ 1162 {"ca_ES_PREEURO", "\\u20A7\\u00A01.150" }, 1163 {"de_LU_PREEURO", "1,150\\u00A0F" }, 1164 {"el_GR_PREEURO", "1.150,50\\u00A0\\u0394\\u03C1\\u03C7" }, 1165 {"en_BE_PREEURO", "1.150,50\\u00A0BEF" }, 1166 {"es_ES_PREEURO", "1.150\\u00A0\\u20A7" }, 1167 {"eu_ES_PREEURO", "\\u20A7\\u00A01.150" }, 1168 {"gl_ES_PREEURO", "1.150\\u00A0\\u20A7" }, 1169 {"it_IT_PREEURO", "ITL\\u00A01.150" }, 1170 {"pt_PT_PREEURO", "1,150$50\\u00A0\\u200B"}, // per cldrbug 7670 1171 {"en_US@currency=JPY", "\\u00A51,150"}, 1172 {"en_US@currency=jpy", "\\u00A51,150"}, 1173 {"en-US-u-cu-jpy", "\\u00A51,150"} 1174 }; 1175 /** 1176 * Test localized currency patterns. 1177 */ 1178 void 1179 NumberFormatTest::TestCurrency(void) 1180 { 1181 UErrorCode status = U_ZERO_ERROR; 1182 NumberFormat* currencyFmt = NumberFormat::createCurrencyInstance(Locale::getCanadaFrench(), status); 1183 if (U_FAILURE(status)) { 1184 dataerrln("Error calling NumberFormat::createCurrencyInstance()"); 1185 return; 1186 } 1187 1188 UnicodeString s; currencyFmt->format(1.50, s); 1189 logln((UnicodeString)"Un pauvre ici a..........." + s); 1190 if (!(s==CharsToUnicodeString("1,50\\u00A0$"))) 1191 errln((UnicodeString)"FAIL: Expected 1,50<nbsp>$"); 1192 delete currencyFmt; 1193 s.truncate(0); 1194 char loc[256]={0}; 1195 int len = uloc_canonicalize("de_DE_PREEURO", loc, 256, &status); 1196 (void)len; // Suppress unused variable warning. 1197 currencyFmt = NumberFormat::createCurrencyInstance(Locale(loc),status); 1198 currencyFmt->format(1.50, s); 1199 logln((UnicodeString)"Un pauvre en Allemagne a.." + s); 1200 if (!(s==CharsToUnicodeString("1,50\\u00A0DM"))) 1201 errln((UnicodeString)"FAIL: Expected 1,50<nbsp>DM"); 1202 delete currencyFmt; 1203 s.truncate(0); 1204 len = uloc_canonicalize("fr_FR_PREEURO", loc, 256, &status); 1205 currencyFmt = NumberFormat::createCurrencyInstance(Locale(loc), status); 1206 currencyFmt->format(1.50, s); 1207 logln((UnicodeString)"Un pauvre en France a....." + s); 1208 if (!(s==CharsToUnicodeString("1,50\\u00A0F"))) 1209 errln((UnicodeString)"FAIL: Expected 1,50<nbsp>F"); 1210 delete currencyFmt; 1211 if (U_FAILURE(status)) 1212 errln((UnicodeString)"FAIL: Status " + (int32_t)status); 1213 1214 for(int i=0; i < UPRV_LENGTHOF(testCases); i++){ 1215 status = U_ZERO_ERROR; 1216 const char *localeID = testCases[i][0]; 1217 UnicodeString expected(testCases[i][1], -1, US_INV); 1218 expected = expected.unescape(); 1219 s.truncate(0); 1220 char loc[256]={0}; 1221 uloc_canonicalize(localeID, loc, 256, &status); 1222 currencyFmt = NumberFormat::createCurrencyInstance(Locale(loc), status); 1223 if(U_FAILURE(status)){ 1224 errln("Could not create currency formatter for locale %s",localeID); 1225 continue; 1226 } 1227 currencyFmt->format(1150.50, s); 1228 if(s!=expected){ 1229 errln(UnicodeString("FAIL: Expected: ")+expected 1230 + UnicodeString(" Got: ") + s 1231 + UnicodeString( " for locale: ")+ UnicodeString(localeID) ); 1232 } 1233 if (U_FAILURE(status)){ 1234 errln((UnicodeString)"FAIL: Status " + (int32_t)status); 1235 } 1236 delete currencyFmt; 1237 } 1238 } 1239 1240 // ------------------------------------- 1241 1242 /** 1243 * Test the Currency object handling, new as of ICU 2.2. 1244 */ 1245 void NumberFormatTest::TestCurrencyObject() { 1246 UErrorCode ec = U_ZERO_ERROR; 1247 NumberFormat* fmt = 1248 NumberFormat::createCurrencyInstance(Locale::getUS(), ec); 1249 1250 if (U_FAILURE(ec)) { 1251 dataerrln("FAIL: getCurrencyInstance(US) - %s", u_errorName(ec)); 1252 delete fmt; 1253 return; 1254 } 1255 1256 Locale null("", "", ""); 1257 1258 expectCurrency(*fmt, null, 1234.56, "$1,234.56"); 1259 1260 expectCurrency(*fmt, Locale::getFrance(), 1261 1234.56, CharsToUnicodeString("\\u20AC1,234.56")); // Euro 1262 1263 expectCurrency(*fmt, Locale::getJapan(), 1264 1234.56, CharsToUnicodeString("\\u00A51,235")); // Yen 1265 1266 expectCurrency(*fmt, Locale("fr", "CH", ""), 1267 1234.56, "CHF1,234.56"); // no more 0.05 rounding here, see cldrbug 5548 1268 1269 expectCurrency(*fmt, Locale::getUS(), 1270 1234.56, "$1,234.56"); 1271 1272 delete fmt; 1273 fmt = NumberFormat::createCurrencyInstance(Locale::getFrance(), ec); 1274 1275 if (U_FAILURE(ec)) { 1276 errln("FAIL: getCurrencyInstance(FRANCE)"); 1277 delete fmt; 1278 return; 1279 } 1280 1281 expectCurrency(*fmt, null, 1234.56, CharsToUnicodeString("1 234,56 \\u20AC")); 1282 1283 expectCurrency(*fmt, Locale::getJapan(), 1284 1234.56, CharsToUnicodeString("1 235 JPY")); // Yen 1285 1286 expectCurrency(*fmt, Locale("fr", "CH", ""), 1287 1234.56, "1 234,56 CHF"); // no more 0.05 rounding here, see cldrbug 5548 1288 1289 expectCurrency(*fmt, Locale::getUS(), 1290 1234.56, "1 234,56 $US"); 1291 1292 expectCurrency(*fmt, Locale::getFrance(), 1293 1234.56, CharsToUnicodeString("1 234,56 \\u20AC")); // Euro 1294 1295 delete fmt; 1296 } 1297 1298 // ------------------------------------- 1299 1300 /** 1301 * Do rudimentary testing of parsing. 1302 */ 1303 void 1304 NumberFormatTest::TestParse(void) 1305 { 1306 UErrorCode status = U_ZERO_ERROR; 1307 UnicodeString arg("0"); 1308 DecimalFormat* format = new DecimalFormat("00", status); 1309 //try { 1310 Formattable n; format->parse(arg, n, status); 1311 logln((UnicodeString)"parse(" + arg + ") = " + n.getLong()); 1312 if (n.getType() != Formattable::kLong || 1313 n.getLong() != 0) errln((UnicodeString)"FAIL: Expected 0"); 1314 delete format; 1315 if (U_FAILURE(status)) errcheckln(status, (UnicodeString)"FAIL: Status " + u_errorName(status)); 1316 //} 1317 //catch(Exception e) { 1318 // errln((UnicodeString)"Exception caught: " + e); 1319 //} 1320 } 1321 1322 // ------------------------------------- 1323 1324 static const char *lenientAffixTestCases[] = { 1325 "(1)", 1326 "( 1)", 1327 "(1 )", 1328 "( 1 )" 1329 }; 1330 1331 static const char *lenientMinusTestCases[] = { 1332 "-5", 1333 "\\u22125", 1334 "\\u20105" 1335 }; 1336 1337 static const char *lenientCurrencyTestCases[] = { 1338 "$1,000", 1339 "$ 1,000", 1340 "$1000", 1341 "$ 1000", 1342 "$1 000.00", 1343 "$ 1 000.00", 1344 "$ 1\\u00A0000.00", 1345 "1000.00" 1346 }; 1347 1348 // changed from () to - per cldrbug 5674 1349 static const char *lenientNegativeCurrencyTestCases[] = { 1350 "-$1,000", 1351 "-$ 1,000", 1352 "-$1000", 1353 "-$ 1000", 1354 "-$1 000.00", 1355 "-$ 1 000.00", 1356 "- $ 1,000.00 ", 1357 "-$ 1\\u00A0000.00", 1358 "-1000.00" 1359 }; 1360 1361 static const char *lenientPercentTestCases[] = { 1362 "25%", 1363 " 25%", 1364 " 25 %", 1365 "25 %", 1366 "25\\u00A0%", 1367 "25" 1368 }; 1369 1370 static const char *lenientNegativePercentTestCases[] = { 1371 "-25%", 1372 " -25%", 1373 " - 25%", 1374 "- 25 %", 1375 " - 25 %", 1376 "-25 %", 1377 "-25\\u00A0%", 1378 "-25", 1379 "- 25" 1380 }; 1381 1382 static const char *strictFailureTestCases[] = { 1383 " 1000", 1384 "10,00", 1385 "1,000,.0" 1386 }; 1387 1388 /** 1389 * Test lenient parsing. 1390 */ 1391 void 1392 NumberFormatTest::TestLenientParse(void) 1393 { 1394 UErrorCode status = U_ZERO_ERROR; 1395 DecimalFormat *format = new DecimalFormat("(#,##0)", status); 1396 Formattable n; 1397 1398 if (format == NULL || U_FAILURE(status)) { 1399 dataerrln("Unable to create DecimalFormat (#,##0) - %s", u_errorName(status)); 1400 } else { 1401 format->setLenient(TRUE); 1402 for (int32_t t = 0; t < UPRV_LENGTHOF (lenientAffixTestCases); t += 1) { 1403 UnicodeString testCase = ctou(lenientAffixTestCases[t]); 1404 1405 format->parse(testCase, n, status); 1406 logln((UnicodeString)"parse(" + testCase + ") = " + n.getLong()); 1407 1408 if (U_FAILURE(status) || n.getType() != Formattable::kLong || 1409 n.getLong() != 1) { 1410 errln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) lenientAffixTestCases[t] + (UnicodeString) "\""); 1411 status = U_ZERO_ERROR; 1412 } 1413 } 1414 delete format; 1415 } 1416 1417 Locale en_US("en_US"); 1418 Locale sv_SE("sv_SE"); 1419 1420 NumberFormat *mFormat = NumberFormat::createInstance(sv_SE, UNUM_DECIMAL, status); 1421 1422 if (mFormat == NULL || U_FAILURE(status)) { 1423 dataerrln("Unable to create NumberFormat (sv_SE, UNUM_DECIMAL) - %s", u_errorName(status)); 1424 } else { 1425 mFormat->setLenient(TRUE); 1426 for (int32_t t = 0; t < UPRV_LENGTHOF(lenientMinusTestCases); t += 1) { 1427 UnicodeString testCase = ctou(lenientMinusTestCases[t]); 1428 1429 mFormat->parse(testCase, n, status); 1430 logln((UnicodeString)"parse(" + testCase + ") = " + n.getLong()); 1431 1432 if (U_FAILURE(status) || n.getType() != Formattable::kLong || n.getLong() != -5) { 1433 errln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) lenientMinusTestCases[t] + (UnicodeString) "\""); 1434 status = U_ZERO_ERROR; 1435 } 1436 } 1437 delete mFormat; 1438 } 1439 1440 mFormat = NumberFormat::createInstance(en_US, UNUM_DECIMAL, status); 1441 1442 if (mFormat == NULL || U_FAILURE(status)) { 1443 dataerrln("Unable to create NumberFormat (en_US, UNUM_DECIMAL) - %s", u_errorName(status)); 1444 } else { 1445 mFormat->setLenient(TRUE); 1446 for (int32_t t = 0; t < UPRV_LENGTHOF(lenientMinusTestCases); t += 1) { 1447 UnicodeString testCase = ctou(lenientMinusTestCases[t]); 1448 1449 mFormat->parse(testCase, n, status); 1450 logln((UnicodeString)"parse(" + testCase + ") = " + n.getLong()); 1451 1452 if (U_FAILURE(status) || n.getType() != Formattable::kLong || n.getLong() != -5) { 1453 errln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) lenientMinusTestCases[t] + (UnicodeString) "\""); 1454 status = U_ZERO_ERROR; 1455 } 1456 } 1457 delete mFormat; 1458 } 1459 1460 NumberFormat *cFormat = NumberFormat::createInstance(en_US, UNUM_CURRENCY, status); 1461 1462 if (cFormat == NULL || U_FAILURE(status)) { 1463 dataerrln("Unable to create NumberFormat (en_US, UNUM_CURRENCY) - %s", u_errorName(status)); 1464 } else { 1465 cFormat->setLenient(TRUE); 1466 for (int32_t t = 0; t < UPRV_LENGTHOF (lenientCurrencyTestCases); t += 1) { 1467 UnicodeString testCase = ctou(lenientCurrencyTestCases[t]); 1468 1469 cFormat->parse(testCase, n, status); 1470 logln((UnicodeString)"parse(" + testCase + ") = " + n.getLong()); 1471 1472 if (U_FAILURE(status) ||n.getType() != Formattable::kLong || 1473 n.getLong() != 1000) { 1474 errln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) lenientCurrencyTestCases[t] + (UnicodeString) "\""); 1475 status = U_ZERO_ERROR; 1476 } 1477 } 1478 1479 for (int32_t t = 0; t < UPRV_LENGTHOF (lenientNegativeCurrencyTestCases); t += 1) { 1480 UnicodeString testCase = ctou(lenientNegativeCurrencyTestCases[t]); 1481 1482 cFormat->parse(testCase, n, status); 1483 logln((UnicodeString)"parse(" + testCase + ") = " + n.getLong()); 1484 1485 if (U_FAILURE(status) ||n.getType() != Formattable::kLong || 1486 n.getLong() != -1000) { 1487 errln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) lenientNegativeCurrencyTestCases[t] + (UnicodeString) "\""); 1488 status = U_ZERO_ERROR; 1489 } 1490 } 1491 1492 delete cFormat; 1493 } 1494 1495 NumberFormat *pFormat = NumberFormat::createPercentInstance(en_US, status); 1496 1497 if (pFormat == NULL || U_FAILURE(status)) { 1498 dataerrln("Unable to create NumberFormat::createPercentInstance (en_US) - %s", u_errorName(status)); 1499 } else { 1500 pFormat->setLenient(TRUE); 1501 for (int32_t t = 0; t < UPRV_LENGTHOF (lenientPercentTestCases); t += 1) { 1502 UnicodeString testCase = ctou(lenientPercentTestCases[t]); 1503 1504 pFormat->parse(testCase, n, status); 1505 logln((UnicodeString)"parse(" + testCase + ") = " + n.getDouble()); 1506 1507 if (U_FAILURE(status) ||n.getType() != Formattable::kDouble || 1508 n.getDouble() != 0.25) { 1509 errln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) lenientPercentTestCases[t] + (UnicodeString) "\""); 1510 status = U_ZERO_ERROR; 1511 } 1512 } 1513 1514 for (int32_t t = 0; t < UPRV_LENGTHOF (lenientNegativePercentTestCases); t += 1) { 1515 UnicodeString testCase = ctou(lenientNegativePercentTestCases[t]); 1516 1517 pFormat->parse(testCase, n, status); 1518 logln((UnicodeString)"parse(" + testCase + ") = " + n.getDouble()); 1519 1520 if (U_FAILURE(status) ||n.getType() != Formattable::kDouble || 1521 n.getDouble() != -0.25) { 1522 errln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) lenientNegativePercentTestCases[t] + (UnicodeString) "\""); 1523 status = U_ZERO_ERROR; 1524 } 1525 } 1526 1527 delete pFormat; 1528 } 1529 1530 // Test cases that should fail with a strict parse and pass with a 1531 // lenient parse. 1532 NumberFormat *nFormat = NumberFormat::createInstance(en_US, status); 1533 1534 if (nFormat == NULL || U_FAILURE(status)) { 1535 dataerrln("Unable to create NumberFormat (en_US) - %s", u_errorName(status)); 1536 } else { 1537 // first, make sure that they fail with a strict parse 1538 for (int32_t t = 0; t < UPRV_LENGTHOF(strictFailureTestCases); t += 1) { 1539 UnicodeString testCase = ctou(strictFailureTestCases[t]); 1540 1541 nFormat->parse(testCase, n, status); 1542 logln((UnicodeString)"parse(" + testCase + ") = " + n.getLong()); 1543 1544 if (! U_FAILURE(status)) { 1545 errln((UnicodeString)"Strict Parse succeeded for \"" + (UnicodeString) strictFailureTestCases[t] + (UnicodeString) "\""); 1546 } 1547 1548 status = U_ZERO_ERROR; 1549 } 1550 1551 // then, make sure that they pass with a lenient parse 1552 nFormat->setLenient(TRUE); 1553 for (int32_t t = 0; t < UPRV_LENGTHOF(strictFailureTestCases); t += 1) { 1554 UnicodeString testCase = ctou(strictFailureTestCases[t]); 1555 1556 nFormat->parse(testCase, n, status); 1557 logln((UnicodeString)"parse(" + testCase + ") = " + n.getLong()); 1558 1559 if (U_FAILURE(status) ||n.getType() != Formattable::kLong || 1560 n.getLong() != 1000) { 1561 errln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) strictFailureTestCases[t] + (UnicodeString) "\""); 1562 status = U_ZERO_ERROR; 1563 } 1564 } 1565 1566 delete nFormat; 1567 } 1568 } 1569 1570 // ------------------------------------- 1571 1572 /** 1573 * Test proper rounding by the format method. 1574 */ 1575 void 1576 NumberFormatTest::TestRounding487(void) 1577 { 1578 UErrorCode status = U_ZERO_ERROR; 1579 NumberFormat *nf = NumberFormat::createInstance(status); 1580 if (U_FAILURE(status)) { 1581 dataerrln("Error calling NumberFormat::createInstance()"); 1582 return; 1583 } 1584 1585 roundingTest(*nf, 0.00159999, 4, "0.0016"); 1586 roundingTest(*nf, 0.00995, 4, "0.01"); 1587 1588 roundingTest(*nf, 12.3995, 3, "12.4"); 1589 1590 roundingTest(*nf, 12.4999, 0, "12"); 1591 roundingTest(*nf, - 19.5, 0, "-20"); 1592 delete nf; 1593 if (U_FAILURE(status)) errln((UnicodeString)"FAIL: Status " + (int32_t)status); 1594 } 1595 1596 /** 1597 * Test the functioning of the secondary grouping value. 1598 */ 1599 void NumberFormatTest::TestSecondaryGrouping(void) { 1600 UErrorCode status = U_ZERO_ERROR; 1601 DecimalFormatSymbols US(Locale::getUS(), status); 1602 CHECK(status, "DecimalFormatSymbols ct"); 1603 1604 DecimalFormat f("#,##,###", US, status); 1605 CHECK(status, "DecimalFormat ct"); 1606 1607 expect2(f, (int32_t)123456789L, "12,34,56,789"); 1608 expectPat(f, "#,##,###"); 1609 f.applyPattern("#,###", status); 1610 CHECK(status, "applyPattern"); 1611 1612 f.setSecondaryGroupingSize(4); 1613 expect2(f, (int32_t)123456789L, "12,3456,789"); 1614 expectPat(f, "#,####,###"); 1615 NumberFormat *g = NumberFormat::createInstance(Locale("hi", "IN"), status); 1616 CHECK_DATA(status, "createInstance(hi_IN)"); 1617 1618 UnicodeString out; 1619 int32_t l = (int32_t)1876543210L; 1620 g->format(l, out); 1621 delete g; 1622 // expect "1,87,65,43,210", but with Hindi digits 1623 // 01234567890123 1624 UBool ok = TRUE; 1625 if (out.length() != 14) { 1626 ok = FALSE; 1627 } else { 1628 for (int32_t i=0; i<out.length(); ++i) { 1629 UBool expectGroup = FALSE; 1630 switch (i) { 1631 case 1: 1632 case 4: 1633 case 7: 1634 case 10: 1635 expectGroup = TRUE; 1636 break; 1637 } 1638 // Later -- fix this to get the actual grouping 1639 // character from the resource bundle. 1640 UBool isGroup = (out.charAt(i) == 0x002C); 1641 if (isGroup != expectGroup) { 1642 ok = FALSE; 1643 break; 1644 } 1645 } 1646 } 1647 if (!ok) { 1648 errln((UnicodeString)"FAIL Expected " + l + 1649 " x hi_IN -> \"1,87,65,43,210\" (with Hindi digits), got \"" + 1650 escape(out) + "\""); 1651 } else { 1652 logln((UnicodeString)"Ok " + l + 1653 " x hi_IN -> \"" + 1654 escape(out) + "\""); 1655 } 1656 } 1657 1658 void NumberFormatTest::TestWhiteSpaceParsing(void) { 1659 UErrorCode ec = U_ZERO_ERROR; 1660 DecimalFormatSymbols US(Locale::getUS(), ec); 1661 DecimalFormat fmt("a b#0c ", US, ec); 1662 if (U_FAILURE(ec)) { 1663 errcheckln(ec, "FAIL: Constructor - %s", u_errorName(ec)); 1664 return; 1665 } 1666 int32_t n = 1234; 1667 expect(fmt, "a b1234c ", n); 1668 expect(fmt, "a b1234c ", n); 1669 } 1670 1671 /** 1672 * Test currencies whose display name is a ChoiceFormat. 1673 */ 1674 void NumberFormatTest::TestComplexCurrency() { 1675 1676 // UErrorCode ec = U_ZERO_ERROR; 1677 // Locale loc("kn", "IN", ""); 1678 // NumberFormat* fmt = NumberFormat::createCurrencyInstance(loc, ec); 1679 // if (U_SUCCESS(ec)) { 1680 // expect2(*fmt, 1.0, CharsToUnicodeString("Re.\\u00A01.00")); 1681 // Use .00392625 because that's 2^-8. Any value less than 0.005 is fine. 1682 // expect(*fmt, 1.00390625, CharsToUnicodeString("Re.\\u00A01.00")); // tricky 1683 // expect2(*fmt, 12345678.0, CharsToUnicodeString("Rs.\\u00A01,23,45,678.00")); 1684 // expect2(*fmt, 0.5, CharsToUnicodeString("Rs.\\u00A00.50")); 1685 // expect2(*fmt, -1.0, CharsToUnicodeString("-Re.\\u00A01.00")); 1686 // expect2(*fmt, -10.0, CharsToUnicodeString("-Rs.\\u00A010.00")); 1687 // } else { 1688 // errln("FAIL: getCurrencyInstance(kn_IN)"); 1689 // } 1690 // delete fmt; 1691 1692 } 1693 1694 // ------------------------------------- 1695 1696 void 1697 NumberFormatTest::roundingTest(NumberFormat& nf, double x, int32_t maxFractionDigits, const char* expected) 1698 { 1699 nf.setMaximumFractionDigits(maxFractionDigits); 1700 UnicodeString out; nf.format(x, out); 1701 logln((UnicodeString)"" + x + " formats with " + maxFractionDigits + " fractional digits to " + out); 1702 if (!(out==expected)) errln((UnicodeString)"FAIL: Expected " + expected); 1703 } 1704 1705 /** 1706 * Upgrade to alphaWorks 1707 */ 1708 void NumberFormatTest::TestExponent(void) { 1709 UErrorCode status = U_ZERO_ERROR; 1710 DecimalFormatSymbols US(Locale::getUS(), status); 1711 CHECK(status, "DecimalFormatSymbols constructor"); 1712 DecimalFormat fmt1(UnicodeString("0.###E0"), US, status); 1713 CHECK(status, "DecimalFormat(0.###E0)"); 1714 DecimalFormat fmt2(UnicodeString("0.###E+0"), US, status); 1715 CHECK(status, "DecimalFormat(0.###E+0)"); 1716 int32_t n = 1234; 1717 expect2(fmt1, n, "1.234E3"); 1718 expect2(fmt2, n, "1.234E+3"); 1719 expect(fmt1, "1.234E+3", n); // Either format should parse "E+3" 1720 } 1721 1722 /** 1723 * Upgrade to alphaWorks 1724 */ 1725 void NumberFormatTest::TestScientific(void) { 1726 UErrorCode status = U_ZERO_ERROR; 1727 DecimalFormatSymbols US(Locale::getUS(), status); 1728 CHECK(status, "DecimalFormatSymbols constructor"); 1729 1730 // Test pattern round-trip 1731 const char* PAT[] = { "#E0", "0.####E0", "00.000E00", "##0.####E000", 1732 "0.###E0;[0.###E0]" }; 1733 int32_t PAT_length = UPRV_LENGTHOF(PAT); 1734 int32_t DIGITS[] = { 1735 // min int, max int, min frac, max frac 1736 0, 1, 0, 0, // "#E0" 1737 1, 1, 0, 4, // "0.####E0" 1738 2, 2, 3, 3, // "00.000E00" 1739 1, 3, 0, 4, // "##0.####E000" 1740 1, 1, 0, 3, // "0.###E0;[0.###E0]" 1741 }; 1742 for (int32_t i=0; i<PAT_length; ++i) { 1743 UnicodeString pat(PAT[i]); 1744 DecimalFormat df(pat, US, status); 1745 CHECK(status, "DecimalFormat constructor"); 1746 UnicodeString pat2; 1747 df.toPattern(pat2); 1748 if (pat == pat2) { 1749 logln(UnicodeString("Ok Pattern rt \"") + 1750 pat + "\" -> \"" + 1751 pat2 + "\""); 1752 } else { 1753 errln(UnicodeString("FAIL Pattern rt \"") + 1754 pat + "\" -> \"" + 1755 pat2 + "\""); 1756 } 1757 // Make sure digit counts match what we expect 1758 if (df.getMinimumIntegerDigits() != DIGITS[4*i] || 1759 df.getMaximumIntegerDigits() != DIGITS[4*i+1] || 1760 df.getMinimumFractionDigits() != DIGITS[4*i+2] || 1761 df.getMaximumFractionDigits() != DIGITS[4*i+3]) { 1762 errln(UnicodeString("FAIL \"" + pat + 1763 "\" min/max int; min/max frac = ") + 1764 df.getMinimumIntegerDigits() + "/" + 1765 df.getMaximumIntegerDigits() + ";" + 1766 df.getMinimumFractionDigits() + "/" + 1767 df.getMaximumFractionDigits() + ", expect " + 1768 DIGITS[4*i] + "/" + 1769 DIGITS[4*i+1] + ";" + 1770 DIGITS[4*i+2] + "/" + 1771 DIGITS[4*i+3]); 1772 } 1773 } 1774 1775 1776 // Test the constructor for default locale. We have to 1777 // manually set the default locale, as there is no 1778 // guarantee that the default locale has the same 1779 // scientific format. 1780 Locale def = Locale::getDefault(); 1781 Locale::setDefault(Locale::getUS(), status); 1782 expect2(NumberFormat::createScientificInstance(status), 1783 12345.678901, 1784 "1.2345678901E4", status); 1785 Locale::setDefault(def, status); 1786 1787 expect2(new DecimalFormat("#E0", US, status), 1788 12345.0, 1789 "1.2345E4", status); 1790 expect(new DecimalFormat("0E0", US, status), 1791 12345.0, 1792 "1E4", status); 1793 expect2(NumberFormat::createScientificInstance(Locale::getUS(), status), 1794 12345.678901, 1795 "1.2345678901E4", status); 1796 expect(new DecimalFormat("##0.###E0", US, status), 1797 12345.0, 1798 "12.34E3", status); 1799 expect(new DecimalFormat("##0.###E0", US, status), 1800 12345.00001, 1801 "12.35E3", status); 1802 expect2(new DecimalFormat("##0.####E0", US, status), 1803 (int32_t) 12345, 1804 "12.345E3", status); 1805 expect2(NumberFormat::createScientificInstance(Locale::getFrance(), status), 1806 12345.678901, 1807 "1,2345678901E4", status); 1808 expect(new DecimalFormat("##0.####E0", US, status), 1809 789.12345e-9, 1810 "789.12E-9", status); 1811 expect2(new DecimalFormat("##0.####E0", US, status), 1812 780.e-9, 1813 "780E-9", status); 1814 expect(new DecimalFormat(".###E0", US, status), 1815 45678.0, 1816 ".457E5", status); 1817 expect2(new DecimalFormat(".###E0", US, status), 1818 (int32_t) 0, 1819 ".0E0", status); 1820 /* 1821 expect(new DecimalFormat[] { new DecimalFormat("#E0", US), 1822 new DecimalFormat("##E0", US), 1823 new DecimalFormat("####E0", US), 1824 new DecimalFormat("0E0", US), 1825 new DecimalFormat("00E0", US), 1826 new DecimalFormat("000E0", US), 1827 }, 1828 new Long(45678000), 1829 new String[] { "4.5678E7", 1830 "45.678E6", 1831 "4567.8E4", 1832 "5E7", 1833 "46E6", 1834 "457E5", 1835 } 1836 ); 1837 ! 1838 ! Unroll this test into individual tests below... 1839 ! 1840 */ 1841 expect2(new DecimalFormat("#E0", US, status), 1842 (int32_t) 45678000, "4.5678E7", status); 1843 expect2(new DecimalFormat("##E0", US, status), 1844 (int32_t) 45678000, "45.678E6", status); 1845 expect2(new DecimalFormat("####E0", US, status), 1846 (int32_t) 45678000, "4567.8E4", status); 1847 expect(new DecimalFormat("0E0", US, status), 1848 (int32_t) 45678000, "5E7", status); 1849 expect(new DecimalFormat("00E0", US, status), 1850 (int32_t) 45678000, "46E6", status); 1851 expect(new DecimalFormat("000E0", US, status), 1852 (int32_t) 45678000, "457E5", status); 1853 /* 1854 expect(new DecimalFormat("###E0", US, status), 1855 new Object[] { new Double(0.0000123), "12.3E-6", 1856 new Double(0.000123), "123E-6", 1857 new Double(0.00123), "1.23E-3", 1858 new Double(0.0123), "12.3E-3", 1859 new Double(0.123), "123E-3", 1860 new Double(1.23), "1.23E0", 1861 new Double(12.3), "12.3E0", 1862 new Double(123), "123E0", 1863 new Double(1230), "1.23E3", 1864 }); 1865 ! 1866 ! Unroll this test into individual tests below... 1867 ! 1868 */ 1869 expect2(new DecimalFormat("###E0", US, status), 1870 0.0000123, "12.3E-6", status); 1871 expect2(new DecimalFormat("###E0", US, status), 1872 0.000123, "123E-6", status); 1873 expect2(new DecimalFormat("###E0", US, status), 1874 0.00123, "1.23E-3", status); 1875 expect2(new DecimalFormat("###E0", US, status), 1876 0.0123, "12.3E-3", status); 1877 expect2(new DecimalFormat("###E0", US, status), 1878 0.123, "123E-3", status); 1879 expect2(new DecimalFormat("###E0", US, status), 1880 1.23, "1.23E0", status); 1881 expect2(new DecimalFormat("###E0", US, status), 1882 12.3, "12.3E0", status); 1883 expect2(new DecimalFormat("###E0", US, status), 1884 123.0, "123E0", status); 1885 expect2(new DecimalFormat("###E0", US, status), 1886 1230.0, "1.23E3", status); 1887 /* 1888 expect(new DecimalFormat("0.#E+00", US, status), 1889 new Object[] { new Double(0.00012), "1.2E-04", 1890 new Long(12000), "1.2E+04", 1891 }); 1892 ! 1893 ! Unroll this test into individual tests below... 1894 ! 1895 */ 1896 expect2(new DecimalFormat("0.#E+00", US, status), 1897 0.00012, "1.2E-04", status); 1898 expect2(new DecimalFormat("0.#E+00", US, status), 1899 (int32_t) 12000, "1.2E+04", status); 1900 } 1901 1902 /** 1903 * Upgrade to alphaWorks 1904 */ 1905 void NumberFormatTest::TestPad(void) { 1906 UErrorCode status = U_ZERO_ERROR; 1907 DecimalFormatSymbols US(Locale::getUS(), status); 1908 CHECK(status, "DecimalFormatSymbols constructor"); 1909 1910 expect2(new DecimalFormat("*^##.##", US, status), 1911 int32_t(0), "^^^^0", status); 1912 expect2(new DecimalFormat("*^##.##", US, status), 1913 -1.3, "^-1.3", status); 1914 expect2(new DecimalFormat("##0.0####E0*_ 'g-m/s^2'", US, status), 1915 int32_t(0), "0.0E0______ g-m/s^2", status); 1916 expect(new DecimalFormat("##0.0####E0*_ 'g-m/s^2'", US, status), 1917 1.0/3, "333.333E-3_ g-m/s^2", status); 1918 expect2(new DecimalFormat("##0.0####*_ 'g-m/s^2'", US, status), 1919 int32_t(0), "0.0______ g-m/s^2", status); 1920 expect(new DecimalFormat("##0.0####*_ 'g-m/s^2'", US, status), 1921 1.0/3, "0.33333__ g-m/s^2", status); 1922 1923 // Test padding before a sign 1924 const char *formatStr = "*x#,###,###,##0.0#;*x(###,###,##0.0#)"; 1925 expect2(new DecimalFormat(formatStr, US, status), 1926 int32_t(-10), "xxxxxxxxxx(10.0)", status); 1927 expect2(new DecimalFormat(formatStr, US, status), 1928 int32_t(-1000),"xxxxxxx(1,000.0)", status); 1929 expect2(new DecimalFormat(formatStr, US, status), 1930 int32_t(-1000000),"xxx(1,000,000.0)", status); 1931 expect2(new DecimalFormat(formatStr, US, status), 1932 -100.37, "xxxxxxxx(100.37)", status); 1933 expect2(new DecimalFormat(formatStr, US, status), 1934 -10456.37, "xxxxx(10,456.37)", status); 1935 expect2(new DecimalFormat(formatStr, US, status), 1936 -1120456.37, "xx(1,120,456.37)", status); 1937 expect2(new DecimalFormat(formatStr, US, status), 1938 -112045600.37, "(112,045,600.37)", status); 1939 expect2(new DecimalFormat(formatStr, US, status), 1940 -1252045600.37,"(1,252,045,600.37)", status); 1941 1942 expect2(new DecimalFormat(formatStr, US, status), 1943 int32_t(10), "xxxxxxxxxxxx10.0", status); 1944 expect2(new DecimalFormat(formatStr, US, status), 1945 int32_t(1000),"xxxxxxxxx1,000.0", status); 1946 expect2(new DecimalFormat(formatStr, US, status), 1947 int32_t(1000000),"xxxxx1,000,000.0", status); 1948 expect2(new DecimalFormat(formatStr, US, status), 1949 100.37, "xxxxxxxxxx100.37", status); 1950 expect2(new DecimalFormat(formatStr, US, status), 1951 10456.37, "xxxxxxx10,456.37", status); 1952 expect2(new DecimalFormat(formatStr, US, status), 1953 1120456.37, "xxxx1,120,456.37", status); 1954 expect2(new DecimalFormat(formatStr, US, status), 1955 112045600.37, "xx112,045,600.37", status); 1956 expect2(new DecimalFormat(formatStr, US, status), 1957 10252045600.37,"10,252,045,600.37", status); 1958 1959 1960 // Test padding between a sign and a number 1961 const char *formatStr2 = "#,###,###,##0.0#*x;(###,###,##0.0#*x)"; 1962 expect2(new DecimalFormat(formatStr2, US, status), 1963 int32_t(-10), "(10.0xxxxxxxxxx)", status); 1964 expect2(new DecimalFormat(formatStr2, US, status), 1965 int32_t(-1000),"(1,000.0xxxxxxx)", status); 1966 expect2(new DecimalFormat(formatStr2, US, status), 1967 int32_t(-1000000),"(1,000,000.0xxx)", status); 1968 expect2(new DecimalFormat(formatStr2, US, status), 1969 -100.37, "(100.37xxxxxxxx)", status); 1970 expect2(new DecimalFormat(formatStr2, US, status), 1971 -10456.37, "(10,456.37xxxxx)", status); 1972 expect2(new DecimalFormat(formatStr2, US, status), 1973 -1120456.37, "(1,120,456.37xx)", status); 1974 expect2(new DecimalFormat(formatStr2, US, status), 1975 -112045600.37, "(112,045,600.37)", status); 1976 expect2(new DecimalFormat(formatStr2, US, status), 1977 -1252045600.37,"(1,252,045,600.37)", status); 1978 1979 expect2(new DecimalFormat(formatStr2, US, status), 1980 int32_t(10), "10.0xxxxxxxxxxxx", status); 1981 expect2(new DecimalFormat(formatStr2, US, status), 1982 int32_t(1000),"1,000.0xxxxxxxxx", status); 1983 expect2(new DecimalFormat(formatStr2, US, status), 1984 int32_t(1000000),"1,000,000.0xxxxx", status); 1985 expect2(new DecimalFormat(formatStr2, US, status), 1986 100.37, "100.37xxxxxxxxxx", status); 1987 expect2(new DecimalFormat(formatStr2, US, status), 1988 10456.37, "10,456.37xxxxxxx", status); 1989 expect2(new DecimalFormat(formatStr2, US, status), 1990 1120456.37, "1,120,456.37xxxx", status); 1991 expect2(new DecimalFormat(formatStr2, US, status), 1992 112045600.37, "112,045,600.37xx", status); 1993 expect2(new DecimalFormat(formatStr2, US, status), 1994 10252045600.37,"10,252,045,600.37", status); 1995 1996 //testing the setPadCharacter(UnicodeString) and getPadCharacterString() 1997 DecimalFormat fmt("#", US, status); 1998 CHECK(status, "DecimalFormat constructor"); 1999 UnicodeString padString("P"); 2000 fmt.setPadCharacter(padString); 2001 expectPad(fmt, "*P##.##", DecimalFormat::kPadBeforePrefix, 5, padString); 2002 fmt.setPadCharacter((UnicodeString)"^"); 2003 expectPad(fmt, "*^#", DecimalFormat::kPadBeforePrefix, 1, (UnicodeString)"^"); 2004 //commented untill implementation is complete 2005 /* fmt.setPadCharacter((UnicodeString)"^^^"); 2006 expectPad(fmt, "*^^^#", DecimalFormat::kPadBeforePrefix, 3, (UnicodeString)"^^^"); 2007 padString.remove(); 2008 padString.append((UChar)0x0061); 2009 padString.append((UChar)0x0302); 2010 fmt.setPadCharacter(padString); 2011 UChar patternChars[]={0x002a, 0x0061, 0x0302, 0x0061, 0x0302, 0x0023, 0x0000}; 2012 UnicodeString pattern(patternChars); 2013 expectPad(fmt, pattern , DecimalFormat::kPadBeforePrefix, 4, padString); 2014 */ 2015 2016 } 2017 2018 /** 2019 * Upgrade to alphaWorks 2020 */ 2021 void NumberFormatTest::TestPatterns2(void) { 2022 UErrorCode status = U_ZERO_ERROR; 2023 DecimalFormatSymbols US(Locale::getUS(), status); 2024 CHECK(status, "DecimalFormatSymbols constructor"); 2025 2026 DecimalFormat fmt("#", US, status); 2027 CHECK(status, "DecimalFormat constructor"); 2028 2029 UChar hat = 0x005E; /*^*/ 2030 2031 expectPad(fmt, "*^#", DecimalFormat::kPadBeforePrefix, 1, hat); 2032 expectPad(fmt, "$*^#", DecimalFormat::kPadAfterPrefix, 2, hat); 2033 expectPad(fmt, "#*^", DecimalFormat::kPadBeforeSuffix, 1, hat); 2034 expectPad(fmt, "#$*^", DecimalFormat::kPadAfterSuffix, 2, hat); 2035 expectPad(fmt, "$*^$#", ILLEGAL); 2036 expectPad(fmt, "#$*^$", ILLEGAL); 2037 expectPad(fmt, "'pre'#,##0*x'post'", DecimalFormat::kPadBeforeSuffix, 2038 12, (UChar)0x0078 /*x*/); 2039 expectPad(fmt, "''#0*x", DecimalFormat::kPadBeforeSuffix, 2040 3, (UChar)0x0078 /*x*/); 2041 expectPad(fmt, "'I''ll'*a###.##", DecimalFormat::kPadAfterPrefix, 2042 10, (UChar)0x0061 /*a*/); 2043 2044 fmt.applyPattern("AA#,##0.00ZZ", status); 2045 CHECK(status, "applyPattern"); 2046 fmt.setPadCharacter(hat); 2047 2048 fmt.setFormatWidth(10); 2049 2050 fmt.setPadPosition(DecimalFormat::kPadBeforePrefix); 2051 expectPat(fmt, "*^AA#,##0.00ZZ"); 2052 2053 fmt.setPadPosition(DecimalFormat::kPadBeforeSuffix); 2054 expectPat(fmt, "AA#,##0.00*^ZZ"); 2055 2056 fmt.setPadPosition(DecimalFormat::kPadAfterSuffix); 2057 expectPat(fmt, "AA#,##0.00ZZ*^"); 2058 2059 // 12 3456789012 2060 UnicodeString exp("AA*^#,##0.00ZZ", ""); 2061 fmt.setFormatWidth(12); 2062 fmt.setPadPosition(DecimalFormat::kPadAfterPrefix); 2063 expectPat(fmt, exp); 2064 2065 fmt.setFormatWidth(13); 2066 // 12 34567890123 2067 expectPat(fmt, "AA*^##,##0.00ZZ"); 2068 2069 fmt.setFormatWidth(14); 2070 // 12 345678901234 2071 expectPat(fmt, "AA*^###,##0.00ZZ"); 2072 2073 fmt.setFormatWidth(15); 2074 // 12 3456789012345 2075 expectPat(fmt, "AA*^####,##0.00ZZ"); // This is the interesting case 2076 2077 fmt.setFormatWidth(16); 2078 // 12 34567890123456 2079 expectPat(fmt, "AA*^#,###,##0.00ZZ"); 2080 } 2081 2082 void NumberFormatTest::TestSurrogateSupport(void) { 2083 UErrorCode status = U_ZERO_ERROR; 2084 DecimalFormatSymbols custom(Locale::getUS(), status); 2085 CHECK(status, "DecimalFormatSymbols constructor"); 2086 2087 custom.setSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol, "decimal"); 2088 custom.setSymbol(DecimalFormatSymbols::kPlusSignSymbol, "plus"); 2089 custom.setSymbol(DecimalFormatSymbols::kMinusSignSymbol, " minus "); 2090 custom.setSymbol(DecimalFormatSymbols::kExponentialSymbol, "exponent"); 2091 2092 UnicodeString patternStr("*\\U00010000##.##", ""); 2093 patternStr = patternStr.unescape(); 2094 UnicodeString expStr("\\U00010000\\U00010000\\U00010000\\U000100000", ""); 2095 expStr = expStr.unescape(); 2096 expect2(new DecimalFormat(patternStr, custom, status), 2097 int32_t(0), expStr, status); 2098 2099 status = U_ZERO_ERROR; 2100 expect2(new DecimalFormat("*^##.##", custom, status), 2101 int32_t(0), "^^^^0", status); 2102 status = U_ZERO_ERROR; 2103 expect2(new DecimalFormat("##.##", custom, status), 2104 -1.3, " minus 1decimal3", status); 2105 status = U_ZERO_ERROR; 2106 expect2(new DecimalFormat("##0.0####E0 'g-m/s^2'", custom, status), 2107 int32_t(0), "0decimal0exponent0 g-m/s^2", status); 2108 status = U_ZERO_ERROR; 2109 expect(new DecimalFormat("##0.0####E0 'g-m/s^2'", custom, status), 2110 1.0/3, "333decimal333exponent minus 3 g-m/s^2", status); 2111 status = U_ZERO_ERROR; 2112 expect2(new DecimalFormat("##0.0#### 'g-m/s^2'", custom, status), 2113 int32_t(0), "0decimal0 g-m/s^2", status); 2114 status = U_ZERO_ERROR; 2115 expect(new DecimalFormat("##0.0#### 'g-m/s^2'", custom, status), 2116 1.0/3, "0decimal33333 g-m/s^2", status); 2117 2118 UnicodeString zero((UChar32)0x10000); 2119 UnicodeString one((UChar32)0x10001); 2120 UnicodeString two((UChar32)0x10002); 2121 UnicodeString five((UChar32)0x10005); 2122 custom.setSymbol(DecimalFormatSymbols::kZeroDigitSymbol, zero); 2123 custom.setSymbol(DecimalFormatSymbols::kOneDigitSymbol, one); 2124 custom.setSymbol(DecimalFormatSymbols::kTwoDigitSymbol, two); 2125 custom.setSymbol(DecimalFormatSymbols::kFiveDigitSymbol, five); 2126 expStr = UnicodeString("\\U00010001decimal\\U00010002\\U00010005\\U00010000", ""); 2127 expStr = expStr.unescape(); 2128 status = U_ZERO_ERROR; 2129 expect2(new DecimalFormat("##0.000", custom, status), 2130 1.25, expStr, status); 2131 2132 custom.setSymbol(DecimalFormatSymbols::kZeroDigitSymbol, (UChar)0x30); 2133 custom.setSymbol(DecimalFormatSymbols::kCurrencySymbol, "units of money"); 2134 custom.setSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol, "money separator"); 2135 patternStr = UNICODE_STRING_SIMPLE("0.00 \\u00A4' in your bank account'"); 2136 patternStr = patternStr.unescape(); 2137 expStr = UnicodeString(" minus 20money separator00 units of money in your bank account", ""); 2138 status = U_ZERO_ERROR; 2139 expect2(new DecimalFormat(patternStr, custom, status), 2140 int32_t(-20), expStr, status); 2141 2142 custom.setSymbol(DecimalFormatSymbols::kPercentSymbol, "percent"); 2143 patternStr = "'You''ve lost ' -0.00 %' of your money today'"; 2144 patternStr = patternStr.unescape(); 2145 expStr = UnicodeString(" minus You've lost minus 2000decimal00 percent of your money today", ""); 2146 status = U_ZERO_ERROR; 2147 expect2(new DecimalFormat(patternStr, custom, status), 2148 int32_t(-20), expStr, status); 2149 } 2150 2151 void NumberFormatTest::TestCurrencyPatterns(void) { 2152 int32_t i, locCount; 2153 const Locale* locs = NumberFormat::getAvailableLocales(locCount); 2154 for (i=0; i<locCount; ++i) { 2155 UErrorCode ec = U_ZERO_ERROR; 2156 NumberFormat* nf = NumberFormat::createCurrencyInstance(locs[i], ec); 2157 if (U_FAILURE(ec)) { 2158 errln("FAIL: Can't create NumberFormat(%s) - %s", locs[i].getName(), u_errorName(ec)); 2159 } else { 2160 // Make sure currency formats do not have a variable number 2161 // of fraction digits 2162 int32_t min = nf->getMinimumFractionDigits(); 2163 int32_t max = nf->getMaximumFractionDigits(); 2164 if (min != max) { 2165 UnicodeString a, b; 2166 nf->format(1.0, a); 2167 nf->format(1.125, b); 2168 errln((UnicodeString)"FAIL: " + locs[i].getName() + 2169 " min fraction digits != max fraction digits; " 2170 "x 1.0 => " + escape(a) + 2171 "; x 1.125 => " + escape(b)); 2172 } 2173 2174 // Make sure EURO currency formats have exactly 2 fraction digits 2175 DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf); 2176 if (df != NULL) { 2177 if (u_strcmp(EUR, df->getCurrency()) == 0) { 2178 if (min != 2 || max != 2) { 2179 UnicodeString a; 2180 nf->format(1.0, a); 2181 errln((UnicodeString)"FAIL: " + locs[i].getName() + 2182 " is a EURO format but it does not have 2 fraction digits; " 2183 "x 1.0 => " + 2184 escape(a)); 2185 } 2186 } 2187 } 2188 } 2189 delete nf; 2190 } 2191 } 2192 2193 void NumberFormatTest::TestRegCurrency(void) { 2194 #if !UCONFIG_NO_SERVICE 2195 UErrorCode status = U_ZERO_ERROR; 2196 UChar USD[4]; 2197 ucurr_forLocale("en_US", USD, 4, &status); 2198 UChar YEN[4]; 2199 ucurr_forLocale("ja_JP", YEN, 4, &status); 2200 UChar TMP[4]; 2201 static const UChar QQQ[] = {0x51, 0x51, 0x51, 0}; 2202 if(U_FAILURE(status)) { 2203 errcheckln(status, "Unable to get currency for locale, error %s", u_errorName(status)); 2204 return; 2205 } 2206 2207 UCurrRegistryKey enkey = ucurr_register(YEN, "en_US", &status); 2208 UCurrRegistryKey enUSEUROkey = ucurr_register(QQQ, "en_US_EURO", &status); 2209 2210 ucurr_forLocale("en_US", TMP, 4, &status); 2211 if (u_strcmp(YEN, TMP) != 0) { 2212 errln("FAIL: didn't return YEN registered for en_US"); 2213 } 2214 2215 ucurr_forLocale("en_US_EURO", TMP, 4, &status); 2216 if (u_strcmp(QQQ, TMP) != 0) { 2217 errln("FAIL: didn't return QQQ for en_US_EURO"); 2218 } 2219 2220 int32_t fallbackLen = ucurr_forLocale("en_XX_BAR", TMP, 4, &status); 2221 if (fallbackLen) { 2222 errln("FAIL: tried to fallback en_XX_BAR"); 2223 } 2224 status = U_ZERO_ERROR; // reset 2225 2226 if (!ucurr_unregister(enkey, &status)) { 2227 errln("FAIL: couldn't unregister enkey"); 2228 } 2229 2230 ucurr_forLocale("en_US", TMP, 4, &status); 2231 if (u_strcmp(USD, TMP) != 0) { 2232 errln("FAIL: didn't return USD for en_US after unregister of en_US"); 2233 } 2234 status = U_ZERO_ERROR; // reset 2235 2236 ucurr_forLocale("en_US_EURO", TMP, 4, &status); 2237 if (u_strcmp(QQQ, TMP) != 0) { 2238 errln("FAIL: didn't return QQQ for en_US_EURO after unregister of en_US"); 2239 } 2240 2241 ucurr_forLocale("en_US_BLAH", TMP, 4, &status); 2242 if (u_strcmp(USD, TMP) != 0) { 2243 errln("FAIL: could not find USD for en_US_BLAH after unregister of en"); 2244 } 2245 status = U_ZERO_ERROR; // reset 2246 2247 if (!ucurr_unregister(enUSEUROkey, &status)) { 2248 errln("FAIL: couldn't unregister enUSEUROkey"); 2249 } 2250 2251 ucurr_forLocale("en_US_EURO", TMP, 4, &status); 2252 if (u_strcmp(EUR, TMP) != 0) { 2253 errln("FAIL: didn't return EUR for en_US_EURO after unregister of en_US_EURO"); 2254 } 2255 status = U_ZERO_ERROR; // reset 2256 #endif 2257 } 2258 2259 void NumberFormatTest::TestCurrencyNames(void) { 2260 // Do a basic check of getName() 2261 // USD { "US$", "US Dollar" } // 04/04/1792- 2262 UErrorCode ec = U_ZERO_ERROR; 2263 static const UChar USD[] = {0x55, 0x53, 0x44, 0}; /*USD*/ 2264 static const UChar USX[] = {0x55, 0x53, 0x58, 0}; /*USX*/ 2265 static const UChar CAD[] = {0x43, 0x41, 0x44, 0}; /*CAD*/ 2266 static const UChar ITL[] = {0x49, 0x54, 0x4C, 0}; /*ITL*/ 2267 UBool isChoiceFormat; 2268 int32_t len; 2269 const UBool possibleDataError = TRUE; 2270 // Warning: HARD-CODED LOCALE DATA in this test. If it fails, CHECK 2271 // THE LOCALE DATA before diving into the code. 2272 assertEquals("USD.getName(SYMBOL_NAME)", 2273 UnicodeString("$"), 2274 UnicodeString(ucurr_getName(USD, "en", 2275 UCURR_SYMBOL_NAME, 2276 &isChoiceFormat, &len, &ec)), 2277 possibleDataError); 2278 assertEquals("USD.getName(LONG_NAME)", 2279 UnicodeString("US Dollar"), 2280 UnicodeString(ucurr_getName(USD, "en", 2281 UCURR_LONG_NAME, 2282 &isChoiceFormat, &len, &ec)), 2283 possibleDataError); 2284 assertEquals("CAD.getName(SYMBOL_NAME)", 2285 UnicodeString("CA$"), 2286 UnicodeString(ucurr_getName(CAD, "en", 2287 UCURR_SYMBOL_NAME, 2288 &isChoiceFormat, &len, &ec)), 2289 possibleDataError); 2290 assertEquals("CAD.getName(SYMBOL_NAME)", 2291 UnicodeString("$"), 2292 UnicodeString(ucurr_getName(CAD, "en_CA", 2293 UCURR_SYMBOL_NAME, 2294 &isChoiceFormat, &len, &ec)), 2295 possibleDataError); 2296 assertEquals("USD.getName(SYMBOL_NAME) in en_NZ", 2297 UnicodeString("US$"), 2298 UnicodeString(ucurr_getName(USD, "en_NZ", 2299 UCURR_SYMBOL_NAME, 2300 &isChoiceFormat, &len, &ec)), 2301 possibleDataError); 2302 assertEquals("CAD.getName(SYMBOL_NAME)", 2303 UnicodeString("CA$"), 2304 UnicodeString(ucurr_getName(CAD, "en_NZ", 2305 UCURR_SYMBOL_NAME, 2306 &isChoiceFormat, &len, &ec)), 2307 possibleDataError); 2308 assertEquals("USX.getName(LONG_NAME)", 2309 UnicodeString("USX"), 2310 UnicodeString(ucurr_getName(USX, "en_US", 2311 UCURR_LONG_NAME, 2312 &isChoiceFormat, &len, &ec)), 2313 possibleDataError); 2314 assertSuccess("ucurr_getName", ec); 2315 2316 ec = U_ZERO_ERROR; 2317 2318 // Test that a default or fallback warning is being returned. JB 4239. 2319 ucurr_getName(CAD, "es_ES", UCURR_LONG_NAME, &isChoiceFormat, 2320 &len, &ec); 2321 assertTrue("ucurr_getName (es_ES fallback)", 2322 U_USING_FALLBACK_WARNING == ec, TRUE, possibleDataError); 2323 2324 ucurr_getName(CAD, "zh_TW", UCURR_LONG_NAME, &isChoiceFormat, 2325 &len, &ec); 2326 assertTrue("ucurr_getName (zh_TW fallback)", 2327 U_USING_FALLBACK_WARNING == ec, TRUE, possibleDataError); 2328 2329 ucurr_getName(CAD, "en_US", UCURR_LONG_NAME, &isChoiceFormat, 2330 &len, &ec); 2331 assertTrue("ucurr_getName (en_US default)", 2332 U_USING_DEFAULT_WARNING == ec || U_USING_FALLBACK_WARNING == ec, TRUE); 2333 2334 ucurr_getName(CAD, "ti", UCURR_LONG_NAME, &isChoiceFormat, 2335 &len, &ec); 2336 assertTrue("ucurr_getName (ti default)", 2337 U_USING_DEFAULT_WARNING == ec, TRUE); 2338 2339 // Test that a default warning is being returned when falling back to root. JB 4536. 2340 ucurr_getName(ITL, "cy", UCURR_LONG_NAME, &isChoiceFormat, 2341 &len, &ec); 2342 assertTrue("ucurr_getName (cy default to root)", 2343 U_USING_DEFAULT_WARNING == ec, TRUE); 2344 2345 // TODO add more tests later 2346 } 2347 2348 void NumberFormatTest::TestCurrencyUnit(void){ 2349 UErrorCode ec = U_ZERO_ERROR; 2350 static const UChar USD[] = {85, 83, 68, 0}; /*USD*/ 2351 static const UChar BAD[] = {63, 63, 63, 0}; /*???*/ 2352 static const UChar BAD2[] = {63, 63, 65, 0}; /*???*/ 2353 CurrencyUnit cu(USD, ec); 2354 assertSuccess("CurrencyUnit", ec); 2355 2356 const UChar * r = cu.getISOCurrency(); // who is the buffer owner ? 2357 assertEquals("getISOCurrency()", USD, r); 2358 2359 CurrencyUnit cu2(cu); 2360 if (!(cu2 == cu)){ 2361 errln("CurrencyUnit copy constructed object should be same"); 2362 } 2363 2364 CurrencyUnit * cu3 = (CurrencyUnit *)cu.clone(); 2365 if (!(*cu3 == cu)){ 2366 errln("CurrencyUnit cloned object should be same"); 2367 } 2368 CurrencyUnit bad(BAD, ec); 2369 assertSuccess("CurrencyUnit", ec); 2370 if (cu.getIndex() == bad.getIndex()) { 2371 errln("Indexes of different currencies should differ."); 2372 } 2373 CurrencyUnit bad2(BAD2, ec); 2374 assertSuccess("CurrencyUnit", ec); 2375 if (bad2.getIndex() != bad.getIndex()) { 2376 errln("Indexes of unrecognized currencies should be the same."); 2377 } 2378 if (bad == bad2) { 2379 errln("Different unrecognized currencies should not be equal."); 2380 } 2381 bad = bad2; 2382 if (bad != bad2) { 2383 errln("Currency unit assignment should be the same."); 2384 } 2385 delete cu3; 2386 } 2387 2388 void NumberFormatTest::TestCurrencyAmount(void){ 2389 UErrorCode ec = U_ZERO_ERROR; 2390 static const UChar USD[] = {85, 83, 68, 0}; /*USD*/ 2391 CurrencyAmount ca(9, USD, ec); 2392 assertSuccess("CurrencyAmount", ec); 2393 2394 CurrencyAmount ca2(ca); 2395 if (!(ca2 == ca)){ 2396 errln("CurrencyAmount copy constructed object should be same"); 2397 } 2398 2399 ca2=ca; 2400 if (!(ca2 == ca)){ 2401 errln("CurrencyAmount assigned object should be same"); 2402 } 2403 2404 CurrencyAmount *ca3 = (CurrencyAmount *)ca.clone(); 2405 if (!(*ca3 == ca)){ 2406 errln("CurrencyAmount cloned object should be same"); 2407 } 2408 delete ca3; 2409 } 2410 2411 void NumberFormatTest::TestSymbolsWithBadLocale(void) { 2412 Locale locDefault; 2413 static const char *badLocales[] = { 2414 // length < ULOC_FULLNAME_CAPACITY 2415 "x-crazy_ZZ_MY_SPECIAL_ADMINISTRATION_REGION_NEEDS_A_SPECIAL_VARIANT_WITH_A_REALLY_REALLY_REALLY_REALLY_REALLY_REALLY_REALLY_LONG_NAME", 2416 2417 // length > ULOC_FULLNAME_CAPACITY 2418 "x-crazy_ZZ_MY_SPECIAL_ADMINISTRATION_REGION_NEEDS_A_SPECIAL_VARIANT_WITH_A_REALLY_REALLY_REALLY_REALLY_REALLY_REALLY_REALLY_REALLY_REALLY_REALLY_REALLY_LONG_NAME" 2419 }; // expect U_USING_DEFAULT_WARNING for both 2420 2421 unsigned int i; 2422 for (i = 0; i < UPRV_LENGTHOF(badLocales); i++) { 2423 const char *localeName = badLocales[i]; 2424 Locale locBad(localeName); 2425 TEST_ASSERT_TRUE(!locBad.isBogus()); 2426 UErrorCode status = U_ZERO_ERROR; 2427 UnicodeString intlCurrencySymbol((UChar)0xa4); 2428 2429 intlCurrencySymbol.append((UChar)0xa4); 2430 2431 logln("Current locale is %s", Locale::getDefault().getName()); 2432 Locale::setDefault(locBad, status); 2433 logln("Current locale is %s", Locale::getDefault().getName()); 2434 DecimalFormatSymbols mySymbols(status); 2435 if (status != U_USING_DEFAULT_WARNING) { 2436 errln("DecimalFormatSymbols should return U_USING_DEFAULT_WARNING."); 2437 } 2438 if (strcmp(mySymbols.getLocale().getName(), locBad.getName()) != 0) { 2439 errln("DecimalFormatSymbols does not have the right locale.", locBad.getName()); 2440 } 2441 int symbolEnum = (int)DecimalFormatSymbols::kDecimalSeparatorSymbol; 2442 for (; symbolEnum < (int)DecimalFormatSymbols::kFormatSymbolCount; symbolEnum++) { 2443 UnicodeString symbolString = mySymbols.getSymbol((DecimalFormatSymbols::ENumberFormatSymbol)symbolEnum); 2444 logln(UnicodeString("DecimalFormatSymbols[") + symbolEnum + UnicodeString("] = ") + prettify(symbolString)); 2445 if (symbolString.length() == 0 2446 && symbolEnum != (int)DecimalFormatSymbols::kGroupingSeparatorSymbol 2447 && symbolEnum != (int)DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol) 2448 { 2449 errln("DecimalFormatSymbols has an empty string at index %d.", symbolEnum); 2450 } 2451 } 2452 2453 status = U_ZERO_ERROR; 2454 Locale::setDefault(locDefault, status); 2455 logln("Current locale is %s", Locale::getDefault().getName()); 2456 } 2457 } 2458 2459 /** 2460 * Check that adoptDecimalFormatSymbols and setDecimalFormatSymbols 2461 * behave the same, except for memory ownership semantics. (No 2462 * version of this test on Java, since Java has only one method.) 2463 */ 2464 void NumberFormatTest::TestAdoptDecimalFormatSymbols(void) { 2465 UErrorCode ec = U_ZERO_ERROR; 2466 DecimalFormatSymbols *sym = new DecimalFormatSymbols(Locale::getUS(), ec); 2467 if (U_FAILURE(ec)) { 2468 errcheckln(ec, "Fail: DecimalFormatSymbols constructor - %s", u_errorName(ec)); 2469 delete sym; 2470 return; 2471 } 2472 UnicodeString pat(" #,##0.00"); 2473 pat.insert(0, (UChar)0x00A4); 2474 DecimalFormat fmt(pat, sym, ec); 2475 if (U_FAILURE(ec)) { 2476 errln("Fail: DecimalFormat constructor"); 2477 return; 2478 } 2479 2480 UnicodeString str; 2481 fmt.format(2350.75, str); 2482 if (str == "$ 2,350.75") { 2483 logln(str); 2484 } else { 2485 dataerrln("Fail: " + str + ", expected $ 2,350.75"); 2486 } 2487 2488 sym = new DecimalFormatSymbols(Locale::getUS(), ec); 2489 if (U_FAILURE(ec)) { 2490 errln("Fail: DecimalFormatSymbols constructor"); 2491 delete sym; 2492 return; 2493 } 2494 sym->setSymbol(DecimalFormatSymbols::kCurrencySymbol, "Q"); 2495 fmt.adoptDecimalFormatSymbols(sym); 2496 2497 str.truncate(0); 2498 fmt.format(2350.75, str); 2499 if (str == "Q 2,350.75") { 2500 logln(str); 2501 } else { 2502 dataerrln("Fail: adoptDecimalFormatSymbols -> " + str + ", expected Q 2,350.75"); 2503 } 2504 2505 sym = new DecimalFormatSymbols(Locale::getUS(), ec); 2506 if (U_FAILURE(ec)) { 2507 errln("Fail: DecimalFormatSymbols constructor"); 2508 delete sym; 2509 return; 2510 } 2511 DecimalFormat fmt2(pat, sym, ec); 2512 if (U_FAILURE(ec)) { 2513 errln("Fail: DecimalFormat constructor"); 2514 return; 2515 } 2516 2517 DecimalFormatSymbols sym2(Locale::getUS(), ec); 2518 if (U_FAILURE(ec)) { 2519 errln("Fail: DecimalFormatSymbols constructor"); 2520 return; 2521 } 2522 sym2.setSymbol(DecimalFormatSymbols::kCurrencySymbol, "Q"); 2523 fmt2.setDecimalFormatSymbols(sym2); 2524 2525 str.truncate(0); 2526 fmt2.format(2350.75, str); 2527 if (str == "Q 2,350.75") { 2528 logln(str); 2529 } else { 2530 dataerrln("Fail: setDecimalFormatSymbols -> " + str + ", expected Q 2,350.75"); 2531 } 2532 } 2533 2534 void NumberFormatTest::TestPerMill() { 2535 UErrorCode ec = U_ZERO_ERROR; 2536 UnicodeString str; 2537 DecimalFormat fmt(ctou("###.###\\u2030"), ec); 2538 if (!assertSuccess("DecimalFormat ct", ec)) return; 2539 assertEquals("0.4857 x ###.###\\u2030", 2540 ctou("485.7\\u2030"), fmt.format(0.4857, str)); 2541 2542 DecimalFormatSymbols sym(Locale::getUS(), ec); 2543 sym.setSymbol(DecimalFormatSymbols::kPerMillSymbol, ctou("m")); 2544 DecimalFormat fmt2("", sym, ec); 2545 fmt2.applyLocalizedPattern("###.###m", ec); 2546 if (!assertSuccess("setup", ec)) return; 2547 str.truncate(0); 2548 assertEquals("0.4857 x ###.###m", 2549 "485.7m", fmt2.format(0.4857, str)); 2550 } 2551 2552 /** 2553 * Generic test for patterns that should be legal/illegal. 2554 */ 2555 void NumberFormatTest::TestIllegalPatterns() { 2556 // Test cases: 2557 // Prefix with "-:" for illegal patterns 2558 // Prefix with "+:" for legal patterns 2559 const char* DATA[] = { 2560 // Unquoted special characters in the suffix are illegal 2561 "-:000.000|###", 2562 "+:000.000'|###'", 2563 0 2564 }; 2565 for (int32_t i=0; DATA[i]; ++i) { 2566 const char* pat=DATA[i]; 2567 UBool valid = (*pat) == '+'; 2568 pat += 2; 2569 UErrorCode ec = U_ZERO_ERROR; 2570 DecimalFormat fmt(pat, ec); // locale doesn't matter here 2571 if (U_SUCCESS(ec) == valid) { 2572 logln("Ok: pattern \"%s\": %s", 2573 pat, u_errorName(ec)); 2574 } else { 2575 errcheckln(ec, "FAIL: pattern \"%s\" should have %s; got %s", 2576 pat, (valid?"succeeded":"failed"), 2577 u_errorName(ec)); 2578 } 2579 } 2580 } 2581 2582 //---------------------------------------------------------------------- 2583 2584 static const char* KEYWORDS[] = { 2585 /*0*/ "ref=", // <reference pattern to parse numbers> 2586 /*1*/ "loc=", // <locale for formats> 2587 /*2*/ "f:", // <pattern or '-'> <number> <exp. string> 2588 /*3*/ "fp:", // <pattern or '-'> <number> <exp. string> <exp. number> 2589 /*4*/ "rt:", // <pattern or '-'> <(exp.) number> <(exp.) string> 2590 /*5*/ "p:", // <pattern or '-'> <string> <exp. number> 2591 /*6*/ "perr:", // <pattern or '-'> <invalid string> 2592 /*7*/ "pat:", // <pattern or '-'> <exp. toPattern or '-' or 'err'> 2593 /*8*/ "fpc:", // <pattern or '-'> <curr.amt> <exp. string> <exp. curr.amt> 2594 0 2595 }; 2596 2597 /** 2598 * Return an integer representing the next token from this 2599 * iterator. The integer will be an index into the given list, or 2600 * -1 if there are no more tokens, or -2 if the token is not on 2601 * the list. 2602 */ 2603 static int32_t keywordIndex(const UnicodeString& tok) { 2604 for (int32_t i=0; KEYWORDS[i]!=0; ++i) { 2605 if (tok==KEYWORDS[i]) { 2606 return i; 2607 } 2608 } 2609 return -1; 2610 } 2611 2612 /** 2613 * Parse a CurrencyAmount using the given NumberFormat, with 2614 * the 'delim' character separating the number and the currency. 2615 */ 2616 static void parseCurrencyAmount(const UnicodeString& str, 2617 const NumberFormat& fmt, 2618 UChar delim, 2619 Formattable& result, 2620 UErrorCode& ec) { 2621 UnicodeString num, cur; 2622 int32_t i = str.indexOf(delim); 2623 str.extractBetween(0, i, num); 2624 str.extractBetween(i+1, INT32_MAX, cur); 2625 Formattable n; 2626 fmt.parse(num, n, ec); 2627 result.adoptObject(new CurrencyAmount(n, cur.getTerminatedBuffer(), ec)); 2628 } 2629 2630 void NumberFormatTest::TestCases() { 2631 UErrorCode ec = U_ZERO_ERROR; 2632 TextFile reader("NumberFormatTestCases.txt", "UTF8", ec); 2633 if (U_FAILURE(ec)) { 2634 dataerrln("Couldn't open NumberFormatTestCases.txt"); 2635 return; 2636 } 2637 TokenIterator tokens(&reader); 2638 2639 Locale loc("en", "US", ""); 2640 DecimalFormat *ref = 0, *fmt = 0; 2641 MeasureFormat *mfmt = 0; 2642 UnicodeString pat, tok, mloc, str, out, where, currAmt; 2643 Formattable n; 2644 2645 for (;;) { 2646 ec = U_ZERO_ERROR; 2647 if (!tokens.next(tok, ec)) { 2648 break; 2649 } 2650 where = UnicodeString("(") + tokens.getLineNumber() + ") "; 2651 int32_t cmd = keywordIndex(tok); 2652 switch (cmd) { 2653 case 0: 2654 // ref= <reference pattern> 2655 if (!tokens.next(tok, ec)) goto error; 2656 delete ref; 2657 ref = new DecimalFormat(tok, 2658 new DecimalFormatSymbols(Locale::getUS(), ec), ec); 2659 if (U_FAILURE(ec)) { 2660 dataerrln("Error constructing DecimalFormat"); 2661 goto error; 2662 } 2663 break; 2664 case 1: 2665 // loc= <locale> 2666 if (!tokens.next(tok, ec)) goto error; 2667 loc = Locale::createFromName(CharString().appendInvariantChars(tok, ec).data()); 2668 break; 2669 case 2: // f: 2670 case 3: // fp: 2671 case 4: // rt: 2672 case 5: // p: 2673 if (!tokens.next(tok, ec)) goto error; 2674 if (tok != "-") { 2675 pat = tok; 2676 delete fmt; 2677 fmt = new DecimalFormat(pat, new DecimalFormatSymbols(loc, ec), ec); 2678 if (U_FAILURE(ec)) { 2679 errln("FAIL: " + where + "Pattern \"" + pat + "\": " + u_errorName(ec)); 2680 ec = U_ZERO_ERROR; 2681 if (!tokens.next(tok, ec)) goto error; 2682 if (!tokens.next(tok, ec)) goto error; 2683 if (cmd == 3) { 2684 if (!tokens.next(tok, ec)) goto error; 2685 } 2686 continue; 2687 } 2688 } 2689 if (cmd == 2 || cmd == 3 || cmd == 4) { 2690 // f: <pattern or '-'> <number> <exp. string> 2691 // fp: <pattern or '-'> <number> <exp. string> <exp. number> 2692 // rt: <pattern or '-'> <number> <string> 2693 UnicodeString num; 2694 if (!tokens.next(num, ec)) goto error; 2695 if (!tokens.next(str, ec)) goto error; 2696 ref->parse(num, n, ec); 2697 assertSuccess("parse", ec); 2698 assertEquals(where + "\"" + pat + "\".format(" + num + ")", 2699 str, fmt->format(n, out.remove(), ec)); 2700 assertSuccess("format", ec); 2701 if (cmd == 3) { // fp: 2702 if (!tokens.next(num, ec)) goto error; 2703 ref->parse(num, n, ec); 2704 assertSuccess("parse", ec); 2705 } 2706 if (cmd != 2) { // != f: 2707 Formattable m; 2708 fmt->parse(str, m, ec); 2709 assertSuccess("parse", ec); 2710 assertEquals(where + "\"" + pat + "\".parse(\"" + str + "\")", 2711 n, m); 2712 } 2713 } 2714 // p: <pattern or '-'> <string to parse> <exp. number> 2715 else { 2716 UnicodeString expstr; 2717 if (!tokens.next(str, ec)) goto error; 2718 if (!tokens.next(expstr, ec)) goto error; 2719 Formattable exp, n; 2720 ref->parse(expstr, exp, ec); 2721 assertSuccess("parse", ec); 2722 fmt->parse(str, n, ec); 2723 assertSuccess("parse", ec); 2724 assertEquals(where + "\"" + pat + "\".parse(\"" + str + "\")", 2725 exp, n); 2726 } 2727 break; 2728 case 8: // fpc: 2729 if (!tokens.next(tok, ec)) goto error; 2730 if (tok != "-") { 2731 mloc = tok; 2732 delete mfmt; 2733 mfmt = MeasureFormat::createCurrencyFormat( 2734 Locale::createFromName( 2735 CharString().appendInvariantChars(mloc, ec).data()), ec); 2736 if (U_FAILURE(ec)) { 2737 errln("FAIL: " + where + "Loc \"" + mloc + "\": " + u_errorName(ec)); 2738 ec = U_ZERO_ERROR; 2739 if (!tokens.next(tok, ec)) goto error; 2740 if (!tokens.next(tok, ec)) goto error; 2741 if (!tokens.next(tok, ec)) goto error; 2742 continue; 2743 } 2744 } else if (mfmt == NULL) { 2745 errln("FAIL: " + where + "Loc \"" + mloc + "\": skip case using previous locale, no valid MeasureFormat"); 2746 if (!tokens.next(tok, ec)) goto error; 2747 if (!tokens.next(tok, ec)) goto error; 2748 if (!tokens.next(tok, ec)) goto error; 2749 continue; 2750 } 2751 // fpc: <loc or '-'> <curr.amt> <exp. string> <exp. curr.amt> 2752 if (!tokens.next(currAmt, ec)) goto error; 2753 if (!tokens.next(str, ec)) goto error; 2754 parseCurrencyAmount(currAmt, *ref, (UChar)0x2F/*'/'*/, n, ec); 2755 if (assertSuccess("parseCurrencyAmount", ec)) { 2756 assertEquals(where + "getCurrencyFormat(" + mloc + ").format(" + currAmt + ")", 2757 str, mfmt->format(n, out.remove(), ec)); 2758 assertSuccess("format", ec); 2759 } 2760 if (!tokens.next(currAmt, ec)) goto error; 2761 parseCurrencyAmount(currAmt, *ref, (UChar)0x2F/*'/'*/, n, ec); 2762 if (assertSuccess("parseCurrencyAmount", ec)) { 2763 Formattable m; 2764 2765 mfmt->parseObject(str, m, ec); 2766 if (assertSuccess("parseCurrency", ec)) { 2767 assertEquals(where + "getCurrencyFormat(" + mloc + ").parse(\"" + str + "\")", 2768 n, m); 2769 } else { 2770 errln("FAIL: source " + str); 2771 } 2772 } 2773 break; 2774 case 6: 2775 // perr: <pattern or '-'> <invalid string> 2776 errln("FAIL: Under construction"); 2777 goto done; 2778 case 7: { 2779 // pat: <pattern> <exp. toPattern, or '-' or 'err'> 2780 UnicodeString testpat; 2781 UnicodeString exppat; 2782 if (!tokens.next(testpat, ec)) goto error; 2783 if (!tokens.next(exppat, ec)) goto error; 2784 UBool err = exppat == "err"; 2785 UBool existingPat = FALSE; 2786 if (testpat == "-") { 2787 if (err) { 2788 errln("FAIL: " + where + "Invalid command \"pat: - err\""); 2789 continue; 2790 } 2791 existingPat = TRUE; 2792 testpat = pat; 2793 } 2794 if (exppat == "-") exppat = testpat; 2795 DecimalFormat* f = 0; 2796 UErrorCode ec2 = U_ZERO_ERROR; 2797 if (existingPat) { 2798 f = fmt; 2799 } else { 2800 f = new DecimalFormat(testpat, ec2); 2801 } 2802 if (U_SUCCESS(ec2)) { 2803 if (err) { 2804 errln("FAIL: " + where + "Invalid pattern \"" + testpat + 2805 "\" was accepted"); 2806 } else { 2807 UnicodeString pat2; 2808 assertEquals(where + "\"" + testpat + "\".toPattern()", 2809 exppat, f->toPattern(pat2)); 2810 } 2811 } else { 2812 if (err) { 2813 logln("Ok: " + where + "Invalid pattern \"" + testpat + 2814 "\" failed: " + u_errorName(ec2)); 2815 } else { 2816 errln("FAIL: " + where + "Valid pattern \"" + testpat + 2817 "\" failed: " + u_errorName(ec2)); 2818 } 2819 } 2820 if (!existingPat) delete f; 2821 } break; 2822 case -1: 2823 errln("FAIL: " + where + "Unknown command \"" + tok + "\""); 2824 goto done; 2825 } 2826 } 2827 goto done; 2828 2829 error: 2830 if (U_SUCCESS(ec)) { 2831 errln("FAIL: Unexpected EOF"); 2832 } else { 2833 errcheckln(ec, "FAIL: " + where + "Unexpected " + u_errorName(ec)); 2834 } 2835 2836 done: 2837 delete mfmt; 2838 delete fmt; 2839 delete ref; 2840 } 2841 2842 2843 //---------------------------------------------------------------------- 2844 // Support methods 2845 //---------------------------------------------------------------------- 2846 2847 UBool NumberFormatTest::equalValue(const Formattable& a, const Formattable& b) { 2848 if (a.getType() == b.getType()) { 2849 return a == b; 2850 } 2851 2852 if (a.getType() == Formattable::kLong) { 2853 if (b.getType() == Formattable::kInt64) { 2854 return a.getLong() == b.getLong(); 2855 } else if (b.getType() == Formattable::kDouble) { 2856 return (double) a.getLong() == b.getDouble(); // TODO check use of double instead of long 2857 } 2858 } else if (a.getType() == Formattable::kDouble) { 2859 if (b.getType() == Formattable::kLong) { 2860 return a.getDouble() == (double) b.getLong(); 2861 } else if (b.getType() == Formattable::kInt64) { 2862 return a.getDouble() == (double)b.getInt64(); 2863 } 2864 } else if (a.getType() == Formattable::kInt64) { 2865 if (b.getType() == Formattable::kLong) { 2866 return a.getInt64() == (int64_t)b.getLong(); 2867 } else if (b.getType() == Formattable::kDouble) { 2868 return a.getInt64() == (int64_t)b.getDouble(); 2869 } 2870 } 2871 return FALSE; 2872 } 2873 2874 void NumberFormatTest::expect3(NumberFormat& fmt, const Formattable& n, const UnicodeString& str) { 2875 // Don't round-trip format test, since we explicitly do it 2876 expect_rbnf(fmt, n, str, FALSE); 2877 expect_rbnf(fmt, str, n); 2878 } 2879 2880 void NumberFormatTest::expect2(NumberFormat& fmt, const Formattable& n, const UnicodeString& str) { 2881 // Don't round-trip format test, since we explicitly do it 2882 expect(fmt, n, str, FALSE); 2883 expect(fmt, str, n); 2884 } 2885 2886 void NumberFormatTest::expect2(NumberFormat* fmt, const Formattable& n, 2887 const UnicodeString& exp, 2888 UErrorCode status) { 2889 if (fmt == NULL || U_FAILURE(status)) { 2890 dataerrln("FAIL: NumberFormat constructor"); 2891 } else { 2892 expect2(*fmt, n, exp); 2893 } 2894 delete fmt; 2895 } 2896 2897 void NumberFormatTest::expect(NumberFormat& fmt, const UnicodeString& str, const Formattable& n) { 2898 UErrorCode status = U_ZERO_ERROR; 2899 Formattable num; 2900 fmt.parse(str, num, status); 2901 if (U_FAILURE(status)) { 2902 dataerrln(UnicodeString("FAIL: Parse failed for \"") + str + "\" - " + u_errorName(status)); 2903 return; 2904 } 2905 UnicodeString pat; 2906 ((DecimalFormat*) &fmt)->toPattern(pat); 2907 if (equalValue(num, n)) { 2908 logln(UnicodeString("Ok \"") + str + "\" x " + 2909 pat + " = " + 2910 toString(num)); 2911 } else { 2912 dataerrln(UnicodeString("FAIL \"") + str + "\" x " + 2913 pat + " = " + 2914 toString(num) + ", expected " + toString(n)); 2915 } 2916 } 2917 2918 void NumberFormatTest::expect_rbnf(NumberFormat& fmt, const UnicodeString& str, const Formattable& n) { 2919 UErrorCode status = U_ZERO_ERROR; 2920 Formattable num; 2921 fmt.parse(str, num, status); 2922 if (U_FAILURE(status)) { 2923 errln(UnicodeString("FAIL: Parse failed for \"") + str + "\""); 2924 return; 2925 } 2926 if (equalValue(num, n)) { 2927 logln(UnicodeString("Ok \"") + str + " = " + 2928 toString(num)); 2929 } else { 2930 errln(UnicodeString("FAIL \"") + str + " = " + 2931 toString(num) + ", expected " + toString(n)); 2932 } 2933 } 2934 2935 void NumberFormatTest::expect_rbnf(NumberFormat& fmt, const Formattable& n, 2936 const UnicodeString& exp, UBool rt) { 2937 UnicodeString saw; 2938 FieldPosition pos; 2939 UErrorCode status = U_ZERO_ERROR; 2940 fmt.format(n, saw, pos, status); 2941 CHECK(status, "NumberFormat::format"); 2942 if (saw == exp) { 2943 logln(UnicodeString("Ok ") + toString(n) + 2944 " = \"" + 2945 escape(saw) + "\""); 2946 // We should be able to round-trip the formatted string => 2947 // number => string (but not the other way around: number 2948 // => string => number2, might have number2 != number): 2949 if (rt) { 2950 Formattable n2; 2951 fmt.parse(exp, n2, status); 2952 if (U_FAILURE(status)) { 2953 errln(UnicodeString("FAIL: Parse failed for \"") + exp + "\""); 2954 return; 2955 } 2956 UnicodeString saw2; 2957 fmt.format(n2, saw2, pos, status); 2958 CHECK(status, "NumberFormat::format"); 2959 if (saw2 != exp) { 2960 errln((UnicodeString)"FAIL \"" + exp + "\" => " + toString(n2) + 2961 " => \"" + saw2 + "\""); 2962 } 2963 } 2964 } else { 2965 errln(UnicodeString("FAIL ") + toString(n) + 2966 " = \"" + 2967 escape(saw) + "\", expected \"" + exp + "\""); 2968 } 2969 } 2970 2971 void NumberFormatTest::expect(NumberFormat& fmt, const Formattable& n, 2972 const UnicodeString& exp, UBool rt) { 2973 UnicodeString saw; 2974 FieldPosition pos; 2975 UErrorCode status = U_ZERO_ERROR; 2976 fmt.format(n, saw, pos, status); 2977 CHECK(status, "NumberFormat::format"); 2978 UnicodeString pat; 2979 ((DecimalFormat*) &fmt)->toPattern(pat); 2980 if (saw == exp) { 2981 logln(UnicodeString("Ok ") + toString(n) + " x " + 2982 escape(pat) + " = \"" + 2983 escape(saw) + "\""); 2984 // We should be able to round-trip the formatted string => 2985 // number => string (but not the other way around: number 2986 // => string => number2, might have number2 != number): 2987 if (rt) { 2988 Formattable n2; 2989 fmt.parse(exp, n2, status); 2990 if (U_FAILURE(status)) { 2991 errln(UnicodeString("FAIL: Parse failed for \"") + exp + "\" - " + u_errorName(status)); 2992 return; 2993 } 2994 UnicodeString saw2; 2995 fmt.format(n2, saw2, pos, status); 2996 CHECK(status, "NumberFormat::format"); 2997 if (saw2 != exp) { 2998 errln((UnicodeString)"FAIL \"" + exp + "\" => " + toString(n2) + 2999 " => \"" + saw2 + "\""); 3000 } 3001 } 3002 } else { 3003 dataerrln(UnicodeString("FAIL ") + toString(n) + " x " + 3004 escape(pat) + " = \"" + 3005 escape(saw) + "\", expected \"" + exp + "\""); 3006 } 3007 } 3008 3009 void NumberFormatTest::expect(NumberFormat* fmt, const Formattable& n, 3010 const UnicodeString& exp, UBool rt, 3011 UErrorCode status) { 3012 if (fmt == NULL || U_FAILURE(status)) { 3013 dataerrln("FAIL: NumberFormat constructor"); 3014 } else { 3015 expect(*fmt, n, exp, rt); 3016 } 3017 delete fmt; 3018 } 3019 3020 void NumberFormatTest::expectCurrency(NumberFormat& nf, const Locale& locale, 3021 double value, const UnicodeString& string) { 3022 UErrorCode ec = U_ZERO_ERROR; 3023 DecimalFormat& fmt = * (DecimalFormat*) &nf; 3024 const UChar DEFAULT_CURR[] = {45/*-*/,0}; 3025 UChar curr[4]; 3026 u_strcpy(curr, DEFAULT_CURR); 3027 if (*locale.getLanguage() != 0) { 3028 ucurr_forLocale(locale.getName(), curr, 4, &ec); 3029 assertSuccess("ucurr_forLocale", ec); 3030 fmt.setCurrency(curr, ec); 3031 assertSuccess("DecimalFormat::setCurrency", ec); 3032 fmt.setCurrency(curr); //Deprecated variant, for coverage only 3033 } 3034 UnicodeString s; 3035 fmt.format(value, s); 3036 s.findAndReplace((UChar32)0x00A0, (UChar32)0x0020); 3037 3038 // Default display of the number yields "1234.5599999999999" 3039 // instead of "1234.56". Use a formatter to fix this. 3040 NumberFormat* f = 3041 NumberFormat::createInstance(Locale::getUS(), ec); 3042 UnicodeString v; 3043 if (U_FAILURE(ec)) { 3044 // Oops; bad formatter. Use default op+= display. 3045 v = (UnicodeString)"" + value; 3046 } else { 3047 f->setMaximumFractionDigits(4); 3048 f->setGroupingUsed(FALSE); 3049 f->format(value, v); 3050 } 3051 delete f; 3052 3053 if (s == string) { 3054 logln((UnicodeString)"Ok: " + v + " x " + curr + " => " + prettify(s)); 3055 } else { 3056 errln((UnicodeString)"FAIL: " + v + " x " + curr + " => " + prettify(s) + 3057 ", expected " + prettify(string)); 3058 } 3059 } 3060 3061 void NumberFormatTest::expectPat(DecimalFormat& fmt, const UnicodeString& exp) { 3062 UnicodeString pat; 3063 fmt.toPattern(pat); 3064 if (pat == exp) { 3065 logln(UnicodeString("Ok \"") + pat + "\""); 3066 } else { 3067 errln(UnicodeString("FAIL \"") + pat + "\", expected \"" + exp + "\""); 3068 } 3069 } 3070 3071 void NumberFormatTest::expectPad(DecimalFormat& fmt, const UnicodeString& pat, 3072 int32_t pos) { 3073 expectPad(fmt, pat, pos, 0, (UnicodeString)""); 3074 } 3075 void NumberFormatTest::expectPad(DecimalFormat& fmt, const UnicodeString& pat, 3076 int32_t pos, int32_t width, UChar pad) { 3077 expectPad(fmt, pat, pos, width, UnicodeString(pad)); 3078 } 3079 void NumberFormatTest::expectPad(DecimalFormat& fmt, const UnicodeString& pat, 3080 int32_t pos, int32_t width, const UnicodeString& pad) { 3081 int32_t apos = 0, awidth = 0; 3082 UnicodeString apadStr; 3083 UErrorCode status = U_ZERO_ERROR; 3084 fmt.applyPattern(pat, status); 3085 if (U_SUCCESS(status)) { 3086 apos = fmt.getPadPosition(); 3087 awidth = fmt.getFormatWidth(); 3088 apadStr=fmt.getPadCharacterString(); 3089 } else { 3090 apos = -1; 3091 awidth = width; 3092 apadStr = pad; 3093 } 3094 if (apos == pos && awidth == width && apadStr == pad) { 3095 UnicodeString infoStr; 3096 if (pos == ILLEGAL) { 3097 infoStr = UnicodeString(" width=", "") + awidth + UnicodeString(" pad=", "") + apadStr; 3098 } 3099 logln(UnicodeString("Ok \"") + pat + "\" pos=" + apos + infoStr); 3100 } else { 3101 errln(UnicodeString("FAIL \"") + pat + "\" pos=" + apos + 3102 " width=" + awidth + " pad=" + apadStr + 3103 ", expected " + pos + " " + width + " " + pad); 3104 } 3105 } 3106 3107 // This test is flaky b/c the symbols for CNY and JPY are equivalent in this locale - FIXME 3108 void NumberFormatTest::TestCompatibleCurrencies() { 3109 /* 3110 static const UChar JPY[] = {0x4A, 0x50, 0x59, 0}; 3111 static const UChar CNY[] = {0x43, 0x4E, 0x59, 0}; 3112 UErrorCode status = U_ZERO_ERROR; 3113 LocalPointer<NumberFormat> fmt( 3114 NumberFormat::createCurrencyInstance(Locale::getUS(), status)); 3115 if (U_FAILURE(status)) { 3116 errln("Could not create number format instance."); 3117 return; 3118 } 3119 logln("%s:%d - testing parse of halfwidth yen sign\n", __FILE__, __LINE__); 3120 expectParseCurrency(*fmt, JPY, 1235, "\\u00A51,235"); 3121 logln("%s:%d - testing parse of fullwidth yen sign\n", __FILE__, __LINE__); 3122 expectParseCurrency(*fmt, JPY, 1235, "\\uFFE51,235"); 3123 logln("%s:%d - testing parse of halfwidth yen sign\n", __FILE__, __LINE__); 3124 expectParseCurrency(*fmt, CNY, 1235, "CN\\u00A51,235"); 3125 3126 LocalPointer<NumberFormat> fmtTW( 3127 NumberFormat::createCurrencyInstance(Locale::getTaiwan(), status)); 3128 3129 logln("%s:%d - testing parse of halfwidth yen sign in TW\n", __FILE__, __LINE__); 3130 expectParseCurrency(*fmtTW, CNY, 1235, "\\u00A51,235"); 3131 logln("%s:%d - testing parse of fullwidth yen sign in TW\n", __FILE__, __LINE__); 3132 expectParseCurrency(*fmtTW, CNY, 1235, "\\uFFE51,235"); 3133 3134 LocalPointer<NumberFormat> fmtJP( 3135 NumberFormat::createCurrencyInstance(Locale::getJapan(), status)); 3136 3137 logln("%s:%d - testing parse of halfwidth yen sign in JP\n", __FILE__, __LINE__); 3138 expectParseCurrency(*fmtJP, JPY, 1235, "\\u00A51,235"); 3139 logln("%s:%d - testing parse of fullwidth yen sign in JP\n", __FILE__, __LINE__); 3140 expectParseCurrency(*fmtJP, JPY, 1235, "\\uFFE51,235"); 3141 3142 // more.. 3143 */ 3144 } 3145 3146 void NumberFormatTest::expectParseCurrency(const NumberFormat &fmt, const UChar* currency, double amount, const char *text) { 3147 ParsePosition ppos; 3148 UnicodeString utext = ctou(text); 3149 LocalPointer<CurrencyAmount> currencyAmount(fmt.parseCurrency(utext, ppos)); 3150 if (!ppos.getIndex()) { 3151 errln(UnicodeString("Parse of ") + utext + " should have succeeded."); 3152 return; 3153 } 3154 UErrorCode status = U_ZERO_ERROR; 3155 3156 char theInfo[100]; 3157 sprintf(theInfo, "For locale %s, string \"%s\", currency ", 3158 fmt.getLocale(ULOC_ACTUAL_LOCALE, status).getBaseName(), 3159 text); 3160 u_austrcpy(theInfo+uprv_strlen(theInfo), currency); 3161 3162 char theOperation[100]; 3163 3164 uprv_strcpy(theOperation, theInfo); 3165 uprv_strcat(theOperation, ", check amount:"); 3166 assertTrue(theOperation, amount == currencyAmount->getNumber().getDouble(status)); 3167 3168 uprv_strcpy(theOperation, theInfo); 3169 uprv_strcat(theOperation, ", check currency:"); 3170 assertEquals(theOperation, currency, currencyAmount->getISOCurrency()); 3171 } 3172 3173 3174 void NumberFormatTest::TestJB3832(){ 3175 const char* localeID = "pt_PT@currency=PTE"; 3176 Locale loc(localeID); 3177 UErrorCode status = U_ZERO_ERROR; 3178 UnicodeString expected(CharsToUnicodeString("1,150$50\\u00A0\\u200B")); // per cldrbug 7670 3179 UnicodeString s; 3180 NumberFormat* currencyFmt = NumberFormat::createCurrencyInstance(loc, status); 3181 if(U_FAILURE(status)){ 3182 dataerrln("Could not create currency formatter for locale %s - %s", localeID, u_errorName(status)); 3183 return; 3184 } 3185 currencyFmt->format(1150.50, s); 3186 if(s!=expected){ 3187 errln(UnicodeString("FAIL: Expected: ")+expected 3188 + UnicodeString(" Got: ") + s 3189 + UnicodeString( " for locale: ")+ UnicodeString(localeID) ); 3190 } 3191 if (U_FAILURE(status)){ 3192 errln("FAIL: Status %s", u_errorName(status)); 3193 } 3194 delete currencyFmt; 3195 } 3196 3197 void NumberFormatTest::TestHost() 3198 { 3199 #if U_PLATFORM_USES_ONLY_WIN32_API 3200 Win32NumberTest::testLocales(this); 3201 #endif 3202 Locale loc("en_US@compat=host"); 3203 for (UNumberFormatStyle k = UNUM_DECIMAL; 3204 k < UNUM_FORMAT_STYLE_COUNT; k = (UNumberFormatStyle)(k+1)) { 3205 UErrorCode status = U_ZERO_ERROR; 3206 LocalPointer<NumberFormat> full(NumberFormat::createInstance(loc, k, status)); 3207 if (!NumberFormat::isStyleSupported(k)) { 3208 if (status != U_UNSUPPORTED_ERROR) { 3209 errln("FAIL: expected style %d to be unsupported - %s", 3210 k, u_errorName(status)); 3211 } 3212 continue; 3213 } 3214 if (full.isNull() || U_FAILURE(status)) { 3215 dataerrln("FAIL: Can't create number instance of style %d for host - %s", 3216 k, u_errorName(status)); 3217 return; 3218 } 3219 UnicodeString result1; 3220 Formattable number(10.00); 3221 full->format(number, result1, status); 3222 if (U_FAILURE(status)) { 3223 errln("FAIL: Can't format for host"); 3224 return; 3225 } 3226 Formattable formattable; 3227 full->parse(result1, formattable, status); 3228 if (U_FAILURE(status)) { 3229 errln("FAIL: Can't parse for host"); 3230 return; 3231 } 3232 } 3233 } 3234 3235 void NumberFormatTest::TestHostClone() 3236 { 3237 /* 3238 Verify that a cloned formatter gives the same results 3239 and is useable after the original has been deleted. 3240 */ 3241 // This is mainly important on Windows. 3242 UErrorCode status = U_ZERO_ERROR; 3243 Locale loc("en_US@compat=host"); 3244 UDate now = Calendar::getNow(); 3245 NumberFormat *full = NumberFormat::createInstance(loc, status); 3246 if (full == NULL || U_FAILURE(status)) { 3247 dataerrln("FAIL: Can't create Relative date instance - %s", u_errorName(status)); 3248 return; 3249 } 3250 UnicodeString result1; 3251 full->format(now, result1, status); 3252 Format *fullClone = full->clone(); 3253 delete full; 3254 full = NULL; 3255 3256 UnicodeString result2; 3257 fullClone->format(now, result2, status); 3258 if (U_FAILURE(status)) { 3259 errln("FAIL: format failure."); 3260 } 3261 if (result1 != result2) { 3262 errln("FAIL: Clone returned different result from non-clone."); 3263 } 3264 delete fullClone; 3265 } 3266 3267 void NumberFormatTest::TestCurrencyFormat() 3268 { 3269 // This test is here to increase code coverage. 3270 UErrorCode status = U_ZERO_ERROR; 3271 MeasureFormat *cloneObj; 3272 UnicodeString str; 3273 Formattable toFormat, result; 3274 static const UChar ISO_CODE[4] = {0x0047, 0x0042, 0x0050, 0}; 3275 3276 Locale saveDefaultLocale = Locale::getDefault(); 3277 Locale::setDefault( Locale::getUK(), status ); 3278 if (U_FAILURE(status)) { 3279 errln("couldn't set default Locale!"); 3280 return; 3281 } 3282 3283 MeasureFormat *measureObj = MeasureFormat::createCurrencyFormat(status); 3284 Locale::setDefault( saveDefaultLocale, status ); 3285 if (U_FAILURE(status)){ 3286 dataerrln("FAIL: Status %s", u_errorName(status)); 3287 return; 3288 } 3289 cloneObj = (MeasureFormat *)measureObj->clone(); 3290 if (cloneObj == NULL) { 3291 errln("Clone doesn't work"); 3292 return; 3293 } 3294 toFormat.adoptObject(new CurrencyAmount(1234.56, ISO_CODE, status)); 3295 measureObj->format(toFormat, str, status); 3296 measureObj->parseObject(str, result, status); 3297 if (U_FAILURE(status)){ 3298 errln("FAIL: Status %s", u_errorName(status)); 3299 } 3300 if (result != toFormat) { 3301 errln("measureObj does not round trip. Formatted string was \"" + str + "\" Got: " + toString(result) + " Expected: " + toString(toFormat)); 3302 } 3303 status = U_ZERO_ERROR; 3304 str.truncate(0); 3305 cloneObj->format(toFormat, str, status); 3306 cloneObj->parseObject(str, result, status); 3307 if (U_FAILURE(status)){ 3308 errln("FAIL: Status %s", u_errorName(status)); 3309 } 3310 if (result != toFormat) { 3311 errln("Clone does not round trip. Formatted string was \"" + str + "\" Got: " + toString(result) + " Expected: " + toString(toFormat)); 3312 } 3313 if (*measureObj != *cloneObj) { 3314 errln("Cloned object is not equal to the original object"); 3315 } 3316 delete measureObj; 3317 delete cloneObj; 3318 3319 status = U_USELESS_COLLATOR_ERROR; 3320 if (MeasureFormat::createCurrencyFormat(status) != NULL) { 3321 errln("createCurrencyFormat should have returned NULL."); 3322 } 3323 } 3324 3325 /* Port of ICU4J rounding test. */ 3326 void NumberFormatTest::TestRounding() { 3327 UErrorCode status = U_ZERO_ERROR; 3328 DecimalFormat *df = (DecimalFormat*)NumberFormat::createCurrencyInstance(Locale::getEnglish(), status); 3329 3330 if (U_FAILURE(status)) { 3331 dataerrln("Unable to create decimal formatter. - %s", u_errorName(status)); 3332 return; 3333 } 3334 3335 int roundingIncrements[]={1, 2, 5, 20, 50, 100}; 3336 int testValues[]={0, 300}; 3337 3338 for (int j=0; j<2; j++) { 3339 for (int mode=DecimalFormat::kRoundUp;mode<DecimalFormat::kRoundHalfEven;mode++) { 3340 df->setRoundingMode((DecimalFormat::ERoundingMode)mode); 3341 for (int increment=0; increment<6; increment++) { 3342 double base=testValues[j]; 3343 double rInc=roundingIncrements[increment]; 3344 checkRounding(df, base, 20, rInc); 3345 rInc=1.000000000/rInc; 3346 checkRounding(df, base, 20, rInc); 3347 } 3348 } 3349 } 3350 delete df; 3351 } 3352 3353 void NumberFormatTest::TestRoundingPattern() { 3354 UErrorCode status = U_ZERO_ERROR; 3355 struct { 3356 UnicodeString pattern; 3357 double testCase; 3358 UnicodeString expected; 3359 } tests[] = { 3360 { (UnicodeString)"##0.65", 1.234, (UnicodeString)"1.30" }, 3361 { (UnicodeString)"#50", 1230, (UnicodeString)"1250" } 3362 }; 3363 int32_t numOfTests = UPRV_LENGTHOF(tests); 3364 UnicodeString result; 3365 3366 DecimalFormat *df = (DecimalFormat*)NumberFormat::createCurrencyInstance(Locale::getEnglish(), status); 3367 if (U_FAILURE(status)) { 3368 dataerrln("Unable to create decimal formatter. - %s", u_errorName(status)); 3369 return; 3370 } 3371 3372 for (int32_t i = 0; i < numOfTests; i++) { 3373 result.remove(); 3374 3375 df->applyPattern(tests[i].pattern, status); 3376 if (U_FAILURE(status)) { 3377 errln("Unable to apply pattern to decimal formatter. - %s", u_errorName(status)); 3378 } 3379 3380 df->format(tests[i].testCase, result); 3381 3382 if (result != tests[i].expected) { 3383 errln("String Pattern Rounding Test Failed: Pattern: \"" + tests[i].pattern + "\" Number: " + tests[i].testCase + " - Got: " + result + " Expected: " + tests[i].expected); 3384 } 3385 } 3386 3387 delete df; 3388 } 3389 3390 void NumberFormatTest::checkRounding(DecimalFormat* df, double base, int iterations, double increment) { 3391 df->setRoundingIncrement(increment); 3392 double lastParsed=INT32_MIN; //Intger.MIN_VALUE 3393 for (int i=-iterations; i<=iterations;i++) { 3394 double iValue=base+(increment*(i*0.1)); 3395 double smallIncrement=0.00000001; 3396 if (iValue!=0) { 3397 smallIncrement*=iValue; 3398 } 3399 //we not only test the value, but some values in a small range around it 3400 lastParsed=checkRound(df, iValue-smallIncrement, lastParsed); 3401 lastParsed=checkRound(df, iValue, lastParsed); 3402 lastParsed=checkRound(df, iValue+smallIncrement, lastParsed); 3403 } 3404 } 3405 3406 double NumberFormatTest::checkRound(DecimalFormat* df, double iValue, double lastParsed) { 3407 UErrorCode status=U_ZERO_ERROR; 3408 UnicodeString formattedDecimal; 3409 double parsed; 3410 Formattable result; 3411 df->format(iValue, formattedDecimal, status); 3412 3413 if (U_FAILURE(status)) { 3414 errln("Error formatting number."); 3415 } 3416 3417 df->parse(formattedDecimal, result, status); 3418 3419 if (U_FAILURE(status)) { 3420 errln("Error parsing number."); 3421 } 3422 3423 parsed=result.getDouble(); 3424 3425 if (lastParsed>parsed) { 3426 errln("Rounding wrong direction! %d > %d", lastParsed, parsed); 3427 } 3428 3429 return lastParsed; 3430 } 3431 3432 void NumberFormatTest::TestNonpositiveMultiplier() { 3433 UErrorCode status = U_ZERO_ERROR; 3434 DecimalFormatSymbols US(Locale::getUS(), status); 3435 CHECK(status, "DecimalFormatSymbols constructor"); 3436 DecimalFormat df(UnicodeString("0"), US, status); 3437 CHECK(status, "DecimalFormat(0)"); 3438 3439 // test zero multiplier 3440 3441 int32_t mult = df.getMultiplier(); 3442 df.setMultiplier(0); 3443 if (df.getMultiplier() != mult) { 3444 errln("DecimalFormat.setMultiplier(0) did not ignore its zero input"); 3445 } 3446 3447 // test negative multiplier 3448 3449 df.setMultiplier(-1); 3450 if (df.getMultiplier() != -1) { 3451 errln("DecimalFormat.setMultiplier(-1) ignored its negative input"); 3452 return; 3453 } 3454 3455 expect(df, "1122.123", -1122.123); 3456 expect(df, "-1122.123", 1122.123); 3457 expect(df, "1.2", -1.2); 3458 expect(df, "-1.2", 1.2); 3459 3460 // Note: the tests with the final parameter of FALSE will not round trip. 3461 // The initial numeric value will format correctly, after the multiplier. 3462 // Parsing the formatted text will be out-of-range for an int64, however. 3463 // The expect() function could be modified to detect this and fall back 3464 // to looking at the decimal parsed value, but it doesn't. 3465 expect(df, U_INT64_MIN, "9223372036854775808", FALSE); 3466 expect(df, U_INT64_MIN+1, "9223372036854775807"); 3467 expect(df, (int64_t)-123, "123"); 3468 expect(df, (int64_t)123, "-123"); 3469 expect(df, U_INT64_MAX-1, "-9223372036854775806"); 3470 expect(df, U_INT64_MAX, "-9223372036854775807"); 3471 3472 df.setMultiplier(-2); 3473 expect(df, -(U_INT64_MIN/2)-1, "-9223372036854775806"); 3474 expect(df, -(U_INT64_MIN/2), "-9223372036854775808"); 3475 expect(df, -(U_INT64_MIN/2)+1, "-9223372036854775810", FALSE); 3476 3477 df.setMultiplier(-7); 3478 expect(df, -(U_INT64_MAX/7)-1, "9223372036854775814", FALSE); 3479 expect(df, -(U_INT64_MAX/7), "9223372036854775807"); 3480 expect(df, -(U_INT64_MAX/7)+1, "9223372036854775800"); 3481 3482 // TODO: uncomment (and fix up) all the following int64_t tests once BigInteger is ported 3483 // (right now the big numbers get turned into doubles and lose tons of accuracy) 3484 //expect2(df, U_INT64_MAX, Int64ToUnicodeString(-U_INT64_MAX)); 3485 //expect2(df, U_INT64_MIN, UnicodeString(Int64ToUnicodeString(U_INT64_MIN), 1)); 3486 //expect2(df, U_INT64_MAX / 2, Int64ToUnicodeString(-(U_INT64_MAX / 2))); 3487 //expect2(df, U_INT64_MIN / 2, Int64ToUnicodeString(-(U_INT64_MIN / 2))); 3488 3489 // TODO: uncomment (and fix up) once BigDecimal is ported and DecimalFormat can handle it 3490 //expect2(df, BigDecimal.valueOf(Long.MAX_VALUE), BigDecimal.valueOf(Long.MAX_VALUE).negate().toString()); 3491 //expect2(df, BigDecimal.valueOf(Long.MIN_VALUE), BigDecimal.valueOf(Long.MIN_VALUE).negate().toString()); 3492 //expect2(df, java.math.BigDecimal.valueOf(Long.MAX_VALUE), java.math.BigDecimal.valueOf(Long.MAX_VALUE).negate().toString()); 3493 //expect2(df, java.math.BigDecimal.valueOf(Long.MIN_VALUE), java.math.BigDecimal.valueOf(Long.MIN_VALUE).negate().toString()); 3494 } 3495 3496 typedef struct { 3497 const char * stringToParse; 3498 int parsedPos; 3499 int errorIndex; 3500 UBool lenient; 3501 } TestSpaceParsingItem; 3502 3503 void 3504 NumberFormatTest::TestSpaceParsing() { 3505 // the data are: 3506 // the string to be parsed, parsed position, parsed error index 3507 const TestSpaceParsingItem DATA[] = { 3508 // TOTO: Update the following TODOs, some may be handled now 3509 {"$124", 4, -1, FALSE}, 3510 {"$124 $124", 4, -1, FALSE}, 3511 {"$124 ", 4, -1, FALSE}, 3512 //{"$ 124 ", 5, -1, FALSE}, // TODO: need to handle space correctly 3513 //{"$\\u00A0124 ", 5, -1, FALSE}, // TODO: need to handle space correctly 3514 {"$ 124 ", 0, 1, FALSE}, // errorIndex used to be 0, now 1 (better) 3515 {"$\\u00A0124 ", 0, 1, FALSE}, // errorIndex used to be 0, now 1 (better) 3516 {" $ 124 ", 0, 0, FALSE}, // TODO: need to handle space correctly 3517 {"124$", 0, 3, FALSE}, // TODO: need to handle space correctly 3518 // {"124 $", 5, -1, FALSE}, // TODO: OK or not, need currency spacing rule 3519 {"124 $", 0, 3, FALSE}, 3520 {"$124", 4, -1, TRUE}, 3521 {"$124 $124", 4, -1, TRUE}, 3522 {"$124 ", 4, -1, TRUE}, 3523 {"$ 124 ", 5, -1, TRUE}, 3524 {"$\\u00A0124 ", 5, -1, TRUE}, 3525 {" $ 124 ", 6, -1, TRUE}, 3526 //{"124$", 4, -1, TRUE}, // TODO: need to handle trailing currency correctly 3527 {"124$", 3, -1, TRUE}, 3528 //{"124 $", 5, -1, TRUE}, // TODO: OK or not, need currency spacing rule 3529 {"124 $", 4, -1, TRUE}, 3530 }; 3531 UErrorCode status = U_ZERO_ERROR; 3532 Locale locale("en_US"); 3533 NumberFormat* foo = NumberFormat::createCurrencyInstance(locale, status); 3534 3535 if (U_FAILURE(status)) { 3536 delete foo; 3537 return; 3538 } 3539 for (uint32_t i = 0; i < UPRV_LENGTHOF(DATA); ++i) { 3540 ParsePosition parsePosition(0); 3541 UnicodeString stringToBeParsed = ctou(DATA[i].stringToParse); 3542 int parsedPosition = DATA[i].parsedPos; 3543 int errorIndex = DATA[i].errorIndex; 3544 foo->setLenient(DATA[i].lenient); 3545 Formattable result; 3546 foo->parse(stringToBeParsed, result, parsePosition); 3547 if (parsePosition.getIndex() != parsedPosition || 3548 parsePosition.getErrorIndex() != errorIndex) { 3549 errln("FAILED parse " + stringToBeParsed + "; lenient: " + DATA[i].lenient + "; wrong position, expected: (" + parsedPosition + ", " + errorIndex + "); got (" + parsePosition.getIndex() + ", " + parsePosition.getErrorIndex() + ")"); 3550 } 3551 if (parsePosition.getErrorIndex() == -1 && 3552 result.getType() == Formattable::kLong && 3553 result.getLong() != 124) { 3554 errln("FAILED parse " + stringToBeParsed + "; wrong number, expect: 124, got " + result.getLong()); 3555 } 3556 } 3557 delete foo; 3558 } 3559 3560 /** 3561 * Test using various numbering systems and numbering system keyword. 3562 */ 3563 typedef struct { 3564 const char *localeName; 3565 double value; 3566 UBool isRBNF; 3567 const char *expectedResult; 3568 } TestNumberingSystemItem; 3569 3570 void NumberFormatTest::TestNumberingSystems() { 3571 3572 const TestNumberingSystemItem DATA[] = { 3573 { "en_US@numbers=thai", 1234.567, FALSE, "\\u0E51,\\u0E52\\u0E53\\u0E54.\\u0E55\\u0E56\\u0E57" }, 3574 { "en_US@numbers=hebr", 5678.0, TRUE, "\\u05D4\\u05F3\\u05EA\\u05E8\\u05E2\\u05F4\\u05D7" }, 3575 { "en_US@numbers=arabext", 1234.567, FALSE, "\\u06F1\\u066c\\u06F2\\u06F3\\u06F4\\u066b\\u06F5\\u06F6\\u06F7" }, 3576 { "ar_EG", 1234.567, FALSE, "\\u0661\\u066C\\u0662\\u0663\\u0664\\u066b\\u0665\\u0666\\u0667" }, 3577 { "th_TH@numbers=traditional", 1234.567, FALSE, "\\u0E51,\\u0E52\\u0E53\\u0E54.\\u0E55\\u0E56\\u0E57" }, // fall back to native per TR35 3578 { "ar_MA", 1234.567, FALSE, "1.234,567" }, 3579 { "en_US@numbers=hanidec", 1234.567, FALSE, "\\u4e00,\\u4e8c\\u4e09\\u56db.\\u4e94\\u516d\\u4e03" }, 3580 { "ta_IN@numbers=native", 1234.567, FALSE, "\\u0BE7,\\u0BE8\\u0BE9\\u0BEA.\\u0BEB\\u0BEC\\u0BED" }, 3581 { "ta_IN@numbers=traditional", 1235.0, TRUE, "\\u0BF2\\u0BE8\\u0BF1\\u0BE9\\u0BF0\\u0BEB" }, 3582 { "ta_IN@numbers=finance", 1234.567, FALSE, "1,234.567" }, // fall back to default per TR35 3583 { "zh_TW@numbers=native", 1234.567, FALSE, "\\u4e00,\\u4e8c\\u4e09\\u56db.\\u4e94\\u516d\\u4e03" }, 3584 { "zh_TW@numbers=traditional", 1234.567, TRUE, "\\u4E00\\u5343\\u4E8C\\u767E\\u4E09\\u5341\\u56DB\\u9EDE\\u4E94\\u516D\\u4E03" }, 3585 { "zh_TW@numbers=finance", 1234.567, TRUE, "\\u58F9\\u4EDF\\u8CB3\\u4F70\\u53C3\\u62FE\\u8086\\u9EDE\\u4F0D\\u9678\\u67D2" }, 3586 { NULL, 0, FALSE, NULL } 3587 }; 3588 3589 UErrorCode ec; 3590 3591 const TestNumberingSystemItem *item; 3592 for (item = DATA; item->localeName != NULL; item++) { 3593 ec = U_ZERO_ERROR; 3594 Locale loc = Locale::createFromName(item->localeName); 3595 3596 NumberFormat *origFmt = NumberFormat::createInstance(loc,ec); 3597 if (U_FAILURE(ec)) { 3598 dataerrln("FAIL: getInstance(%s) - %s", item->localeName, u_errorName(ec)); 3599 continue; 3600 } 3601 // Clone to test ticket #10682 3602 NumberFormat *fmt = (NumberFormat *) origFmt->clone(); 3603 delete origFmt; 3604 3605 3606 if (item->isRBNF) { 3607 expect3(*fmt,item->value,CharsToUnicodeString(item->expectedResult)); 3608 } else { 3609 expect2(*fmt,item->value,CharsToUnicodeString(item->expectedResult)); 3610 } 3611 delete fmt; 3612 } 3613 3614 3615 // Test bogus keyword value 3616 ec = U_ZERO_ERROR; 3617 Locale loc4 = Locale::createFromName("en_US@numbers=foobar"); 3618 NumberFormat* fmt4= NumberFormat::createInstance(loc4, ec); 3619 if ( ec != U_UNSUPPORTED_ERROR ) { 3620 errln("FAIL: getInstance(en_US@numbers=foobar) should have returned U_UNSUPPORTED_ERROR"); 3621 delete fmt4; 3622 } 3623 3624 ec = U_ZERO_ERROR; 3625 NumberingSystem *ns = NumberingSystem::createInstance(ec); 3626 if (U_FAILURE(ec)) { 3627 dataerrln("FAIL: NumberingSystem::createInstance(ec); - %s", u_errorName(ec)); 3628 } 3629 3630 if ( ns != NULL ) { 3631 ns->getDynamicClassID(); 3632 ns->getStaticClassID(); 3633 } else { 3634 errln("FAIL: getInstance() returned NULL."); 3635 } 3636 3637 NumberingSystem *ns1 = new NumberingSystem(*ns); 3638 if (ns1 == NULL) { 3639 errln("FAIL: NumberSystem copy constructor returned NULL."); 3640 } 3641 3642 delete ns1; 3643 delete ns; 3644 3645 } 3646 3647 3648 void 3649 NumberFormatTest::TestMultiCurrencySign() { 3650 const char* DATA[][6] = { 3651 // the fields in the following test are: 3652 // locale, 3653 // currency pattern (with negative pattern), 3654 // currency number to be formatted, 3655 // currency format using currency symbol name, such as "$" for USD, 3656 // currency format using currency ISO name, such as "USD", 3657 // currency format using plural name, such as "US dollars". 3658 // for US locale 3659 {"en_US", "\\u00A4#,##0.00;-\\u00A4#,##0.00", "1234.56", "$1,234.56", "USD1,234.56", "US dollars1,234.56"}, 3660 {"en_US", "\\u00A4#,##0.00;-\\u00A4#,##0.00", "-1234.56", "-$1,234.56", "-USD1,234.56", "-US dollars1,234.56"}, 3661 {"en_US", "\\u00A4#,##0.00;-\\u00A4#,##0.00", "1", "$1.00", "USD1.00", "US dollars1.00"}, 3662 // for CHINA locale 3663 {"zh_CN", "\\u00A4#,##0.00;(\\u00A4#,##0.00)", "1234.56", "\\uFFE51,234.56", "CNY1,234.56", "\\u4EBA\\u6C11\\u5E011,234.56"}, 3664 {"zh_CN", "\\u00A4#,##0.00;(\\u00A4#,##0.00)", "-1234.56", "(\\uFFE51,234.56)", "(CNY1,234.56)", "(\\u4EBA\\u6C11\\u5E011,234.56)"}, 3665 {"zh_CN", "\\u00A4#,##0.00;(\\u00A4#,##0.00)", "1", "\\uFFE51.00", "CNY1.00", "\\u4EBA\\u6C11\\u5E011.00"} 3666 }; 3667 3668 const UChar doubleCurrencySign[] = {0xA4, 0xA4, 0}; 3669 UnicodeString doubleCurrencyStr(doubleCurrencySign); 3670 const UChar tripleCurrencySign[] = {0xA4, 0xA4, 0xA4, 0}; 3671 UnicodeString tripleCurrencyStr(tripleCurrencySign); 3672 3673 for (uint32_t i=0; i<UPRV_LENGTHOF(DATA); ++i) { 3674 const char* locale = DATA[i][0]; 3675 UnicodeString pat = ctou(DATA[i][1]); 3676 double numberToBeFormat = atof(DATA[i][2]); 3677 UErrorCode status = U_ZERO_ERROR; 3678 DecimalFormatSymbols* sym = new DecimalFormatSymbols(Locale(locale), status); 3679 if (U_FAILURE(status)) { 3680 delete sym; 3681 continue; 3682 } 3683 for (int j=1; j<=3; ++j) { 3684 // j represents the number of currency sign in the pattern. 3685 if (j == 2) { 3686 pat = pat.findAndReplace(ctou("\\u00A4"), doubleCurrencyStr); 3687 } else if (j == 3) { 3688 pat = pat.findAndReplace(ctou("\\u00A4\\u00A4"), tripleCurrencyStr); 3689 } 3690 3691 DecimalFormat* fmt = new DecimalFormat(pat, new DecimalFormatSymbols(*sym), status); 3692 if (U_FAILURE(status)) { 3693 errln("FAILED init DecimalFormat "); 3694 delete fmt; 3695 continue; 3696 } 3697 UnicodeString s; 3698 ((NumberFormat*) fmt)->format(numberToBeFormat, s); 3699 // DATA[i][3] is the currency format result using a 3700 // single currency sign. 3701 // DATA[i][4] is the currency format result using 3702 // double currency sign. 3703 // DATA[i][5] is the currency format result using 3704 // triple currency sign. 3705 // DATA[i][j+2] is the currency format result using 3706 // 'j' number of currency sign. 3707 UnicodeString currencyFormatResult = ctou(DATA[i][2+j]); 3708 if (s.compare(currencyFormatResult)) { 3709 errln("FAIL format: Expected " + currencyFormatResult + "; Got " + s); 3710 } 3711 // mix style parsing 3712 for (int k=3; k<=5; ++k) { 3713 // DATA[i][3] is the currency format result using a 3714 // single currency sign. 3715 // DATA[i][4] is the currency format result using 3716 // double currency sign. 3717 // DATA[i][5] is the currency format result using 3718 // triple currency sign. 3719 UnicodeString oneCurrencyFormat = ctou(DATA[i][k]); 3720 UErrorCode status = U_ZERO_ERROR; 3721 Formattable parseRes; 3722 fmt->parse(oneCurrencyFormat, parseRes, status); 3723 if (U_FAILURE(status) || 3724 (parseRes.getType() == Formattable::kDouble && 3725 parseRes.getDouble() != numberToBeFormat) || 3726 (parseRes.getType() == Formattable::kLong && 3727 parseRes.getLong() != numberToBeFormat)) { 3728 errln("FAILED parse " + oneCurrencyFormat + "; (i, j, k): " + 3729 i + ", " + j + ", " + k); 3730 } 3731 } 3732 delete fmt; 3733 } 3734 delete sym; 3735 } 3736 } 3737 3738 3739 void 3740 NumberFormatTest::TestCurrencyFormatForMixParsing() { 3741 UErrorCode status = U_ZERO_ERROR; 3742 MeasureFormat* curFmt = MeasureFormat::createCurrencyFormat(Locale("en_US"), status); 3743 if (U_FAILURE(status)) { 3744 delete curFmt; 3745 return; 3746 } 3747 const char* formats[] = { 3748 "$1,234.56", // string to be parsed 3749 "USD1,234.56", 3750 "US dollars1,234.56", 3751 "1,234.56 US dollars" 3752 }; 3753 const CurrencyAmount* curramt = NULL; 3754 for (uint32_t i = 0; i < UPRV_LENGTHOF(formats); ++i) { 3755 UnicodeString stringToBeParsed = ctou(formats[i]); 3756 logln(UnicodeString("stringToBeParsed: ") + stringToBeParsed); 3757 Formattable result; 3758 UErrorCode status = U_ZERO_ERROR; 3759 curFmt->parseObject(stringToBeParsed, result, status); 3760 if (U_FAILURE(status)) { 3761 errln("FAIL: measure format parsing: '%s' ec: %s", formats[i], u_errorName(status)); 3762 } else if (result.getType() != Formattable::kObject || 3763 (curramt = dynamic_cast<const CurrencyAmount*>(result.getObject())) == NULL || 3764 curramt->getNumber().getDouble() != 1234.56 || 3765 UnicodeString(curramt->getISOCurrency()).compare(ISO_CURRENCY_USD) 3766 ) { 3767 errln("FAIL: getCurrencyFormat of default locale (en_US) failed roundtripping the number "); 3768 if (curramt->getNumber().getDouble() != 1234.56) { 3769 errln((UnicodeString)"wong number, expect: 1234.56" + ", got: " + curramt->getNumber().getDouble()); 3770 } 3771 if (curramt->getISOCurrency() != ISO_CURRENCY_USD) { 3772 errln((UnicodeString)"wong currency, expect: USD" + ", got: " + curramt->getISOCurrency()); 3773 } 3774 } 3775 } 3776 delete curFmt; 3777 } 3778 3779 3780 void 3781 NumberFormatTest::TestDecimalFormatCurrencyParse() { 3782 // Locale.US 3783 UErrorCode status = U_ZERO_ERROR; 3784 DecimalFormatSymbols* sym = new DecimalFormatSymbols(Locale("en_US"), status); 3785 if (U_FAILURE(status)) { 3786 delete sym; 3787 return; 3788 } 3789 UnicodeString pat; 3790 UChar currency = 0x00A4; 3791 // "\xA4#,##0.00;-\xA4#,##0.00" 3792 pat.append(currency).append(currency).append(currency).append("#,##0.00;-").append(currency).append(currency).append(currency).append("#,##0.00"); 3793 DecimalFormat* fmt = new DecimalFormat(pat, sym, status); 3794 if (U_FAILURE(status)) { 3795 delete fmt; 3796 errln("failed to new DecimalFormat in TestDecimalFormatCurrencyParse"); 3797 return; 3798 } 3799 const char* DATA[][2] = { 3800 // the data are: 3801 // string to be parsed, the parsed result (number) 3802 {"$1.00", "1"}, 3803 {"USD1.00", "1"}, 3804 {"1.00 US dollar", "1"}, 3805 {"$1,234.56", "1234.56"}, 3806 {"USD1,234.56", "1234.56"}, 3807 {"1,234.56 US dollar", "1234.56"}, 3808 }; 3809 for (uint32_t i = 0; i < UPRV_LENGTHOF(DATA); ++i) { 3810 UnicodeString stringToBeParsed = ctou(DATA[i][0]); 3811 double parsedResult = atof(DATA[i][1]); 3812 UErrorCode status = U_ZERO_ERROR; 3813 Formattable result; 3814 fmt->parse(stringToBeParsed, result, status); 3815 if (U_FAILURE(status) || 3816 (result.getType() == Formattable::kDouble && 3817 result.getDouble() != parsedResult) || 3818 (result.getType() == Formattable::kLong && 3819 result.getLong() != parsedResult)) { 3820 errln((UnicodeString)"FAIL parse: Expected " + parsedResult); 3821 } 3822 } 3823 delete fmt; 3824 } 3825 3826 3827 void 3828 NumberFormatTest::TestCurrencyIsoPluralFormat() { 3829 static const char* DATA[][6] = { 3830 // the data are: 3831 // locale, 3832 // currency amount to be formatted, 3833 // currency ISO code to be formatted, 3834 // format result using CURRENCYSTYLE, 3835 // format result using ISOCURRENCYSTYLE, 3836 // format result using PLURALCURRENCYSTYLE, 3837 3838 {"en_US", "1", "USD", "$1.00", "USD1.00", "1.00 US dollars"}, 3839 {"en_US", "1234.56", "USD", "$1,234.56", "USD1,234.56", "1,234.56 US dollars"}, 3840 {"en_US", "-1234.56", "USD", "-$1,234.56", "-USD1,234.56", "-1,234.56 US dollars"}, 3841 {"zh_CN", "1", "USD", "US$1.00", "USD1.00", "1.00\\u7F8E\\u5143"}, 3842 {"zh_CN", "1234.56", "USD", "US$1,234.56", "USD1,234.56", "1,234.56\\u7F8E\\u5143"}, 3843 {"zh_CN", "1", "CNY", "\\uFFE51.00", "CNY1.00", "1.00\\u4EBA\\u6C11\\u5E01"}, 3844 {"zh_CN", "1234.56", "CNY", "\\uFFE51,234.56", "CNY1,234.56", "1,234.56\\u4EBA\\u6C11\\u5E01"}, 3845 {"ru_RU", "1", "RUB", "1,00\\u00A0\\u20BD", "1,00\\u00A0RUB", "1,00 \\u0440\\u043E\\u0441\\u0441\\u0438\\u0439\\u0441\\u043A\\u043E\\u0433\\u043E \\u0440\\u0443\\u0431\\u043B\\u044F"}, 3846 {"ru_RU", "2", "RUB", "2,00\\u00A0\\u20BD", "2,00\\u00A0RUB", "2,00 \\u0440\\u043E\\u0441\\u0441\\u0438\\u0439\\u0441\\u043A\\u043E\\u0433\\u043E \\u0440\\u0443\\u0431\\u043B\\u044F"}, 3847 {"ru_RU", "5", "RUB", "5,00\\u00A0\\u20BD", "5,00\\u00A0RUB", "5,00 \\u0440\\u043E\\u0441\\u0441\\u0438\\u0439\\u0441\\u043A\\u043E\\u0433\\u043E \\u0440\\u0443\\u0431\\u043B\\u044F"}, 3848 // test locale without currency information 3849 {"root", "-1.23", "USD", "-US$\\u00A01.23", "-USD\\u00A01.23", "-1.23 USD"}, 3850 // test choice format 3851 {"es_AR", "1", "INR", "INR\\u00A01,00", "INR\\u00A01,00", "1,00 rupia india"}, 3852 }; 3853 static const UNumberFormatStyle currencyStyles[] = { 3854 UNUM_CURRENCY, 3855 UNUM_CURRENCY_ISO, 3856 UNUM_CURRENCY_PLURAL 3857 }; 3858 3859 for (int32_t i=0; i<UPRV_LENGTHOF(DATA); ++i) { 3860 for (int32_t kIndex = 0; kIndex < UPRV_LENGTHOF(currencyStyles); ++kIndex) { 3861 UNumberFormatStyle k = currencyStyles[kIndex]; 3862 const char* localeString = DATA[i][0]; 3863 double numberToBeFormat = atof(DATA[i][1]); 3864 const char* currencyISOCode = DATA[i][2]; 3865 Locale locale(localeString); 3866 UErrorCode status = U_ZERO_ERROR; 3867 NumberFormat* numFmt = NumberFormat::createInstance(locale, k, status); 3868 if (U_FAILURE(status)) { 3869 delete numFmt; 3870 dataerrln((UnicodeString)"can not create instance, locale:" + localeString + ", style: " + k + " - " + u_errorName(status)); 3871 continue; 3872 } 3873 UChar currencyCode[4]; 3874 u_charsToUChars(currencyISOCode, currencyCode, 4); 3875 numFmt->setCurrency(currencyCode, status); 3876 if (U_FAILURE(status)) { 3877 delete numFmt; 3878 errln((UnicodeString)"can not set currency:" + currencyISOCode); 3879 continue; 3880 } 3881 3882 UnicodeString strBuf; 3883 numFmt->format(numberToBeFormat, strBuf); 3884 int resultDataIndex = 3 + kIndex; 3885 // DATA[i][resultDataIndex] is the currency format result 3886 // using 'k' currency style. 3887 UnicodeString formatResult = ctou(DATA[i][resultDataIndex]); 3888 if (strBuf.compare(formatResult)) { 3889 errln("FAIL: Expected " + formatResult + " actual: " + strBuf); 3890 } 3891 // test parsing, and test parsing for all currency formats. 3892 for (int j = 3; j < 6; ++j) { 3893 // DATA[i][3] is the currency format result using 3894 // CURRENCYSTYLE formatter. 3895 // DATA[i][4] is the currency format result using 3896 // ISOCURRENCYSTYLE formatter. 3897 // DATA[i][5] is the currency format result using 3898 // PLURALCURRENCYSTYLE formatter. 3899 UnicodeString oneCurrencyFormatResult = ctou(DATA[i][j]); 3900 UErrorCode status = U_ZERO_ERROR; 3901 Formattable parseResult; 3902 numFmt->parse(oneCurrencyFormatResult, parseResult, status); 3903 if (U_FAILURE(status) || 3904 (parseResult.getType() == Formattable::kDouble && 3905 parseResult.getDouble() != numberToBeFormat) || 3906 (parseResult.getType() == Formattable::kLong && 3907 parseResult.getLong() != numberToBeFormat)) { 3908 errln((UnicodeString)"FAIL: getCurrencyFormat of locale " + 3909 localeString + " failed roundtripping the number"); 3910 if (parseResult.getType() == Formattable::kDouble) { 3911 errln((UnicodeString)"expected: " + numberToBeFormat + "; actual: " +parseResult.getDouble()); 3912 } else { 3913 errln((UnicodeString)"expected: " + numberToBeFormat + "; actual: " +parseResult.getLong()); 3914 } 3915 } 3916 } 3917 delete numFmt; 3918 } 3919 } 3920 } 3921 3922 void 3923 NumberFormatTest::TestCurrencyParsing() { 3924 static const char* DATA[][6] = { 3925 // the data are: 3926 // locale, 3927 // currency amount to be formatted, 3928 // currency ISO code to be formatted, 3929 // format result using CURRENCYSTYLE, 3930 // format result using ISOCURRENCYSTYLE, 3931 // format result using PLURALCURRENCYSTYLE, 3932 {"en_US", "1", "USD", "$1.00", "USD1.00", "1.00 US dollar"}, 3933 {"pa_IN", "1", "USD", "US$\\u00A01.00", "USD\\u00A01.00", "1.00 \\u0a2f\\u0a42.\\u0a10\\u0a38. \\u0a21\\u0a3e\\u0a32\\u0a30"}, 3934 {"es_AR", "1", "USD", "US$\\u00A01,00", "USD\\u00A01,00", "1,00 d\\u00f3lar estadounidense"}, 3935 {"ar_EG", "1", "USD", "\\u0661\\u066b\\u0660\\u0660\\u00a0US$", "\\u0661\\u066b\\u0660\\u0660\\u00a0USD", "\\u0661\\u066b\\u0660\\u0660 \\u062f\\u0648\\u0644\\u0627\\u0631 \\u0623\\u0645\\u0631\\u064a\\u0643\\u064a"}, 3936 {"fa_CA", "1", "USD", "\\u06f1\\u066b\\u06f0\\u06f0\\u00a0\\u061c$", "\\u06f1\\u066b\\u06f0\\u06f0\\u00a0\\u061cUSD", "\\u06f1\\u066b\\u06f0\\u06f0 \\u062f\\u0644\\u0627\\u0631 \\u0627\\u0645\\u0631\\u06cc\\u06a9\\u0627"}, 3937 {"he_IL", "1", "USD", "\\u200f1.00\\u00a0$", "\\u200f1.00\\u00a0USD", "1.00 \\u05d3\\u05d5\\u05dc\\u05e8 \\u05d0\\u05de\\u05e8\\u05d9\\u05e7\\u05d0\\u05d9"}, 3938 {"hr_HR", "1", "USD", "1,00\\u00a0USD", "1,00\\u00a0USD", "1,00 Ameri\\u010dki dolar"}, 3939 {"id_ID", "1", "USD", "US$1,00", "USD1,00", "1,00 Dolar Amerika Serikat"}, 3940 {"it_IT", "1", "USD", "1,00\\u00a0US$", "1,00\\u00a0USD", "1,00 Dollaro Statunitense"}, 3941 {"ko_KR", "1", "USD", "US$1.00", "USD1.00", "1.00 \\ubbf8\\uad6d \\ub2ec\\ub7ec"}, 3942 {"ja_JP", "1", "USD", "$1.00", "USD1.00", "1.00\\u7c73\\u30c9\\u30eb"}, 3943 {"zh_CN", "1", "CNY", "\\uFFE51.00", "CNY01.00", "1.00\\u4EBA\\u6C11\\u5E01"}, 3944 {"zh_TW", "1", "CNY", "CN\\u00A51.00", "CNY1.00", "1.00 \\u4eba\\u6c11\\u5e63"}, 3945 {"zh_Hant", "1", "CNY", "CN\\u00A51.00", "CNY1.00", "1.00 \\u4eba\\u6c11\\u5e63"}, 3946 {"zh_Hant", "1", "JPY", "\\u00A51.00", "JPY1.00", "1.00 \\u65e5\\u5713"}, 3947 {"ja_JP", "1", "JPY", "\\uFFE51.00", "JPY1.00", "1.00\\u65e5\\u672c\\u5186"}, 3948 {"ja_JP", "1", "JPY", "\\u00A51.00", "JPY1.00", "1.00\\u65e5\\u672c\\u5186"}, 3949 {"ru_RU", "1", "RUB", "1,00\\u00A0\\u20BD", "1,00\\u00A0RUB", "1,00 \\u0420\\u043E\\u0441\\u0441\\u0438\\u0439\\u0441\\u043A\\u0438\\u0439 \\u0440\\u0443\\u0431\\u043B\\u044C"} 3950 }; 3951 static const UNumberFormatStyle currencyStyles[] = { 3952 UNUM_CURRENCY, 3953 UNUM_CURRENCY_ISO, 3954 UNUM_CURRENCY_PLURAL 3955 }; 3956 static const char* currencyStyleNames[] = { 3957 "UNUM_CURRENCY", 3958 "UNUM_CURRENCY_ISO", 3959 "UNUM_CURRENCY_PLURAL" 3960 }; 3961 3962 #ifdef NUMFMTST_CACHE_DEBUG 3963 int deadloop = 0; 3964 for (;;) { 3965 printf("loop: %d\n", deadloop++); 3966 #endif 3967 for (uint32_t i=0; i< UPRV_LENGTHOF(DATA); ++i) { /* i = test case # - should be i=0*/ 3968 for (int32_t kIndex = 2; kIndex < UPRV_LENGTHOF(currencyStyles); ++kIndex) { 3969 UNumberFormatStyle k = currencyStyles[kIndex]; /* k = style */ 3970 const char* localeString = DATA[i][0]; 3971 double numberToBeFormat = atof(DATA[i][1]); 3972 const char* currencyISOCode = DATA[i][2]; 3973 Locale locale(localeString); 3974 UErrorCode status = U_ZERO_ERROR; 3975 NumberFormat* numFmt = NumberFormat::createInstance(locale, k, status); 3976 logln("#%d NumberFormat(%s, %s) Currency=%s\n", 3977 i, localeString, currencyStyleNames[kIndex], 3978 currencyISOCode); 3979 3980 if (U_FAILURE(status)) { 3981 delete numFmt; 3982 dataerrln((UnicodeString)"can not create instance, locale:" + localeString + ", style: " + k + " - " + u_errorName(status)); 3983 continue; 3984 } 3985 UChar currencyCode[4]; 3986 u_charsToUChars(currencyISOCode, currencyCode, 4); 3987 numFmt->setCurrency(currencyCode, status); 3988 if (U_FAILURE(status)) { 3989 delete numFmt; 3990 errln((UnicodeString)"can not set currency:" + currencyISOCode); 3991 continue; 3992 } 3993 3994 UnicodeString strBuf; 3995 numFmt->format(numberToBeFormat, strBuf); 3996 /* 3997 int resultDataIndex = 3 + kIndex; 3998 // DATA[i][resultDataIndex] is the currency format result 3999 // using 'k' currency style. 4000 UnicodeString formatResult = ctou(DATA[i][resultDataIndex]); 4001 if (strBuf.compare(formatResult)) { 4002 errln("FAIL: Expected " + formatResult + " actual: " + strBuf); 4003 } 4004 */ 4005 // test parsing, and test parsing for all currency formats. 4006 for (int j = 3; j < 6; ++j) { 4007 // DATA[i][3] is the currency format result using 4008 // CURRENCYSTYLE formatter. 4009 // DATA[i][4] is the currency format result using 4010 // ISOCURRENCYSTYLE formatter. 4011 // DATA[i][5] is the currency format result using 4012 // PLURALCURRENCYSTYLE formatter. 4013 UnicodeString oneCurrencyFormatResult = ctou(DATA[i][j]); 4014 UErrorCode status = U_ZERO_ERROR; 4015 Formattable parseResult; 4016 logln("parse(%s)", DATA[i][j]); 4017 numFmt->parse(oneCurrencyFormatResult, parseResult, status); 4018 if (U_FAILURE(status) || 4019 (parseResult.getType() == Formattable::kDouble && 4020 parseResult.getDouble() != numberToBeFormat) || 4021 (parseResult.getType() == Formattable::kLong && 4022 parseResult.getLong() != numberToBeFormat)) { 4023 errln((UnicodeString)"FAIL: NumberFormat(" + localeString +", " + currencyStyleNames[kIndex] + 4024 "), Currency="+currencyISOCode+", parse("+DATA[i][j]+") returned error " + (UnicodeString)u_errorName(status)+". Testcase: data[" + i + "][" + currencyStyleNames[j-3] +"="+j+"]"); 4025 if (parseResult.getType() == Formattable::kDouble) { 4026 errln((UnicodeString)"expected: " + numberToBeFormat + "; actual (double): " +parseResult.getDouble()); 4027 } else { 4028 errln((UnicodeString)"expected: " + numberToBeFormat + "; actual (long): " +parseResult.getLong()); 4029 } 4030 errln((UnicodeString)" round-trip would be: " + strBuf); 4031 } 4032 } 4033 delete numFmt; 4034 } 4035 } 4036 #ifdef NUMFMTST_CACHE_DEBUG 4037 } 4038 #endif 4039 } 4040 4041 4042 void 4043 NumberFormatTest::TestParseCurrencyInUCurr() { 4044 const char* DATA[] = { 4045 "1.00 US DOLLAR", // case in-sensitive 4046 "$1.00", 4047 "USD1.00", 4048 "US dollar1.00", 4049 "US dollars1.00", 4050 "$1.00", 4051 "A$1.00", 4052 "ADP1.00", 4053 "ADP1.00", 4054 "AED1.00", 4055 "AED1.00", 4056 "AFA1.00", 4057 "AFA1.00", 4058 "AFN1.00", 4059 "ALL1.00", 4060 "AMD1.00", 4061 "ANG1.00", 4062 "AOA1.00", 4063 "AOK1.00", 4064 "AOK1.00", 4065 "AON1.00", 4066 "AON1.00", 4067 "AOR1.00", 4068 "AOR1.00", 4069 "ARS1.00", 4070 "ARA1.00", 4071 "ARA1.00", 4072 "ARP1.00", 4073 "ARP1.00", 4074 "ARS1.00", 4075 "ATS1.00", 4076 "ATS1.00", 4077 "AUD1.00", 4078 "AWG1.00", 4079 "AZM1.00", 4080 "AZM1.00", 4081 "AZN1.00", 4082 "Afghan Afghani (1927\\u20132002)1.00", 4083 "Afghan afghani (1927\\u20132002)1.00", 4084 "Afghan Afghani1.00", 4085 "Afghan Afghanis1.00", 4086 "Albanian Lek1.00", 4087 "Albanian lek1.00", 4088 "Albanian lek\\u00eb1.00", 4089 "Algerian Dinar1.00", 4090 "Algerian dinar1.00", 4091 "Algerian dinars1.00", 4092 "Andorran Peseta1.00", 4093 "Andorran peseta1.00", 4094 "Andorran pesetas1.00", 4095 "Angolan Kwanza (1977\\u20131991)1.00", 4096 "Angolan Readjusted Kwanza (1995\\u20131999)1.00", 4097 "Angolan Kwanza1.00", 4098 "Angolan New Kwanza (1990\\u20132000)1.00", 4099 "Angolan kwanza (1977\\u20131991)1.00", 4100 "Angolan readjusted kwanza (1995\\u20131999)1.00", 4101 "Angolan kwanza1.00", 4102 "Angolan kwanzas (1977\\u20131991)1.00", 4103 "Angolan readjusted kwanzas (1995\\u20131999)1.00", 4104 "Angolan kwanzas1.00", 4105 "Angolan new kwanza (1990\\u20132000)1.00", 4106 "Angolan new kwanzas (1990\\u20132000)1.00", 4107 "Argentine Austral1.00", 4108 "Argentine Peso (1983\\u20131985)1.00", 4109 "Argentine Peso1.00", 4110 "Argentine austral1.00", 4111 "Argentine australs1.00", 4112 "Argentine peso (1983\\u20131985)1.00", 4113 "Argentine peso1.00", 4114 "Argentine pesos (1983\\u20131985)1.00", 4115 "Argentine pesos1.00", 4116 "Armenian Dram1.00", 4117 "Armenian dram1.00", 4118 "Armenian drams1.00", 4119 "Aruban Florin1.00", 4120 "Aruban florin1.00", 4121 "Australian Dollar1.00", 4122 "Australian dollar1.00", 4123 "Australian dollars1.00", 4124 "Austrian Schilling1.00", 4125 "Austrian schilling1.00", 4126 "Austrian schillings1.00", 4127 "Azerbaijani Manat (1993\\u20132006)1.00", 4128 "Azerbaijani Manat1.00", 4129 "Azerbaijani manat (1993\\u20132006)1.00", 4130 "Azerbaijani manat1.00", 4131 "Azerbaijani manats (1993\\u20132006)1.00", 4132 "Azerbaijani manats1.00", 4133 "BAD1.00", 4134 "BAD1.00", 4135 "BAM1.00", 4136 "BBD1.00", 4137 "BDT1.00", 4138 "BEC1.00", 4139 "BEC1.00", 4140 "BEF1.00", 4141 "BEL1.00", 4142 "BEL1.00", 4143 "BGL1.00", 4144 "BGN1.00", 4145 "BGN1.00", 4146 "BHD1.00", 4147 "BIF1.00", 4148 "BMD1.00", 4149 "BND1.00", 4150 "BOB1.00", 4151 "BOP1.00", 4152 "BOP1.00", 4153 "BOV1.00", 4154 "BOV1.00", 4155 "BRB1.00", 4156 "BRB1.00", 4157 "BRC1.00", 4158 "BRC1.00", 4159 "BRE1.00", 4160 "BRE1.00", 4161 "BRL1.00", 4162 "BRN1.00", 4163 "BRN1.00", 4164 "BRR1.00", 4165 "BRR1.00", 4166 "BSD1.00", 4167 "BSD1.00", 4168 "BTN1.00", 4169 "BUK1.00", 4170 "BUK1.00", 4171 "BWP1.00", 4172 "BYB1.00", 4173 "BYB1.00", 4174 "BYR1.00", 4175 "BZD1.00", 4176 "Bahamian Dollar1.00", 4177 "Bahamian dollar1.00", 4178 "Bahamian dollars1.00", 4179 "Bahraini Dinar1.00", 4180 "Bahraini dinar1.00", 4181 "Bahraini dinars1.00", 4182 "Bangladeshi Taka1.00", 4183 "Bangladeshi taka1.00", 4184 "Bangladeshi takas1.00", 4185 "Barbadian Dollar1.00", 4186 "Barbadian dollar1.00", 4187 "Barbadian dollars1.00", 4188 "Belarusian Ruble (1994\\u20131999)1.00", 4189 "Belarusian Ruble1.00", 4190 "Belarusian ruble (1994\\u20131999)1.00", 4191 "Belarusian rubles (1994\\u20131999)1.00", 4192 "Belarusian ruble1.00", 4193 "Belarusian rubles1.00", 4194 "Belgian Franc (convertible)1.00", 4195 "Belgian Franc (financial)1.00", 4196 "Belgian Franc1.00", 4197 "Belgian franc (convertible)1.00", 4198 "Belgian franc (financial)1.00", 4199 "Belgian franc1.00", 4200 "Belgian francs (convertible)1.00", 4201 "Belgian francs (financial)1.00", 4202 "Belgian francs1.00", 4203 "Belize Dollar1.00", 4204 "Belize dollar1.00", 4205 "Belize dollars1.00", 4206 "Bermudan Dollar1.00", 4207 "Bermudan dollar1.00", 4208 "Bermudan dollars1.00", 4209 "Bhutanese Ngultrum1.00", 4210 "Bhutanese ngultrum1.00", 4211 "Bhutanese ngultrums1.00", 4212 "Bolivian Mvdol1.00", 4213 "Bolivian Peso1.00", 4214 "Bolivian mvdol1.00", 4215 "Bolivian mvdols1.00", 4216 "Bolivian peso1.00", 4217 "Bolivian pesos1.00", 4218 "Bolivian Boliviano1.00", 4219 "Bolivian Boliviano1.00", 4220 "Bolivian Bolivianos1.00", 4221 "Bosnia-Herzegovina Convertible Mark1.00", 4222 "Bosnia-Herzegovina Dinar (1992\\u20131994)1.00", 4223 "Bosnia-Herzegovina convertible mark1.00", 4224 "Bosnia-Herzegovina convertible marks1.00", 4225 "Bosnia-Herzegovina dinar (1992\\u20131994)1.00", 4226 "Bosnia-Herzegovina dinars (1992\\u20131994)1.00", 4227 "Botswanan Pula1.00", 4228 "Botswanan pula1.00", 4229 "Botswanan pulas1.00", 4230 "Brazilian New Cruzado (1989\\u20131990)1.00", 4231 "Brazilian Cruzado (1986\\u20131989)1.00", 4232 "Brazilian Cruzeiro (1990\\u20131993)1.00", 4233 "Brazilian New Cruzeiro (1967\\u20131986)1.00", 4234 "Brazilian Cruzeiro (1993\\u20131994)1.00", 4235 "Brazilian Real1.00", 4236 "Brazilian new cruzado (1989\\u20131990)1.00", 4237 "Brazilian new cruzados (1989\\u20131990)1.00", 4238 "Brazilian cruzado (1986\\u20131989)1.00", 4239 "Brazilian cruzados (1986\\u20131989)1.00", 4240 "Brazilian cruzeiro (1990\\u20131993)1.00", 4241 "Brazilian new cruzeiro (1967\\u20131986)1.00", 4242 "Brazilian cruzeiro (1993\\u20131994)1.00", 4243 "Brazilian cruzeiros (1990\\u20131993)1.00", 4244 "Brazilian new cruzeiros (1967\\u20131986)1.00", 4245 "Brazilian cruzeiros (1993\\u20131994)1.00", 4246 "Brazilian real1.00", 4247 "Brazilian reals1.00", 4248 "British Pound1.00", 4249 "British pound1.00", 4250 "British pounds1.00", 4251 "Brunei Dollar1.00", 4252 "Brunei dollar1.00", 4253 "Brunei dollars1.00", 4254 "Bulgarian Hard Lev1.00", 4255 "Bulgarian Lev1.00", 4256 "Bulgarian Leva1.00", 4257 "Bulgarian hard lev1.00", 4258 "Bulgarian hard leva1.00", 4259 "Bulgarian lev1.00", 4260 "Burmese Kyat1.00", 4261 "Burmese kyat1.00", 4262 "Burmese kyats1.00", 4263 "Burundian Franc1.00", 4264 "Burundian franc1.00", 4265 "Burundian francs1.00", 4266 "CA$1.00", 4267 "CAD1.00", 4268 "CDF1.00", 4269 "CDF1.00", 4270 "West African CFA Franc1.00", 4271 "Central African CFA Franc1.00", 4272 "West African CFA franc1.00", 4273 "Central African CFA franc1.00", 4274 "West African CFA francs1.00", 4275 "Central African CFA francs1.00", 4276 "CFP Franc1.00", 4277 "CFP franc1.00", 4278 "CFP francs1.00", 4279 "CFPF1.00", 4280 "CHE1.00", 4281 "CHE1.00", 4282 "CHF1.00", 4283 "CHW1.00", 4284 "CHW1.00", 4285 "CLF1.00", 4286 "CLF1.00", 4287 "CLP1.00", 4288 "CNY1.00", 4289 "COP1.00", 4290 "COU1.00", 4291 "COU1.00", 4292 "CRC1.00", 4293 "CSD1.00", 4294 "CSD1.00", 4295 "CSK1.00", 4296 "CSK1.00", 4297 "CUP1.00", 4298 "CUP1.00", 4299 "CVE1.00", 4300 "CYP1.00", 4301 "CZK1.00", 4302 "Cambodian Riel1.00", 4303 "Cambodian riel1.00", 4304 "Cambodian riels1.00", 4305 "Canadian Dollar1.00", 4306 "Canadian dollar1.00", 4307 "Canadian dollars1.00", 4308 "Cape Verdean Escudo1.00", 4309 "Cape Verdean escudo1.00", 4310 "Cape Verdean escudos1.00", 4311 "Cayman Islands Dollar1.00", 4312 "Cayman Islands dollar1.00", 4313 "Cayman Islands dollars1.00", 4314 "Chilean Peso1.00", 4315 "Chilean Unit of Account (UF)1.00", 4316 "Chilean peso1.00", 4317 "Chilean pesos1.00", 4318 "Chilean unit of account (UF)1.00", 4319 "Chilean units of account (UF)1.00", 4320 "Chinese Yuan1.00", 4321 "Chinese yuan1.00", 4322 "Colombian Peso1.00", 4323 "Colombian peso1.00", 4324 "Colombian pesos1.00", 4325 "Comorian Franc1.00", 4326 "Comorian franc1.00", 4327 "Comorian francs1.00", 4328 "Congolese Franc1.00", 4329 "Congolese franc1.00", 4330 "Congolese francs1.00", 4331 "Costa Rican Col\\u00f3n1.00", 4332 "Costa Rican col\\u00f3n1.00", 4333 "Costa Rican col\\u00f3ns1.00", 4334 "Croatian Dinar1.00", 4335 "Croatian Kuna1.00", 4336 "Croatian dinar1.00", 4337 "Croatian dinars1.00", 4338 "Croatian kuna1.00", 4339 "Croatian kunas1.00", 4340 "Cuban Peso1.00", 4341 "Cuban peso1.00", 4342 "Cuban pesos1.00", 4343 "Cypriot Pound1.00", 4344 "Cypriot pound1.00", 4345 "Cypriot pounds1.00", 4346 "Czech Republic Koruna1.00", 4347 "Czech Republic koruna1.00", 4348 "Czech Republic korunas1.00", 4349 "Czechoslovak Hard Koruna1.00", 4350 "Czechoslovak hard koruna1.00", 4351 "Czechoslovak hard korunas1.00", 4352 "DDM1.00", 4353 "DDM1.00", 4354 "DEM1.00", 4355 "DEM1.00", 4356 "DJF1.00", 4357 "DKK1.00", 4358 "DOP1.00", 4359 "DZD1.00", 4360 "Danish Krone1.00", 4361 "Danish krone1.00", 4362 "Danish kroner1.00", 4363 "German Mark1.00", 4364 "German mark1.00", 4365 "German marks1.00", 4366 "Djiboutian Franc1.00", 4367 "Djiboutian franc1.00", 4368 "Djiboutian francs1.00", 4369 "Dominican Peso1.00", 4370 "Dominican peso1.00", 4371 "Dominican pesos1.00", 4372 "EC$1.00", 4373 "ECS1.00", 4374 "ECS1.00", 4375 "ECV1.00", 4376 "ECV1.00", 4377 "EEK1.00", 4378 "EEK1.00", 4379 "EGP1.00", 4380 "EGP1.00", 4381 "ERN1.00", 4382 "ERN1.00", 4383 "ESA1.00", 4384 "ESA1.00", 4385 "ESB1.00", 4386 "ESB1.00", 4387 "ESP1.00", 4388 "ETB1.00", 4389 "EUR1.00", 4390 "East Caribbean Dollar1.00", 4391 "East Caribbean dollar1.00", 4392 "East Caribbean dollars1.00", 4393 "East German Mark1.00", 4394 "East German mark1.00", 4395 "East German marks1.00", 4396 "Ecuadorian Sucre1.00", 4397 "Ecuadorian Unit of Constant Value1.00", 4398 "Ecuadorian sucre1.00", 4399 "Ecuadorian sucres1.00", 4400 "Ecuadorian unit of constant value1.00", 4401 "Ecuadorian units of constant value1.00", 4402 "Egyptian Pound1.00", 4403 "Egyptian pound1.00", 4404 "Egyptian pounds1.00", 4405 "Salvadoran Col\\u00f3n1.00", 4406 "Salvadoran col\\u00f3n1.00", 4407 "Salvadoran colones1.00", 4408 "Equatorial Guinean Ekwele1.00", 4409 "Equatorial Guinean ekwele1.00", 4410 "Eritrean Nakfa1.00", 4411 "Eritrean nakfa1.00", 4412 "Eritrean nakfas1.00", 4413 "Estonian Kroon1.00", 4414 "Estonian kroon1.00", 4415 "Estonian kroons1.00", 4416 "Ethiopian Birr1.00", 4417 "Ethiopian birr1.00", 4418 "Ethiopian birrs1.00", 4419 "Euro1.00", 4420 "European Composite Unit1.00", 4421 "European Currency Unit1.00", 4422 "European Monetary Unit1.00", 4423 "European Unit of Account (XBC)1.00", 4424 "European Unit of Account (XBD)1.00", 4425 "European composite unit1.00", 4426 "European composite units1.00", 4427 "European currency unit1.00", 4428 "European currency units1.00", 4429 "European monetary unit1.00", 4430 "European monetary units1.00", 4431 "European unit of account (XBC)1.00", 4432 "European unit of account (XBD)1.00", 4433 "European units of account (XBC)1.00", 4434 "European units of account (XBD)1.00", 4435 "FIM1.00", 4436 "FIM1.00", 4437 "FJD1.00", 4438 "FKP1.00", 4439 "FKP1.00", 4440 "FRF1.00", 4441 "FRF1.00", 4442 "Falkland Islands Pound1.00", 4443 "Falkland Islands pound1.00", 4444 "Falkland Islands pounds1.00", 4445 "Fijian Dollar1.00", 4446 "Fijian dollar1.00", 4447 "Fijian dollars1.00", 4448 "Finnish Markka1.00", 4449 "Finnish markka1.00", 4450 "Finnish markkas1.00", 4451 "CHF1.00", 4452 "French Franc1.00", 4453 "French Gold Franc1.00", 4454 "French UIC-Franc1.00", 4455 "French UIC-franc1.00", 4456 "French UIC-francs1.00", 4457 "French franc1.00", 4458 "French francs1.00", 4459 "French gold franc1.00", 4460 "French gold francs1.00", 4461 "GBP1.00", 4462 "GEK1.00", 4463 "GEK1.00", 4464 "GEL1.00", 4465 "GHC1.00", 4466 "GHC1.00", 4467 "GHS1.00", 4468 "GIP1.00", 4469 "GIP1.00", 4470 "GMD1.00", 4471 "GMD1.00", 4472 "GNF1.00", 4473 "GNS1.00", 4474 "GNS1.00", 4475 "GQE1.00", 4476 "GQE1.00", 4477 "GRD1.00", 4478 "GRD1.00", 4479 "GTQ1.00", 4480 "GWE1.00", 4481 "GWE1.00", 4482 "GWP1.00", 4483 "GWP1.00", 4484 "GYD1.00", 4485 "Gambian Dalasi1.00", 4486 "Gambian dalasi1.00", 4487 "Gambian dalasis1.00", 4488 "Georgian Kupon Larit1.00", 4489 "Georgian Lari1.00", 4490 "Georgian kupon larit1.00", 4491 "Georgian kupon larits1.00", 4492 "Georgian lari1.00", 4493 "Georgian laris1.00", 4494 "Ghanaian Cedi (1979\\u20132007)1.00", 4495 "Ghanaian Cedi1.00", 4496 "Ghanaian cedi (1979\\u20132007)1.00", 4497 "Ghanaian cedi1.00", 4498 "Ghanaian cedis (1979\\u20132007)1.00", 4499 "Ghanaian cedis1.00", 4500 "Gibraltar Pound1.00", 4501 "Gibraltar pound1.00", 4502 "Gibraltar pounds1.00", 4503 "Gold1.00", 4504 "Gold1.00", 4505 "Greek Drachma1.00", 4506 "Greek drachma1.00", 4507 "Greek drachmas1.00", 4508 "Guatemalan Quetzal1.00", 4509 "Guatemalan quetzal1.00", 4510 "Guatemalan quetzals1.00", 4511 "Guinean Franc1.00", 4512 "Guinean Syli1.00", 4513 "Guinean franc1.00", 4514 "Guinean francs1.00", 4515 "Guinean syli1.00", 4516 "Guinean sylis1.00", 4517 "Guinea-Bissau Peso1.00", 4518 "Guinea-Bissau peso1.00", 4519 "Guinea-Bissau pesos1.00", 4520 "Guyanaese Dollar1.00", 4521 "Guyanaese dollar1.00", 4522 "Guyanaese dollars1.00", 4523 "HK$1.00", 4524 "HKD1.00", 4525 "HNL1.00", 4526 "HRD1.00", 4527 "HRD1.00", 4528 "HRK1.00", 4529 "HRK1.00", 4530 "HTG1.00", 4531 "HTG1.00", 4532 "HUF1.00", 4533 "Haitian Gourde1.00", 4534 "Haitian gourde1.00", 4535 "Haitian gourdes1.00", 4536 "Honduran Lempira1.00", 4537 "Honduran lempira1.00", 4538 "Honduran lempiras1.00", 4539 "Hong Kong Dollar1.00", 4540 "Hong Kong dollar1.00", 4541 "Hong Kong dollars1.00", 4542 "Hungarian Forint1.00", 4543 "Hungarian forint1.00", 4544 "Hungarian forints1.00", 4545 "IDR1.00", 4546 "IEP1.00", 4547 "ILP1.00", 4548 "ILP1.00", 4549 "ILS1.00", 4550 "INR1.00", 4551 "IQD1.00", 4552 "IRR1.00", 4553 "ISK1.00", 4554 "ISK1.00", 4555 "ITL1.00", 4556 "Icelandic Kr\\u00f3na1.00", 4557 "Icelandic kr\\u00f3na1.00", 4558 "Icelandic kr\\u00f3nur1.00", 4559 "Indian Rupee1.00", 4560 "Indian rupee1.00", 4561 "Indian rupees1.00", 4562 "Indonesian Rupiah1.00", 4563 "Indonesian rupiah1.00", 4564 "Indonesian rupiahs1.00", 4565 "Iranian Rial1.00", 4566 "Iranian rial1.00", 4567 "Iranian rials1.00", 4568 "Iraqi Dinar1.00", 4569 "Iraqi dinar1.00", 4570 "Iraqi dinars1.00", 4571 "Irish Pound1.00", 4572 "Irish pound1.00", 4573 "Irish pounds1.00", 4574 "Israeli Pound1.00", 4575 "Israeli new shekel1.00", 4576 "Israeli pound1.00", 4577 "Israeli pounds1.00", 4578 "Italian Lira1.00", 4579 "Italian lira1.00", 4580 "Italian liras1.00", 4581 "JMD1.00", 4582 "JOD1.00", 4583 "JPY1.00", 4584 "Jamaican Dollar1.00", 4585 "Jamaican dollar1.00", 4586 "Jamaican dollars1.00", 4587 "Japanese Yen1.00", 4588 "Japanese yen1.00", 4589 "Jordanian Dinar1.00", 4590 "Jordanian dinar1.00", 4591 "Jordanian dinars1.00", 4592 "KES1.00", 4593 "KGS1.00", 4594 "KHR1.00", 4595 "KMF1.00", 4596 "KPW1.00", 4597 "KPW1.00", 4598 "KRW1.00", 4599 "KWD1.00", 4600 "KYD1.00", 4601 "KYD1.00", 4602 "KZT1.00", 4603 "Kazakhstani Tenge1.00", 4604 "Kazakhstani tenge1.00", 4605 "Kazakhstani tenges1.00", 4606 "Kenyan Shilling1.00", 4607 "Kenyan shilling1.00", 4608 "Kenyan shillings1.00", 4609 "Kuwaiti Dinar1.00", 4610 "Kuwaiti dinar1.00", 4611 "Kuwaiti dinars1.00", 4612 "Kyrgystani Som1.00", 4613 "Kyrgystani som1.00", 4614 "Kyrgystani soms1.00", 4615 "HNL1.00", 4616 "LAK1.00", 4617 "LAK1.00", 4618 "LBP1.00", 4619 "LKR1.00", 4620 "LRD1.00", 4621 "LRD1.00", 4622 "LSL1.00", 4623 "LTL1.00", 4624 "LTL1.00", 4625 "LTT1.00", 4626 "LTT1.00", 4627 "LUC1.00", 4628 "LUC1.00", 4629 "LUF1.00", 4630 "LUF1.00", 4631 "LUL1.00", 4632 "LUL1.00", 4633 "LVL1.00", 4634 "LVL1.00", 4635 "LVR1.00", 4636 "LVR1.00", 4637 "LYD1.00", 4638 "Laotian Kip1.00", 4639 "Laotian kip1.00", 4640 "Laotian kips1.00", 4641 "Latvian Lats1.00", 4642 "Latvian Ruble1.00", 4643 "Latvian lats1.00", 4644 "Latvian lati1.00", 4645 "Latvian ruble1.00", 4646 "Latvian rubles1.00", 4647 "Lebanese Pound1.00", 4648 "Lebanese pound1.00", 4649 "Lebanese pounds1.00", 4650 "Lesotho Loti1.00", 4651 "Lesotho loti1.00", 4652 "Lesotho lotis1.00", 4653 "Liberian Dollar1.00", 4654 "Liberian dollar1.00", 4655 "Liberian dollars1.00", 4656 "Libyan Dinar1.00", 4657 "Libyan dinar1.00", 4658 "Libyan dinars1.00", 4659 "Lithuanian Litas1.00", 4660 "Lithuanian Talonas1.00", 4661 "Lithuanian litas1.00", 4662 "Lithuanian litai1.00", 4663 "Lithuanian talonas1.00", 4664 "Lithuanian talonases1.00", 4665 "Luxembourgian Convertible Franc1.00", 4666 "Luxembourg Financial Franc1.00", 4667 "Luxembourgian Franc1.00", 4668 "Luxembourgian convertible franc1.00", 4669 "Luxembourgian convertible francs1.00", 4670 "Luxembourg financial franc1.00", 4671 "Luxembourg financial francs1.00", 4672 "Luxembourgian franc1.00", 4673 "Luxembourgian francs1.00", 4674 "MAD1.00", 4675 "MAD1.00", 4676 "MAF1.00", 4677 "MAF1.00", 4678 "MDL1.00", 4679 "MDL1.00", 4680 "MX$1.00", 4681 "MGA1.00", 4682 "MGA1.00", 4683 "MGF1.00", 4684 "MGF1.00", 4685 "MKD1.00", 4686 "MLF1.00", 4687 "MLF1.00", 4688 "MMK1.00", 4689 "MMK1.00", 4690 "MNT1.00", 4691 "MOP1.00", 4692 "MOP1.00", 4693 "MRO1.00", 4694 "MTL1.00", 4695 "MTP1.00", 4696 "MTP1.00", 4697 "MUR1.00", 4698 "MUR1.00", 4699 "MVR1.00", 4700 "MVR1.00", 4701 "MWK1.00", 4702 "MXN1.00", 4703 "MXP1.00", 4704 "MXP1.00", 4705 "MXV1.00", 4706 "MXV1.00", 4707 "MYR1.00", 4708 "MZE1.00", 4709 "MZE1.00", 4710 "MZM1.00", 4711 "MZN1.00", 4712 "Macanese Pataca1.00", 4713 "Macanese pataca1.00", 4714 "Macanese patacas1.00", 4715 "Macedonian Denar1.00", 4716 "Macedonian denar1.00", 4717 "Macedonian denari1.00", 4718 "Malagasy Ariaries1.00", 4719 "Malagasy Ariary1.00", 4720 "Malagasy Ariary1.00", 4721 "Malagasy Franc1.00", 4722 "Malagasy franc1.00", 4723 "Malagasy francs1.00", 4724 "Malawian Kwacha1.00", 4725 "Malawian Kwacha1.00", 4726 "Malawian Kwachas1.00", 4727 "Malaysian Ringgit1.00", 4728 "Malaysian ringgit1.00", 4729 "Malaysian ringgits1.00", 4730 "Maldivian Rufiyaa1.00", 4731 "Maldivian rufiyaa1.00", 4732 "Maldivian rufiyaas1.00", 4733 "Malian Franc1.00", 4734 "Malian franc1.00", 4735 "Malian francs1.00", 4736 "Maltese Lira1.00", 4737 "Maltese Pound1.00", 4738 "Maltese lira1.00", 4739 "Maltese lira1.00", 4740 "Maltese pound1.00", 4741 "Maltese pounds1.00", 4742 "Mauritanian Ouguiya1.00", 4743 "Mauritanian ouguiya1.00", 4744 "Mauritanian ouguiyas1.00", 4745 "Mauritian Rupee1.00", 4746 "Mauritian rupee1.00", 4747 "Mauritian rupees1.00", 4748 "Mexican Peso1.00", 4749 "Mexican Silver Peso (1861\\u20131992)1.00", 4750 "Mexican Investment Unit1.00", 4751 "Mexican peso1.00", 4752 "Mexican pesos1.00", 4753 "Mexican silver peso (1861\\u20131992)1.00", 4754 "Mexican silver pesos (1861\\u20131992)1.00", 4755 "Mexican investment unit1.00", 4756 "Mexican investment units1.00", 4757 "Moldovan Leu1.00", 4758 "Moldovan leu1.00", 4759 "Moldovan lei1.00", 4760 "Mongolian Tugrik1.00", 4761 "Mongolian tugrik1.00", 4762 "Mongolian tugriks1.00", 4763 "Moroccan Dirham1.00", 4764 "Moroccan Franc1.00", 4765 "Moroccan dirham1.00", 4766 "Moroccan dirhams1.00", 4767 "Moroccan franc1.00", 4768 "Moroccan francs1.00", 4769 "Mozambican Escudo1.00", 4770 "Mozambican Metical1.00", 4771 "Mozambican escudo1.00", 4772 "Mozambican escudos1.00", 4773 "Mozambican metical1.00", 4774 "Mozambican meticals1.00", 4775 "Myanmar Kyat1.00", 4776 "Myanmar kyat1.00", 4777 "Myanmar kyats1.00", 4778 "NAD1.00", 4779 "NGN1.00", 4780 "NIC1.00", 4781 "NIO1.00", 4782 "NIO1.00", 4783 "NLG1.00", 4784 "NLG1.00", 4785 "NOK1.00", 4786 "NPR1.00", 4787 "NT$1.00", 4788 "NZ$1.00", 4789 "NZD1.00", 4790 "Namibian Dollar1.00", 4791 "Namibian dollar1.00", 4792 "Namibian dollars1.00", 4793 "Nepalese Rupee1.00", 4794 "Nepalese rupee1.00", 4795 "Nepalese rupees1.00", 4796 "Netherlands Antillean Guilder1.00", 4797 "Netherlands Antillean guilder1.00", 4798 "Netherlands Antillean guilders1.00", 4799 "Dutch Guilder1.00", 4800 "Dutch guilder1.00", 4801 "Dutch guilders1.00", 4802 "Israeli New Shekel1.00", 4803 "Israeli New Shekels1.00", 4804 "New Zealand Dollar1.00", 4805 "New Zealand dollar1.00", 4806 "New Zealand dollars1.00", 4807 "Nicaraguan C\\u00f3rdoba1.00", 4808 "Nicaraguan C\\u00f3rdoba (1988\\u20131991)1.00", 4809 "Nicaraguan c\\u00f3rdoba1.00", 4810 "Nicaraguan c\\u00f3rdobas1.00", 4811 "Nicaraguan c\\u00f3rdoba (1988\\u20131991)1.00", 4812 "Nicaraguan c\\u00f3rdobas (1988\\u20131991)1.00", 4813 "Nigerian Naira1.00", 4814 "Nigerian naira1.00", 4815 "Nigerian nairas1.00", 4816 "North Korean Won1.00", 4817 "North Korean won1.00", 4818 "North Korean won1.00", 4819 "Norwegian Krone1.00", 4820 "Norwegian krone1.00", 4821 "Norwegian kroner1.00", 4822 "OMR1.00", 4823 "Mozambican Metical (1980\\u20132006)1.00", 4824 "Mozambican metical (1980\\u20132006)1.00", 4825 "Mozambican meticals (1980\\u20132006)1.00", 4826 "Romanian Lei (1952\\u20132006)1.00", 4827 "Romanian Leu (1952\\u20132006)1.00", 4828 "Romanian leu (1952\\u20132006)1.00", 4829 "Serbian Dinar (2002\\u20132006)1.00", 4830 "Serbian dinar (2002\\u20132006)1.00", 4831 "Serbian dinars (2002\\u20132006)1.00", 4832 "Sudanese Dinar (1992\\u20132007)1.00", 4833 "Sudanese Pound (1957\\u20131998)1.00", 4834 "Sudanese dinar (1992\\u20132007)1.00", 4835 "Sudanese dinars (1992\\u20132007)1.00", 4836 "Sudanese pound (1957\\u20131998)1.00", 4837 "Sudanese pounds (1957\\u20131998)1.00", 4838 "Turkish Lira (1922\\u20132005)1.00", 4839 "Turkish Lira (1922\\u20132005)1.00", 4840 "Omani Rial1.00", 4841 "Omani rial1.00", 4842 "Omani rials1.00", 4843 "PAB1.00", 4844 "PAB1.00", 4845 "PEI1.00", 4846 "PEI1.00", 4847 "PEN1.00", 4848 "PEN1.00", 4849 "PES1.00", 4850 "PES1.00", 4851 "PGK1.00", 4852 "PGK1.00", 4853 "PHP1.00", 4854 "PKR1.00", 4855 "PLN1.00", 4856 "PLZ1.00", 4857 "PLZ1.00", 4858 "PTE1.00", 4859 "PTE1.00", 4860 "PYG1.00", 4861 "Pakistani Rupee1.00", 4862 "Pakistani rupee1.00", 4863 "Pakistani rupees1.00", 4864 "Palladium1.00", 4865 "Palladium1.00", 4866 "Panamanian Balboa1.00", 4867 "Panamanian balboa1.00", 4868 "Panamanian balboas1.00", 4869 "Papua New Guinean Kina1.00", 4870 "Papua New Guinean kina1.00", 4871 "Papua New Guinean kina1.00", 4872 "Paraguayan Guarani1.00", 4873 "Paraguayan guarani1.00", 4874 "Paraguayan guaranis1.00", 4875 "Peruvian Inti1.00", 4876 "Peruvian Sol1.00", 4877 "Peruvian Sol (1863\\u20131965)1.00", 4878 "Peruvian inti1.00", 4879 "Peruvian intis1.00", 4880 "Peruvian sol1.00", 4881 "Peruvian soles1.00", 4882 "Peruvian sol (1863\\u20131965)1.00", 4883 "Peruvian soles (1863\\u20131965)1.00", 4884 "Philippine Peso1.00", 4885 "Philippine peso1.00", 4886 "Philippine pesos1.00", 4887 "Platinum1.00", 4888 "Platinum1.00", 4889 "Polish Zloty (1950\\u20131995)1.00", 4890 "Polish Zloty1.00", 4891 "Polish zlotys1.00", 4892 "Polish zloty (PLZ)1.00", 4893 "Polish zloty1.00", 4894 "Polish zlotys (PLZ)1.00", 4895 "Portuguese Escudo1.00", 4896 "Portuguese Guinea Escudo1.00", 4897 "Portuguese Guinea escudo1.00", 4898 "Portuguese Guinea escudos1.00", 4899 "Portuguese escudo1.00", 4900 "Portuguese escudos1.00", 4901 "GTQ1.00", 4902 "QAR1.00", 4903 "Qatari Rial1.00", 4904 "Qatari rial1.00", 4905 "Qatari rials1.00", 4906 "RHD1.00", 4907 "RHD1.00", 4908 "RINET Funds1.00", 4909 "RINET Funds1.00", 4910 "CN\\u00a51.00", 4911 "ROL1.00", 4912 "ROL1.00", 4913 "RON1.00", 4914 "RON1.00", 4915 "RSD1.00", 4916 "RSD1.00", 4917 "RUB1.00", 4918 "RUR1.00", 4919 "RUR1.00", 4920 "RWF1.00", 4921 "RWF1.00", 4922 "Rhodesian Dollar1.00", 4923 "Rhodesian dollar1.00", 4924 "Rhodesian dollars1.00", 4925 "Romanian Leu1.00", 4926 "Romanian lei1.00", 4927 "Romanian leu1.00", 4928 "Russian Ruble (1991\\u20131998)1.00", 4929 "Russian Ruble1.00", 4930 "Russian ruble (1991\\u20131998)1.00", 4931 "Russian ruble1.00", 4932 "Russian rubles (1991\\u20131998)1.00", 4933 "Russian rubles1.00", 4934 "Rwandan Franc1.00", 4935 "Rwandan franc1.00", 4936 "Rwandan francs1.00", 4937 "SAR1.00", 4938 "SBD1.00", 4939 "SCR1.00", 4940 "SDD1.00", 4941 "SDD1.00", 4942 "SDG1.00", 4943 "SDG1.00", 4944 "SDP1.00", 4945 "SDP1.00", 4946 "SEK1.00", 4947 "SGD1.00", 4948 "SHP1.00", 4949 "SHP1.00", 4950 "SIT1.00", 4951 "SIT1.00", 4952 "SKK1.00", 4953 "SLL1.00", 4954 "SLL1.00", 4955 "SOS1.00", 4956 "SRD1.00", 4957 "SRD1.00", 4958 "SRG1.00", 4959 "STD1.00", 4960 "SUR1.00", 4961 "SUR1.00", 4962 "SVC1.00", 4963 "SVC1.00", 4964 "SYP1.00", 4965 "SZL1.00", 4966 "St. Helena Pound1.00", 4967 "St. Helena pound1.00", 4968 "St. Helena pounds1.00", 4969 "S\\u00e3o Tom\\u00e9 & Pr\\u00edncipe Dobra1.00", 4970 "S\\u00e3o Tom\\u00e9 & Pr\\u00edncipe dobra1.00", 4971 "S\\u00e3o Tom\\u00e9 & Pr\\u00edncipe dobras1.00", 4972 "Saudi Riyal1.00", 4973 "Saudi riyal1.00", 4974 "Saudi riyals1.00", 4975 "Serbian Dinar1.00", 4976 "Serbian dinar1.00", 4977 "Serbian dinars1.00", 4978 "Seychellois Rupee1.00", 4979 "Seychellois rupee1.00", 4980 "Seychellois rupees1.00", 4981 "Sierra Leonean Leone1.00", 4982 "Sierra Leonean leone1.00", 4983 "Sierra Leonean leones1.00", 4984 "Silver1.00", 4985 "Silver1.00", 4986 "Singapore Dollar1.00", 4987 "Singapore dollar1.00", 4988 "Singapore dollars1.00", 4989 "Slovak Koruna1.00", 4990 "Slovak koruna1.00", 4991 "Slovak korunas1.00", 4992 "Slovenian Tolar1.00", 4993 "Slovenian tolar1.00", 4994 "Slovenian tolars1.00", 4995 "Solomon Islands Dollar1.00", 4996 "Solomon Islands dollar1.00", 4997 "Solomon Islands dollars1.00", 4998 "Somali Shilling1.00", 4999 "Somali shilling1.00", 5000 "Somali shillings1.00", 5001 "South African Rand (financial)1.00", 5002 "South African Rand1.00", 5003 "South African rand (financial)1.00", 5004 "South African rand1.00", 5005 "South African rands (financial)1.00", 5006 "South African rand1.00", 5007 "South Korean Won1.00", 5008 "South Korean won1.00", 5009 "South Korean won1.00", 5010 "Soviet Rouble1.00", 5011 "Soviet rouble1.00", 5012 "Soviet roubles1.00", 5013 "Spanish Peseta (A account)1.00", 5014 "Spanish Peseta (convertible account)1.00", 5015 "Spanish Peseta1.00", 5016 "Spanish peseta (A account)1.00", 5017 "Spanish peseta (convertible account)1.00", 5018 "Spanish peseta1.00", 5019 "Spanish pesetas (A account)1.00", 5020 "Spanish pesetas (convertible account)1.00", 5021 "Spanish pesetas1.00", 5022 "Special Drawing Rights1.00", 5023 "Sri Lankan Rupee1.00", 5024 "Sri Lankan rupee1.00", 5025 "Sri Lankan rupees1.00", 5026 "Sudanese Pound1.00", 5027 "Sudanese pound1.00", 5028 "Sudanese pounds1.00", 5029 "Surinamese Dollar1.00", 5030 "Surinamese dollar1.00", 5031 "Surinamese dollars1.00", 5032 "Surinamese Guilder1.00", 5033 "Surinamese guilder1.00", 5034 "Surinamese guilders1.00", 5035 "Swazi Lilangeni1.00", 5036 "Swazi lilangeni1.00", 5037 "Swazi emalangeni1.00", 5038 "Swedish Krona1.00", 5039 "Swedish krona1.00", 5040 "Swedish kronor1.00", 5041 "Swiss Franc1.00", 5042 "Swiss franc1.00", 5043 "Swiss francs1.00", 5044 "Syrian Pound1.00", 5045 "Syrian pound1.00", 5046 "Syrian pounds1.00", 5047 "THB1.00", 5048 "TJR1.00", 5049 "TJR1.00", 5050 "TJS1.00", 5051 "TJS1.00", 5052 "TMM1.00", 5053 "TMM1.00", 5054 "TND1.00", 5055 "TND1.00", 5056 "TOP1.00", 5057 "TPE1.00", 5058 "TPE1.00", 5059 "TRL1.00", 5060 "TRY1.00", 5061 "TRY1.00", 5062 "TTD1.00", 5063 "TWD1.00", 5064 "TZS1.00", 5065 "New Taiwan Dollar1.00", 5066 "New Taiwan dollar1.00", 5067 "New Taiwan dollars1.00", 5068 "Tajikistani Ruble1.00", 5069 "Tajikistani Somoni1.00", 5070 "Tajikistani ruble1.00", 5071 "Tajikistani rubles1.00", 5072 "Tajikistani somoni1.00", 5073 "Tajikistani somonis1.00", 5074 "Tanzanian Shilling1.00", 5075 "Tanzanian shilling1.00", 5076 "Tanzanian shillings1.00", 5077 "Testing Currency Code1.00", 5078 "Testing Currency Code1.00", 5079 "Thai Baht1.00", 5080 "Thai baht1.00", 5081 "Thai baht1.00", 5082 "Timorese Escudo1.00", 5083 "Timorese escudo1.00", 5084 "Timorese escudos1.00", 5085 "Tongan Pa\\u02bbanga1.00", 5086 "Tongan pa\\u02bbanga1.00", 5087 "Tongan pa\\u02bbanga1.00", 5088 "Trinidad & Tobago Dollar1.00", 5089 "Trinidad & Tobago dollar1.00", 5090 "Trinidad & Tobago dollars1.00", 5091 "Tunisian Dinar1.00", 5092 "Tunisian dinar1.00", 5093 "Tunisian dinars1.00", 5094 "Turkish Lira1.00", 5095 "Turkish Lira1.00", 5096 "Turkish lira1.00", 5097 "Turkmenistani Manat1.00", 5098 "Turkmenistani manat1.00", 5099 "Turkmenistani manat1.00", 5100 "UAE dirham1.00", 5101 "UAE dirhams1.00", 5102 "UAH1.00", 5103 "UAK1.00", 5104 "UAK1.00", 5105 "UGS1.00", 5106 "UGS1.00", 5107 "UGX1.00", 5108 "US Dollar (Next day)1.00", 5109 "US Dollar (Same day)1.00", 5110 "US Dollar1.00", 5111 "US dollar (next day)1.00", 5112 "US dollar (same day)1.00", 5113 "US dollar1.00", 5114 "US dollars (next day)1.00", 5115 "US dollars (same day)1.00", 5116 "US dollars1.00", 5117 "USD1.00", 5118 "USN1.00", 5119 "USN1.00", 5120 "USS1.00", 5121 "USS1.00", 5122 "UYI1.00", 5123 "UYI1.00", 5124 "UYP1.00", 5125 "UYP1.00", 5126 "UYU1.00", 5127 "UZS1.00", 5128 "UZS1.00", 5129 "Ugandan Shilling (1966\\u20131987)1.00", 5130 "Ugandan Shilling1.00", 5131 "Ugandan shilling (1966\\u20131987)1.00", 5132 "Ugandan shilling1.00", 5133 "Ugandan shillings (1966\\u20131987)1.00", 5134 "Ugandan shillings1.00", 5135 "Ukrainian Hryvnia1.00", 5136 "Ukrainian Karbovanets1.00", 5137 "Ukrainian hryvnia1.00", 5138 "Ukrainian hryvnias1.00", 5139 "Ukrainian karbovanets1.00", 5140 "Ukrainian karbovantsiv1.00", 5141 "Colombian Real Value Unit1.00", 5142 "United Arab Emirates Dirham1.00", 5143 "Unknown Currency1.00", 5144 "Uruguayan Peso (1975\\u20131993)1.00", 5145 "Uruguayan Peso1.00", 5146 "Uruguayan Peso (Indexed Units)1.00", 5147 "Uruguayan peso (1975\\u20131993)1.00", 5148 "Uruguayan peso (indexed units)1.00", 5149 "Uruguayan peso1.00", 5150 "Uruguayan pesos (1975\\u20131993)1.00", 5151 "Uruguayan pesos (indexed units)1.00", 5152 "Uruguayan pesos1.00", 5153 "Uzbekistani Som1.00", 5154 "Uzbekistani som1.00", 5155 "Uzbekistani som1.00", 5156 "VEB1.00", 5157 "VEF1.00", 5158 "VND1.00", 5159 "VUV1.00", 5160 "Vanuatu Vatu1.00", 5161 "Vanuatu vatu1.00", 5162 "Vanuatu vatus1.00", 5163 "Venezuelan Bol\\u00edvar1.00", 5164 "Venezuelan Bol\\u00edvar (1871\\u20132008)1.00", 5165 "Venezuelan bol\\u00edvar1.00", 5166 "Venezuelan bol\\u00edvars1.00", 5167 "Venezuelan bol\\u00edvar (1871\\u20132008)1.00", 5168 "Venezuelan bol\\u00edvars (1871\\u20132008)1.00", 5169 "Vietnamese Dong1.00", 5170 "Vietnamese dong1.00", 5171 "Vietnamese dong1.00", 5172 "WIR Euro1.00", 5173 "WIR Franc1.00", 5174 "WIR euro1.00", 5175 "WIR euros1.00", 5176 "WIR franc1.00", 5177 "WIR francs1.00", 5178 "WST1.00", 5179 "WST1.00", 5180 "Samoan Tala1.00", 5181 "Samoan tala1.00", 5182 "Samoan tala1.00", 5183 "XAF1.00", 5184 "XAF1.00", 5185 "XAG1.00", 5186 "XAG1.00", 5187 "XAU1.00", 5188 "XAU1.00", 5189 "XBA1.00", 5190 "XBA1.00", 5191 "XBB1.00", 5192 "XBB1.00", 5193 "XBC1.00", 5194 "XBC1.00", 5195 "XBD1.00", 5196 "XBD1.00", 5197 "XCD1.00", 5198 "XDR1.00", 5199 "XDR1.00", 5200 "XEU1.00", 5201 "XEU1.00", 5202 "XFO1.00", 5203 "XFO1.00", 5204 "XFU1.00", 5205 "XFU1.00", 5206 "XOF1.00", 5207 "XOF1.00", 5208 "XPD1.00", 5209 "XPD1.00", 5210 "XPF1.00", 5211 "XPT1.00", 5212 "XPT1.00", 5213 "XRE1.00", 5214 "XRE1.00", 5215 "XTS1.00", 5216 "XTS1.00", 5217 "XXX1.00", 5218 "XXX1.00", 5219 "YDD1.00", 5220 "YDD1.00", 5221 "YER1.00", 5222 "YUD1.00", 5223 "YUD1.00", 5224 "YUM1.00", 5225 "YUM1.00", 5226 "YUN1.00", 5227 "YUN1.00", 5228 "Yemeni Dinar1.00", 5229 "Yemeni Rial1.00", 5230 "Yemeni dinar1.00", 5231 "Yemeni dinars1.00", 5232 "Yemeni rial1.00", 5233 "Yemeni rials1.00", 5234 "Yugoslavian Convertible Dinar (1990\\u20131992)1.00", 5235 "Yugoslavian Hard Dinar (1966\\u20131990)1.00", 5236 "Yugoslavian New Dinar (1994\\u20132002)1.00", 5237 "Yugoslavian convertible dinar (1990\\u20131992)1.00", 5238 "Yugoslavian convertible dinars (1990\\u20131992)1.00", 5239 "Yugoslavian hard dinar (1966\\u20131990)1.00", 5240 "Yugoslavian hard dinars (1966\\u20131990)1.00", 5241 "Yugoslavian new dinar (1994\\u20132002)1.00", 5242 "Yugoslavian new dinars (1994\\u20132002)1.00", 5243 "ZAL1.00", 5244 "ZAL1.00", 5245 "ZAR1.00", 5246 "ZMK1.00", 5247 "ZMK1.00", 5248 "ZRN1.00", 5249 "ZRN1.00", 5250 "ZRZ1.00", 5251 "ZRZ1.00", 5252 "ZWD1.00", 5253 "Zairean New Zaire (1993\\u20131998)1.00", 5254 "Zairean Zaire (1971\\u20131993)1.00", 5255 "Zairean new zaire (1993\\u20131998)1.00", 5256 "Zairean new zaires (1993\\u20131998)1.00", 5257 "Zairean zaire (1971\\u20131993)1.00", 5258 "Zairean zaires (1971\\u20131993)1.00", 5259 "Zambian Kwacha1.00", 5260 "Zambian kwacha1.00", 5261 "Zambian kwachas1.00", 5262 "Zimbabwean Dollar (1980\\u20132008)1.00", 5263 "Zimbabwean dollar (1980\\u20132008)1.00", 5264 "Zimbabwean dollars (1980\\u20132008)1.00", 5265 "euro1.00", 5266 "euros1.00", 5267 "Turkish lira (1922\\u20132005)1.00", 5268 "special drawing rights1.00", 5269 "Colombian real value unit1.00", 5270 "Colombian real value units1.00", 5271 "unknown currency1.00", 5272 "\\u00a31.00", 5273 "\\u00a51.00", 5274 "\\u20ab1.00", 5275 "\\u20aa1.00", 5276 "\\u20ac1.00", 5277 "\\u20b91.00", 5278 // 5279 // Following has extra text, should be parsed correctly too 5280 "$1.00 random", 5281 "USD1.00 random", 5282 "1.00 US dollar random", 5283 "1.00 US dollars random", 5284 "1.00 Afghan Afghani random", 5285 "1.00 Afghan Afghani random", 5286 "1.00 Afghan Afghanis (1927\\u20131992) random", 5287 "1.00 Afghan Afghanis random", 5288 "1.00 Albanian Lek random", 5289 "1.00 Albanian lek random", 5290 "1.00 Albanian lek\\u00eb random", 5291 "1.00 Algerian Dinar random", 5292 "1.00 Algerian dinar random", 5293 "1.00 Algerian dinars random", 5294 "1.00 Andorran Peseta random", 5295 "1.00 Andorran peseta random", 5296 "1.00 Andorran pesetas random", 5297 "1.00 Angolan Kwanza (1977\\u20131990) random", 5298 "1.00 Angolan Readjusted Kwanza (1995\\u20131999) random", 5299 "1.00 Angolan Kwanza random", 5300 "1.00 Angolan New Kwanza (1990\\u20132000) random", 5301 "1.00 Angolan kwanza (1977\\u20131991) random", 5302 "1.00 Angolan readjusted kwanza (1995\\u20131999) random", 5303 "1.00 Angolan kwanza random", 5304 "1.00 Angolan kwanzas (1977\\u20131991) random", 5305 "1.00 Angolan readjusted kwanzas (1995\\u20131999) random", 5306 "1.00 Angolan kwanzas random", 5307 "1.00 Angolan new kwanza (1990\\u20132000) random", 5308 "1.00 Angolan new kwanzas (1990\\u20132000) random", 5309 "1.00 Argentine Austral random", 5310 "1.00 Argentine Peso (1983\\u20131985) random", 5311 "1.00 Argentine Peso random", 5312 "1.00 Argentine austral random", 5313 "1.00 Argentine australs random", 5314 "1.00 Argentine peso (1983\\u20131985) random", 5315 "1.00 Argentine peso random", 5316 "1.00 Argentine pesos (1983\\u20131985) random", 5317 "1.00 Argentine pesos random", 5318 "1.00 Armenian Dram random", 5319 "1.00 Armenian dram random", 5320 "1.00 Armenian drams random", 5321 "1.00 Aruban Florin random", 5322 "1.00 Aruban florin random", 5323 "1.00 Australian Dollar random", 5324 "1.00 Australian dollar random", 5325 "1.00 Australian dollars random", 5326 "1.00 Austrian Schilling random", 5327 "1.00 Austrian schilling random", 5328 "1.00 Austrian schillings random", 5329 "1.00 Azerbaijani Manat (1993\\u20132006) random", 5330 "1.00 Azerbaijani Manat random", 5331 "1.00 Azerbaijani manat (1993\\u20132006) random", 5332 "1.00 Azerbaijani manat random", 5333 "1.00 Azerbaijani manats (1993\\u20132006) random", 5334 "1.00 Azerbaijani manats random", 5335 "1.00 Bahamian Dollar random", 5336 "1.00 Bahamian dollar random", 5337 "1.00 Bahamian dollars random", 5338 "1.00 Bahraini Dinar random", 5339 "1.00 Bahraini dinar random", 5340 "1.00 Bahraini dinars random", 5341 "1.00 Bangladeshi Taka random", 5342 "1.00 Bangladeshi taka random", 5343 "1.00 Bangladeshi takas random", 5344 "1.00 Barbadian Dollar random", 5345 "1.00 Barbadian dollar random", 5346 "1.00 Barbadian dollars random", 5347 "1.00 Belarusian Ruble (1994\\u20131999) random", 5348 "1.00 Belarusian Ruble random", 5349 "1.00 Belarusian ruble (1994\\u20131999) random", 5350 "1.00 Belarusian rubles (1994\\u20131999) random", 5351 "1.00 Belarusian ruble random", 5352 "1.00 Belarusian rubles random", 5353 "1.00 Belgian Franc (convertible) random", 5354 "1.00 Belgian Franc (financial) random", 5355 "1.00 Belgian Franc random", 5356 "1.00 Belgian franc (convertible) random", 5357 "1.00 Belgian franc (financial) random", 5358 "1.00 Belgian franc random", 5359 "1.00 Belgian francs (convertible) random", 5360 "1.00 Belgian francs (financial) random", 5361 "1.00 Belgian francs random", 5362 "1.00 Belize Dollar random", 5363 "1.00 Belize dollar random", 5364 "1.00 Belize dollars random", 5365 "1.00 Bermudan Dollar random", 5366 "1.00 Bermudan dollar random", 5367 "1.00 Bermudan dollars random", 5368 "1.00 Bhutanese Ngultrum random", 5369 "1.00 Bhutanese ngultrum random", 5370 "1.00 Bhutanese ngultrums random", 5371 "1.00 Bolivian Mvdol random", 5372 "1.00 Bolivian Peso random", 5373 "1.00 Bolivian mvdol random", 5374 "1.00 Bolivian mvdols random", 5375 "1.00 Bolivian peso random", 5376 "1.00 Bolivian pesos random", 5377 "1.00 Bolivian Boliviano random", 5378 "1.00 Bolivian Boliviano random", 5379 "1.00 Bolivian Bolivianos random", 5380 "1.00 Bosnia-Herzegovina Convertible Mark random", 5381 "1.00 Bosnia-Herzegovina Dinar (1992\\u20131994) random", 5382 "1.00 Bosnia-Herzegovina convertible mark random", 5383 "1.00 Bosnia-Herzegovina convertible marks random", 5384 "1.00 Bosnia-Herzegovina dinar (1992\\u20131994) random", 5385 "1.00 Bosnia-Herzegovina dinars (1992\\u20131994) random", 5386 "1.00 Botswanan Pula random", 5387 "1.00 Botswanan pula random", 5388 "1.00 Botswanan pulas random", 5389 "1.00 Brazilian New Cruzado (1989\\u20131990) random", 5390 "1.00 Brazilian Cruzado (1986\\u20131989) random", 5391 "1.00 Brazilian Cruzeiro (1990\\u20131993) random", 5392 "1.00 Brazilian New Cruzeiro (1967\\u20131986) random", 5393 "1.00 Brazilian Cruzeiro (1993\\u20131994) random", 5394 "1.00 Brazilian Real random", 5395 "1.00 Brazilian new cruzado (1989\\u20131990) random", 5396 "1.00 Brazilian new cruzados (1989\\u20131990) random", 5397 "1.00 Brazilian cruzado (1986\\u20131989) random", 5398 "1.00 Brazilian cruzados (1986\\u20131989) random", 5399 "1.00 Brazilian cruzeiro (1990\\u20131993) random", 5400 "1.00 Brazilian new cruzeiro (1967\\u20131986) random", 5401 "1.00 Brazilian cruzeiro (1993\\u20131994) random", 5402 "1.00 Brazilian cruzeiros (1990\\u20131993) random", 5403 "1.00 Brazilian new cruzeiros (1967\\u20131986) random", 5404 "1.00 Brazilian cruzeiros (1993\\u20131994) random", 5405 "1.00 Brazilian real random", 5406 "1.00 Brazilian reals random", 5407 "1.00 British Pound random", 5408 "1.00 British pound random", 5409 "1.00 British pounds random", 5410 "1.00 Brunei Dollar random", 5411 "1.00 Brunei dollar random", 5412 "1.00 Brunei dollars random", 5413 "1.00 Bulgarian Hard Lev random", 5414 "1.00 Bulgarian Lev random", 5415 "1.00 Bulgarian Leva random", 5416 "1.00 Bulgarian hard lev random", 5417 "1.00 Bulgarian hard leva random", 5418 "1.00 Bulgarian lev random", 5419 "1.00 Burmese Kyat random", 5420 "1.00 Burmese kyat random", 5421 "1.00 Burmese kyats random", 5422 "1.00 Burundian Franc random", 5423 "1.00 Burundian franc random", 5424 "1.00 Burundian francs random", 5425 "1.00 Cambodian Riel random", 5426 "1.00 Cambodian riel random", 5427 "1.00 Cambodian riels random", 5428 "1.00 Canadian Dollar random", 5429 "1.00 Canadian dollar random", 5430 "1.00 Canadian dollars random", 5431 "1.00 Cape Verdean Escudo random", 5432 "1.00 Cape Verdean escudo random", 5433 "1.00 Cape Verdean escudos random", 5434 "1.00 Cayman Islands Dollar random", 5435 "1.00 Cayman Islands dollar random", 5436 "1.00 Cayman Islands dollars random", 5437 "1.00 Chilean Peso random", 5438 "1.00 Chilean Unit of Account (UF) random", 5439 "1.00 Chilean peso random", 5440 "1.00 Chilean pesos random", 5441 "1.00 Chilean unit of account (UF) random", 5442 "1.00 Chilean units of account (UF) random", 5443 "1.00 Chinese Yuan random", 5444 "1.00 Chinese yuan random", 5445 "1.00 Colombian Peso random", 5446 "1.00 Colombian peso random", 5447 "1.00 Colombian pesos random", 5448 "1.00 Comorian Franc random", 5449 "1.00 Comorian franc random", 5450 "1.00 Comorian francs random", 5451 "1.00 Congolese Franc Congolais random", 5452 "1.00 Congolese franc Congolais random", 5453 "1.00 Congolese francs Congolais random", 5454 "1.00 Costa Rican Col\\u00f3n random", 5455 "1.00 Costa Rican col\\u00f3n random", 5456 "1.00 Costa Rican col\\u00f3ns random", 5457 "1.00 Croatian Dinar random", 5458 "1.00 Croatian Kuna random", 5459 "1.00 Croatian dinar random", 5460 "1.00 Croatian dinars random", 5461 "1.00 Croatian kuna random", 5462 "1.00 Croatian kunas random", 5463 "1.00 Cuban Peso random", 5464 "1.00 Cuban peso random", 5465 "1.00 Cuban pesos random", 5466 "1.00 Cypriot Pound random", 5467 "1.00 Cypriot pound random", 5468 "1.00 Cypriot pounds random", 5469 "1.00 Czech Republic Koruna random", 5470 "1.00 Czech Republic koruna random", 5471 "1.00 Czech Republic korunas random", 5472 "1.00 Czechoslovak Hard Koruna random", 5473 "1.00 Czechoslovak hard koruna random", 5474 "1.00 Czechoslovak hard korunas random", 5475 "1.00 Danish Krone random", 5476 "1.00 Danish krone random", 5477 "1.00 Danish kroner random", 5478 "1.00 German Mark random", 5479 "1.00 German mark random", 5480 "1.00 German marks random", 5481 "1.00 Djiboutian Franc random", 5482 "1.00 Djiboutian franc random", 5483 "1.00 Djiboutian francs random", 5484 "1.00 Dominican Peso random", 5485 "1.00 Dominican peso random", 5486 "1.00 Dominican pesos random", 5487 "1.00 East Caribbean Dollar random", 5488 "1.00 East Caribbean dollar random", 5489 "1.00 East Caribbean dollars random", 5490 "1.00 East German Mark random", 5491 "1.00 East German mark random", 5492 "1.00 East German marks random", 5493 "1.00 Ecuadorian Sucre random", 5494 "1.00 Ecuadorian Unit of Constant Value random", 5495 "1.00 Ecuadorian sucre random", 5496 "1.00 Ecuadorian sucres random", 5497 "1.00 Ecuadorian unit of constant value random", 5498 "1.00 Ecuadorian units of constant value random", 5499 "1.00 Egyptian Pound random", 5500 "1.00 Egyptian pound random", 5501 "1.00 Egyptian pounds random", 5502 "1.00 Salvadoran Col\\u00f3n random", 5503 "1.00 Salvadoran col\\u00f3n random", 5504 "1.00 Salvadoran colones random", 5505 "1.00 Equatorial Guinean Ekwele random", 5506 "1.00 Equatorial Guinean ekwele random", 5507 "1.00 Eritrean Nakfa random", 5508 "1.00 Eritrean nakfa random", 5509 "1.00 Eritrean nakfas random", 5510 "1.00 Estonian Kroon random", 5511 "1.00 Estonian kroon random", 5512 "1.00 Estonian kroons random", 5513 "1.00 Ethiopian Birr random", 5514 "1.00 Ethiopian birr random", 5515 "1.00 Ethiopian birrs random", 5516 "1.00 European Composite Unit random", 5517 "1.00 European Currency Unit random", 5518 "1.00 European Monetary Unit random", 5519 "1.00 European Unit of Account (XBC) random", 5520 "1.00 European Unit of Account (XBD) random", 5521 "1.00 European composite unit random", 5522 "1.00 European composite units random", 5523 "1.00 European currency unit random", 5524 "1.00 European currency units random", 5525 "1.00 European monetary unit random", 5526 "1.00 European monetary units random", 5527 "1.00 European unit of account (XBC) random", 5528 "1.00 European unit of account (XBD) random", 5529 "1.00 European units of account (XBC) random", 5530 "1.00 European units of account (XBD) random", 5531 "1.00 Falkland Islands Pound random", 5532 "1.00 Falkland Islands pound random", 5533 "1.00 Falkland Islands pounds random", 5534 "1.00 Fijian Dollar random", 5535 "1.00 Fijian dollar random", 5536 "1.00 Fijian dollars random", 5537 "1.00 Finnish Markka random", 5538 "1.00 Finnish markka random", 5539 "1.00 Finnish markkas random", 5540 "1.00 French Franc random", 5541 "1.00 French Gold Franc random", 5542 "1.00 French UIC-Franc random", 5543 "1.00 French UIC-franc random", 5544 "1.00 French UIC-francs random", 5545 "1.00 French franc random", 5546 "1.00 French francs random", 5547 "1.00 French gold franc random", 5548 "1.00 French gold francs random", 5549 "1.00 Gambian Dalasi random", 5550 "1.00 Gambian dalasi random", 5551 "1.00 Gambian dalasis random", 5552 "1.00 Georgian Kupon Larit random", 5553 "1.00 Georgian Lari random", 5554 "1.00 Georgian kupon larit random", 5555 "1.00 Georgian kupon larits random", 5556 "1.00 Georgian lari random", 5557 "1.00 Georgian laris random", 5558 "1.00 Ghanaian Cedi (1979\\u20132007) random", 5559 "1.00 Ghanaian Cedi random", 5560 "1.00 Ghanaian cedi (1979\\u20132007) random", 5561 "1.00 Ghanaian cedi random", 5562 "1.00 Ghanaian cedis (1979\\u20132007) random", 5563 "1.00 Ghanaian cedis random", 5564 "1.00 Gibraltar Pound random", 5565 "1.00 Gibraltar pound random", 5566 "1.00 Gibraltar pounds random", 5567 "1.00 Gold random", 5568 "1.00 Gold random", 5569 "1.00 Greek Drachma random", 5570 "1.00 Greek drachma random", 5571 "1.00 Greek drachmas random", 5572 "1.00 Guatemalan Quetzal random", 5573 "1.00 Guatemalan quetzal random", 5574 "1.00 Guatemalan quetzals random", 5575 "1.00 Guinean Franc random", 5576 "1.00 Guinean Syli random", 5577 "1.00 Guinean franc random", 5578 "1.00 Guinean francs random", 5579 "1.00 Guinean syli random", 5580 "1.00 Guinean sylis random", 5581 "1.00 Guinea-Bissau Peso random", 5582 "1.00 Guinea-Bissau peso random", 5583 "1.00 Guinea-Bissau pesos random", 5584 "1.00 Guyanaese Dollar random", 5585 "1.00 Guyanaese dollar random", 5586 "1.00 Guyanaese dollars random", 5587 "1.00 Haitian Gourde random", 5588 "1.00 Haitian gourde random", 5589 "1.00 Haitian gourdes random", 5590 "1.00 Honduran Lempira random", 5591 "1.00 Honduran lempira random", 5592 "1.00 Honduran lempiras random", 5593 "1.00 Hong Kong Dollar random", 5594 "1.00 Hong Kong dollar random", 5595 "1.00 Hong Kong dollars random", 5596 "1.00 Hungarian Forint random", 5597 "1.00 Hungarian forint random", 5598 "1.00 Hungarian forints random", 5599 "1.00 Icelandic Kr\\u00f3na random", 5600 "1.00 Icelandic kr\\u00f3na random", 5601 "1.00 Icelandic kr\\u00f3nur random", 5602 "1.00 Indian Rupee random", 5603 "1.00 Indian rupee random", 5604 "1.00 Indian rupees random", 5605 "1.00 Indonesian Rupiah random", 5606 "1.00 Indonesian rupiah random", 5607 "1.00 Indonesian rupiahs random", 5608 "1.00 Iranian Rial random", 5609 "1.00 Iranian rial random", 5610 "1.00 Iranian rials random", 5611 "1.00 Iraqi Dinar random", 5612 "1.00 Iraqi dinar random", 5613 "1.00 Iraqi dinars random", 5614 "1.00 Irish Pound random", 5615 "1.00 Irish pound random", 5616 "1.00 Irish pounds random", 5617 "1.00 Israeli Pound random", 5618 "1.00 Israeli new shekel random", 5619 "1.00 Israeli pound random", 5620 "1.00 Israeli pounds random", 5621 "1.00 Italian Lira random", 5622 "1.00 Italian lira random", 5623 "1.00 Italian liras random", 5624 "1.00 Jamaican Dollar random", 5625 "1.00 Jamaican dollar random", 5626 "1.00 Jamaican dollars random", 5627 "1.00 Japanese Yen random", 5628 "1.00 Japanese yen random", 5629 "1.00 Jordanian Dinar random", 5630 "1.00 Jordanian dinar random", 5631 "1.00 Jordanian dinars random", 5632 "1.00 Kazakhstani Tenge random", 5633 "1.00 Kazakhstani tenge random", 5634 "1.00 Kazakhstani tenges random", 5635 "1.00 Kenyan Shilling random", 5636 "1.00 Kenyan shilling random", 5637 "1.00 Kenyan shillings random", 5638 "1.00 Kuwaiti Dinar random", 5639 "1.00 Kuwaiti dinar random", 5640 "1.00 Kuwaiti dinars random", 5641 "1.00 Kyrgystani Som random", 5642 "1.00 Kyrgystani som random", 5643 "1.00 Kyrgystani soms random", 5644 "1.00 Laotian Kip random", 5645 "1.00 Laotian kip random", 5646 "1.00 Laotian kips random", 5647 "1.00 Latvian Lats random", 5648 "1.00 Latvian Ruble random", 5649 "1.00 Latvian lats random", 5650 "1.00 Latvian lati random", 5651 "1.00 Latvian ruble random", 5652 "1.00 Latvian rubles random", 5653 "1.00 Lebanese Pound random", 5654 "1.00 Lebanese pound random", 5655 "1.00 Lebanese pounds random", 5656 "1.00 Lesotho Loti random", 5657 "1.00 Lesotho loti random", 5658 "1.00 Lesotho lotis random", 5659 "1.00 Liberian Dollar random", 5660 "1.00 Liberian dollar random", 5661 "1.00 Liberian dollars random", 5662 "1.00 Libyan Dinar random", 5663 "1.00 Libyan dinar random", 5664 "1.00 Libyan dinars random", 5665 "1.00 Lithuanian Litas random", 5666 "1.00 Lithuanian Talonas random", 5667 "1.00 Lithuanian litas random", 5668 "1.00 Lithuanian litai random", 5669 "1.00 Lithuanian talonas random", 5670 "1.00 Lithuanian talonases random", 5671 "1.00 Luxembourgian Convertible Franc random", 5672 "1.00 Luxembourg Financial Franc random", 5673 "1.00 Luxembourgian Franc random", 5674 "1.00 Luxembourgian convertible franc random", 5675 "1.00 Luxembourgian convertible francs random", 5676 "1.00 Luxembourg financial franc random", 5677 "1.00 Luxembourg financial francs random", 5678 "1.00 Luxembourgian franc random", 5679 "1.00 Luxembourgian francs random", 5680 "1.00 Macanese Pataca random", 5681 "1.00 Macanese pataca random", 5682 "1.00 Macanese patacas random", 5683 "1.00 Macedonian Denar random", 5684 "1.00 Macedonian denar random", 5685 "1.00 Macedonian denari random", 5686 "1.00 Malagasy Ariaries random", 5687 "1.00 Malagasy Ariary random", 5688 "1.00 Malagasy Ariary random", 5689 "1.00 Malagasy Franc random", 5690 "1.00 Malagasy franc random", 5691 "1.00 Malagasy francs random", 5692 "1.00 Malawian Kwacha random", 5693 "1.00 Malawian Kwacha random", 5694 "1.00 Malawian Kwachas random", 5695 "1.00 Malaysian Ringgit random", 5696 "1.00 Malaysian ringgit random", 5697 "1.00 Malaysian ringgits random", 5698 "1.00 Maldivian Rufiyaa random", 5699 "1.00 Maldivian rufiyaa random", 5700 "1.00 Maldivian rufiyaas random", 5701 "1.00 Malian Franc random", 5702 "1.00 Malian franc random", 5703 "1.00 Malian francs random", 5704 "1.00 Maltese Lira random", 5705 "1.00 Maltese Pound random", 5706 "1.00 Maltese lira random", 5707 "1.00 Maltese liras random", 5708 "1.00 Maltese pound random", 5709 "1.00 Maltese pounds random", 5710 "1.00 Mauritanian Ouguiya random", 5711 "1.00 Mauritanian ouguiya random", 5712 "1.00 Mauritanian ouguiyas random", 5713 "1.00 Mauritian Rupee random", 5714 "1.00 Mauritian rupee random", 5715 "1.00 Mauritian rupees random", 5716 "1.00 Mexican Peso random", 5717 "1.00 Mexican Silver Peso (1861\\u20131992) random", 5718 "1.00 Mexican Investment Unit random", 5719 "1.00 Mexican peso random", 5720 "1.00 Mexican pesos random", 5721 "1.00 Mexican silver peso (1861\\u20131992) random", 5722 "1.00 Mexican silver pesos (1861\\u20131992) random", 5723 "1.00 Mexican investment unit random", 5724 "1.00 Mexican investment units random", 5725 "1.00 Moldovan Leu random", 5726 "1.00 Moldovan leu random", 5727 "1.00 Moldovan lei random", 5728 "1.00 Mongolian Tugrik random", 5729 "1.00 Mongolian tugrik random", 5730 "1.00 Mongolian tugriks random", 5731 "1.00 Moroccan Dirham random", 5732 "1.00 Moroccan Franc random", 5733 "1.00 Moroccan dirham random", 5734 "1.00 Moroccan dirhams random", 5735 "1.00 Moroccan franc random", 5736 "1.00 Moroccan francs random", 5737 "1.00 Mozambican Escudo random", 5738 "1.00 Mozambican Metical random", 5739 "1.00 Mozambican escudo random", 5740 "1.00 Mozambican escudos random", 5741 "1.00 Mozambican metical random", 5742 "1.00 Mozambican meticals random", 5743 "1.00 Myanmar Kyat random", 5744 "1.00 Myanmar kyat random", 5745 "1.00 Myanmar kyats random", 5746 "1.00 Namibian Dollar random", 5747 "1.00 Namibian dollar random", 5748 "1.00 Namibian dollars random", 5749 "1.00 Nepalese Rupee random", 5750 "1.00 Nepalese rupee random", 5751 "1.00 Nepalese rupees random", 5752 "1.00 Netherlands Antillean Guilder random", 5753 "1.00 Netherlands Antillean guilder random", 5754 "1.00 Netherlands Antillean guilders random", 5755 "1.00 Dutch Guilder random", 5756 "1.00 Dutch guilder random", 5757 "1.00 Dutch guilders random", 5758 "1.00 Israeli New Shekel random", 5759 "1.00 Israeli new shekels random", 5760 "1.00 New Zealand Dollar random", 5761 "1.00 New Zealand dollar random", 5762 "1.00 New Zealand dollars random", 5763 "1.00 Nicaraguan C\\u00f3rdoba random", 5764 "1.00 Nicaraguan C\\u00f3rdoba (1988\\u20131991) random", 5765 "1.00 Nicaraguan c\\u00f3rdoba random", 5766 "1.00 Nicaraguan c\\u00f3rdoba random", 5767 "1.00 Nicaraguan c\\u00f3rdoba (1988\\u20131991) random", 5768 "1.00 Nicaraguan c\\u00f3rdobas (1988\\u20131991) random", 5769 "1.00 Nigerian Naira random", 5770 "1.00 Nigerian naira random", 5771 "1.00 Nigerian nairas random", 5772 "1.00 North Korean Won random", 5773 "1.00 North Korean won random", 5774 "1.00 North Korean won random", 5775 "1.00 Norwegian Krone random", 5776 "1.00 Norwegian krone random", 5777 "1.00 Norwegian kroner random", 5778 "1.00 Mozambican Metical (1980\\u20132006) random", 5779 "1.00 Mozambican metical (1980\\u20132006) random", 5780 "1.00 Mozambican meticals (1980\\u20132006) random", 5781 "1.00 Romanian Lei (1952\\u20132006) random", 5782 "1.00 Romanian Leu (1952\\u20132006) random", 5783 "1.00 Romanian leu (1952\\u20132006) random", 5784 "1.00 Serbian Dinar (2002\\u20132006) random", 5785 "1.00 Serbian dinar (2002\\u20132006) random", 5786 "1.00 Serbian dinars (2002\\u20132006) random", 5787 "1.00 Sudanese Dinar (1992\\u20132007) random", 5788 "1.00 Sudanese Pound (1957\\u20131998) random", 5789 "1.00 Sudanese dinar (1992\\u20132007) random", 5790 "1.00 Sudanese dinars (1992\\u20132007) random", 5791 "1.00 Sudanese pound (1957\\u20131998) random", 5792 "1.00 Sudanese pounds (1957\\u20131998) random", 5793 "1.00 Turkish Lira (1922\\u20132005) random", 5794 "1.00 Turkish Lira (1922\\u20132005) random", 5795 "1.00 Omani Rial random", 5796 "1.00 Omani rial random", 5797 "1.00 Omani rials random", 5798 "1.00 Pakistani Rupee random", 5799 "1.00 Pakistani rupee random", 5800 "1.00 Pakistani rupees random", 5801 "1.00 Palladium random", 5802 "1.00 Palladium random", 5803 "1.00 Panamanian Balboa random", 5804 "1.00 Panamanian balboa random", 5805 "1.00 Panamanian balboas random", 5806 "1.00 Papua New Guinean Kina random", 5807 "1.00 Papua New Guinean kina random", 5808 "1.00 Papua New Guinean kina random", 5809 "1.00 Paraguayan Guarani random", 5810 "1.00 Paraguayan guarani random", 5811 "1.00 Paraguayan guaranis random", 5812 "1.00 Peruvian Inti random", 5813 "1.00 Peruvian Sol random", 5814 "1.00 Peruvian Sol (1863\\u20131965) random", 5815 "1.00 Peruvian inti random", 5816 "1.00 Peruvian intis random", 5817 "1.00 Peruvian sol random", 5818 "1.00 Peruvian soles random", 5819 "1.00 Peruvian sol (1863\\u20131965) random", 5820 "1.00 Peruvian soles (1863\\u20131965) random", 5821 "1.00 Philippine Peso random", 5822 "1.00 Philippine peso random", 5823 "1.00 Philippine pesos random", 5824 "1.00 Platinum random", 5825 "1.00 Platinum random", 5826 "1.00 Polish Zloty (1950\\u20131995) random", 5827 "1.00 Polish Zloty random", 5828 "1.00 Polish zlotys random", 5829 "1.00 Polish zloty (PLZ) random", 5830 "1.00 Polish zloty random", 5831 "1.00 Polish zlotys (PLZ) random", 5832 "1.00 Portuguese Escudo random", 5833 "1.00 Portuguese Guinea Escudo random", 5834 "1.00 Portuguese Guinea escudo random", 5835 "1.00 Portuguese Guinea escudos random", 5836 "1.00 Portuguese escudo random", 5837 "1.00 Portuguese escudos random", 5838 "1.00 Qatari Rial random", 5839 "1.00 Qatari rial random", 5840 "1.00 Qatari rials random", 5841 "1.00 RINET Funds random", 5842 "1.00 RINET Funds random", 5843 "1.00 Rhodesian Dollar random", 5844 "1.00 Rhodesian dollar random", 5845 "1.00 Rhodesian dollars random", 5846 "1.00 Romanian Leu random", 5847 "1.00 Romanian lei random", 5848 "1.00 Romanian leu random", 5849 "1.00 Russian Ruble (1991\\u20131998) random", 5850 "1.00 Russian Ruble random", 5851 "1.00 Russian ruble (1991\\u20131998) random", 5852 "1.00 Russian ruble random", 5853 "1.00 Russian rubles (1991\\u20131998) random", 5854 "1.00 Russian rubles random", 5855 "1.00 Rwandan Franc random", 5856 "1.00 Rwandan franc random", 5857 "1.00 Rwandan francs random", 5858 "1.00 St. Helena Pound random", 5859 "1.00 St. Helena pound random", 5860 "1.00 St. Helena pounds random", 5861 "1.00 S\\u00e3o Tom\\u00e9 & Pr\\u00edncipe Dobra random", 5862 "1.00 S\\u00e3o Tom\\u00e9 & Pr\\u00edncipe dobra random", 5863 "1.00 S\\u00e3o Tom\\u00e9 & Pr\\u00edncipe dobras random", 5864 "1.00 Saudi Riyal random", 5865 "1.00 Saudi riyal random", 5866 "1.00 Saudi riyals random", 5867 "1.00 Serbian Dinar random", 5868 "1.00 Serbian dinar random", 5869 "1.00 Serbian dinars random", 5870 "1.00 Seychellois Rupee random", 5871 "1.00 Seychellois rupee random", 5872 "1.00 Seychellois rupees random", 5873 "1.00 Sierra Leonean Leone random", 5874 "1.00 Sierra Leonean leone random", 5875 "1.00 Sierra Leonean leones random", 5876 "1.00 Singapore Dollar random", 5877 "1.00 Singapore dollar random", 5878 "1.00 Singapore dollars random", 5879 "1.00 Slovak Koruna random", 5880 "1.00 Slovak koruna random", 5881 "1.00 Slovak korunas random", 5882 "1.00 Slovenian Tolar random", 5883 "1.00 Slovenian tolar random", 5884 "1.00 Slovenian tolars random", 5885 "1.00 Solomon Islands Dollar random", 5886 "1.00 Solomon Islands dollar random", 5887 "1.00 Solomon Islands dollars random", 5888 "1.00 Somali Shilling random", 5889 "1.00 Somali shilling random", 5890 "1.00 Somali shillings random", 5891 "1.00 South African Rand (financial) random", 5892 "1.00 South African Rand random", 5893 "1.00 South African rand (financial) random", 5894 "1.00 South African rand random", 5895 "1.00 South African rands (financial) random", 5896 "1.00 South African rand random", 5897 "1.00 South Korean Won random", 5898 "1.00 South Korean won random", 5899 "1.00 South Korean won random", 5900 "1.00 Soviet Rouble random", 5901 "1.00 Soviet rouble random", 5902 "1.00 Soviet roubles random", 5903 "1.00 Spanish Peseta (A account) random", 5904 "1.00 Spanish Peseta (convertible account) random", 5905 "1.00 Spanish Peseta random", 5906 "1.00 Spanish peseta (A account) random", 5907 "1.00 Spanish peseta (convertible account) random", 5908 "1.00 Spanish peseta random", 5909 "1.00 Spanish pesetas (A account) random", 5910 "1.00 Spanish pesetas (convertible account) random", 5911 "1.00 Spanish pesetas random", 5912 "1.00 Special Drawing Rights random", 5913 "1.00 Sri Lankan Rupee random", 5914 "1.00 Sri Lankan rupee random", 5915 "1.00 Sri Lankan rupees random", 5916 "1.00 Sudanese Pound random", 5917 "1.00 Sudanese pound random", 5918 "1.00 Sudanese pounds random", 5919 "1.00 Surinamese Dollar random", 5920 "1.00 Surinamese dollar random", 5921 "1.00 Surinamese dollars random", 5922 "1.00 Surinamese Guilder random", 5923 "1.00 Surinamese guilder random", 5924 "1.00 Surinamese guilders random", 5925 "1.00 Swazi Lilangeni random", 5926 "1.00 Swazi lilangeni random", 5927 "1.00 Swazi emalangeni random", 5928 "1.00 Swedish Krona random", 5929 "1.00 Swedish krona random", 5930 "1.00 Swedish kronor random", 5931 "1.00 Swiss Franc random", 5932 "1.00 Swiss franc random", 5933 "1.00 Swiss francs random", 5934 "1.00 Syrian Pound random", 5935 "1.00 Syrian pound random", 5936 "1.00 Syrian pounds random", 5937 "1.00 New Taiwan Dollar random", 5938 "1.00 New Taiwan dollar random", 5939 "1.00 New Taiwan dollars random", 5940 "1.00 Tajikistani Ruble random", 5941 "1.00 Tajikistani Somoni random", 5942 "1.00 Tajikistani ruble random", 5943 "1.00 Tajikistani rubles random", 5944 "1.00 Tajikistani somoni random", 5945 "1.00 Tajikistani somonis random", 5946 "1.00 Tanzanian Shilling random", 5947 "1.00 Tanzanian shilling random", 5948 "1.00 Tanzanian shillings random", 5949 "1.00 Testing Currency Code random", 5950 "1.00 Testing Currency Code random", 5951 "1.00 Thai Baht random", 5952 "1.00 Thai baht random", 5953 "1.00 Thai baht random", 5954 "1.00 Timorese Escudo random", 5955 "1.00 Timorese escudo random", 5956 "1.00 Timorese escudos random", 5957 "1.00 Trinidad & Tobago Dollar random", 5958 "1.00 Trinidad & Tobago dollar random", 5959 "1.00 Trinidad & Tobago dollars random", 5960 "1.00 Tunisian Dinar random", 5961 "1.00 Tunisian dinar random", 5962 "1.00 Tunisian dinars random", 5963 "1.00 Turkish Lira random", 5964 "1.00 Turkish Lira random", 5965 "1.00 Turkish lira random", 5966 "1.00 Turkmenistani Manat random", 5967 "1.00 Turkmenistani manat random", 5968 "1.00 Turkmenistani manat random", 5969 "1.00 US Dollar (Next day) random", 5970 "1.00 US Dollar (Same day) random", 5971 "1.00 US Dollar random", 5972 "1.00 US dollar (next day) random", 5973 "1.00 US dollar (same day) random", 5974 "1.00 US dollar random", 5975 "1.00 US dollars (next day) random", 5976 "1.00 US dollars (same day) random", 5977 "1.00 US dollars random", 5978 "1.00 Ugandan Shilling (1966\\u20131987) random", 5979 "1.00 Ugandan Shilling random", 5980 "1.00 Ugandan shilling (1966\\u20131987) random", 5981 "1.00 Ugandan shilling random", 5982 "1.00 Ugandan shillings (1966\\u20131987) random", 5983 "1.00 Ugandan shillings random", 5984 "1.00 Ukrainian Hryvnia random", 5985 "1.00 Ukrainian Karbovanets random", 5986 "1.00 Ukrainian hryvnia random", 5987 "1.00 Ukrainian hryvnias random", 5988 "1.00 Ukrainian karbovanets random", 5989 "1.00 Ukrainian karbovantsiv random", 5990 "1.00 Colombian Real Value Unit random", 5991 "1.00 United Arab Emirates Dirham random", 5992 "1.00 Unknown Currency random", 5993 "1.00 Uruguayan Peso (1975\\u20131993) random", 5994 "1.00 Uruguayan Peso random", 5995 "1.00 Uruguayan Peso (Indexed Units) random", 5996 "1.00 Uruguayan peso (1975\\u20131993) random", 5997 "1.00 Uruguayan peso (indexed units) random", 5998 "1.00 Uruguayan peso random", 5999 "1.00 Uruguayan pesos (1975\\u20131993) random", 6000 "1.00 Uruguayan pesos (indexed units) random", 6001 "1.00 Uzbekistani Som random", 6002 "1.00 Uzbekistani som random", 6003 "1.00 Uzbekistani som random", 6004 "1.00 Vanuatu Vatu random", 6005 "1.00 Vanuatu vatu random", 6006 "1.00 Vanuatu vatus random", 6007 "1.00 Venezuelan Bol\\u00edvar random", 6008 "1.00 Venezuelan Bol\\u00edvar (1871\\u20132008) random", 6009 "1.00 Venezuelan bol\\u00edvar random", 6010 "1.00 Venezuelan bol\\u00edvars random", 6011 "1.00 Venezuelan bol\\u00edvar (1871\\u20132008) random", 6012 "1.00 Venezuelan bol\\u00edvars (1871\\u20132008) random", 6013 "1.00 Vietnamese Dong random", 6014 "1.00 Vietnamese dong random", 6015 "1.00 Vietnamese dong random", 6016 "1.00 WIR Euro random", 6017 "1.00 WIR Franc random", 6018 "1.00 WIR euro random", 6019 "1.00 WIR euros random", 6020 "1.00 WIR franc random", 6021 "1.00 WIR francs random", 6022 "1.00 Samoan Tala random", 6023 "1.00 Samoan tala random", 6024 "1.00 Samoan tala random", 6025 "1.00 Yemeni Dinar random", 6026 "1.00 Yemeni Rial random", 6027 "1.00 Yemeni dinar random", 6028 "1.00 Yemeni dinars random", 6029 "1.00 Yemeni rial random", 6030 "1.00 Yemeni rials random", 6031 "1.00 Yugoslavian Convertible Dinar (1990\\u20131992) random", 6032 "1.00 Yugoslavian Hard Dinar (1966\\u20131990) random", 6033 "1.00 Yugoslavian New Dinar (1994\\u20132002) random", 6034 "1.00 Yugoslavian convertible dinar (1990\\u20131992) random", 6035 "1.00 Yugoslavian convertible dinars (1990\\u20131992) random", 6036 "1.00 Yugoslavian hard dinar (1966\\u20131990) random", 6037 "1.00 Yugoslavian hard dinars (1966\\u20131990) random", 6038 "1.00 Yugoslavian new dinar (1994\\u20132002) random", 6039 "1.00 Yugoslavian new dinars (1994\\u20132002) random", 6040 "1.00 Zairean New Zaire (1993\\u20131998) random", 6041 "1.00 Zairean Zaire (1971\\u20131993) random", 6042 "1.00 Zairean new zaire (1993\\u20131998) random", 6043 "1.00 Zairean new zaires (1993\\u20131998) random", 6044 "1.00 Zairean zaire (1971\\u20131993) random", 6045 "1.00 Zairean zaires (1971\\u20131993) random", 6046 "1.00 Zambian Kwacha random", 6047 "1.00 Zambian kwacha random", 6048 "1.00 Zambian kwachas random", 6049 "1.00 Zimbabwean Dollar (1980\\u20132008) random", 6050 "1.00 Zimbabwean dollar (1980\\u20132008) random", 6051 "1.00 Zimbabwean dollars (1980\\u20132008) random", 6052 "1.00 euro random", 6053 "1.00 euros random", 6054 "1.00 Turkish lira (1922\\u20132005) random", 6055 "1.00 special drawing rights random", 6056 "1.00 Colombian real value unit random", 6057 "1.00 Colombian real value units random", 6058 "1.00 unknown currency random", 6059 }; 6060 6061 const char* WRONG_DATA[] = { 6062 // Following are missing one last char in the currency name 6063 "usd1.00", // case sensitive 6064 "1.00 Nicaraguan Cordob", 6065 "1.00 Namibian Dolla", 6066 "1.00 Namibian dolla", 6067 "1.00 Nepalese Rupe", 6068 "1.00 Nepalese rupe", 6069 "1.00 Netherlands Antillean Guilde", 6070 "1.00 Netherlands Antillean guilde", 6071 "1.00 Dutch Guilde", 6072 "1.00 Dutch guilde", 6073 "1.00 Israeli New Sheqe", 6074 "1.00 New Zealand Dolla", 6075 "1.00 New Zealand dolla", 6076 "1.00 Nicaraguan cordob", 6077 "1.00 Nigerian Nair", 6078 "1.00 Nigerian nair", 6079 "1.00 North Korean Wo", 6080 "1.00 North Korean wo", 6081 "1.00 Norwegian Kron", 6082 "1.00 Norwegian kron", 6083 "1.00 US dolla", 6084 "1.00", 6085 "A1.00", 6086 "AD1.00", 6087 "AE1.00", 6088 "AF1.00", 6089 "AL1.00", 6090 "AM1.00", 6091 "AN1.00", 6092 "AO1.00", 6093 "AR1.00", 6094 "AT1.00", 6095 "AU1.00", 6096 "AW1.00", 6097 "AZ1.00", 6098 "Afghan Afghan1.00", 6099 "Afghan Afghani (1927\\u201320021.00", 6100 "Afl1.00", 6101 "Albanian Le1.00", 6102 "Algerian Dina1.00", 6103 "Andorran Peset1.00", 6104 "Angolan Kwanz1.00", 6105 "Angolan Kwanza (1977\\u201319901.00", 6106 "Angolan Readjusted Kwanza (1995\\u201319991.00", 6107 "Angolan New Kwanza (1990\\u201320001.00", 6108 "Argentine Austra1.00", 6109 "Argentine Pes1.00", 6110 "Argentine Peso (1983\\u201319851.00", 6111 "Armenian Dra1.00", 6112 "Aruban Flori1.00", 6113 "Australian Dolla1.00", 6114 "Austrian Schillin1.00", 6115 "Azerbaijani Mana1.00", 6116 "Azerbaijani Manat (1993\\u201320061.00", 6117 "B1.00", 6118 "BA1.00", 6119 "BB1.00", 6120 "BE1.00", 6121 "BG1.00", 6122 "BH1.00", 6123 "BI1.00", 6124 "BM1.00", 6125 "BN1.00", 6126 "BO1.00", 6127 "BR1.00", 6128 "BS1.00", 6129 "BT1.00", 6130 "BU1.00", 6131 "BW1.00", 6132 "BY1.00", 6133 "BZ1.00", 6134 "Bahamian Dolla1.00", 6135 "Bahraini Dina1.00", 6136 "Bangladeshi Tak1.00", 6137 "Barbadian Dolla1.00", 6138 "Bds1.00", 6139 "Belarusian Ruble (1994\\u201319991.00", 6140 "Belarusian Rubl1.00", 6141 "Belgian Fran1.00", 6142 "Belgian Franc (convertible1.00", 6143 "Belgian Franc (financial1.00", 6144 "Belize Dolla1.00", 6145 "Bermudan Dolla1.00", 6146 "Bhutanese Ngultru1.00", 6147 "Bolivian Mvdo1.00", 6148 "Bolivian Pes1.00", 6149 "Bolivian Bolivian1.00", 6150 "Bosnia-Herzegovina Convertible Mar1.00", 6151 "Bosnia-Herzegovina Dina1.00", 6152 "Botswanan Pul1.00", 6153 "Brazilian Cruzad1.00", 6154 "Brazilian Cruzado Nov1.00", 6155 "Brazilian Cruzeir1.00", 6156 "Brazilian Cruzeiro (1990\\u201319931.00", 6157 "Brazilian New Cruzeiro (1967\\u201319861.00", 6158 "Brazilian Rea1.00", 6159 "British Pound Sterlin1.00", 6160 "Brunei Dolla1.00", 6161 "Bulgarian Hard Le1.00", 6162 "Bulgarian Le1.00", 6163 "Burmese Kya1.00", 6164 "Burundian Fran1.00", 6165 "C1.00", 6166 "CA1.00", 6167 "CD1.00", 6168 "CFP Fran1.00", 6169 "CFP1.00", 6170 "CH1.00", 6171 "CL1.00", 6172 "CN1.00", 6173 "CO1.00", 6174 "CS1.00", 6175 "CU1.00", 6176 "CV1.00", 6177 "CY1.00", 6178 "CZ1.00", 6179 "Cambodian Rie1.00", 6180 "Canadian Dolla1.00", 6181 "Cape Verdean Escud1.00", 6182 "Cayman Islands Dolla1.00", 6183 "Chilean Pes1.00", 6184 "Chilean Unit of Accoun1.00", 6185 "Chinese Yua1.00", 6186 "Colombian Pes1.00", 6187 "Comoro Fran1.00", 6188 "Congolese Fran1.00", 6189 "Costa Rican Col\\u00f31.00", 6190 "Croatian Dina1.00", 6191 "Croatian Kun1.00", 6192 "Cuban Pes1.00", 6193 "Cypriot Poun1.00", 6194 "Czech Republic Korun1.00", 6195 "Czechoslovak Hard Korun1.00", 6196 "D1.00", 6197 "DD1.00", 6198 "DE1.00", 6199 "DJ1.00", 6200 "DK1.00", 6201 "DO1.00", 6202 "DZ1.00", 6203 "Danish Kron1.00", 6204 "German Mar1.00", 6205 "Djiboutian Fran1.00", 6206 "Dk1.00", 6207 "Dominican Pes1.00", 6208 "EC1.00", 6209 "EE1.00", 6210 "EG1.00", 6211 "EQ1.00", 6212 "ER1.00", 6213 "ES1.00", 6214 "ET1.00", 6215 "EU1.00", 6216 "East Caribbean Dolla1.00", 6217 "East German Ostmar1.00", 6218 "Ecuadorian Sucr1.00", 6219 "Ecuadorian Unit of Constant Valu1.00", 6220 "Egyptian Poun1.00", 6221 "Ekwel1.00", 6222 "Salvadoran Col\\u00f31.00", 6223 "Equatorial Guinean Ekwel1.00", 6224 "Eritrean Nakf1.00", 6225 "Es1.00", 6226 "Estonian Kroo1.00", 6227 "Ethiopian Bir1.00", 6228 "Eur1.00", 6229 "European Composite Uni1.00", 6230 "European Currency Uni1.00", 6231 "European Monetary Uni1.00", 6232 "European Unit of Account (XBC1.00", 6233 "European Unit of Account (XBD1.00", 6234 "F1.00", 6235 "FB1.00", 6236 "FI1.00", 6237 "FJ1.00", 6238 "FK1.00", 6239 "FR1.00", 6240 "Falkland Islands Poun1.00", 6241 "Fd1.00", 6242 "Fijian Dolla1.00", 6243 "Finnish Markk1.00", 6244 "Fr1.00", 6245 "French Fran1.00", 6246 "French Gold Fran1.00", 6247 "French UIC-Fran1.00", 6248 "G1.00", 6249 "GB1.00", 6250 "GE1.00", 6251 "GH1.00", 6252 "GI1.00", 6253 "GM1.00", 6254 "GN1.00", 6255 "GQ1.00", 6256 "GR1.00", 6257 "GT1.00", 6258 "GW1.00", 6259 "GY1.00", 6260 "Gambian Dalas1.00", 6261 "Georgian Kupon Lari1.00", 6262 "Georgian Lar1.00", 6263 "Ghanaian Ced1.00", 6264 "Ghanaian Cedi (1979\\u201320071.00", 6265 "Gibraltar Poun1.00", 6266 "Gol1.00", 6267 "Greek Drachm1.00", 6268 "Guatemalan Quetza1.00", 6269 "Guinean Fran1.00", 6270 "Guinean Syl1.00", 6271 "Guinea-Bissau Pes1.00", 6272 "Guyanaese Dolla1.00", 6273 "HK1.00", 6274 "HN1.00", 6275 "HR1.00", 6276 "HT1.00", 6277 "HU1.00", 6278 "Haitian Gourd1.00", 6279 "Honduran Lempir1.00", 6280 "Hong Kong Dolla1.00", 6281 "Hungarian Forin1.00", 6282 "I1.00", 6283 "IE1.00", 6284 "IL1.00", 6285 "IN1.00", 6286 "IQ1.00", 6287 "IR1.00", 6288 "IS1.00", 6289 "IT1.00", 6290 "Icelandic Kron1.00", 6291 "Indian Rupe1.00", 6292 "Indonesian Rupia1.00", 6293 "Iranian Ria1.00", 6294 "Iraqi Dina1.00", 6295 "Irish Poun1.00", 6296 "Israeli Poun1.00", 6297 "Italian Lir1.00", 6298 "J1.00", 6299 "JM1.00", 6300 "JO1.00", 6301 "JP1.00", 6302 "Jamaican Dolla1.00", 6303 "Japanese Ye1.00", 6304 "Jordanian Dina1.00", 6305 "K S1.00", 6306 "K1.00", 6307 "KE1.00", 6308 "KG1.00", 6309 "KH1.00", 6310 "KP1.00", 6311 "KR1.00", 6312 "KW1.00", 6313 "KY1.00", 6314 "KZ1.00", 6315 "Kazakhstani Teng1.00", 6316 "Kenyan Shillin1.00", 6317 "Kuwaiti Dina1.00", 6318 "Kyrgystani So1.00", 6319 "LA1.00", 6320 "LB1.00", 6321 "LK1.00", 6322 "LR1.00", 6323 "LT1.00", 6324 "LU1.00", 6325 "LV1.00", 6326 "LY1.00", 6327 "Laotian Ki1.00", 6328 "Latvian Lat1.00", 6329 "Latvian Rubl1.00", 6330 "Lebanese Poun1.00", 6331 "Lesotho Lot1.00", 6332 "Liberian Dolla1.00", 6333 "Libyan Dina1.00", 6334 "Lithuanian Lit1.00", 6335 "Lithuanian Talona1.00", 6336 "Luxembourgian Convertible Fran1.00", 6337 "Luxembourg Financial Fran1.00", 6338 "Luxembourgian Fran1.00", 6339 "MA1.00", 6340 "MD1.00", 6341 "MDe1.00", 6342 "MEX1.00", 6343 "MG1.00", 6344 "ML1.00", 6345 "MM1.00", 6346 "MN1.00", 6347 "MO1.00", 6348 "MR1.00", 6349 "MT1.00", 6350 "MU1.00", 6351 "MV1.00", 6352 "MW1.00", 6353 "MX1.00", 6354 "MY1.00", 6355 "MZ1.00", 6356 "Macanese Patac1.00", 6357 "Macedonian Dena1.00", 6358 "Malagasy Ariar1.00", 6359 "Malagasy Fran1.00", 6360 "Malawian Kwach1.00", 6361 "Malaysian Ringgi1.00", 6362 "Maldivian Rufiya1.00", 6363 "Malian Fran1.00", 6364 "Malot1.00", 6365 "Maltese Lir1.00", 6366 "Maltese Poun1.00", 6367 "Mauritanian Ouguiy1.00", 6368 "Mauritian Rupe1.00", 6369 "Mexican Pes1.00", 6370 "Mexican Silver Peso (1861\\u201319921.00", 6371 "Mexican Investment Uni1.00", 6372 "Moldovan Le1.00", 6373 "Mongolian Tugri1.00", 6374 "Moroccan Dirha1.00", 6375 "Moroccan Fran1.00", 6376 "Mozambican Escud1.00", 6377 "Mozambican Metica1.00", 6378 "Myanmar Kya1.00", 6379 "N1.00", 6380 "NA1.00", 6381 "NAf1.00", 6382 "NG1.00", 6383 "NI1.00", 6384 "NK1.00", 6385 "NL1.00", 6386 "NO1.00", 6387 "NP1.00", 6388 "NT1.00", 6389 "Namibian Dolla1.00", 6390 "Nepalese Rupe1.00", 6391 "Netherlands Antillean Guilde1.00", 6392 "Dutch Guilde1.00", 6393 "Israeli New Sheqe1.00", 6394 "New Zealand Dolla1.00", 6395 "Nicaraguan C\\u00f3rdoba (1988\\u201319911.00", 6396 "Nicaraguan C\\u00f3rdob1.00", 6397 "Nigerian Nair1.00", 6398 "North Korean Wo1.00", 6399 "Norwegian Kron1.00", 6400 "Nr1.00", 6401 "OM1.00", 6402 "Old Mozambican Metica1.00", 6403 "Romanian Leu (1952\\u201320061.00", 6404 "Serbian Dinar (2002\\u201320061.00", 6405 "Sudanese Dinar (1992\\u201320071.00", 6406 "Sudanese Pound (1957\\u201319981.00", 6407 "Turkish Lira (1922\\u201320051.00", 6408 "Omani Ria1.00", 6409 "PA1.00", 6410 "PE1.00", 6411 "PG1.00", 6412 "PH1.00", 6413 "PK1.00", 6414 "PL1.00", 6415 "PT1.00", 6416 "PY1.00", 6417 "Pakistani Rupe1.00", 6418 "Palladiu1.00", 6419 "Panamanian Balbo1.00", 6420 "Papua New Guinean Kin1.00", 6421 "Paraguayan Guaran1.00", 6422 "Peruvian Int1.00", 6423 "Peruvian Sol (1863\\u201319651.00", 6424 "Peruvian Sol Nuev1.00", 6425 "Philippine Pes1.00", 6426 "Platinu1.00", 6427 "Polish Zlot1.00", 6428 "Polish Zloty (1950\\u201319951.00", 6429 "Portuguese Escud1.00", 6430 "Portuguese Guinea Escud1.00", 6431 "Pr1.00", 6432 "QA1.00", 6433 "Qatari Ria1.00", 6434 "RD1.00", 6435 "RH1.00", 6436 "RINET Fund1.00", 6437 "RS1.00", 6438 "RU1.00", 6439 "RW1.00", 6440 "Rb1.00", 6441 "Rhodesian Dolla1.00", 6442 "Romanian Le1.00", 6443 "Russian Rubl1.00", 6444 "Russian Ruble (1991\\u201319981.00", 6445 "Rwandan Fran1.00", 6446 "S1.00", 6447 "SA1.00", 6448 "SB1.00", 6449 "SC1.00", 6450 "SD1.00", 6451 "SE1.00", 6452 "SG1.00", 6453 "SH1.00", 6454 "SI1.00", 6455 "SK1.00", 6456 "SL R1.00", 6457 "SL1.00", 6458 "SO1.00", 6459 "ST1.00", 6460 "SU1.00", 6461 "SV1.00", 6462 "SY1.00", 6463 "SZ1.00", 6464 "St. Helena Poun1.00", 6465 "S\\u00e3o Tom\\u00e9 & Pr\\u00edncipe Dobr1.00", 6466 "Saudi Riya1.00", 6467 "Serbian Dina1.00", 6468 "Seychellois Rupe1.00", 6469 "Sh1.00", 6470 "Sierra Leonean Leon1.00", 6471 "Silve1.00", 6472 "Singapore Dolla1.00", 6473 "Slovak Korun1.00", 6474 "Slovenian Tola1.00", 6475 "Solomon Islands Dolla1.00", 6476 "Somali Shillin1.00", 6477 "South African Ran1.00", 6478 "South African Rand (financial1.00", 6479 "South Korean Wo1.00", 6480 "Soviet Roubl1.00", 6481 "Spanish Peset1.00", 6482 "Spanish Peseta (A account1.00", 6483 "Spanish Peseta (convertible account1.00", 6484 "Special Drawing Right1.00", 6485 "Sri Lankan Rupe1.00", 6486 "Sudanese Poun1.00", 6487 "Surinamese Dolla1.00", 6488 "Surinamese Guilde1.00", 6489 "Swazi Lilangen1.00", 6490 "Swedish Kron1.00", 6491 "Swiss Fran1.00", 6492 "Syrian Poun1.00", 6493 "T S1.00", 6494 "TH1.00", 6495 "TJ1.00", 6496 "TM1.00", 6497 "TN1.00", 6498 "TO1.00", 6499 "TP1.00", 6500 "TR1.00", 6501 "TT1.00", 6502 "TW1.00", 6503 "TZ1.00", 6504 "New Taiwan Dolla1.00", 6505 "Tajikistani Rubl1.00", 6506 "Tajikistani Somon1.00", 6507 "Tanzanian Shillin1.00", 6508 "Testing Currency Cod1.00", 6509 "Thai Bah1.00", 6510 "Timorese Escud1.00", 6511 "Tongan Pa\\u20bbang1.00", 6512 "Trinidad & Tobago Dolla1.00", 6513 "Tunisian Dina1.00", 6514 "Turkish Lir1.00", 6515 "Turkmenistani Mana1.00", 6516 "U S1.00", 6517 "U1.00", 6518 "UA1.00", 6519 "UG1.00", 6520 "US Dolla1.00", 6521 "US Dollar (Next day1.00", 6522 "US Dollar (Same day1.00", 6523 "US1.00", 6524 "UY1.00", 6525 "UZ1.00", 6526 "Ugandan Shillin1.00", 6527 "Ugandan Shilling (1966\\u201319871.00", 6528 "Ukrainian Hryvni1.00", 6529 "Ukrainian Karbovanet1.00", 6530 "Colombian Real Value Uni1.00", 6531 "United Arab Emirates Dirha1.00", 6532 "Unknown Currenc1.00", 6533 "Ur1.00", 6534 "Uruguay Peso (1975\\u201319931.00", 6535 "Uruguay Peso Uruguay1.00", 6536 "Uruguay Peso (Indexed Units1.00", 6537 "Uzbekistani So1.00", 6538 "V1.00", 6539 "VE1.00", 6540 "VN1.00", 6541 "VU1.00", 6542 "Vanuatu Vat1.00", 6543 "Venezuelan Bol\\u00edva1.00", 6544 "Venezuelan Bol\\u00edvar Fuert1.00", 6545 "Vietnamese Don1.00", 6546 "West African CFA Fran1.00", 6547 "Central African CFA Fran1.00", 6548 "WIR Eur1.00", 6549 "WIR Fran1.00", 6550 "WS1.00", 6551 "Samoa Tal1.00", 6552 "XA1.00", 6553 "XB1.00", 6554 "XC1.00", 6555 "XD1.00", 6556 "XE1.00", 6557 "XF1.00", 6558 "XO1.00", 6559 "XP1.00", 6560 "XR1.00", 6561 "XT1.00", 6562 "XX1.00", 6563 "YD1.00", 6564 "YE1.00", 6565 "YU1.00", 6566 "Yemeni Dina1.00", 6567 "Yemeni Ria1.00", 6568 "Yugoslavian Convertible Dina1.00", 6569 "Yugoslavian Hard Dinar (1966\\u201319901.00", 6570 "Yugoslavian New Dina1.00", 6571 "Z1.00", 6572 "ZA1.00", 6573 "ZM1.00", 6574 "ZR1.00", 6575 "ZW1.00", 6576 "Zairean New Zaire (1993\\u201319981.00", 6577 "Zairean Zair1.00", 6578 "Zambian Kwach1.00", 6579 "Zimbabwean Dollar (1980\\u201320081.00", 6580 "dra1.00", 6581 "lar1.00", 6582 "le1.00", 6583 "man1.00", 6584 "so1.00", 6585 }; 6586 6587 Locale locale("en_US"); 6588 for (uint32_t i=0; i<UPRV_LENGTHOF(DATA); ++i) { 6589 UnicodeString formatted = ctou(DATA[i]); 6590 UErrorCode status = U_ZERO_ERROR; 6591 NumberFormat* numFmt = NumberFormat::createInstance(locale, UNUM_CURRENCY, status); 6592 if (numFmt != NULL && U_SUCCESS(status)) { 6593 ParsePosition parsePos; 6594 LocalPointer<CurrencyAmount> currAmt(numFmt->parseCurrency(formatted, parsePos)); 6595 if (parsePos.getIndex() > 0) { 6596 double doubleVal = currAmt->getNumber().getDouble(status); 6597 if ( doubleVal != 1.0 ) { 6598 errln("Parsed as currency value other than 1.0: " + formatted + " -> " + doubleVal); 6599 } 6600 } else { 6601 errln("Failed to parse as currency: " + formatted); 6602 } 6603 } else { 6604 dataerrln("Unable to create NumberFormat. - %s", u_errorName(status)); 6605 delete numFmt; 6606 break; 6607 } 6608 delete numFmt; 6609 } 6610 6611 for (uint32_t i=0; i<UPRV_LENGTHOF(WRONG_DATA); ++i) { 6612 UnicodeString formatted = ctou(WRONG_DATA[i]); 6613 UErrorCode status = U_ZERO_ERROR; 6614 NumberFormat* numFmt = NumberFormat::createInstance(locale, UNUM_CURRENCY, status); 6615 if (numFmt != NULL && U_SUCCESS(status)) { 6616 ParsePosition parsePos; 6617 LocalPointer<CurrencyAmount> currAmt(numFmt->parseCurrency(formatted, parsePos)); 6618 if (parsePos.getIndex() > 0) { 6619 double doubleVal = currAmt->getNumber().getDouble(status); 6620 errln("Parsed as currency, should not have: " + formatted + " -> " + doubleVal); 6621 } 6622 } else { 6623 dataerrln("Unable to create NumberFormat. - %s", u_errorName(status)); 6624 delete numFmt; 6625 break; 6626 } 6627 delete numFmt; 6628 } 6629 } 6630 6631 const char* attrString(int32_t); 6632 6633 // UnicodeString s; 6634 // std::string ss; 6635 // std::cout << s.toUTF8String(ss) 6636 void NumberFormatTest::expectPositions(FieldPositionIterator& iter, int32_t *values, int32_t tupleCount, 6637 const UnicodeString& str) { 6638 UBool found[10]; 6639 FieldPosition fp; 6640 6641 if (tupleCount > 10) { 6642 assertTrue("internal error, tupleCount too large", FALSE); 6643 } else { 6644 for (int i = 0; i < tupleCount; ++i) { 6645 found[i] = FALSE; 6646 } 6647 } 6648 6649 logln(str); 6650 while (iter.next(fp)) { 6651 UBool ok = FALSE; 6652 int32_t id = fp.getField(); 6653 int32_t start = fp.getBeginIndex(); 6654 int32_t limit = fp.getEndIndex(); 6655 6656 // is there a logln using printf? 6657 char buf[128]; 6658 sprintf(buf, "%24s %3d %3d %3d", attrString(id), id, start, limit); 6659 logln(buf); 6660 6661 for (int i = 0; i < tupleCount; ++i) { 6662 if (found[i]) { 6663 continue; 6664 } 6665 if (values[i*3] == id && 6666 values[i*3+1] == start && 6667 values[i*3+2] == limit) { 6668 found[i] = ok = TRUE; 6669 break; 6670 } 6671 } 6672 6673 assertTrue((UnicodeString)"found [" + id + "," + start + "," + limit + "]", ok); 6674 } 6675 6676 // check that all were found 6677 UBool ok = TRUE; 6678 for (int i = 0; i < tupleCount; ++i) { 6679 if (!found[i]) { 6680 ok = FALSE; 6681 assertTrue((UnicodeString) "missing [" + values[i*3] + "," + values[i*3+1] + "," + values[i*3+2] + "]", found[i]); 6682 } 6683 } 6684 assertTrue("no expected values were missing", ok); 6685 } 6686 6687 void NumberFormatTest::expectPosition(FieldPosition& pos, int32_t id, int32_t start, int32_t limit, 6688 const UnicodeString& str) { 6689 logln(str); 6690 assertTrue((UnicodeString)"id " + id + " == " + pos.getField(), id == pos.getField()); 6691 assertTrue((UnicodeString)"begin " + start + " == " + pos.getBeginIndex(), start == pos.getBeginIndex()); 6692 assertTrue((UnicodeString)"end " + limit + " == " + pos.getEndIndex(), limit == pos.getEndIndex()); 6693 } 6694 6695 void NumberFormatTest::TestFieldPositionIterator() { 6696 // bug 7372 6697 UErrorCode status = U_ZERO_ERROR; 6698 FieldPositionIterator iter1; 6699 FieldPositionIterator iter2; 6700 FieldPosition pos; 6701 6702 DecimalFormat *decFmt = (DecimalFormat *) NumberFormat::createInstance(status); 6703 if (failure(status, "NumberFormat::createInstance", TRUE)) return; 6704 6705 double num = 1234.56; 6706 UnicodeString str1; 6707 UnicodeString str2; 6708 6709 assertTrue((UnicodeString)"self==", iter1 == iter1); 6710 assertTrue((UnicodeString)"iter1==iter2", iter1 == iter2); 6711 6712 decFmt->format(num, str1, &iter1, status); 6713 assertTrue((UnicodeString)"iter1 != iter2", iter1 != iter2); 6714 decFmt->format(num, str2, &iter2, status); 6715 assertTrue((UnicodeString)"iter1 == iter2 (2)", iter1 == iter2); 6716 iter1.next(pos); 6717 assertTrue((UnicodeString)"iter1 != iter2 (2)", iter1 != iter2); 6718 iter2.next(pos); 6719 assertTrue((UnicodeString)"iter1 == iter2 (3)", iter1 == iter2); 6720 6721 // should format ok with no iterator 6722 str2.remove(); 6723 decFmt->format(num, str2, NULL, status); 6724 assertEquals("null fpiter", str1, str2); 6725 6726 delete decFmt; 6727 } 6728 6729 void NumberFormatTest::TestFormatAttributes() { 6730 Locale locale("en_US"); 6731 UErrorCode status = U_ZERO_ERROR; 6732 DecimalFormat *decFmt = (DecimalFormat *) NumberFormat::createInstance(locale, UNUM_CURRENCY, status); 6733 if (failure(status, "NumberFormat::createInstance", TRUE)) return; 6734 double val = 12345.67; 6735 6736 { 6737 int32_t expected[] = { 6738 UNUM_CURRENCY_FIELD, 0, 1, 6739 UNUM_GROUPING_SEPARATOR_FIELD, 3, 4, 6740 UNUM_INTEGER_FIELD, 1, 7, 6741 UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8, 6742 UNUM_FRACTION_FIELD, 8, 10, 6743 }; 6744 int32_t tupleCount = UPRV_LENGTHOF(expected)/3; 6745 6746 FieldPositionIterator posIter; 6747 UnicodeString result; 6748 decFmt->format(val, result, &posIter, status); 6749 expectPositions(posIter, expected, tupleCount, result); 6750 } 6751 { 6752 FieldPosition fp(UNUM_INTEGER_FIELD); 6753 UnicodeString result; 6754 decFmt->format(val, result, fp); 6755 expectPosition(fp, UNUM_INTEGER_FIELD, 1, 7, result); 6756 } 6757 { 6758 FieldPosition fp(UNUM_FRACTION_FIELD); 6759 UnicodeString result; 6760 decFmt->format(val, result, fp); 6761 expectPosition(fp, UNUM_FRACTION_FIELD, 8, 10, result); 6762 } 6763 delete decFmt; 6764 6765 decFmt = (DecimalFormat *) NumberFormat::createInstance(locale, UNUM_SCIENTIFIC, status); 6766 val = -0.0000123; 6767 { 6768 int32_t expected[] = { 6769 UNUM_SIGN_FIELD, 0, 1, 6770 UNUM_INTEGER_FIELD, 1, 2, 6771 UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3, 6772 UNUM_FRACTION_FIELD, 3, 5, 6773 UNUM_EXPONENT_SYMBOL_FIELD, 5, 6, 6774 UNUM_EXPONENT_SIGN_FIELD, 6, 7, 6775 UNUM_EXPONENT_FIELD, 7, 8 6776 }; 6777 int32_t tupleCount = UPRV_LENGTHOF(expected)/3; 6778 6779 FieldPositionIterator posIter; 6780 UnicodeString result; 6781 decFmt->format(val, result, &posIter, status); 6782 expectPositions(posIter, expected, tupleCount, result); 6783 } 6784 { 6785 FieldPosition fp(UNUM_INTEGER_FIELD); 6786 UnicodeString result; 6787 decFmt->format(val, result, fp); 6788 expectPosition(fp, UNUM_INTEGER_FIELD, 1, 2, result); 6789 } 6790 { 6791 FieldPosition fp(UNUM_FRACTION_FIELD); 6792 UnicodeString result; 6793 decFmt->format(val, result, fp); 6794 expectPosition(fp, UNUM_FRACTION_FIELD, 3, 5, result); 6795 } 6796 delete decFmt; 6797 6798 fflush(stderr); 6799 } 6800 6801 const char* attrString(int32_t attrId) { 6802 switch (attrId) { 6803 case UNUM_INTEGER_FIELD: return "integer"; 6804 case UNUM_FRACTION_FIELD: return "fraction"; 6805 case UNUM_DECIMAL_SEPARATOR_FIELD: return "decimal separator"; 6806 case UNUM_EXPONENT_SYMBOL_FIELD: return "exponent symbol"; 6807 case UNUM_EXPONENT_SIGN_FIELD: return "exponent sign"; 6808 case UNUM_EXPONENT_FIELD: return "exponent"; 6809 case UNUM_GROUPING_SEPARATOR_FIELD: return "grouping separator"; 6810 case UNUM_CURRENCY_FIELD: return "currency"; 6811 case UNUM_PERCENT_FIELD: return "percent"; 6812 case UNUM_PERMILL_FIELD: return "permille"; 6813 case UNUM_SIGN_FIELD: return "sign"; 6814 default: return ""; 6815 } 6816 } 6817 6818 // 6819 // Test formatting & parsing of big decimals. 6820 // API test, not a comprehensive test. 6821 // See DecimalFormatTest/DataDrivenTests 6822 // 6823 #define ASSERT_SUCCESS(status) {if (U_FAILURE(status)) errln("file %s, line %d: status: %s", \ 6824 __FILE__, __LINE__, u_errorName(status));} 6825 #define ASSERT_EQUALS(expected, actual) {if ((expected) != (actual)) \ 6826 errln("file %s, line %d: %s != %s", __FILE__, __LINE__, #expected, #actual);} 6827 6828 static UBool operator != (const char *s1, UnicodeString &s2) { 6829 // This function lets ASSERT_EQUALS("literal", UnicodeString) work. 6830 UnicodeString us1(s1); 6831 return us1 != s2; 6832 } 6833 6834 void NumberFormatTest::TestDecimal() { 6835 { 6836 UErrorCode status = U_ZERO_ERROR; 6837 Formattable f("12.345678999987654321E666", status); 6838 ASSERT_SUCCESS(status); 6839 StringPiece s = f.getDecimalNumber(status); 6840 ASSERT_SUCCESS(status); 6841 ASSERT_EQUALS("1.2345678999987654321E+667", s); 6842 //printf("%s\n", s.data()); 6843 } 6844 6845 { 6846 UErrorCode status = U_ZERO_ERROR; 6847 Formattable f1("this is not a number", status); 6848 ASSERT_EQUALS(U_DECIMAL_NUMBER_SYNTAX_ERROR, status); 6849 } 6850 6851 { 6852 UErrorCode status = U_ZERO_ERROR; 6853 Formattable f; 6854 f.setDecimalNumber("123.45", status); 6855 ASSERT_SUCCESS(status); 6856 ASSERT_EQUALS( Formattable::kDouble, f.getType()); 6857 ASSERT_EQUALS(123.45, f.getDouble()); 6858 ASSERT_EQUALS(123.45, f.getDouble(status)); 6859 ASSERT_SUCCESS(status); 6860 ASSERT_EQUALS("123.45", f.getDecimalNumber(status)); 6861 ASSERT_SUCCESS(status); 6862 6863 f.setDecimalNumber("4.5678E7", status); 6864 int32_t n; 6865 n = f.getLong(); 6866 ASSERT_EQUALS(45678000, n); 6867 6868 status = U_ZERO_ERROR; 6869 f.setDecimalNumber("-123", status); 6870 ASSERT_SUCCESS(status); 6871 ASSERT_EQUALS( Formattable::kLong, f.getType()); 6872 ASSERT_EQUALS(-123, f.getLong()); 6873 ASSERT_EQUALS(-123, f.getLong(status)); 6874 ASSERT_SUCCESS(status); 6875 ASSERT_EQUALS("-123", f.getDecimalNumber(status)); 6876 ASSERT_SUCCESS(status); 6877 6878 status = U_ZERO_ERROR; 6879 f.setDecimalNumber("1234567890123", status); // Number too big for 32 bits 6880 ASSERT_SUCCESS(status); 6881 ASSERT_EQUALS( Formattable::kInt64, f.getType()); 6882 ASSERT_EQUALS(1234567890123LL, f.getInt64()); 6883 ASSERT_EQUALS(1234567890123LL, f.getInt64(status)); 6884 ASSERT_SUCCESS(status); 6885 ASSERT_EQUALS("1234567890123", f.getDecimalNumber(status)); 6886 ASSERT_SUCCESS(status); 6887 } 6888 6889 { 6890 UErrorCode status = U_ZERO_ERROR; 6891 NumberFormat *fmtr = NumberFormat::createInstance(Locale::getUS(), UNUM_DECIMAL, status); 6892 if (U_FAILURE(status) || fmtr == NULL) { 6893 dataerrln("Unable to create NumberFormat"); 6894 } else { 6895 UnicodeString formattedResult; 6896 StringPiece num("244444444444444444444444444444444444446.4"); 6897 fmtr->format(num, formattedResult, NULL, status); 6898 ASSERT_SUCCESS(status); 6899 ASSERT_EQUALS("244,444,444,444,444,444,444,444,444,444,444,444,446.4", formattedResult); 6900 //std::string ss; std::cout << formattedResult.toUTF8String(ss); 6901 delete fmtr; 6902 } 6903 } 6904 6905 { 6906 // Check formatting a DigitList. DigitList is internal, but this is 6907 // a critical interface that must work. 6908 UErrorCode status = U_ZERO_ERROR; 6909 NumberFormat *fmtr = NumberFormat::createInstance(Locale::getUS(), UNUM_DECIMAL, status); 6910 if (U_FAILURE(status) || fmtr == NULL) { 6911 dataerrln("Unable to create NumberFormat"); 6912 } else { 6913 UnicodeString formattedResult; 6914 DigitList dl; 6915 StringPiece num("123.4566666666666666666666666666666666621E+40"); 6916 dl.set(num, status); 6917 ASSERT_SUCCESS(status); 6918 fmtr->format(dl, formattedResult, NULL, status); 6919 ASSERT_SUCCESS(status); 6920 ASSERT_EQUALS("1,234,566,666,666,666,666,666,666,666,666,666,666,621,000", formattedResult); 6921 6922 status = U_ZERO_ERROR; 6923 num.set("666.666"); 6924 dl.set(num, status); 6925 FieldPosition pos(NumberFormat::FRACTION_FIELD); 6926 ASSERT_SUCCESS(status); 6927 formattedResult.remove(); 6928 fmtr->format(dl, formattedResult, pos, status); 6929 ASSERT_SUCCESS(status); 6930 ASSERT_EQUALS("666.666", formattedResult); 6931 ASSERT_EQUALS(4, pos.getBeginIndex()); 6932 ASSERT_EQUALS(7, pos.getEndIndex()); 6933 delete fmtr; 6934 } 6935 } 6936 6937 { 6938 // Check a parse with a formatter with a multiplier. 6939 UErrorCode status = U_ZERO_ERROR; 6940 NumberFormat *fmtr = NumberFormat::createInstance(Locale::getUS(), UNUM_PERCENT, status); 6941 if (U_FAILURE(status) || fmtr == NULL) { 6942 dataerrln("Unable to create NumberFormat"); 6943 } else { 6944 UnicodeString input = "1.84%"; 6945 Formattable result; 6946 fmtr->parse(input, result, status); 6947 ASSERT_SUCCESS(status); 6948 ASSERT_EQUALS(0, strcmp("0.0184", result.getDecimalNumber(status).data())); 6949 //std::cout << result.getDecimalNumber(status).data(); 6950 delete fmtr; 6951 } 6952 } 6953 6954 #if U_PLATFORM != U_PF_CYGWIN || defined(CYGWINMSVC) 6955 /* 6956 * This test fails on Cygwin (1.7.16) using GCC because of a rounding issue with strtod(). 6957 * See #9463 6958 */ 6959 { 6960 // Check that a parse returns a decimal number with full accuracy 6961 UErrorCode status = U_ZERO_ERROR; 6962 NumberFormat *fmtr = NumberFormat::createInstance(Locale::getUS(), UNUM_DECIMAL, status); 6963 if (U_FAILURE(status) || fmtr == NULL) { 6964 dataerrln("Unable to create NumberFormat"); 6965 } else { 6966 UnicodeString input = "1.002200044400088880000070000"; 6967 Formattable result; 6968 fmtr->parse(input, result, status); 6969 ASSERT_SUCCESS(status); 6970 ASSERT_EQUALS(0, strcmp("1.00220004440008888000007", result.getDecimalNumber(status).data())); 6971 ASSERT_EQUALS(1.00220004440008888, result.getDouble()); 6972 //std::cout << result.getDecimalNumber(status).data(); 6973 delete fmtr; 6974 } 6975 } 6976 #endif 6977 6978 } 6979 6980 void NumberFormatTest::TestCurrencyFractionDigits() { 6981 UErrorCode status = U_ZERO_ERROR; 6982 UnicodeString text1, text2; 6983 double value = 99.12345; 6984 6985 // Create currenct instance 6986 NumberFormat* fmt = NumberFormat::createCurrencyInstance("ja_JP", status); 6987 if (U_FAILURE(status) || fmt == NULL) { 6988 dataerrln("Unable to create NumberFormat"); 6989 } else { 6990 fmt->format(value, text1); 6991 6992 // Reset the same currency and format the test value again 6993 fmt->setCurrency(fmt->getCurrency(), status); 6994 ASSERT_SUCCESS(status); 6995 fmt->format(value, text2); 6996 6997 if (text1 != text2) { 6998 errln((UnicodeString)"NumberFormat::format() should return the same result - text1=" 6999 + text1 + " text2=" + text2); 7000 } 7001 delete fmt; 7002 } 7003 } 7004 7005 void NumberFormatTest::TestExponentParse() { 7006 7007 UErrorCode status = U_ZERO_ERROR; 7008 Formattable result; 7009 ParsePosition parsePos(0); 7010 7011 // set the exponent symbol 7012 status = U_ZERO_ERROR; 7013 DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getDefault(), status); 7014 if(U_FAILURE(status)) { 7015 dataerrln((UnicodeString)"ERROR: Could not create DecimalFormatSymbols (Default)"); 7016 return; 7017 } 7018 7019 // create format instance 7020 status = U_ZERO_ERROR; 7021 DecimalFormat fmt("#####", symbols, status); 7022 if(U_FAILURE(status)) { 7023 errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols*)"); 7024 } 7025 7026 // parse the text 7027 fmt.parse("5.06e-27", result, parsePos); 7028 if(result.getType() != Formattable::kDouble && 7029 result.getDouble() != 5.06E-27 && 7030 parsePos.getIndex() != 8 7031 ) 7032 { 7033 errln("ERROR: parse failed - expected 5.06E-27, 8 - returned %d, %i", 7034 result.getDouble(), parsePos.getIndex()); 7035 } 7036 } 7037 7038 void NumberFormatTest::TestExplicitParents() { 7039 7040 /* Test that number formats are properly inherited from es_419 */ 7041 /* These could be subject to change if the CLDR data changes */ 7042 static const char* parentLocaleTests[][2]= { 7043 /* locale ID */ /* expected */ 7044 {"es_CO", "1.250,75" }, 7045 {"es_ES", "1.250,75" }, 7046 {"es_GQ", "1.250,75" }, 7047 {"es_MX", "1,250.75" }, 7048 {"es_US", "1,250.75" }, 7049 {"es_VE", "1.250,75" }, 7050 }; 7051 7052 UnicodeString s; 7053 7054 for(int i=0; i < UPRV_LENGTHOF(parentLocaleTests); i++){ 7055 UErrorCode status = U_ZERO_ERROR; 7056 const char *localeID = parentLocaleTests[i][0]; 7057 UnicodeString expected(parentLocaleTests[i][1], -1, US_INV); 7058 expected = expected.unescape(); 7059 char loc[256]={0}; 7060 uloc_canonicalize(localeID, loc, 256, &status); 7061 NumberFormat *fmt= NumberFormat::createInstance(Locale(loc), status); 7062 if(U_FAILURE(status)){ 7063 dataerrln("Could not create number formatter for locale %s - %s",localeID, u_errorName(status)); 7064 continue; 7065 } 7066 s.remove(); 7067 fmt->format(1250.75, s); 7068 if(s!=expected){ 7069 errln(UnicodeString("FAIL: Expected: ")+expected 7070 + UnicodeString(" Got: ") + s 7071 + UnicodeString( " for locale: ")+ UnicodeString(localeID) ); 7072 } 7073 if (U_FAILURE(status)){ 7074 errln((UnicodeString)"FAIL: Status " + (int32_t)status); 7075 } 7076 delete fmt; 7077 } 7078 7079 } 7080 7081 /** 7082 * Test available numbering systems API. 7083 */ 7084 void NumberFormatTest::TestAvailableNumberingSystems() { 7085 UErrorCode status = U_ZERO_ERROR; 7086 StringEnumeration *availableNumberingSystems = NumberingSystem::getAvailableNames(status); 7087 CHECK_DATA(status, "NumberingSystem::getAvailableNames()") 7088 7089 int32_t nsCount = availableNumberingSystems->count(status); 7090 if ( nsCount < 74 ) { 7091 errln("FAIL: Didn't get as many numbering systems as we had hoped for. Need at least 74, got %d",nsCount); 7092 } 7093 7094 /* A relatively simple test of the API. We call getAvailableNames() and cycle through */ 7095 /* each name returned, attempting to create a numbering system based on that name and */ 7096 /* verifying that the name returned from the resulting numbering system is the same */ 7097 /* one that we initially thought. */ 7098 7099 int32_t len; 7100 for ( int32_t i = 0 ; i < nsCount ; i++ ) { 7101 const char *nsname = availableNumberingSystems->next(&len,status); 7102 NumberingSystem* ns = NumberingSystem::createInstanceByName(nsname,status); 7103 logln("OK for ns = %s",nsname); 7104 if ( uprv_strcmp(nsname,ns->getName()) ) { 7105 errln("FAIL: Numbering system name didn't match for name = %s\n",nsname); 7106 } 7107 7108 delete ns; 7109 } 7110 7111 delete availableNumberingSystems; 7112 } 7113 7114 void 7115 NumberFormatTest::Test9087(void) 7116 { 7117 U_STRING_DECL(pattern,"#",1); 7118 U_STRING_INIT(pattern,"#",1); 7119 7120 U_STRING_DECL(infstr,"INF",3); 7121 U_STRING_INIT(infstr,"INF",3); 7122 7123 U_STRING_DECL(nanstr,"NAN",3); 7124 U_STRING_INIT(nanstr,"NAN",3); 7125 7126 UChar outputbuf[50] = {0}; 7127 UErrorCode status = U_ZERO_ERROR; 7128 UNumberFormat* fmt = unum_open(UNUM_PATTERN_DECIMAL,pattern,1,NULL,NULL,&status); 7129 if ( U_FAILURE(status) ) { 7130 dataerrln("FAIL: error in unum_open() - %s", u_errorName(status)); 7131 return; 7132 } 7133 7134 unum_setSymbol(fmt,UNUM_INFINITY_SYMBOL,infstr,3,&status); 7135 unum_setSymbol(fmt,UNUM_NAN_SYMBOL,nanstr,3,&status); 7136 if ( U_FAILURE(status) ) { 7137 errln("FAIL: error setting symbols"); 7138 } 7139 7140 double inf = uprv_getInfinity(); 7141 7142 unum_setAttribute(fmt,UNUM_ROUNDING_MODE,UNUM_ROUND_HALFEVEN); 7143 unum_setDoubleAttribute(fmt,UNUM_ROUNDING_INCREMENT,0); 7144 7145 UFieldPosition position = { 0, 0, 0}; 7146 unum_formatDouble(fmt,inf,outputbuf,50,&position,&status); 7147 7148 if ( u_strcmp(infstr, outputbuf)) { 7149 errln((UnicodeString)"FAIL: unexpected result for infinity - expected " + infstr + " got " + outputbuf); 7150 } 7151 7152 unum_close(fmt); 7153 } 7154 7155 #include "dcfmtimp.h" 7156 7157 void NumberFormatTest::TestFormatFastpaths() { 7158 #if UCONFIG_FORMAT_FASTPATHS_49 7159 logln("Sizeof DecimalFormat = %d, Sizeof DecimalFormatInternal=%d, UNUM_DECIMALFORMAT_INTERNAL_SIZE=%d\n", 7160 sizeof(DecimalFormat), sizeof(DecimalFormatInternal), UNUM_DECIMALFORMAT_INTERNAL_SIZE); 7161 if(UNUM_DECIMALFORMAT_INTERNAL_SIZE < sizeof(DecimalFormatInternal)) { 7162 errln("Error: sizeof(DecimalFormatInternal)=%d but UNUM_DECIMALFORMAT_INTERNAL_SIZE is only %d. Increase the #define?\n", sizeof(DecimalFormatInternal), UNUM_DECIMALFORMAT_INTERNAL_SIZE); 7163 } else if(UNUM_DECIMALFORMAT_INTERNAL_SIZE > (sizeof(DecimalFormatInternal)+16)) { 7164 infoln("Note: sizeof(DecimalFormatInternal)=%d but UNUM_DECIMALFORMAT_INTERNAL_SIZE is %d. Decrease the #define? sizeof(DecimalFormat)=%d\n", sizeof(DecimalFormatInternal), UNUM_DECIMALFORMAT_INTERNAL_SIZE, sizeof(DecimalFormat)); 7165 } 7166 #else 7167 infoln("NOTE: UCONFIG_FORMAT_FASTPATHS not set, test skipped."); 7168 #endif 7169 7170 // get some additional case 7171 { 7172 UErrorCode status=U_ZERO_ERROR; 7173 DecimalFormat df(UnicodeString("0000",""),status); 7174 if (U_FAILURE(status)) { 7175 dataerrln("Error creating DecimalFormat - %s", u_errorName(status)); 7176 } else { 7177 int64_t long_number = 1; 7178 UnicodeString expect = "0001"; 7179 UnicodeString result; 7180 FieldPosition pos; 7181 df.format(long_number, result, pos); 7182 if(U_FAILURE(status)||expect!=result) { 7183 errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),"")); 7184 } else { 7185 logln("OK: got expected '"+result+"' status "+UnicodeString(u_errorName(status),"")); 7186 } 7187 } 7188 } 7189 { 7190 UErrorCode status=U_ZERO_ERROR; 7191 DecimalFormat df(UnicodeString("0000000000000000000",""),status); 7192 if (U_FAILURE(status)) { 7193 dataerrln("Error creating DecimalFormat - %s", u_errorName(status)); 7194 } else { 7195 int64_t long_number = U_INT64_MIN; // -9223372036854775808L; 7196 // uint8_t bits[8]; 7197 // memcpy(bits,&long_number,8); 7198 // for(int i=0;i<8;i++) { 7199 // logln("bits: %02X", (unsigned int)bits[i]); 7200 // } 7201 UnicodeString expect = "-9223372036854775808"; 7202 UnicodeString result; 7203 FieldPosition pos; 7204 df.format(long_number, result, pos); 7205 if(U_FAILURE(status)||expect!=result) { 7206 errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on -9223372036854775808"); 7207 } else { 7208 logln("OK: got expected '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on -9223372036854775808"); 7209 } 7210 } 7211 } 7212 { 7213 UErrorCode status=U_ZERO_ERROR; 7214 DecimalFormat df(UnicodeString("0000000000000000000",""),status); 7215 if (U_FAILURE(status)) { 7216 dataerrln("Error creating DecimalFormat - %s", u_errorName(status)); 7217 } else { 7218 int64_t long_number = U_INT64_MAX; // -9223372036854775808L; 7219 // uint8_t bits[8]; 7220 // memcpy(bits,&long_number,8); 7221 // for(int i=0;i<8;i++) { 7222 // logln("bits: %02X", (unsigned int)bits[i]); 7223 // } 7224 UnicodeString expect = "9223372036854775807"; 7225 UnicodeString result; 7226 FieldPosition pos; 7227 df.format(long_number, result, pos); 7228 if(U_FAILURE(status)||expect!=result) { 7229 errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on U_INT64_MAX"); 7230 } else { 7231 logln("OK: got expected '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on U_INT64_MAX"); 7232 } 7233 } 7234 } 7235 { 7236 UErrorCode status=U_ZERO_ERROR; 7237 DecimalFormat df(UnicodeString("0000000000000000000",""),status); 7238 if (U_FAILURE(status)) { 7239 dataerrln("Error creating DecimalFormat - %s", u_errorName(status)); 7240 } else { 7241 int64_t long_number = 0; 7242 // uint8_t bits[8]; 7243 // memcpy(bits,&long_number,8); 7244 // for(int i=0;i<8;i++) { 7245 // logln("bits: %02X", (unsigned int)bits[i]); 7246 // } 7247 UnicodeString expect = "0000000000000000000"; 7248 UnicodeString result; 7249 FieldPosition pos; 7250 df.format(long_number, result, pos); 7251 if(U_FAILURE(status)||expect!=result) { 7252 errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on 0"); 7253 } else { 7254 logln("OK: got expected '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on 0"); 7255 } 7256 } 7257 } 7258 { 7259 UErrorCode status=U_ZERO_ERROR; 7260 DecimalFormat df(UnicodeString("0000000000000000000",""),status); 7261 if (U_FAILURE(status)) { 7262 dataerrln("Error creating DecimalFormat - %s", u_errorName(status)); 7263 } else { 7264 int64_t long_number = U_INT64_MIN + 1; 7265 UnicodeString expect = "-9223372036854775807"; 7266 UnicodeString result; 7267 FieldPosition pos; 7268 df.format(long_number, result, pos); 7269 if(U_FAILURE(status)||expect!=result) { 7270 errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on -9223372036854775807"); 7271 } else { 7272 logln("OK: got expected '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on -9223372036854775807"); 7273 } 7274 } 7275 } 7276 } 7277 7278 7279 void NumberFormatTest::TestFormattableSize(void) { 7280 if(sizeof(FmtStackData) > UNUM_INTERNAL_STACKARRAY_SIZE) { 7281 errln("Error: sizeof(FmtStackData)=%d, UNUM_INTERNAL_STACKARRAY_SIZE=%d\n", 7282 sizeof(FmtStackData), UNUM_INTERNAL_STACKARRAY_SIZE); 7283 } else if(sizeof(FmtStackData) < UNUM_INTERNAL_STACKARRAY_SIZE) { 7284 logln("Warning: sizeof(FmtStackData)=%d, UNUM_INTERNAL_STACKARRAY_SIZE=%d\n", 7285 sizeof(FmtStackData), UNUM_INTERNAL_STACKARRAY_SIZE); 7286 } else { 7287 logln("sizeof(FmtStackData)=%d, UNUM_INTERNAL_STACKARRAY_SIZE=%d\n", 7288 sizeof(FmtStackData), UNUM_INTERNAL_STACKARRAY_SIZE); 7289 } 7290 } 7291 7292 UBool NumberFormatTest::testFormattableAsUFormattable(const char *file, int line, Formattable &f) { 7293 UnicodeString fileLine = UnicodeString(file)+UnicodeString(":")+line+UnicodeString(": "); 7294 7295 UFormattable *u = f.toUFormattable(); 7296 logln(); 7297 if (u == NULL) { 7298 errln("%s:%d: Error: f.toUFormattable() retuned NULL."); 7299 return FALSE; 7300 } 7301 logln("%s:%d: comparing Formattable with UFormattable", file, line); 7302 logln(fileLine + toString(f)); 7303 7304 UErrorCode status = U_ZERO_ERROR; 7305 UErrorCode valueStatus = U_ZERO_ERROR; 7306 UFormattableType expectUType = UFMT_COUNT; // invalid 7307 7308 UBool triedExact = FALSE; // did we attempt an exact comparison? 7309 UBool exactMatch = FALSE; // was the exact comparison true? 7310 7311 switch( f.getType() ) { 7312 case Formattable::kDate: 7313 expectUType = UFMT_DATE; 7314 exactMatch = (f.getDate()==ufmt_getDate(u, &valueStatus)); 7315 triedExact = TRUE; 7316 break; 7317 case Formattable::kDouble: 7318 expectUType = UFMT_DOUBLE; 7319 exactMatch = (f.getDouble()==ufmt_getDouble(u, &valueStatus)); 7320 triedExact = TRUE; 7321 break; 7322 case Formattable::kLong: 7323 expectUType = UFMT_LONG; 7324 exactMatch = (f.getLong()==ufmt_getLong(u, &valueStatus)); 7325 triedExact = TRUE; 7326 break; 7327 case Formattable::kString: 7328 expectUType = UFMT_STRING; 7329 { 7330 UnicodeString str; 7331 f.getString(str); 7332 int32_t len; 7333 const UChar* uch = ufmt_getUChars(u, &len, &valueStatus); 7334 if(U_SUCCESS(valueStatus)) { 7335 UnicodeString str2(uch, len); 7336 assertTrue("UChar* NULL-terminated", uch[len]==0); 7337 exactMatch = (str == str2); 7338 } 7339 triedExact = TRUE; 7340 } 7341 break; 7342 case Formattable::kArray: 7343 expectUType = UFMT_ARRAY; 7344 triedExact = TRUE; 7345 { 7346 int32_t count = ufmt_getArrayLength(u, &valueStatus); 7347 int32_t count2; 7348 const Formattable *array2 = f.getArray(count2); 7349 exactMatch = assertEquals(fileLine + " array count", count, count2); 7350 7351 if(exactMatch) { 7352 for(int i=0;U_SUCCESS(valueStatus) && i<count;i++) { 7353 UFormattable *uu = ufmt_getArrayItemByIndex(u, i, &valueStatus); 7354 if(*Formattable::fromUFormattable(uu) != (array2[i])) { 7355 errln("%s:%d: operator== did not match at index[%d] - %p vs %p", file, line, i, 7356 (const void*)Formattable::fromUFormattable(uu), (const void*)&(array2[i])); 7357 exactMatch = FALSE; 7358 } else { 7359 if(!testFormattableAsUFormattable("(sub item)",i,*Formattable::fromUFormattable(uu))) { 7360 exactMatch = FALSE; 7361 } 7362 } 7363 } 7364 } 7365 } 7366 break; 7367 case Formattable::kInt64: 7368 expectUType = UFMT_INT64; 7369 exactMatch = (f.getInt64()==ufmt_getInt64(u, &valueStatus)); 7370 triedExact = TRUE; 7371 break; 7372 case Formattable::kObject: 7373 expectUType = UFMT_OBJECT; 7374 exactMatch = (f.getObject()==ufmt_getObject(u, &valueStatus)); 7375 triedExact = TRUE; 7376 break; 7377 } 7378 UFormattableType uType = ufmt_getType(u, &status); 7379 7380 if(U_FAILURE(status)) { 7381 errln("%s:%d: Error calling ufmt_getType - %s", file, line, u_errorName(status)); 7382 return FALSE; 7383 } 7384 7385 if(uType != expectUType) { 7386 errln("%s:%d: got type (%d) expected (%d) from ufmt_getType", file, line, (int) uType, (int) expectUType); 7387 } 7388 7389 if(triedExact) { 7390 if(U_FAILURE(valueStatus)) { 7391 errln("%s:%d: got err %s trying to ufmt_get...() for exact match check", file, line, u_errorName(valueStatus)); 7392 } else if(!exactMatch) { 7393 errln("%s:%d: failed exact match for the Formattable type", file, line); 7394 } else { 7395 logln("%s:%d: exact match OK", file, line); 7396 } 7397 } else { 7398 logln("%s:%d: note, did not attempt exact match for this formattable type", file, line); 7399 } 7400 7401 if( assertEquals(fileLine + " isNumeric()", f.isNumeric(), ufmt_isNumeric(u)) 7402 && f.isNumeric()) { 7403 UErrorCode convStatus = U_ZERO_ERROR; 7404 7405 if(uType != UFMT_INT64) { // may fail to compare 7406 assertTrue(fileLine + " as doubles ==", f.getDouble(convStatus)==ufmt_getDouble(u, &convStatus)); 7407 } 7408 7409 if( assertSuccess(fileLine + " (numeric conversion status)", convStatus) ) { 7410 StringPiece fDecNum = f.getDecimalNumber(convStatus); 7411 #if 1 7412 int32_t len; 7413 const char *decNumChars = ufmt_getDecNumChars(u, &len, &convStatus); 7414 #else 7415 // copy version 7416 char decNumChars[200]; 7417 int32_t len = ufmt_getDecNumChars(u, decNumChars, 200, &convStatus); 7418 #endif 7419 7420 if( assertSuccess(fileLine + " (decNumbers conversion)", convStatus) ) { 7421 logln(fileLine + decNumChars); 7422 assertEquals(fileLine + " decNumChars length==", len, fDecNum.length()); 7423 assertEquals(fileLine + " decNumChars digits", decNumChars, fDecNum.data()); 7424 } 7425 7426 UErrorCode int64ConversionF = U_ZERO_ERROR; 7427 int64_t l = f.getInt64(int64ConversionF); 7428 UErrorCode int64ConversionU = U_ZERO_ERROR; 7429 int64_t r = ufmt_getInt64(u, &int64ConversionU); 7430 7431 if( (l==r) 7432 && ( uType != UFMT_INT64 ) // int64 better not overflow 7433 && (U_INVALID_FORMAT_ERROR==int64ConversionU) 7434 && (U_INVALID_FORMAT_ERROR==int64ConversionF) ) { 7435 logln("%s:%d: OK: 64 bit overflow", file, line); 7436 } else { 7437 assertEquals(fileLine + " as int64 ==", l, r); 7438 assertSuccess(fileLine + " Formattable.getnt64()", int64ConversionF); 7439 assertSuccess(fileLine + " ufmt_getInt64()", int64ConversionU); 7440 } 7441 } 7442 } 7443 return exactMatch || !triedExact; 7444 } 7445 7446 void NumberFormatTest::TestUFormattable(void) { 7447 { 7448 // test that a default formattable is equal to Formattable() 7449 UErrorCode status = U_ZERO_ERROR; 7450 LocalUFormattablePointer defaultUFormattable(ufmt_open(&status)); 7451 assertSuccess("calling umt_open", status); 7452 Formattable defaultFormattable; 7453 assertTrue((UnicodeString)"comparing ufmt_open() with Formattable()", 7454 (defaultFormattable 7455 == *(Formattable::fromUFormattable(defaultUFormattable.getAlias())))); 7456 assertTrue((UnicodeString)"comparing ufmt_open() with Formattable()", 7457 (defaultFormattable 7458 == *(Formattable::fromUFormattable(defaultUFormattable.getAlias())))); 7459 assertTrue((UnicodeString)"comparing Formattable() round tripped through UFormattable", 7460 (defaultFormattable 7461 == *(Formattable::fromUFormattable(defaultFormattable.toUFormattable())))); 7462 assertTrue((UnicodeString)"comparing &Formattable() round tripped through UFormattable", 7463 ((&defaultFormattable) 7464 == Formattable::fromUFormattable(defaultFormattable.toUFormattable()))); 7465 assertFalse((UnicodeString)"comparing &Formattable() with ufmt_open()", 7466 ((&defaultFormattable) 7467 == Formattable::fromUFormattable(defaultUFormattable.getAlias()))); 7468 testFormattableAsUFormattable(__FILE__, __LINE__, defaultFormattable); 7469 } 7470 // test some random Formattables 7471 { 7472 Formattable f(ucal_getNow(), Formattable::kIsDate); 7473 testFormattableAsUFormattable(__FILE__, __LINE__, f); 7474 } 7475 { 7476 Formattable f((double)1.61803398874989484820); // golden ratio 7477 testFormattableAsUFormattable(__FILE__, __LINE__, f); 7478 } 7479 { 7480 Formattable f((int64_t)80994231587905127LL); // weight of the moon, in kilotons http://solarsystem.nasa.gov/planets/profile.cfm?Display=Facts&Object=Moon 7481 testFormattableAsUFormattable(__FILE__, __LINE__, f); 7482 } 7483 { 7484 Formattable f((int32_t)4); // random number, source: http://www.xkcd.com/221/ 7485 testFormattableAsUFormattable(__FILE__, __LINE__, f); 7486 } 7487 { 7488 Formattable f("Hello world."); // should be invariant? 7489 testFormattableAsUFormattable(__FILE__, __LINE__, f); 7490 } 7491 { 7492 UErrorCode status2 = U_ZERO_ERROR; 7493 Formattable f(StringPiece("73476730924573500000000.0"), status2); // weight of the moon, kg 7494 assertSuccess("Constructing a StringPiece", status2); 7495 testFormattableAsUFormattable(__FILE__, __LINE__, f); 7496 } 7497 { 7498 UErrorCode status2 = U_ZERO_ERROR; 7499 UObject *obj = new Locale(); 7500 Formattable f(obj); 7501 assertSuccess("Constructing a Formattable from a default constructed Locale()", status2); 7502 testFormattableAsUFormattable(__FILE__, __LINE__, f); 7503 } 7504 { 7505 const Formattable array[] = { 7506 Formattable(ucal_getNow(), Formattable::kIsDate), 7507 Formattable((int32_t)4), 7508 Formattable((double)1.234), 7509 }; 7510 7511 Formattable fa(array, 3); 7512 testFormattableAsUFormattable(__FILE__, __LINE__, fa); 7513 } 7514 } 7515 7516 void NumberFormatTest::TestSignificantDigits(void) { 7517 double input[] = { 7518 0, 0, 7519 0.1, -0.1, 7520 123, -123, 7521 12345, -12345, 7522 123.45, -123.45, 7523 123.44501, -123.44501, 7524 0.001234, -0.001234, 7525 0.00000000123, -0.00000000123, 7526 0.0000000000000000000123, -0.0000000000000000000123, 7527 1.2, -1.2, 7528 0.0000000012344501, -0.0000000012344501, 7529 123445.01, -123445.01, 7530 12344501000000000000000000000000000.0, -12344501000000000000000000000000000.0, 7531 }; 7532 const char* expected[] = { 7533 "0.00", "0.00", 7534 "0.100", "-0.100", 7535 "123", "-123", 7536 "12345", "-12345", 7537 "123.45", "-123.45", 7538 "123.45", "-123.45", 7539 "0.001234", "-0.001234", 7540 "0.00000000123", "-0.00000000123", 7541 "0.0000000000000000000123", "-0.0000000000000000000123", 7542 "1.20", "-1.20", 7543 "0.0000000012345", "-0.0000000012345", 7544 "123450", "-123450", 7545 "12345000000000000000000000000000000", "-12345000000000000000000000000000000", 7546 }; 7547 7548 UErrorCode status = U_ZERO_ERROR; 7549 Locale locale("en_US"); 7550 LocalPointer<DecimalFormat> numberFormat(static_cast<DecimalFormat*>( 7551 NumberFormat::createInstance(locale, status))); 7552 CHECK_DATA(status,"NumberFormat::createInstance") 7553 7554 numberFormat->setSignificantDigitsUsed(TRUE); 7555 numberFormat->setMinimumSignificantDigits(3); 7556 numberFormat->setMaximumSignificantDigits(5); 7557 numberFormat->setGroupingUsed(false); 7558 7559 UnicodeString result; 7560 UnicodeString expectedResult; 7561 for (unsigned int i = 0; i < UPRV_LENGTHOF(input); ++i) { 7562 numberFormat->format(input[i], result); 7563 UnicodeString expectedResult(expected[i]); 7564 if (result != expectedResult) { 7565 errln((UnicodeString)"Expected: '" + expectedResult + "' got '" + result); 7566 } 7567 result.remove(); 7568 } 7569 } 7570 7571 void NumberFormatTest::TestShowZero() { 7572 UErrorCode status = U_ZERO_ERROR; 7573 Locale locale("en_US"); 7574 LocalPointer<DecimalFormat> numberFormat(static_cast<DecimalFormat*>( 7575 NumberFormat::createInstance(locale, status))); 7576 CHECK_DATA(status, "NumberFormat::createInstance") 7577 7578 numberFormat->setSignificantDigitsUsed(TRUE); 7579 numberFormat->setMaximumSignificantDigits(3); 7580 7581 UnicodeString result; 7582 numberFormat->format(0.0, result); 7583 if (result != "0") { 7584 errln((UnicodeString)"Expected: 0, got " + result); 7585 } 7586 } 7587 7588 void NumberFormatTest::TestBug9936() { 7589 UErrorCode status = U_ZERO_ERROR; 7590 Locale locale("en_US"); 7591 LocalPointer<DecimalFormat> numberFormat(static_cast<DecimalFormat*>( 7592 NumberFormat::createInstance(locale, status))); 7593 if (U_FAILURE(status)) { 7594 dataerrln("File %s, Line %d: status = %s.\n", __FILE__, __LINE__, u_errorName(status)); 7595 return; 7596 } 7597 7598 if (numberFormat->areSignificantDigitsUsed() == TRUE) { 7599 errln("File %s, Line %d: areSignificantDigitsUsed() was TRUE, expected FALSE.\n", __FILE__, __LINE__); 7600 } 7601 numberFormat->setSignificantDigitsUsed(TRUE); 7602 if (numberFormat->areSignificantDigitsUsed() == FALSE) { 7603 errln("File %s, Line %d: areSignificantDigitsUsed() was FALSE, expected TRUE.\n", __FILE__, __LINE__); 7604 } 7605 7606 numberFormat->setSignificantDigitsUsed(FALSE); 7607 if (numberFormat->areSignificantDigitsUsed() == TRUE) { 7608 errln("File %s, Line %d: areSignificantDigitsUsed() was TRUE, expected FALSE.\n", __FILE__, __LINE__); 7609 } 7610 7611 numberFormat->setMinimumSignificantDigits(3); 7612 if (numberFormat->areSignificantDigitsUsed() == FALSE) { 7613 errln("File %s, Line %d: areSignificantDigitsUsed() was FALSE, expected TRUE.\n", __FILE__, __LINE__); 7614 } 7615 7616 numberFormat->setSignificantDigitsUsed(FALSE); 7617 numberFormat->setMaximumSignificantDigits(6); 7618 if (numberFormat->areSignificantDigitsUsed() == FALSE) { 7619 errln("File %s, Line %d: areSignificantDigitsUsed() was FALSE, expected TRUE.\n", __FILE__, __LINE__); 7620 } 7621 7622 } 7623 7624 void NumberFormatTest::TestParseNegativeWithFaLocale() { 7625 UErrorCode status = U_ZERO_ERROR; 7626 DecimalFormat *test = (DecimalFormat *) NumberFormat::createInstance("fa", status); 7627 CHECK_DATA(status, "NumberFormat::createInstance") 7628 test->setLenient(TRUE); 7629 Formattable af; 7630 ParsePosition ppos; 7631 UnicodeString value("\\u200e-0,5"); 7632 value = value.unescape(); 7633 test->parse(value, af, ppos); 7634 if (ppos.getIndex() == 0) { 7635 errln("Expected -0,5 to parse for Farsi."); 7636 } 7637 delete test; 7638 } 7639 7640 void NumberFormatTest::TestParseNegativeWithAlternateMinusSign() { 7641 UErrorCode status = U_ZERO_ERROR; 7642 DecimalFormat *test = (DecimalFormat *) NumberFormat::createInstance("en", status); 7643 CHECK_DATA(status, "NumberFormat::createInstance") 7644 test->setLenient(TRUE); 7645 Formattable af; 7646 ParsePosition ppos; 7647 UnicodeString value("\\u208B0.5"); 7648 value = value.unescape(); 7649 test->parse(value, af, ppos); 7650 if (ppos.getIndex() == 0) { 7651 errln(UnicodeString("Expected ") + value + UnicodeString(" to parse.")); 7652 } 7653 delete test; 7654 } 7655 7656 void NumberFormatTest::TestCustomCurrencySignAndSeparator() { 7657 UErrorCode status = U_ZERO_ERROR; 7658 DecimalFormatSymbols custom(Locale::getUS(), status); 7659 CHECK(status, "DecimalFormatSymbols constructor"); 7660 7661 custom.setSymbol(DecimalFormatSymbols::kCurrencySymbol, "*"); 7662 custom.setSymbol(DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol, "^"); 7663 custom.setSymbol(DecimalFormatSymbols::kMonetarySeparatorSymbol, ":"); 7664 7665 UnicodeString pat(" #,##0.00"); 7666 pat.insert(0, (UChar)0x00A4); 7667 7668 DecimalFormat fmt(pat, custom, status); 7669 CHECK(status, "DecimalFormat constructor"); 7670 7671 UnicodeString numstr("* 1^234:56"); 7672 expect2(fmt, (Formattable)((double)1234.56), numstr); 7673 } 7674 7675 typedef struct { 7676 const char * locale; 7677 UBool lenient; 7678 UnicodeString numString; 7679 double value; 7680 } SignsAndMarksItem; 7681 7682 7683 void NumberFormatTest::TestParseSignsAndMarks() { 7684 const SignsAndMarksItem items[] = { 7685 // locale lenient numString value 7686 { "en", FALSE, CharsToUnicodeString("12"), 12 }, 7687 { "en", TRUE, CharsToUnicodeString("12"), 12 }, 7688 { "en", FALSE, CharsToUnicodeString("-23"), -23 }, 7689 { "en", TRUE, CharsToUnicodeString("-23"), -23 }, 7690 { "en", TRUE, CharsToUnicodeString("- 23"), -23 }, 7691 { "en", FALSE, CharsToUnicodeString("\\u200E-23"), -23 }, 7692 { "en", TRUE, CharsToUnicodeString("\\u200E-23"), -23 }, 7693 { "en", TRUE, CharsToUnicodeString("\\u200E- 23"), -23 }, 7694 7695 { "en@numbers=arab", FALSE, CharsToUnicodeString("\\u0663\\u0664"), 34 }, 7696 { "en@numbers=arab", TRUE, CharsToUnicodeString("\\u0663\\u0664"), 34 }, 7697 { "en@numbers=arab", FALSE, CharsToUnicodeString("-\\u0664\\u0665"), -45 }, 7698 { "en@numbers=arab", TRUE, CharsToUnicodeString("-\\u0664\\u0665"), -45 }, 7699 { "en@numbers=arab", TRUE, CharsToUnicodeString("- \\u0664\\u0665"), -45 }, 7700 { "en@numbers=arab", FALSE, CharsToUnicodeString("\\u200F-\\u0664\\u0665"), -45 }, 7701 { "en@numbers=arab", TRUE, CharsToUnicodeString("\\u200F-\\u0664\\u0665"), -45 }, 7702 { "en@numbers=arab", TRUE, CharsToUnicodeString("\\u200F- \\u0664\\u0665"), -45 }, 7703 7704 { "en@numbers=arabext", FALSE, CharsToUnicodeString("\\u06F5\\u06F6"), 56 }, 7705 { "en@numbers=arabext", TRUE, CharsToUnicodeString("\\u06F5\\u06F6"), 56 }, 7706 { "en@numbers=arabext", FALSE, CharsToUnicodeString("-\\u06F6\\u06F7"), -67 }, 7707 { "en@numbers=arabext", TRUE, CharsToUnicodeString("-\\u06F6\\u06F7"), -67 }, 7708 { "en@numbers=arabext", TRUE, CharsToUnicodeString("- \\u06F6\\u06F7"), -67 }, 7709 { "en@numbers=arabext", FALSE, CharsToUnicodeString("\\u200E-\\u200E\\u06F6\\u06F7"), -67 }, 7710 { "en@numbers=arabext", TRUE, CharsToUnicodeString("\\u200E-\\u200E\\u06F6\\u06F7"), -67 }, 7711 { "en@numbers=arabext", TRUE, CharsToUnicodeString("\\u200E-\\u200E \\u06F6\\u06F7"), -67 }, 7712 7713 { "he", FALSE, CharsToUnicodeString("12"), 12 }, 7714 { "he", TRUE, CharsToUnicodeString("12"), 12 }, 7715 { "he", FALSE, CharsToUnicodeString("-23"), -23 }, 7716 { "he", TRUE, CharsToUnicodeString("-23"), -23 }, 7717 { "he", TRUE, CharsToUnicodeString("- 23"), -23 }, 7718 { "he", FALSE, CharsToUnicodeString("\\u200E-23"), -23 }, 7719 { "he", TRUE, CharsToUnicodeString("\\u200E-23"), -23 }, 7720 { "he", TRUE, CharsToUnicodeString("\\u200E- 23"), -23 }, 7721 7722 { "ar", FALSE, CharsToUnicodeString("\\u0663\\u0664"), 34 }, 7723 { "ar", TRUE, CharsToUnicodeString("\\u0663\\u0664"), 34 }, 7724 { "ar", FALSE, CharsToUnicodeString("-\\u0664\\u0665"), -45 }, 7725 { "ar", TRUE, CharsToUnicodeString("-\\u0664\\u0665"), -45 }, 7726 { "ar", TRUE, CharsToUnicodeString("- \\u0664\\u0665"), -45 }, 7727 { "ar", FALSE, CharsToUnicodeString("\\u200F-\\u0664\\u0665"), -45 }, 7728 { "ar", TRUE, CharsToUnicodeString("\\u200F-\\u0664\\u0665"), -45 }, 7729 { "ar", TRUE, CharsToUnicodeString("\\u200F- \\u0664\\u0665"), -45 }, 7730 7731 { "ar_MA", FALSE, CharsToUnicodeString("12"), 12 }, 7732 { "ar_MA", TRUE, CharsToUnicodeString("12"), 12 }, 7733 { "ar_MA", FALSE, CharsToUnicodeString("-23"), -23 }, 7734 { "ar_MA", TRUE, CharsToUnicodeString("-23"), -23 }, 7735 { "ar_MA", TRUE, CharsToUnicodeString("- 23"), -23 }, 7736 { "ar_MA", FALSE, CharsToUnicodeString("\\u200E-23"), -23 }, 7737 { "ar_MA", TRUE, CharsToUnicodeString("\\u200E-23"), -23 }, 7738 { "ar_MA", TRUE, CharsToUnicodeString("\\u200E- 23"), -23 }, 7739 7740 { "fa", FALSE, CharsToUnicodeString("\\u06F5\\u06F6"), 56 }, 7741 { "fa", TRUE, CharsToUnicodeString("\\u06F5\\u06F6"), 56 }, 7742 { "fa", FALSE, CharsToUnicodeString("\\u2212\\u06F6\\u06F7"), -67 }, 7743 { "fa", TRUE, CharsToUnicodeString("\\u2212\\u06F6\\u06F7"), -67 }, 7744 { "fa", TRUE, CharsToUnicodeString("\\u2212 \\u06F6\\u06F7"), -67 }, 7745 { "fa", FALSE, CharsToUnicodeString("\\u200E\\u2212\\u200E\\u06F6\\u06F7"), -67 }, 7746 { "fa", TRUE, CharsToUnicodeString("\\u200E\\u2212\\u200E\\u06F6\\u06F7"), -67 }, 7747 { "fa", TRUE, CharsToUnicodeString("\\u200E\\u2212\\u200E \\u06F6\\u06F7"), -67 }, 7748 7749 { "ps", FALSE, CharsToUnicodeString("\\u06F5\\u06F6"), 56 }, 7750 { "ps", TRUE, CharsToUnicodeString("\\u06F5\\u06F6"), 56 }, 7751 { "ps", FALSE, CharsToUnicodeString("-\\u06F6\\u06F7"), -67 }, 7752 { "ps", TRUE, CharsToUnicodeString("-\\u06F6\\u06F7"), -67 }, 7753 { "ps", TRUE, CharsToUnicodeString("- \\u06F6\\u06F7"), -67 }, 7754 { "ps", FALSE, CharsToUnicodeString("\\u200E-\\u200E\\u06F6\\u06F7"), -67 }, 7755 { "ps", TRUE, CharsToUnicodeString("\\u200E-\\u200E\\u06F6\\u06F7"), -67 }, 7756 { "ps", TRUE, CharsToUnicodeString("\\u200E-\\u200E \\u06F6\\u06F7"), -67 }, 7757 { "ps", FALSE, CharsToUnicodeString("-\\u200E\\u06F6\\u06F7"), -67 }, 7758 { "ps", TRUE, CharsToUnicodeString("-\\u200E\\u06F6\\u06F7"), -67 }, 7759 { "ps", TRUE, CharsToUnicodeString("-\\u200E \\u06F6\\u06F7"), -67 }, 7760 // terminator 7761 { NULL, 0, UnicodeString(""), 0 }, 7762 }; 7763 7764 const SignsAndMarksItem * itemPtr; 7765 for (itemPtr = items; itemPtr->locale != NULL; itemPtr++ ) { 7766 UErrorCode status = U_ZERO_ERROR; 7767 NumberFormat *numfmt = NumberFormat::createInstance(Locale(itemPtr->locale), status); 7768 if (U_SUCCESS(status)) { 7769 numfmt->setLenient(itemPtr->lenient); 7770 Formattable fmtobj; 7771 ParsePosition ppos; 7772 numfmt->parse(itemPtr->numString, fmtobj, ppos); 7773 if (ppos.getIndex() == itemPtr->numString.length()) { 7774 double parsedValue = fmtobj.getDouble(status); 7775 if (U_FAILURE(status) || parsedValue != itemPtr->value) { 7776 errln((UnicodeString)"FAIL: locale " + itemPtr->locale + ", lenient " + itemPtr->lenient + ", parse of \"" + itemPtr->numString + "\" gives value " + parsedValue); 7777 } 7778 } else { 7779 errln((UnicodeString)"FAIL: locale " + itemPtr->locale + ", lenient " + itemPtr->lenient + ", parse of \"" + itemPtr->numString + "\" gives position " + ppos.getIndex()); 7780 } 7781 } else { 7782 dataerrln("FAIL: NumberFormat::createInstance for locale % gives error %s", itemPtr->locale, u_errorName(status)); 7783 } 7784 delete numfmt; 7785 } 7786 } 7787 7788 typedef struct { 7789 DecimalFormat::ERoundingMode mode; 7790 double value; 7791 UnicodeString expected; 7792 } Test10419Data; 7793 7794 7795 // Tests that rounding works right when fractional digits is set to 0. 7796 void NumberFormatTest::Test10419RoundingWith0FractionDigits() { 7797 const Test10419Data items[] = { 7798 { DecimalFormat::kRoundCeiling, 1.488, "2"}, 7799 { DecimalFormat::kRoundDown, 1.588, "1"}, 7800 { DecimalFormat::kRoundFloor, 1.888, "1"}, 7801 { DecimalFormat::kRoundHalfDown, 1.5, "1"}, 7802 { DecimalFormat::kRoundHalfEven, 2.5, "2"}, 7803 { DecimalFormat::kRoundHalfUp, 2.5, "3"}, 7804 { DecimalFormat::kRoundUp, 1.5, "2"}, 7805 }; 7806 UErrorCode status = U_ZERO_ERROR; 7807 LocalPointer<DecimalFormat> decfmt((DecimalFormat *) NumberFormat::createInstance(Locale("en_US"), status)); 7808 if (U_FAILURE(status)) { 7809 dataerrln("Failure creating DecimalFormat %s", u_errorName(status)); 7810 return; 7811 } 7812 for (int32_t i = 0; i < UPRV_LENGTHOF(items); ++i) { 7813 decfmt->setRoundingMode(items[i].mode); 7814 decfmt->setMaximumFractionDigits(0); 7815 UnicodeString actual; 7816 if (items[i].expected != decfmt->format(items[i].value, actual)) { 7817 errln("Expected " + items[i].expected + ", got " + actual); 7818 } 7819 } 7820 } 7821 7822 void NumberFormatTest::Test10468ApplyPattern() { 7823 // Padding char of fmt is now 'a' 7824 UErrorCode status = U_ZERO_ERROR; 7825 DecimalFormat fmt("'I''ll'*a###.##", status); 7826 7827 if (U_FAILURE(status)) { 7828 errcheckln(status, "DecimalFormat constructor failed - %s", u_errorName(status)); 7829 return; 7830 } 7831 7832 if (fmt.getPadCharacterString() != UnicodeString("a")) { 7833 errln("Padding character should be 'a'."); 7834 return; 7835 } 7836 7837 // Padding char of fmt ought to be '*' since that is the default and no 7838 // explicit padding char is specified in the new pattern. 7839 fmt.applyPattern("AA#,##0.00ZZ", status); 7840 7841 // Oops this still prints 'a' even though we changed the pattern. 7842 if (fmt.getPadCharacterString() != UnicodeString(" ")) { 7843 errln("applyPattern did not clear padding character."); 7844 } 7845 } 7846 7847 void NumberFormatTest::TestRoundingScientific10542() { 7848 UErrorCode status = U_ZERO_ERROR; 7849 DecimalFormat format("0.00E0", status); 7850 if (U_FAILURE(status)) { 7851 errcheckln(status, "DecimalFormat constructor failed - %s", u_errorName(status)); 7852 return; 7853 } 7854 7855 DecimalFormat::ERoundingMode roundingModes[] = { 7856 DecimalFormat::kRoundCeiling, 7857 DecimalFormat::kRoundDown, 7858 DecimalFormat::kRoundFloor, 7859 DecimalFormat::kRoundHalfDown, 7860 DecimalFormat::kRoundHalfEven, 7861 DecimalFormat::kRoundHalfUp, 7862 DecimalFormat::kRoundUp}; 7863 const char *descriptions[] = { 7864 "Round Ceiling", 7865 "Round Down", 7866 "Round Floor", 7867 "Round half down", 7868 "Round half even", 7869 "Round half up", 7870 "Round up"}; 7871 7872 { 7873 double values[] = {-0.003006, -0.003005, -0.003004, 0.003014, 0.003015, 0.003016}; 7874 // The order of these expected values correspond to the order of roundingModes and the order of values. 7875 const char *expected[] = { 7876 "-3.00E-3", "-3.00E-3", "-3.00E-3", "3.02E-3", "3.02E-3", "3.02E-3", 7877 "-3.00E-3", "-3.00E-3", "-3.00E-3", "3.01E-3", "3.01E-3", "3.01E-3", 7878 "-3.01E-3", "-3.01E-3", "-3.01E-3", "3.01E-3", "3.01E-3", "3.01E-3", 7879 "-3.01E-3", "-3.00E-3", "-3.00E-3", "3.01E-3", "3.01E-3", "3.02E-3", 7880 "-3.01E-3", "-3.00E-3", "-3.00E-3", "3.01E-3", "3.02E-3", "3.02E-3", 7881 "-3.01E-3", "-3.01E-3", "-3.00E-3", "3.01E-3", "3.02E-3", "3.02E-3", 7882 "-3.01E-3", "-3.01E-3", "-3.01E-3", "3.02E-3", "3.02E-3", "3.02E-3"}; 7883 verifyRounding( 7884 format, 7885 values, 7886 expected, 7887 roundingModes, 7888 descriptions, 7889 UPRV_LENGTHOF(values), 7890 UPRV_LENGTHOF(roundingModes)); 7891 } 7892 { 7893 double values[] = {-3006.0, -3005, -3004, 3014, 3015, 3016}; 7894 // The order of these expected values correspond to the order of roundingModes and the order of values. 7895 const char *expected[] = { 7896 "-3.00E3", "-3.00E3", "-3.00E3", "3.02E3", "3.02E3", "3.02E3", 7897 "-3.00E3", "-3.00E3", "-3.00E3", "3.01E3", "3.01E3", "3.01E3", 7898 "-3.01E3", "-3.01E3", "-3.01E3", "3.01E3", "3.01E3", "3.01E3", 7899 "-3.01E3", "-3.00E3", "-3.00E3", "3.01E3", "3.01E3", "3.02E3", 7900 "-3.01E3", "-3.00E3", "-3.00E3", "3.01E3", "3.02E3", "3.02E3", 7901 "-3.01E3", "-3.01E3", "-3.00E3", "3.01E3", "3.02E3", "3.02E3", 7902 "-3.01E3", "-3.01E3", "-3.01E3", "3.02E3", "3.02E3", "3.02E3"}; 7903 verifyRounding( 7904 format, 7905 values, 7906 expected, 7907 roundingModes, 7908 descriptions, 7909 UPRV_LENGTHOF(values), 7910 UPRV_LENGTHOF(roundingModes)); 7911 } 7912 /* Commented out for now until we decide how rounding to zero should work, +0 vs. -0 7913 { 7914 double values[] = {0.0, -0.0}; 7915 // The order of these expected values correspond to the order of roundingModes and the order of values. 7916 const char *expected[] = { 7917 "0.00E0", "-0.00E0", 7918 "0.00E0", "-0.00E0", 7919 "0.00E0", "-0.00E0", 7920 "0.00E0", "-0.00E0", 7921 "0.00E0", "-0.00E0", 7922 "0.00E0", "-0.00E0", 7923 "0.00E0", "-0.00E0"}; 7924 verifyRounding( 7925 format, 7926 values, 7927 expected, 7928 roundingModes, 7929 descriptions, 7930 UPRV_LENGTHOF(values), 7931 UPRV_LENGTHOF(roundingModes)); 7932 } 7933 */ 7934 { 7935 7936 double values[] = {1e25, 1e25 + 1e15, 1e25 - 1e15}; 7937 // The order of these expected values correspond to the order of roundingModes and the order of values. 7938 const char *expected[] = { 7939 "1.00E25", "1.01E25", "1.00E25", 7940 "1.00E25", "1.00E25", "9.99E24", 7941 "1.00E25", "1.00E25", "9.99E24", 7942 "1.00E25", "1.00E25", "1.00E25", 7943 "1.00E25", "1.00E25", "1.00E25", 7944 "1.00E25", "1.00E25", "1.00E25", 7945 "1.00E25", "1.01E25", "1.00E25"}; 7946 verifyRounding( 7947 format, 7948 values, 7949 expected, 7950 roundingModes, 7951 descriptions, 7952 UPRV_LENGTHOF(values), 7953 UPRV_LENGTHOF(roundingModes)); 7954 } 7955 { 7956 double values[] = {-1e25, -1e25 + 1e15, -1e25 - 1e15}; 7957 // The order of these expected values correspond to the order of roundingModes and the order of values. 7958 const char *expected[] = { 7959 "-1.00E25", "-9.99E24", "-1.00E25", 7960 "-1.00E25", "-9.99E24", "-1.00E25", 7961 "-1.00E25", "-1.00E25", "-1.01E25", 7962 "-1.00E25", "-1.00E25", "-1.00E25", 7963 "-1.00E25", "-1.00E25", "-1.00E25", 7964 "-1.00E25", "-1.00E25", "-1.00E25", 7965 "-1.00E25", "-1.00E25", "-1.01E25"}; 7966 verifyRounding( 7967 format, 7968 values, 7969 expected, 7970 roundingModes, 7971 descriptions, 7972 UPRV_LENGTHOF(values), 7973 UPRV_LENGTHOF(roundingModes)); 7974 } 7975 { 7976 double values[] = {1e-25, 1e-25 + 1e-35, 1e-25 - 1e-35}; 7977 // The order of these expected values correspond to the order of roundingModes and the order of values. 7978 const char *expected[] = { 7979 "1.00E-25", "1.01E-25", "1.00E-25", 7980 "1.00E-25", "1.00E-25", "9.99E-26", 7981 "1.00E-25", "1.00E-25", "9.99E-26", 7982 "1.00E-25", "1.00E-25", "1.00E-25", 7983 "1.00E-25", "1.00E-25", "1.00E-25", 7984 "1.00E-25", "1.00E-25", "1.00E-25", 7985 "1.00E-25", "1.01E-25", "1.00E-25"}; 7986 verifyRounding( 7987 format, 7988 values, 7989 expected, 7990 roundingModes, 7991 descriptions, 7992 UPRV_LENGTHOF(values), 7993 UPRV_LENGTHOF(roundingModes)); 7994 } 7995 { 7996 double values[] = {-1e-25, -1e-25 + 1e-35, -1e-25 - 1e-35}; 7997 // The order of these expected values correspond to the order of roundingModes and the order of values. 7998 const char *expected[] = { 7999 "-1.00E-25", "-9.99E-26", "-1.00E-25", 8000 "-1.00E-25", "-9.99E-26", "-1.00E-25", 8001 "-1.00E-25", "-1.00E-25", "-1.01E-25", 8002 "-1.00E-25", "-1.00E-25", "-1.00E-25", 8003 "-1.00E-25", "-1.00E-25", "-1.00E-25", 8004 "-1.00E-25", "-1.00E-25", "-1.00E-25", 8005 "-1.00E-25", "-1.00E-25", "-1.01E-25"}; 8006 verifyRounding( 8007 format, 8008 values, 8009 expected, 8010 roundingModes, 8011 descriptions, 8012 UPRV_LENGTHOF(values), 8013 UPRV_LENGTHOF(roundingModes)); 8014 } 8015 } 8016 8017 void NumberFormatTest::TestZeroScientific10547() { 8018 UErrorCode status = U_ZERO_ERROR; 8019 DecimalFormat fmt("0.00E0", status); 8020 if (!assertSuccess("Formt creation", status)) { 8021 return; 8022 } 8023 UnicodeString out; 8024 fmt.format(-0.0, out); 8025 assertEquals("format", "-0.00E0", out); 8026 } 8027 8028 void NumberFormatTest::verifyRounding( 8029 DecimalFormat& format, 8030 const double *values, 8031 const char * const *expected, 8032 const DecimalFormat::ERoundingMode *roundingModes, 8033 const char * const *descriptions, 8034 int32_t valueSize, 8035 int32_t roundingModeSize) { 8036 for (int32_t i = 0; i < roundingModeSize; ++i) { 8037 format.setRoundingMode(roundingModes[i]); 8038 for (int32_t j = 0; j < valueSize; j++) { 8039 UnicodeString currentExpected(expected[i * valueSize + j]); 8040 currentExpected = currentExpected.unescape(); 8041 UnicodeString actual; 8042 format.format(values[j], actual); 8043 if (currentExpected != actual) { 8044 char buffer[256]; 8045 sprintf( 8046 buffer, 8047 "For %s value %f, expected ", 8048 descriptions[i], 8049 values[j]); 8050 errln(UnicodeString(buffer) + currentExpected + ", got " + actual); 8051 } 8052 } 8053 } 8054 } 8055 8056 void NumberFormatTest::TestAccountingCurrency() { 8057 UErrorCode status = U_ZERO_ERROR; 8058 UNumberFormatStyle style = UNUM_CURRENCY_ACCOUNTING; 8059 8060 expect(NumberFormat::createInstance("en_US", style, status), 8061 (Formattable)(double)1234.5, "$1,234.50", TRUE, status); 8062 expect(NumberFormat::createInstance("en_US", style, status), 8063 (Formattable)(double)-1234.5, "($1,234.50)", TRUE, status); 8064 expect(NumberFormat::createInstance("en_US", style, status), 8065 (Formattable)(double)0, "$0.00", TRUE, status); 8066 expect(NumberFormat::createInstance("en_US", style, status), 8067 (Formattable)(double)-0.2, "($0.20)", TRUE, status); 8068 expect(NumberFormat::createInstance("ja_JP", style, status), 8069 (Formattable)(double)10000, UnicodeString("\\uFFE510,000").unescape(), TRUE, status); 8070 expect(NumberFormat::createInstance("ja_JP", style, status), 8071 (Formattable)(double)-1000.5, UnicodeString("(\\uFFE51,000)").unescape(), FALSE, status); 8072 expect(NumberFormat::createInstance("de_DE", style, status), 8073 (Formattable)(double)-23456.7, UnicodeString("-23.456,70\\u00A0\\u20AC").unescape(), TRUE, status); 8074 } 8075 8076 // for #5186 8077 void NumberFormatTest::TestEquality() { 8078 UErrorCode status = U_ZERO_ERROR; 8079 DecimalFormatSymbols* symbols = new DecimalFormatSymbols(Locale("root"), status); 8080 if (U_FAILURE(status)) { 8081 dataerrln("Fail: can't create DecimalFormatSymbols for root"); 8082 return; 8083 } 8084 UnicodeString pattern("#,##0.###"); 8085 DecimalFormat* fmtBase = new DecimalFormat(pattern, symbols, status); 8086 if (U_FAILURE(status)) { 8087 dataerrln("Fail: can't create DecimalFormat using root symbols"); 8088 return; 8089 } 8090 8091 DecimalFormat* fmtClone = (DecimalFormat*)fmtBase->clone(); 8092 fmtClone->setFormatWidth(fmtBase->getFormatWidth() + 32); 8093 if (*fmtClone == *fmtBase) { 8094 errln("Error: DecimalFormat == does not distinguish objects that differ only in FormatWidth"); 8095 } 8096 delete fmtClone; 8097 8098 delete fmtBase; 8099 } 8100 8101 void NumberFormatTest::TestCurrencyUsage() { 8102 double agent = 123.567; 8103 8104 UErrorCode status; 8105 DecimalFormat *fmt; 8106 8107 // compare the Currency and Currency Cash Digits 8108 // Note that as of CLDR 26: 8109 // * TWD switches from 0 decimals to 2; PKR still has 0, so change test to that 8110 // * CAD rounds to .05 in cash mode only 8111 // 1st time for getter/setter, 2nd time for factory method 8112 Locale enUS_PKR("en_US@currency=PKR"); 8113 8114 for(int i=0; i<2; i++){ 8115 status = U_ZERO_ERROR; 8116 if(i == 0){ 8117 fmt = (DecimalFormat *) NumberFormat::createInstance(enUS_PKR, UNUM_CURRENCY, status); 8118 if (assertSuccess("en_US@currency=PKR/CURRENCY", status, TRUE) == FALSE) { 8119 continue; 8120 } 8121 8122 UnicodeString original; 8123 fmt->format(agent,original); 8124 assertEquals("Test Currency Usage 1", UnicodeString("PKR124"), original); 8125 8126 // test the getter here 8127 UCurrencyUsage curUsage = fmt->getCurrencyUsage(); 8128 assertEquals("Test usage getter - standard", (int32_t)curUsage, (int32_t)UCURR_USAGE_STANDARD); 8129 8130 fmt->setCurrencyUsage(UCURR_USAGE_CASH, &status); 8131 }else{ 8132 fmt = (DecimalFormat *) NumberFormat::createInstance(enUS_PKR, UNUM_CASH_CURRENCY, status); 8133 if (assertSuccess("en_US@currency=PKR/CASH", status, TRUE) == FALSE) { 8134 continue; 8135 } 8136 } 8137 8138 // must be usage = cash 8139 UCurrencyUsage curUsage = fmt->getCurrencyUsage(); 8140 assertEquals("Test usage getter - cash", (int32_t)curUsage, (int32_t)UCURR_USAGE_CASH); 8141 8142 UnicodeString cash_currency; 8143 fmt->format(agent,cash_currency); 8144 assertEquals("Test Currency Usage 2", UnicodeString("PKR124"), cash_currency); 8145 delete fmt; 8146 } 8147 8148 // compare the Currency and Currency Cash Rounding 8149 // 1st time for getter/setter, 2nd time for factory method 8150 Locale enUS_CAD("en_US@currency=CAD"); 8151 for(int i=0; i<2; i++){ 8152 status = U_ZERO_ERROR; 8153 if(i == 0){ 8154 fmt = (DecimalFormat *) NumberFormat::createInstance(enUS_CAD, UNUM_CURRENCY, status); 8155 if (assertSuccess("en_US@currency=CAD/CURRENCY", status, TRUE) == FALSE) { 8156 continue; 8157 } 8158 8159 UnicodeString original_rounding; 8160 fmt->format(agent, original_rounding); 8161 assertEquals("Test Currency Usage 3", UnicodeString("CA$123.57"), original_rounding); 8162 fmt->setCurrencyUsage(UCURR_USAGE_CASH, &status); 8163 }else{ 8164 fmt = (DecimalFormat *) NumberFormat::createInstance(enUS_CAD, UNUM_CASH_CURRENCY, status); 8165 if (assertSuccess("en_US@currency=CAD/CASH", status, TRUE) == FALSE) { 8166 continue; 8167 } 8168 } 8169 8170 UnicodeString cash_rounding_currency; 8171 fmt->format(agent, cash_rounding_currency); 8172 assertEquals("Test Currency Usage 4", UnicodeString("CA$123.55"), cash_rounding_currency); 8173 delete fmt; 8174 } 8175 8176 // Test the currency change 8177 // 1st time for getter/setter, 2nd time for factory method 8178 const UChar CUR_PKR[] = {0x50, 0x4B, 0x52, 0}; 8179 for(int i=0; i<2; i++){ 8180 status = U_ZERO_ERROR; 8181 if(i == 0){ 8182 fmt = (DecimalFormat *) NumberFormat::createInstance(enUS_CAD, UNUM_CURRENCY, status); 8183 if (assertSuccess("en_US@currency=CAD/CURRENCY", status, TRUE) == FALSE) { 8184 continue; 8185 } 8186 fmt->setCurrencyUsage(UCURR_USAGE_CASH, &status); 8187 }else{ 8188 fmt = (DecimalFormat *) NumberFormat::createInstance(enUS_CAD, UNUM_CASH_CURRENCY, status); 8189 if (assertSuccess("en_US@currency=CAD/CASH", status, TRUE) == FALSE) { 8190 continue; 8191 } 8192 } 8193 8194 UnicodeString cur_original; 8195 fmt->setCurrencyUsage(UCURR_USAGE_STANDARD, &status); 8196 fmt->format(agent, cur_original); 8197 assertEquals("Test Currency Usage 5", UnicodeString("CA$123.57"), cur_original); 8198 8199 fmt->setCurrency(CUR_PKR, status); 8200 assertSuccess("Set currency to PKR", status); 8201 8202 UnicodeString PKR_changed; 8203 fmt->format(agent, PKR_changed); 8204 assertEquals("Test Currency Usage 6", UnicodeString("PKR124"), PKR_changed); 8205 delete fmt; 8206 } 8207 } 8208 8209 void NumberFormatTest::TestNumberFormatTestTuple() { 8210 NumberFormatTestTuple tuple; 8211 UErrorCode status = U_ZERO_ERROR; 8212 8213 tuple.setField( 8214 NumberFormatTestTuple::getFieldByName("locale"), 8215 "en", 8216 status); 8217 tuple.setField( 8218 NumberFormatTestTuple::getFieldByName("pattern"), 8219 "#,##0.00", 8220 status); 8221 tuple.setField( 8222 NumberFormatTestTuple::getFieldByName("minIntegerDigits"), 8223 "-10", 8224 status); 8225 if (!assertSuccess("", status)) { 8226 return; 8227 } 8228 8229 // only what we set should be set. 8230 assertEquals("", "en", tuple.locale.getName()); 8231 assertEquals("", "#,##0.00", tuple.pattern); 8232 assertEquals("", -10, tuple.minIntegerDigits); 8233 assertTrue("", tuple.localeFlag); 8234 assertTrue("", tuple.patternFlag); 8235 assertTrue("", tuple.minIntegerDigitsFlag); 8236 assertFalse("", tuple.formatFlag); 8237 8238 UnicodeString appendTo; 8239 assertEquals( 8240 "", 8241 "{locale: en, pattern: #,##0.00, minIntegerDigits: -10}", 8242 tuple.toString(appendTo)); 8243 8244 tuple.clear(); 8245 appendTo.remove(); 8246 assertEquals( 8247 "", 8248 "{}", 8249 tuple.toString(appendTo)); 8250 tuple.setField( 8251 NumberFormatTestTuple::getFieldByName("aBadFieldName"), 8252 "someValue", 8253 status); 8254 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 8255 errln("Expected U_ILLEGAL_ARGUMENT_ERROR"); 8256 } 8257 status = U_ZERO_ERROR; 8258 tuple.setField( 8259 NumberFormatTestTuple::getFieldByName("minIntegerDigits"), 8260 "someBadValue", 8261 status); 8262 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 8263 errln("Expected U_ILLEGAL_ARGUMENT_ERROR"); 8264 } 8265 } 8266 8267 void 8268 NumberFormatTest::TestDataDriven() { 8269 NumberFormatTestDataDriven dd; 8270 dd.setCaller(this); 8271 dd.run("numberformattestspecification.txt", FALSE); 8272 } 8273 8274 8275 // Check the constant MAX_INT64_IN_DOUBLE. 8276 // The value should convert to a double with no loss of precision. 8277 // A failure may indicate a platform with a different double format, requiring 8278 // a revision to the constant. 8279 // 8280 // Note that this is actually hard to test, because the language standard gives 8281 // compilers considerable flexibility to do unexpected things with rounding and 8282 // with overflow in simple int to/from float conversions. Some compilers will completely optimize 8283 // away a simple round-trip conversion from int64_t -> double -> int64_t. 8284 8285 void NumberFormatTest::TestDoubleLimit11439() { 8286 char buf[50]; 8287 for (int64_t num = MAX_INT64_IN_DOUBLE-10; num<=MAX_INT64_IN_DOUBLE; num++) { 8288 sprintf(buf, "%lld", (long long)num); 8289 double fNum = 0.0; 8290 sscanf(buf, "%lf", &fNum); 8291 int64_t rtNum = fNum; 8292 if (num != rtNum) { 8293 errln("%s:%d MAX_INT64_IN_DOUBLE test, %lld did not round trip. Got %lld", __FILE__, __LINE__, (long long)num, (long long)rtNum); 8294 return; 8295 } 8296 } 8297 for (int64_t num = -MAX_INT64_IN_DOUBLE+10; num>=-MAX_INT64_IN_DOUBLE; num--) { 8298 sprintf(buf, "%lld", (long long)num); 8299 double fNum = 0.0; 8300 sscanf(buf, "%lf", &fNum); 8301 int64_t rtNum = fNum; 8302 if (num != rtNum) { 8303 errln("%s:%d MAX_INT64_IN_DOUBLE test, %lld did not round trip. Got %lld", __FILE__, __LINE__, (long long)num, (long long)rtNum); 8304 return; 8305 } 8306 } 8307 } 8308 8309 void NumberFormatTest::TestFastPathConsistent11524() { 8310 UErrorCode status = U_ZERO_ERROR; 8311 NumberFormat *fmt = NumberFormat::createInstance("en", status); 8312 if (U_FAILURE(status) || fmt == NULL) { 8313 dataerrln("Failed call to NumberFormat::createInstance() - %s", u_errorName(status)); 8314 return; 8315 } 8316 fmt->setMaximumIntegerDigits(INT32_MIN); 8317 UnicodeString appendTo; 8318 assertEquals("", "0", fmt->format((int32_t)123, appendTo)); 8319 appendTo.remove(); 8320 assertEquals("", "0", fmt->format((int32_t)12345, appendTo)); 8321 delete fmt; 8322 } 8323 8324 void NumberFormatTest::TestGetAffixes() { 8325 UErrorCode status = U_ZERO_ERROR; 8326 DecimalFormatSymbols sym("en_US", status); 8327 UnicodeString pattern("\\u00a4\\u00a4\\u00a4 0.00 %\\u00a4\\u00a4"); 8328 pattern = pattern.unescape(); 8329 DecimalFormat fmt(pattern, sym, status); 8330 if (U_FAILURE(status)) { 8331 dataerrln("Error creating DecimalFormat - %s", u_errorName(status)); 8332 return; 8333 } 8334 UnicodeString affixStr; 8335 assertEquals("", "US dollars ", fmt.getPositivePrefix(affixStr)); 8336 assertEquals("", " %USD", fmt.getPositiveSuffix(affixStr)); 8337 assertEquals("", "-US dollars ", fmt.getNegativePrefix(affixStr)); 8338 assertEquals("", " %USD", fmt.getNegativeSuffix(affixStr)); 8339 8340 // Test equality with affixes. set affix methods can't capture special 8341 // characters which is why equality should fail. 8342 { 8343 DecimalFormat fmtCopy(fmt); 8344 assertTrue("", fmt == fmtCopy); 8345 UnicodeString someAffix; 8346 fmtCopy.setPositivePrefix(fmtCopy.getPositivePrefix(someAffix)); 8347 assertTrue("", fmt != fmtCopy); 8348 } 8349 { 8350 DecimalFormat fmtCopy(fmt); 8351 assertTrue("", fmt == fmtCopy); 8352 UnicodeString someAffix; 8353 fmtCopy.setPositiveSuffix(fmtCopy.getPositiveSuffix(someAffix)); 8354 assertTrue("", fmt != fmtCopy); 8355 } 8356 { 8357 DecimalFormat fmtCopy(fmt); 8358 assertTrue("", fmt == fmtCopy); 8359 UnicodeString someAffix; 8360 fmtCopy.setNegativePrefix(fmtCopy.getNegativePrefix(someAffix)); 8361 assertTrue("", fmt != fmtCopy); 8362 } 8363 { 8364 DecimalFormat fmtCopy(fmt); 8365 assertTrue("", fmt == fmtCopy); 8366 UnicodeString someAffix; 8367 fmtCopy.setNegativeSuffix(fmtCopy.getNegativeSuffix(someAffix)); 8368 assertTrue("", fmt != fmtCopy); 8369 } 8370 fmt.setPositivePrefix("Don't"); 8371 fmt.setPositiveSuffix("do"); 8372 UnicodeString someAffix("be''eet\\u00a4\\u00a4\\u00a4 it."); 8373 someAffix = someAffix.unescape(); 8374 fmt.setNegativePrefix(someAffix); 8375 fmt.setNegativeSuffix("%"); 8376 assertEquals("", "Don't", fmt.getPositivePrefix(affixStr)); 8377 assertEquals("", "do", fmt.getPositiveSuffix(affixStr)); 8378 assertEquals("", someAffix, fmt.getNegativePrefix(affixStr)); 8379 assertEquals("", "%", fmt.getNegativeSuffix(affixStr)); 8380 } 8381 8382 void NumberFormatTest::TestToPatternScientific11648() { 8383 UErrorCode status = U_ZERO_ERROR; 8384 Locale en("en"); 8385 DecimalFormatSymbols sym(en, status); 8386 DecimalFormat fmt("0.00", sym, status); 8387 if (U_FAILURE(status)) { 8388 dataerrln("Error creating DecimalFormat - %s", u_errorName(status)); 8389 return; 8390 } 8391 fmt.setScientificNotation(TRUE); 8392 UnicodeString pattern; 8393 assertEquals("", "0.00E0", fmt.toPattern(pattern)); 8394 DecimalFormat fmt2(pattern, sym, status); 8395 assertSuccess("", status); 8396 } 8397 8398 void NumberFormatTest::TestBenchmark() { 8399 /* 8400 UErrorCode status = U_ZERO_ERROR; 8401 Locale en("en"); 8402 DecimalFormatSymbols sym(en, status); 8403 DecimalFormat fmt("0.0000000", new DecimalFormatSymbols(sym), status); 8404 // DecimalFormat fmt("0.00000E0", new DecimalFormatSymbols(sym), status); 8405 // DecimalFormat fmt("0", new DecimalFormatSymbols(sym), status); 8406 FieldPosition fpos(FieldPosition::DONT_CARE); 8407 clock_t start = clock(); 8408 for (int32_t i = 0; i < 1000000; ++i) { 8409 UnicodeString append; 8410 fmt.format(3.0, append, fpos, status); 8411 // fmt.format(4.6692016, append, fpos, status); 8412 // fmt.format(1234567.8901, append, fpos, status); 8413 // fmt.format(2.99792458E8, append, fpos, status); 8414 // fmt.format(31, append); 8415 } 8416 errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC); 8417 assertSuccess("", status); 8418 8419 UErrorCode status = U_ZERO_ERROR; 8420 MessageFormat fmt("{0, plural, one {I have # friend.} other {I have # friends.}}", status); 8421 FieldPosition fpos(FieldPosition::DONT_CARE); 8422 Formattable one(1.0); 8423 Formattable three(3.0); 8424 clock_t start = clock(); 8425 for (int32_t i = 0; i < 500000; ++i) { 8426 UnicodeString append; 8427 fmt.format(&one, 1, append, fpos, status); 8428 UnicodeString append2; 8429 fmt.format(&three, 1, append2, fpos, status); 8430 } 8431 errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC); 8432 assertSuccess("", status); 8433 8434 UErrorCode status = U_ZERO_ERROR; 8435 Locale en("en"); 8436 Measure measureC(23, MeasureUnit::createCelsius(status), status); 8437 MeasureFormat fmt(en, UMEASFMT_WIDTH_WIDE, status); 8438 FieldPosition fpos(FieldPosition::DONT_CARE); 8439 clock_t start = clock(); 8440 for (int32_t i = 0; i < 1000000; ++i) { 8441 UnicodeString appendTo; 8442 fmt.formatMeasures( 8443 &measureC, 1, appendTo, fpos, status); 8444 } 8445 errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC); 8446 assertSuccess("", status); 8447 */ 8448 } 8449 8450 void NumberFormatTest::TestFractionalDigitsForCurrency() { 8451 UErrorCode status = U_ZERO_ERROR; 8452 LocalPointer<NumberFormat> fmt(NumberFormat::createCurrencyInstance("en", status)); 8453 if (U_FAILURE(status)) { 8454 dataerrln("Error creating NumberFormat - %s", u_errorName(status)); 8455 return; 8456 } 8457 UChar JPY[] = {0x4A, 0x50, 0x59, 0x0}; 8458 fmt->setCurrency(JPY, status); 8459 if (!assertSuccess("", status)) { 8460 return; 8461 } 8462 assertEquals("", 0, fmt->getMaximumFractionDigits()); 8463 } 8464 8465 8466 void NumberFormatTest::TestFormatCurrencyPlural() { 8467 UErrorCode status = U_ZERO_ERROR; 8468 Locale locale = Locale::createCanonical("en_US"); 8469 NumberFormat *fmt = NumberFormat::createInstance(locale, UNUM_CURRENCY_PLURAL, status); 8470 if (U_FAILURE(status)) { 8471 dataerrln("Error creating NumberFormat - %s", u_errorName(status)); 8472 return; 8473 } 8474 UnicodeString formattedNum; 8475 fmt->format(11234.567, formattedNum, NULL, status); 8476 assertEquals("", "11,234.57 US dollars", formattedNum); 8477 delete fmt; 8478 } 8479 8480 void NumberFormatTest::TestCtorApplyPatternDifference() { 8481 UErrorCode status = U_ZERO_ERROR; 8482 DecimalFormatSymbols sym("en_US", status); 8483 UnicodeString pattern("\\u00a40"); 8484 DecimalFormat fmt(pattern.unescape(), sym, status); 8485 if (U_FAILURE(status)) { 8486 dataerrln("Error creating DecimalFormat - %s", u_errorName(status)); 8487 return; 8488 } 8489 UnicodeString result; 8490 assertEquals( 8491 "ctor favors precision of currency", 8492 "$5.00", 8493 fmt.format((double)5, result)); 8494 result.remove(); 8495 fmt.applyPattern(pattern.unescape(), status); 8496 assertEquals( 8497 "applyPattern favors precision of pattern", 8498 "$5", 8499 fmt.format((double)5, result)); 8500 } 8501 8502 void NumberFormatTest::Test11868() { 8503 double posAmt = 34.567; 8504 double negAmt = -9876.543; 8505 8506 Locale selectedLocale("en_US"); 8507 UErrorCode status = U_ZERO_ERROR; 8508 8509 UnicodeString result; 8510 FieldPosition fpCurr(UNUM_CURRENCY_FIELD); 8511 LocalPointer<NumberFormat> fmt( 8512 NumberFormat::createInstance( 8513 selectedLocale, UNUM_CURRENCY_PLURAL, status)); 8514 if (!assertSuccess("Format creation", status)) { 8515 return; 8516 } 8517 fmt->format(posAmt, result, fpCurr, status); 8518 assertEquals("", "34.57 US dollars", result); 8519 assertEquals("begin index", 6, fpCurr.getBeginIndex()); 8520 assertEquals("end index", 16, fpCurr.getEndIndex()); 8521 8522 // Test field position iterator 8523 { 8524 NumberFormatTest_Attributes attributes[] = { 8525 {UNUM_INTEGER_FIELD, 0, 2}, 8526 {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3}, 8527 {UNUM_FRACTION_FIELD, 3, 5}, 8528 {UNUM_CURRENCY_FIELD, 6, 16}, 8529 {0, -1, 0}}; 8530 UnicodeString result; 8531 FieldPositionIterator iter; 8532 fmt->format(posAmt, result, &iter, status); 8533 assertEquals("", "34.57 US dollars", result); 8534 verifyFieldPositionIterator(attributes, iter); 8535 } 8536 8537 result.remove(); 8538 fmt->format(negAmt, result, fpCurr, status); 8539 assertEquals("", "-9,876.54 US dollars", result); 8540 assertEquals("begin index", 10, fpCurr.getBeginIndex()); 8541 assertEquals("end index", 20, fpCurr.getEndIndex()); 8542 8543 // Test field position iterator 8544 { 8545 NumberFormatTest_Attributes attributes[] = { 8546 {UNUM_SIGN_FIELD, 0, 1}, 8547 {UNUM_GROUPING_SEPARATOR_FIELD, 2, 3}, 8548 {UNUM_INTEGER_FIELD, 1, 6}, 8549 {UNUM_DECIMAL_SEPARATOR_FIELD, 6, 7}, 8550 {UNUM_FRACTION_FIELD, 7, 9}, 8551 {UNUM_CURRENCY_FIELD, 10, 20}, 8552 {0, -1, 0}}; 8553 UnicodeString result; 8554 FieldPositionIterator iter; 8555 fmt->format(negAmt, result, &iter, status); 8556 assertEquals("", "-9,876.54 US dollars", result); 8557 verifyFieldPositionIterator(attributes, iter); 8558 } 8559 } 8560 8561 void NumberFormatTest::Test10727_RoundingZero() { 8562 DigitList d; 8563 d.set(-0.0); 8564 assertFalse("", d.isPositive()); 8565 d.round(3); 8566 assertFalse("", d.isPositive()); 8567 } 8568 8569 void NumberFormatTest::Test11376_getAndSetPositivePrefix() { 8570 { 8571 const UChar USD[] = {0x55, 0x53, 0x44, 0x0}; 8572 UErrorCode status = U_ZERO_ERROR; 8573 LocalPointer<NumberFormat> fmt( 8574 NumberFormat::createCurrencyInstance("en", status)); 8575 if (!assertSuccess("", status)) { 8576 return; 8577 } 8578 DecimalFormat *dfmt = (DecimalFormat *) fmt.getAlias(); 8579 dfmt->setCurrency(USD); 8580 UnicodeString result; 8581 8582 // This line should be a no-op. I am setting the positive prefix 8583 // to be the same thing it was before. 8584 dfmt->setPositivePrefix(dfmt->getPositivePrefix(result)); 8585 8586 UnicodeString appendTo; 8587 assertEquals("", "$3.78", dfmt->format(3.78, appendTo, status)); 8588 assertSuccess("", status); 8589 } 8590 { 8591 const UChar USD[] = {0x55, 0x53, 0x44, 0x0}; 8592 UErrorCode status = U_ZERO_ERROR; 8593 LocalPointer<NumberFormat> fmt( 8594 NumberFormat::createInstance("en", UNUM_CURRENCY_PLURAL, status)); 8595 if (!assertSuccess("", status)) { 8596 return; 8597 } 8598 DecimalFormat *dfmt = (DecimalFormat *) fmt.getAlias(); 8599 UnicodeString result; 8600 UnicodeString tripleIntlCurrency(" \\u00a4\\u00a4\\u00a4"); 8601 tripleIntlCurrency = tripleIntlCurrency.unescape(); 8602 assertEquals("", tripleIntlCurrency, dfmt->getPositiveSuffix(result)); 8603 dfmt->setCurrency(USD); 8604 8605 // getPositiveSuffix() always returns the suffix for the 8606 // "other" plural category 8607 assertEquals("", " US dollars", dfmt->getPositiveSuffix(result)); 8608 UnicodeString appendTo; 8609 assertEquals("", "3.78 US dollars", dfmt->format(3.78, appendTo, status)); 8610 assertEquals("", " US dollars", dfmt->getPositiveSuffix(result)); 8611 dfmt->setPositiveSuffix("booya"); 8612 appendTo.remove(); 8613 assertEquals("", "3.78booya", dfmt->format(3.78, appendTo, status)); 8614 assertEquals("", "booya", dfmt->getPositiveSuffix(result)); 8615 } 8616 } 8617 8618 void NumberFormatTest::Test11475_signRecognition() { 8619 UErrorCode status = U_ZERO_ERROR; 8620 DecimalFormatSymbols sym("en", status); 8621 UnicodeString result; 8622 { 8623 DecimalFormat fmt("+0.00", sym, status); 8624 if (!assertSuccess("", status)) { 8625 return; 8626 } 8627 NumberFormatTest_Attributes attributes[] = { 8628 {UNUM_SIGN_FIELD, 0, 1}, 8629 {UNUM_INTEGER_FIELD, 1, 2}, 8630 {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3}, 8631 {UNUM_FRACTION_FIELD, 3, 5}, 8632 {0, -1, 0}}; 8633 UnicodeString result; 8634 FieldPositionIterator iter; 8635 fmt.format(2.3, result, &iter, status); 8636 assertEquals("", "+2.30", result); 8637 verifyFieldPositionIterator(attributes, iter); 8638 } 8639 { 8640 DecimalFormat fmt("++0.00+;-(#)--", sym, status); 8641 if (!assertSuccess("", status)) { 8642 return; 8643 } 8644 { 8645 NumberFormatTest_Attributes attributes[] = { 8646 {UNUM_SIGN_FIELD, 0, 2}, 8647 {UNUM_INTEGER_FIELD, 2, 3}, 8648 {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4}, 8649 {UNUM_FRACTION_FIELD, 4, 6}, 8650 {UNUM_SIGN_FIELD, 6, 7}, 8651 {0, -1, 0}}; 8652 UnicodeString result; 8653 FieldPositionIterator iter; 8654 fmt.format(2.3, result, &iter, status); 8655 assertEquals("", "++2.30+", result); 8656 verifyFieldPositionIterator(attributes, iter); 8657 } 8658 { 8659 NumberFormatTest_Attributes attributes[] = { 8660 {UNUM_SIGN_FIELD, 0, 1}, 8661 {UNUM_INTEGER_FIELD, 2, 3}, 8662 {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4}, 8663 {UNUM_FRACTION_FIELD, 4, 6}, 8664 {UNUM_SIGN_FIELD, 7, 9}, 8665 {0, -1, 0}}; 8666 UnicodeString result; 8667 FieldPositionIterator iter; 8668 fmt.format(-2.3, result, &iter, status); 8669 assertEquals("", "-(2.30)--", result); 8670 verifyFieldPositionIterator(attributes, iter); 8671 } 8672 } 8673 } 8674 8675 void NumberFormatTest::Test11640_getAffixes() { 8676 UErrorCode status = U_ZERO_ERROR; 8677 DecimalFormatSymbols symbols("en_US", status); 8678 if (!assertSuccess("", status)) { 8679 return; 8680 } 8681 UnicodeString pattern("\\u00a4\\u00a4\\u00a4 0.00 %\\u00a4\\u00a4"); 8682 pattern = pattern.unescape(); 8683 DecimalFormat fmt(pattern, symbols, status); 8684 if (!assertSuccess("", status)) { 8685 return; 8686 } 8687 UnicodeString affixStr; 8688 assertEquals("", "US dollars ", fmt.getPositivePrefix(affixStr)); 8689 assertEquals("", " %USD", fmt.getPositiveSuffix(affixStr)); 8690 assertEquals("", "-US dollars ", fmt.getNegativePrefix(affixStr)); 8691 assertEquals("", " %USD", fmt.getNegativeSuffix(affixStr)); 8692 } 8693 8694 void NumberFormatTest::Test11649_toPatternWithMultiCurrency() { 8695 UnicodeString pattern("\\u00a4\\u00a4\\u00a4 0.00"); 8696 pattern = pattern.unescape(); 8697 UErrorCode status = U_ZERO_ERROR; 8698 DecimalFormat fmt(pattern, status); 8699 if (!assertSuccess("", status)) { 8700 return; 8701 } 8702 static UChar USD[] = {0x55, 0x53, 0x44, 0x0}; 8703 fmt.setCurrency(USD); 8704 UnicodeString appendTo; 8705 8706 assertEquals("", "US dollars 12.34", fmt.format(12.34, appendTo)); 8707 8708 UnicodeString topattern; 8709 fmt.toPattern(topattern); 8710 DecimalFormat fmt2(topattern, status); 8711 if (!assertSuccess("", status)) { 8712 return; 8713 } 8714 fmt2.setCurrency(USD); 8715 8716 appendTo.remove(); 8717 assertEquals("", "US dollars 12.34", fmt2.format(12.34, appendTo)); 8718 } 8719 8720 8721 void NumberFormatTest::verifyFieldPositionIterator( 8722 NumberFormatTest_Attributes *expected, FieldPositionIterator &iter) { 8723 int32_t idx = 0; 8724 FieldPosition fp; 8725 while (iter.next(fp)) { 8726 if (expected[idx].spos == -1) { 8727 errln("Iterator should have ended. got %d", fp.getField()); 8728 return; 8729 } 8730 assertEquals("id", expected[idx].id, fp.getField()); 8731 assertEquals("start", expected[idx].spos, fp.getBeginIndex()); 8732 assertEquals("end", expected[idx].epos, fp.getEndIndex()); 8733 ++idx; 8734 } 8735 if (expected[idx].spos != -1) { 8736 errln("Premature end of iterator. expected %d", expected[idx].id); 8737 } 8738 } 8739 8740 void NumberFormatTest::checkExceptionIssue11735() { 8741 UErrorCode status; 8742 Locale enLocale("en"); 8743 DecimalFormatSymbols symbols(enLocale, status); 8744 8745 if (U_FAILURE(status)) { 8746 errln((UnicodeString) 8747 "Fail: Construct DecimalFormatSymbols"); 8748 } 8749 8750 DecimalFormat fmt("0", symbols, status); 8751 if (U_FAILURE(status)) { 8752 errln((UnicodeString) 8753 "Fail: Construct DecimalFormat formatter"); 8754 } 8755 8756 ParsePosition ppos(0); 8757 fmt.parseCurrency("53.45", ppos); // NPE thrown here in ICU4J. 8758 assertEquals("Issue11735 ppos", 0, ppos.getIndex()); 8759 } 8760 8761 #endif /* #if !UCONFIG_NO_FORMATTING */ 8762
