1 // Copyright (C) 2016 and later: Unicode, Inc. and others. 2 // License & terms of use: http://www.unicode.org/copyright.html 3 /* 4 ******************************************************************************* 5 * Copyright (C) 2015, International Business Machines Corporation and * 6 * others. All Rights Reserved. * 7 ******************************************************************************* 8 * 9 * File NUMBERFORMAT2TEST.CPP 10 * 11 ******************************************************************************* 12 */ 13 #include "unicode/utypes.h" 14 15 #include "intltest.h" 16 17 #if !UCONFIG_NO_FORMATTING 18 19 #include "unicode/localpointer.h" 20 #include "unicode/plurrule.h" 21 22 #include "affixpatternparser.h" 23 #include "charstr.h" 24 #include "datadrivennumberformattestsuite.h" 25 #include "decimalformatpattern.h" 26 #include "digitaffixesandpadding.h" 27 #include "digitformatter.h" 28 #include "digitgrouping.h" 29 #include "digitinterval.h" 30 #include "digitlst.h" 31 #include "fphdlimp.h" 32 #include "plurrule_impl.h" 33 #include "precision.h" 34 #include "significantdigitinterval.h" 35 #include "smallintformatter.h" 36 #include "uassert.h" 37 #include "valueformatter.h" 38 #include "visibledigits.h" 39 40 struct NumberFormat2Test_Attributes { 41 int32_t id; 42 int32_t spos; 43 int32_t epos; 44 }; 45 46 class NumberFormat2Test_FieldPositionHandler : public FieldPositionHandler { 47 public: 48 NumberFormat2Test_Attributes attributes[100]; 49 int32_t count; 50 UBool bRecording; 51 52 53 54 NumberFormat2Test_FieldPositionHandler() : count(0), bRecording(TRUE) { attributes[0].spos = -1; } 55 NumberFormat2Test_FieldPositionHandler(UBool recording) : count(0), bRecording(recording) { attributes[0].spos = -1; } 56 virtual ~NumberFormat2Test_FieldPositionHandler(); 57 virtual void addAttribute(int32_t id, int32_t start, int32_t limit); 58 virtual void shiftLast(int32_t delta); 59 virtual UBool isRecording(void) const; 60 }; 61 62 NumberFormat2Test_FieldPositionHandler::~NumberFormat2Test_FieldPositionHandler() { 63 } 64 65 void NumberFormat2Test_FieldPositionHandler::addAttribute( 66 int32_t id, int32_t start, int32_t limit) { 67 if (count == UPRV_LENGTHOF(attributes) - 1) { 68 return; 69 } 70 attributes[count].id = id; 71 attributes[count].spos = start; 72 attributes[count].epos = limit; 73 ++count; 74 attributes[count].spos = -1; 75 } 76 77 void NumberFormat2Test_FieldPositionHandler::shiftLast(int32_t /* delta */) { 78 } 79 80 UBool NumberFormat2Test_FieldPositionHandler::isRecording() const { 81 return bRecording; 82 } 83 84 85 class NumberFormat2Test : public IntlTest { 86 public: 87 void runIndexedTest(int32_t index, UBool exec, const char *&name, char *par=0); 88 private: 89 void TestQuantize(); 90 void TestConvertScientificNotation(); 91 void TestLowerUpperExponent(); 92 void TestRounding(); 93 void TestRoundingIncrement(); 94 void TestDigitInterval(); 95 void TestGroupingUsed(); 96 void TestBenchmark(); 97 void TestBenchmark2(); 98 void TestSmallIntFormatter(); 99 void TestPositiveIntDigitFormatter(); 100 void TestDigitListInterval(); 101 void TestLargeIntValue(); 102 void TestIntInitVisibleDigits(); 103 void TestIntInitVisibleDigitsToDigitList(); 104 void TestDoubleInitVisibleDigits(); 105 void TestDoubleInitVisibleDigitsToDigitList(); 106 void TestDigitListInitVisibleDigits(); 107 void TestSpecialInitVisibleDigits(); 108 void TestVisibleDigitsWithExponent(); 109 void TestDigitAffixesAndPadding(); 110 void TestPluralsAndRounding(); 111 void TestPluralsAndRoundingScientific(); 112 void TestValueFormatterIsFastFormattable(); 113 void TestCurrencyAffixInfo(); 114 void TestAffixPattern(); 115 void TestAffixPatternAppend(); 116 void TestAffixPatternAppendAjoiningLiterals(); 117 void TestAffixPatternDoubleQuote(); 118 void TestAffixPatternParser(); 119 void TestPluralAffix(); 120 void TestDigitAffix(); 121 void TestDigitFormatterDefaultCtor(); 122 void TestDigitFormatterMonetary(); 123 void TestDigitFormatter(); 124 void TestSciFormatterDefaultCtor(); 125 void TestSciFormatter(); 126 void TestToPatternScientific11648(); 127 void verifyInterval(const DigitInterval &, int32_t minInclusive, int32_t maxExclusive); 128 void verifyAffix( 129 const UnicodeString &expected, 130 const DigitAffix &affix, 131 const NumberFormat2Test_Attributes *expectedAttributes); 132 void verifyAffixesAndPadding( 133 const UnicodeString &expected, 134 const DigitAffixesAndPadding &aaf, 135 DigitList &digits, 136 const ValueFormatter &vf, 137 const PluralRules *optPluralRules, 138 const NumberFormat2Test_Attributes *expectedAttributes); 139 void verifyAffixesAndPaddingInt32( 140 const UnicodeString &expected, 141 const DigitAffixesAndPadding &aaf, 142 int32_t value, 143 const ValueFormatter &vf, 144 const PluralRules *optPluralRules, 145 const NumberFormat2Test_Attributes *expectedAttributes); 146 void verifyDigitList( 147 const UnicodeString &expected, 148 const DigitList &digits); 149 void verifyVisibleDigits( 150 const UnicodeString &expected, 151 UBool bNegative, 152 const VisibleDigits &digits); 153 void verifyVisibleDigitsWithExponent( 154 const UnicodeString &expected, 155 UBool bNegative, 156 const VisibleDigitsWithExponent &digits); 157 void verifyDigitFormatter( 158 const UnicodeString &expected, 159 const DigitFormatter &formatter, 160 const VisibleDigits &digits, 161 const DigitGrouping &grouping, 162 const DigitFormatterOptions &options, 163 const NumberFormat2Test_Attributes *expectedAttributes); 164 void verifySciFormatter( 165 const UnicodeString &expected, 166 const DigitFormatter &formatter, 167 const VisibleDigitsWithExponent &digits, 168 const SciFormatterOptions &options, 169 const NumberFormat2Test_Attributes *expectedAttributes); 170 void verifySmallIntFormatter( 171 const UnicodeString &expected, 172 int32_t positiveValue, 173 int32_t minDigits, 174 int32_t maxDigits); 175 void verifyPositiveIntDigitFormatter( 176 const UnicodeString &expected, 177 const DigitFormatter &formatter, 178 int32_t value, 179 int32_t minDigits, 180 int32_t maxDigits, 181 const NumberFormat2Test_Attributes *expectedAttributes); 182 void verifyAttributes( 183 const NumberFormat2Test_Attributes *expected, 184 const NumberFormat2Test_Attributes *actual); 185 void verifyIntValue( 186 int64_t expected, const VisibleDigits &digits); 187 void verifySource( 188 double expected, const VisibleDigits &digits); 189 }; 190 191 void NumberFormat2Test::runIndexedTest( 192 int32_t index, UBool exec, const char *&name, char *) { 193 if (exec) { 194 logln("TestSuite ScientificNumberFormatterTest: "); 195 } 196 TESTCASE_AUTO_BEGIN; 197 TESTCASE_AUTO(TestQuantize); 198 TESTCASE_AUTO(TestConvertScientificNotation); 199 TESTCASE_AUTO(TestLowerUpperExponent); 200 TESTCASE_AUTO(TestRounding); 201 TESTCASE_AUTO(TestRoundingIncrement); 202 TESTCASE_AUTO(TestDigitInterval); 203 TESTCASE_AUTO(TestGroupingUsed); 204 TESTCASE_AUTO(TestDigitListInterval); 205 TESTCASE_AUTO(TestDigitFormatterDefaultCtor); 206 TESTCASE_AUTO(TestDigitFormatterMonetary); 207 TESTCASE_AUTO(TestDigitFormatter); 208 TESTCASE_AUTO(TestSciFormatterDefaultCtor); 209 TESTCASE_AUTO(TestSciFormatter); 210 TESTCASE_AUTO(TestBenchmark); 211 TESTCASE_AUTO(TestBenchmark2); 212 TESTCASE_AUTO(TestSmallIntFormatter); 213 TESTCASE_AUTO(TestPositiveIntDigitFormatter); 214 TESTCASE_AUTO(TestCurrencyAffixInfo); 215 TESTCASE_AUTO(TestAffixPattern); 216 TESTCASE_AUTO(TestAffixPatternAppend); 217 TESTCASE_AUTO(TestAffixPatternAppendAjoiningLiterals); 218 TESTCASE_AUTO(TestAffixPatternDoubleQuote); 219 TESTCASE_AUTO(TestAffixPatternParser); 220 TESTCASE_AUTO(TestPluralAffix); 221 TESTCASE_AUTO(TestDigitAffix); 222 TESTCASE_AUTO(TestValueFormatterIsFastFormattable); 223 TESTCASE_AUTO(TestLargeIntValue); 224 TESTCASE_AUTO(TestIntInitVisibleDigits); 225 TESTCASE_AUTO(TestIntInitVisibleDigitsToDigitList); 226 TESTCASE_AUTO(TestDoubleInitVisibleDigits); 227 TESTCASE_AUTO(TestDoubleInitVisibleDigitsToDigitList); 228 TESTCASE_AUTO(TestDigitListInitVisibleDigits); 229 TESTCASE_AUTO(TestSpecialInitVisibleDigits); 230 TESTCASE_AUTO(TestVisibleDigitsWithExponent); 231 TESTCASE_AUTO(TestDigitAffixesAndPadding); 232 TESTCASE_AUTO(TestPluralsAndRounding); 233 TESTCASE_AUTO(TestPluralsAndRoundingScientific); 234 TESTCASE_AUTO(TestToPatternScientific11648); 235 236 TESTCASE_AUTO_END; 237 } 238 239 void NumberFormat2Test::TestDigitInterval() { 240 DigitInterval all; 241 DigitInterval threeInts; 242 DigitInterval fourFrac; 243 threeInts.setIntDigitCount(3); 244 fourFrac.setFracDigitCount(4); 245 verifyInterval(all, INT32_MIN, INT32_MAX); 246 verifyInterval(threeInts, INT32_MIN, 3); 247 verifyInterval(fourFrac, -4, INT32_MAX); 248 { 249 DigitInterval result(threeInts); 250 result.shrinkToFitWithin(fourFrac); 251 verifyInterval(result, -4, 3); 252 assertEquals("", 7, result.length()); 253 } 254 { 255 DigitInterval result(threeInts); 256 result.expandToContain(fourFrac); 257 verifyInterval(result, INT32_MIN, INT32_MAX); 258 } 259 { 260 DigitInterval result(threeInts); 261 result.setIntDigitCount(0); 262 verifyInterval(result, INT32_MIN, 0); 263 result.setIntDigitCount(-1); 264 verifyInterval(result, INT32_MIN, INT32_MAX); 265 } 266 { 267 DigitInterval result(fourFrac); 268 result.setFracDigitCount(0); 269 verifyInterval(result, 0, INT32_MAX); 270 result.setFracDigitCount(-1); 271 verifyInterval(result, INT32_MIN, INT32_MAX); 272 } 273 { 274 DigitInterval result; 275 result.setIntDigitCount(3); 276 result.setFracDigitCount(1); 277 result.expandToContainDigit(0); 278 result.expandToContainDigit(-1); 279 result.expandToContainDigit(2); 280 verifyInterval(result, -1, 3); 281 result.expandToContainDigit(3); 282 verifyInterval(result, -1, 4); 283 result.expandToContainDigit(-2); 284 verifyInterval(result, -2, 4); 285 result.expandToContainDigit(15); 286 result.expandToContainDigit(-15); 287 verifyInterval(result, -15, 16); 288 } 289 { 290 DigitInterval result; 291 result.setIntDigitCount(3); 292 result.setFracDigitCount(1); 293 assertTrue("", result.contains(2)); 294 assertTrue("", result.contains(-1)); 295 assertFalse("", result.contains(3)); 296 assertFalse("", result.contains(-2)); 297 } 298 } 299 300 void NumberFormat2Test::verifyInterval( 301 const DigitInterval &interval, 302 int32_t minInclusive, int32_t maxExclusive) { 303 assertEquals("", minInclusive, interval.getLeastSignificantInclusive()); 304 assertEquals("", maxExclusive, interval.getMostSignificantExclusive()); 305 assertEquals("", maxExclusive, interval.getIntDigitCount()); 306 } 307 308 void NumberFormat2Test::TestGroupingUsed() { 309 { 310 DigitGrouping grouping; 311 assertFalse("", grouping.isGroupingUsed()); 312 } 313 { 314 DigitGrouping grouping; 315 grouping.fGrouping = 2; 316 assertTrue("", grouping.isGroupingUsed()); 317 } 318 } 319 320 void NumberFormat2Test::TestDigitListInterval() { 321 DigitInterval result; 322 DigitList digitList; 323 { 324 digitList.set((int32_t)12345); 325 verifyInterval(digitList.getSmallestInterval(result), 0, 5); 326 } 327 { 328 digitList.set(1000.00); 329 verifyInterval(digitList.getSmallestInterval(result), 0, 4); 330 } 331 { 332 digitList.set(43.125); 333 verifyInterval(digitList.getSmallestInterval(result), -3, 2); 334 } 335 { 336 digitList.set(.0078125); 337 verifyInterval(digitList.getSmallestInterval(result), -7, 0); 338 } 339 { 340 digitList.set(1000.00); 341 digitList.getSmallestInterval(result); 342 result.expandToContainDigit(3); 343 verifyInterval(result, 0, 4); 344 } 345 { 346 digitList.set(1000.00); 347 digitList.getSmallestInterval(result); 348 result.expandToContainDigit(4); 349 verifyInterval(result, 0, 5); 350 } 351 { 352 digitList.set(1000.00); 353 digitList.getSmallestInterval(result); 354 result.expandToContainDigit(0); 355 verifyInterval(result, 0, 4); 356 } 357 { 358 digitList.set(1000.00); 359 digitList.getSmallestInterval(result); 360 result.expandToContainDigit(-1); 361 verifyInterval(result, -1, 4); 362 } 363 { 364 digitList.set(43.125); 365 digitList.getSmallestInterval(result); 366 result.expandToContainDigit(1); 367 verifyInterval(result, -3, 2); 368 } 369 { 370 digitList.set(43.125); 371 digitList.getSmallestInterval(result); 372 result.expandToContainDigit(2); 373 verifyInterval(result, -3, 3); 374 } 375 { 376 digitList.set(43.125); 377 digitList.getSmallestInterval(result); 378 result.expandToContainDigit(-3); 379 verifyInterval(result, -3, 2); 380 } 381 { 382 digitList.set(43.125); 383 digitList.getSmallestInterval(result); 384 result.expandToContainDigit(-4); 385 verifyInterval(result, -4, 2); 386 } 387 } 388 389 void NumberFormat2Test::TestQuantize() { 390 DigitList quantity; 391 quantity.set(0.00168); 392 quantity.roundAtExponent(-5); 393 DigitList digits; 394 UErrorCode status = U_ZERO_ERROR; 395 { 396 digits.set((int32_t)1); 397 digits.quantize(quantity, status); 398 verifyDigitList(".9996", digits); 399 } 400 { 401 // round half even up 402 digits.set(1.00044); 403 digits.roundAtExponent(-5); 404 digits.quantize(quantity, status); 405 verifyDigitList("1.00128", digits); 406 } 407 { 408 // round half down 409 digits.set(0.99876); 410 digits.roundAtExponent(-5); 411 digits.quantize(quantity, status); 412 verifyDigitList(".99792", digits); 413 } 414 assertSuccess("", status); 415 } 416 417 void NumberFormat2Test::TestConvertScientificNotation() { 418 DigitList digits; 419 { 420 digits.set((int32_t)186283); 421 assertEquals("", 5, digits.toScientific(1, 1)); 422 verifyDigitList( 423 "1.86283", 424 digits); 425 } 426 { 427 digits.set((int32_t)186283); 428 assertEquals("", 0, digits.toScientific(6, 1)); 429 verifyDigitList( 430 "186283", 431 digits); 432 } 433 { 434 digits.set((int32_t)186283); 435 assertEquals("", -2, digits.toScientific(8, 1)); 436 verifyDigitList( 437 "18628300", 438 digits); 439 } 440 { 441 digits.set((int32_t)43561); 442 assertEquals("", 6, digits.toScientific(-1, 3)); 443 verifyDigitList( 444 ".043561", 445 digits); 446 } 447 { 448 digits.set((int32_t)43561); 449 assertEquals("", 3, digits.toScientific(0, 3)); 450 verifyDigitList( 451 "43.561", 452 digits); 453 } 454 { 455 digits.set((int32_t)43561); 456 assertEquals("", 3, digits.toScientific(2, 3)); 457 verifyDigitList( 458 "43.561", 459 digits); 460 } 461 { 462 digits.set((int32_t)43561); 463 assertEquals("", 0, digits.toScientific(3, 3)); 464 verifyDigitList( 465 "43561", 466 digits); 467 } 468 { 469 digits.set((int32_t)43561); 470 assertEquals("", 0, digits.toScientific(5, 3)); 471 verifyDigitList( 472 "43561", 473 digits); 474 } 475 { 476 digits.set((int32_t)43561); 477 assertEquals("", -3, digits.toScientific(6, 3)); 478 verifyDigitList( 479 "43561000", 480 digits); 481 } 482 { 483 digits.set((int32_t)43561); 484 assertEquals("", -3, digits.toScientific(8, 3)); 485 verifyDigitList( 486 "43561000", 487 digits); 488 } 489 { 490 digits.set((int32_t)43561); 491 assertEquals("", -6, digits.toScientific(9, 3)); 492 verifyDigitList( 493 "43561000000", 494 digits); 495 } 496 } 497 498 void NumberFormat2Test::TestLowerUpperExponent() { 499 DigitList digits; 500 501 digits.set(98.7); 502 assertEquals("", -1, digits.getLowerExponent()); 503 assertEquals("", 2, digits.getUpperExponent()); 504 } 505 506 void NumberFormat2Test::TestRounding() { 507 DigitList digits; 508 uprv_decContextSetRounding(&digits.fContext, DEC_ROUND_CEILING); 509 { 510 // Round at very large exponent 511 digits.set(789.123); 512 digits.roundAtExponent(100); 513 verifyDigitList( 514 "10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", // 100 0's after 1 515 digits); 516 } 517 { 518 // Round at very large exponent 519 digits.set(789.123); 520 digits.roundAtExponent(1); 521 verifyDigitList( 522 "790", // 100 0's after 1 523 digits); 524 } 525 { 526 // Round at positive exponent 527 digits.set(789.123); 528 digits.roundAtExponent(1); 529 verifyDigitList("790", digits); 530 } 531 { 532 // Round at zero exponent 533 digits.set(788.123); 534 digits.roundAtExponent(0); 535 verifyDigitList("789", digits); 536 } 537 { 538 // Round at negative exponent 539 digits.set(789.123); 540 digits.roundAtExponent(-2); 541 verifyDigitList("789.13", digits); 542 } 543 { 544 // Round to exponent of digits. 545 digits.set(789.123); 546 digits.roundAtExponent(-3); 547 verifyDigitList("789.123", digits); 548 } 549 { 550 // Round at large negative exponent 551 digits.set(789.123); 552 digits.roundAtExponent(-100); 553 verifyDigitList("789.123", digits); 554 } 555 { 556 // Round negative 557 digits.set(-789.123); 558 digits.roundAtExponent(-2); 559 digits.setPositive(TRUE); 560 verifyDigitList("789.12", digits); 561 } 562 { 563 // Round to 1 significant digit 564 digits.set(789.123); 565 digits.roundAtExponent(INT32_MIN, 1); 566 verifyDigitList("800", digits); 567 } 568 { 569 // Round to 5 significant digit 570 digits.set(789.123); 571 digits.roundAtExponent(INT32_MIN, 5); 572 verifyDigitList("789.13", digits); 573 } 574 { 575 // Round to 6 significant digit 576 digits.set(789.123); 577 digits.roundAtExponent(INT32_MIN, 6); 578 verifyDigitList("789.123", digits); 579 } 580 { 581 // no-op 582 digits.set(789.123); 583 digits.roundAtExponent(INT32_MIN, INT32_MAX); 584 verifyDigitList("789.123", digits); 585 } 586 { 587 // Rounding at -1 produces fewer than 5 significant digits 588 digits.set(789.123); 589 digits.roundAtExponent(-1, 5); 590 verifyDigitList("789.2", digits); 591 } 592 { 593 // Rounding at -1 produces exactly 4 significant digits 594 digits.set(789.123); 595 digits.roundAtExponent(-1, 4); 596 verifyDigitList("789.2", digits); 597 } 598 { 599 // Rounding at -1 produces more than 3 significant digits 600 digits.set(788.123); 601 digits.roundAtExponent(-1, 3); 602 verifyDigitList("789", digits); 603 } 604 { 605 digits.set(123.456); 606 digits.round(INT32_MAX); 607 verifyDigitList("123.456", digits); 608 } 609 { 610 digits.set(123.456); 611 digits.round(1); 612 verifyDigitList("200", digits); 613 } 614 } 615 void NumberFormat2Test::TestBenchmark() { 616 /* 617 UErrorCode status = U_ZERO_ERROR; 618 Locale en("en"); 619 DecimalFormatSymbols *sym = new DecimalFormatSymbols(en, status); 620 DecimalFormat2 fmt(en, "0.0000000", status); 621 FieldPosition fpos(FieldPostion::DONT_CARE); 622 clock_t start = clock(); 623 for (int32_t i = 0; i < 100000; ++i) { 624 UParseError perror; 625 DecimalFormat2 fmt2("0.0000000", new DecimalFormatSymbols(*sym), perror, status); 626 // UnicodeString append; 627 // fmt.format(4.6692016, append, fpos, status); 628 } 629 errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC); 630 assertSuccess("", status); 631 */ 632 } 633 634 void NumberFormat2Test::TestBenchmark2() { 635 /* 636 UErrorCode status = U_ZERO_ERROR; 637 Locale en("en"); 638 DecimalFormatSymbols *sym = new DecimalFormatSymbols(en, status); 639 DecimalFormat fmt("0.0000000", sym, status); 640 FieldPosition fpos(FieldPostion::DONT_CARE); 641 clock_t start = clock(); 642 for (int32_t i = 0; i < 100000; ++i) { 643 UParseError perror; 644 DecimalFormat fmt("0.0000000", new DecimalFormatSymbols(*sym), perror, status); 645 // UnicodeString append; 646 // fmt.format(4.6692016, append, fpos, status); 647 } 648 errln("Took %f", (double) (clock() - start) / CLOCKS_PER_SEC); 649 assertSuccess("", status); 650 */ 651 } 652 653 void NumberFormat2Test::TestSmallIntFormatter() { 654 verifySmallIntFormatter("0", 7, 0, -2); 655 verifySmallIntFormatter("7", 7, 1, -2); 656 verifySmallIntFormatter("07", 7, 2, -2); 657 verifySmallIntFormatter("07", 7, 2, 2); 658 verifySmallIntFormatter("007", 7, 3, 4); 659 verifySmallIntFormatter("7", 7, -1, 3); 660 verifySmallIntFormatter("0", 0, -1, 3); 661 verifySmallIntFormatter("057", 57, 3, 7); 662 verifySmallIntFormatter("0057", 57, 4, 7); 663 // too many digits for small int 664 verifySmallIntFormatter("", 57, 5, 7); 665 // too many digits for small int 666 verifySmallIntFormatter("", 57, 5, 4); 667 verifySmallIntFormatter("03", 3, 2, 3); 668 verifySmallIntFormatter("32", 32, 2, 3); 669 verifySmallIntFormatter("321", 321, 2, 3); 670 verifySmallIntFormatter("219", 3219, 2, 3); 671 verifySmallIntFormatter("4095", 4095, 2, 4); 672 verifySmallIntFormatter("4095", 4095, 2, 5); 673 verifySmallIntFormatter("", 4096, 2, 5); 674 } 675 676 void NumberFormat2Test::TestPositiveIntDigitFormatter() { 677 DigitFormatter formatter; 678 { 679 NumberFormat2Test_Attributes expectedAttributes[] = { 680 {UNUM_INTEGER_FIELD, 0, 4}, 681 {0, -1, 0}}; 682 verifyPositiveIntDigitFormatter( 683 "0057", 684 formatter, 685 57, 686 4, 687 INT32_MAX, 688 expectedAttributes); 689 } 690 { 691 NumberFormat2Test_Attributes expectedAttributes[] = { 692 {UNUM_INTEGER_FIELD, 0, 5}, 693 {0, -1, 0}}; 694 verifyPositiveIntDigitFormatter( 695 "00057", 696 formatter, 697 57, 698 5, 699 INT32_MAX, 700 expectedAttributes); 701 } 702 { 703 NumberFormat2Test_Attributes expectedAttributes[] = { 704 {UNUM_INTEGER_FIELD, 0, 5}, 705 {0, -1, 0}}; 706 verifyPositiveIntDigitFormatter( 707 "01000", 708 formatter, 709 1000, 710 5, 711 INT32_MAX, 712 expectedAttributes); 713 } 714 { 715 NumberFormat2Test_Attributes expectedAttributes[] = { 716 {UNUM_INTEGER_FIELD, 0, 3}, 717 {0, -1, 0}}; 718 verifyPositiveIntDigitFormatter( 719 "100", 720 formatter, 721 100, 722 0, 723 INT32_MAX, 724 expectedAttributes); 725 } 726 { 727 NumberFormat2Test_Attributes expectedAttributes[] = { 728 {UNUM_INTEGER_FIELD, 0, 10}, 729 {0, -1, 0}}; 730 verifyPositiveIntDigitFormatter( 731 "2147483647", 732 formatter, 733 2147483647, 734 5, 735 INT32_MAX, 736 expectedAttributes); 737 } 738 { 739 NumberFormat2Test_Attributes expectedAttributes[] = { 740 {UNUM_INTEGER_FIELD, 0, 12}, 741 {0, -1, 0}}; 742 verifyPositiveIntDigitFormatter( 743 "002147483647", 744 formatter, 745 2147483647, 746 12, 747 INT32_MAX, 748 expectedAttributes); 749 } 750 { 751 // Test long digit string where we have to append one 752 // character at a time. 753 NumberFormat2Test_Attributes expectedAttributes[] = { 754 {UNUM_INTEGER_FIELD, 0, 40}, 755 {0, -1, 0}}; 756 verifyPositiveIntDigitFormatter( 757 "0000000000000000000000000000002147483647", 758 formatter, 759 2147483647, 760 40, 761 INT32_MAX, 762 expectedAttributes); 763 } 764 { 765 NumberFormat2Test_Attributes expectedAttributes[] = { 766 {UNUM_INTEGER_FIELD, 0, 4}, 767 {0, -1, 0}}; 768 verifyPositiveIntDigitFormatter( 769 "6283", 770 formatter, 771 186283, 772 2, 773 4, 774 expectedAttributes); 775 } 776 { 777 NumberFormat2Test_Attributes expectedAttributes[] = { 778 {UNUM_INTEGER_FIELD, 0, 1}, 779 {0, -1, 0}}; 780 verifyPositiveIntDigitFormatter( 781 "0", 782 formatter, 783 186283, 784 0, 785 0, 786 expectedAttributes); 787 } 788 { 789 NumberFormat2Test_Attributes expectedAttributes[] = { 790 {UNUM_INTEGER_FIELD, 0, 1}, 791 {0, -1, 0}}; 792 verifyPositiveIntDigitFormatter( 793 "3", 794 formatter, 795 186283, 796 1, 797 1, 798 expectedAttributes); 799 } 800 } 801 802 803 void NumberFormat2Test::TestDigitFormatterDefaultCtor() { 804 DigitFormatter formatter; 805 VisibleDigits digits; 806 FixedPrecision precision; 807 UErrorCode status = U_ZERO_ERROR; 808 precision.initVisibleDigits(246.801, digits, status); 809 assertSuccess("", status); 810 DigitGrouping grouping; 811 DigitFormatterOptions options; 812 verifyDigitFormatter( 813 "246.801", 814 formatter, 815 digits, 816 grouping, 817 options, 818 NULL); 819 } 820 821 void NumberFormat2Test::TestDigitFormatterMonetary() { 822 UErrorCode status = U_ZERO_ERROR; 823 DecimalFormatSymbols symbols("en", status); 824 if (!assertSuccess("", status)) { 825 return; 826 } 827 symbols.setSymbol( 828 DecimalFormatSymbols::kMonetarySeparatorSymbol, 829 "decimal separator"); 830 symbols.setSymbol( 831 DecimalFormatSymbols::kMonetaryGroupingSeparatorSymbol, 832 "grouping separator"); 833 DigitFormatter formatter(symbols); 834 VisibleDigits visibleDigits; 835 DigitGrouping grouping; 836 FixedPrecision precision; 837 precision.initVisibleDigits(43560.02, visibleDigits, status); 838 if (!assertSuccess("", status)) { 839 return; 840 } 841 DigitFormatterOptions options; 842 grouping.fGrouping = 3; 843 { 844 verifyDigitFormatter( 845 "43,560.02", 846 formatter, 847 visibleDigits, 848 grouping, 849 options, 850 NULL); 851 formatter.setDecimalFormatSymbolsForMonetary(symbols); 852 verifyDigitFormatter( 853 "43grouping separator560decimal separator02", 854 formatter, 855 visibleDigits, 856 grouping, 857 options, 858 NULL); 859 } 860 } 861 862 void NumberFormat2Test::TestDigitFormatter() { 863 UErrorCode status = U_ZERO_ERROR; 864 DecimalFormatSymbols symbols("en", status); 865 if (!assertSuccess("", status)) { 866 return; 867 } 868 DigitFormatter formatter(symbols); 869 DigitInterval interval; 870 { 871 VisibleDigits visibleDigits; 872 DigitGrouping grouping; 873 FixedPrecision precision; 874 precision.initVisibleDigits((int64_t) 8192, visibleDigits, status); 875 if (!assertSuccess("", status)) { 876 return; 877 } 878 DigitFormatterOptions options; 879 verifyDigitFormatter( 880 "8192", 881 formatter, 882 visibleDigits, 883 grouping, 884 options, 885 NULL); 886 NumberFormat2Test_Attributes expectedAttributes[] = { 887 {UNUM_INTEGER_FIELD, 0, 4}, 888 {UNUM_DECIMAL_SEPARATOR_FIELD, 4, 5}, 889 {0, -1, 0}}; 890 options.fAlwaysShowDecimal = TRUE; 891 verifyDigitFormatter( 892 "8192.", 893 formatter, 894 visibleDigits, 895 grouping, 896 options, 897 expectedAttributes); 898 899 // Turn on grouping 900 grouping.fGrouping = 3; 901 options.fAlwaysShowDecimal = FALSE; 902 verifyDigitFormatter( 903 "8,192", 904 formatter, 905 visibleDigits, 906 grouping, 907 options, 908 NULL); 909 910 // turn on min grouping which will suppress grouping 911 grouping.fMinGrouping = 2; 912 verifyDigitFormatter( 913 "8192", 914 formatter, 915 visibleDigits, 916 grouping, 917 options, 918 NULL); 919 920 // adding one more digit will enable grouping once again. 921 precision.initVisibleDigits((int64_t) 43560, visibleDigits, status); 922 if (!assertSuccess("", status)) { 923 return; 924 } 925 verifyDigitFormatter( 926 "43,560", 927 formatter, 928 visibleDigits, 929 grouping, 930 options, 931 NULL); 932 } 933 { 934 DigitGrouping grouping; 935 FixedPrecision precision; 936 VisibleDigits visibleDigits; 937 precision.initVisibleDigits( 938 31415926.0078125, visibleDigits, status); 939 if (!assertSuccess("", status)) { 940 return; 941 } 942 DigitFormatterOptions options; 943 verifyDigitFormatter( 944 "31415926.0078125", 945 formatter, 946 visibleDigits, 947 grouping, 948 options, 949 NULL); 950 951 // Turn on grouping with secondary. 952 grouping.fGrouping = 2; 953 grouping.fGrouping2 = 3; 954 verifyDigitFormatter( 955 "314,159,26.0078125", 956 formatter, 957 visibleDigits, 958 grouping, 959 options, 960 NULL); 961 962 // Pad with zeros by widening interval. 963 precision.fMin.setIntDigitCount(9); 964 precision.fMin.setFracDigitCount(10); 965 precision.initVisibleDigits( 966 31415926.0078125, visibleDigits, status); 967 if (!assertSuccess("", status)) { 968 return; 969 } 970 NumberFormat2Test_Attributes expectedAttributes[] = { 971 {UNUM_GROUPING_SEPARATOR_FIELD, 1, 2}, 972 {UNUM_GROUPING_SEPARATOR_FIELD, 5, 6}, 973 {UNUM_GROUPING_SEPARATOR_FIELD, 9, 10}, 974 {UNUM_INTEGER_FIELD, 0, 12}, 975 {UNUM_DECIMAL_SEPARATOR_FIELD, 12, 13}, 976 {UNUM_FRACTION_FIELD, 13, 23}, 977 {0, -1, 0}}; 978 verifyDigitFormatter( 979 "0,314,159,26.0078125000", 980 formatter, 981 visibleDigits, 982 grouping, 983 options, 984 expectedAttributes); 985 } 986 { 987 DigitGrouping grouping; 988 FixedPrecision precision; 989 VisibleDigits visibleDigits; 990 DigitFormatterOptions options; 991 precision.fMax.setIntDigitCount(0); 992 precision.fMax.setFracDigitCount(0); 993 precision.initVisibleDigits( 994 3125.0, visibleDigits, status); 995 if (!assertSuccess("", status)) { 996 return; 997 } 998 NumberFormat2Test_Attributes expectedAttributes[] = { 999 {UNUM_INTEGER_FIELD, 0, 1}, 1000 {0, -1, 0}}; 1001 verifyDigitFormatter( 1002 "0", 1003 formatter, 1004 visibleDigits, 1005 grouping, 1006 options, 1007 expectedAttributes); 1008 NumberFormat2Test_Attributes expectedAttributesWithDecimal[] = { 1009 {UNUM_INTEGER_FIELD, 0, 1}, 1010 {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, 1011 {0, -1, 0}}; 1012 options.fAlwaysShowDecimal = TRUE; 1013 verifyDigitFormatter( 1014 "0.", 1015 formatter, 1016 visibleDigits, 1017 grouping, 1018 options, 1019 expectedAttributesWithDecimal); 1020 } 1021 { 1022 DigitGrouping grouping; 1023 FixedPrecision precision; 1024 VisibleDigits visibleDigits; 1025 DigitFormatterOptions options; 1026 precision.fMax.setIntDigitCount(1); 1027 precision.fMin.setFracDigitCount(1); 1028 precision.initVisibleDigits( 1029 3125.0, visibleDigits, status); 1030 if (!assertSuccess("", status)) { 1031 return; 1032 } 1033 NumberFormat2Test_Attributes expectedAttributes[] = { 1034 {UNUM_INTEGER_FIELD, 0, 1}, 1035 {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, 1036 {UNUM_FRACTION_FIELD, 2, 3}, 1037 {0, -1, 0}}; 1038 options.fAlwaysShowDecimal = TRUE; 1039 verifyDigitFormatter( 1040 "5.0", 1041 formatter, 1042 visibleDigits, 1043 grouping, 1044 options, 1045 expectedAttributes); 1046 } 1047 } 1048 1049 void NumberFormat2Test::TestSciFormatterDefaultCtor() { 1050 DigitFormatter formatter; 1051 ScientificPrecision precision; 1052 VisibleDigitsWithExponent visibleDigits; 1053 UErrorCode status = U_ZERO_ERROR; 1054 precision.initVisibleDigitsWithExponent( 1055 6.02E23, visibleDigits, status); 1056 if (!assertSuccess("", status)) { 1057 return; 1058 } 1059 SciFormatterOptions options; 1060 verifySciFormatter( 1061 "6.02E23", 1062 formatter, 1063 visibleDigits, 1064 options, 1065 NULL); 1066 precision.initVisibleDigitsWithExponent( 1067 6.62E-34, visibleDigits, status); 1068 if (!assertSuccess("", status)) { 1069 return; 1070 } 1071 verifySciFormatter( 1072 "6.62E-34", 1073 formatter, 1074 visibleDigits, 1075 options, 1076 NULL); 1077 } 1078 1079 void NumberFormat2Test::TestSciFormatter() { 1080 DigitFormatter formatter; 1081 ScientificPrecision precision; 1082 precision.fMantissa.fMin.setIntDigitCount(4); 1083 precision.fMantissa.fMax.setIntDigitCount(4); 1084 precision.fMantissa.fMin.setFracDigitCount(0); 1085 precision.fMantissa.fMax.setFracDigitCount(0); 1086 precision.fMinExponentDigits = 3; 1087 VisibleDigitsWithExponent visibleDigits; 1088 UErrorCode status = U_ZERO_ERROR; 1089 precision.initVisibleDigitsWithExponent( 1090 1.248E26, visibleDigits, status); 1091 if (!assertSuccess("", status)) { 1092 return; 1093 } 1094 SciFormatterOptions options; 1095 1096 { 1097 options.fExponent.fAlwaysShowSign = TRUE; 1098 NumberFormat2Test_Attributes expectedAttributes[] = { 1099 {UNUM_INTEGER_FIELD, 0, 4}, 1100 {UNUM_EXPONENT_SYMBOL_FIELD, 4, 5}, 1101 {UNUM_EXPONENT_SIGN_FIELD, 5, 6}, 1102 {UNUM_EXPONENT_FIELD, 6, 9}, 1103 {0, -1, 0}}; 1104 verifySciFormatter( 1105 "1248E+023", 1106 formatter, 1107 visibleDigits, 1108 options, 1109 expectedAttributes); 1110 } 1111 { 1112 options.fMantissa.fAlwaysShowDecimal = TRUE; 1113 options.fExponent.fAlwaysShowSign = FALSE; 1114 NumberFormat2Test_Attributes expectedAttributes[] = { 1115 {UNUM_INTEGER_FIELD, 0, 4}, 1116 {UNUM_DECIMAL_SEPARATOR_FIELD, 4, 5}, 1117 {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6}, 1118 {UNUM_EXPONENT_FIELD, 6, 9}, 1119 {0, -1, 0}}; 1120 verifySciFormatter( 1121 "1248.E023", 1122 formatter, 1123 visibleDigits, 1124 options, 1125 expectedAttributes); 1126 } 1127 } 1128 1129 void NumberFormat2Test::TestValueFormatterIsFastFormattable() { 1130 UErrorCode status = U_ZERO_ERROR; 1131 DecimalFormatSymbols symbols("en", status); 1132 if (!assertSuccess("", status)) { 1133 return; 1134 } 1135 DigitFormatter formatter(symbols); 1136 DigitGrouping grouping; 1137 FixedPrecision precision; 1138 DigitFormatterOptions options; 1139 ValueFormatter vf; 1140 vf.prepareFixedDecimalFormatting( 1141 formatter, grouping, precision, options); 1142 assertTrue("", vf.isFastFormattable(0)); 1143 assertTrue("", vf.isFastFormattable(35)); 1144 assertTrue("", vf.isFastFormattable(-48)); 1145 assertTrue("", vf.isFastFormattable(2147483647)); 1146 assertTrue("", vf.isFastFormattable(-2147483647)); 1147 assertFalse("", vf.isFastFormattable(-2147483648L)); 1148 { 1149 DigitGrouping grouping; 1150 grouping.fGrouping = 3; 1151 ValueFormatter vf; 1152 vf.prepareFixedDecimalFormatting( 1153 formatter, grouping, precision, options); 1154 assertTrue("0", vf.isFastFormattable(0)); 1155 assertTrue("62", vf.isFastFormattable(62)); 1156 assertTrue("999", vf.isFastFormattable(999)); 1157 assertFalse("1000", vf.isFastFormattable(1000)); 1158 assertTrue("-1", vf.isFastFormattable(-1)); 1159 assertTrue("-38", vf.isFastFormattable(-38)); 1160 assertTrue("-999", vf.isFastFormattable(-999)); 1161 assertFalse("-1000", vf.isFastFormattable(-1000)); 1162 grouping.fMinGrouping = 2; 1163 assertTrue("-1000", vf.isFastFormattable(-1000)); 1164 assertTrue("-4095", vf.isFastFormattable(-4095)); 1165 assertTrue("4095", vf.isFastFormattable(4095)); 1166 // We give up on acounting digits at 4096 1167 assertFalse("-4096", vf.isFastFormattable(-4096)); 1168 assertFalse("4096", vf.isFastFormattable(4096)); 1169 } 1170 { 1171 // grouping on but with max integer digits set. 1172 DigitGrouping grouping; 1173 grouping.fGrouping = 4; 1174 FixedPrecision precision; 1175 precision.fMax.setIntDigitCount(4); 1176 ValueFormatter vf; 1177 vf.prepareFixedDecimalFormatting( 1178 formatter, grouping, precision, options); 1179 assertTrue("-4096", vf.isFastFormattable(-4096)); 1180 assertTrue("4096", vf.isFastFormattable(4096)); 1181 assertTrue("-10000", vf.isFastFormattable(-10000)); 1182 assertTrue("10000", vf.isFastFormattable(10000)); 1183 assertTrue("-2147483647", vf.isFastFormattable(-2147483647)); 1184 assertTrue("2147483647", vf.isFastFormattable(2147483647)); 1185 1186 precision.fMax.setIntDigitCount(5); 1187 assertFalse("-4096", vf.isFastFormattable(-4096)); 1188 assertFalse("4096", vf.isFastFormattable(4096)); 1189 1190 } 1191 { 1192 // grouping on but with min integer digits set. 1193 DigitGrouping grouping; 1194 grouping.fGrouping = 3; 1195 FixedPrecision precision; 1196 precision.fMin.setIntDigitCount(3); 1197 ValueFormatter vf; 1198 vf.prepareFixedDecimalFormatting( 1199 formatter, grouping, precision, options); 1200 assertTrue("-999", vf.isFastFormattable(-999)); 1201 assertTrue("999", vf.isFastFormattable(999)); 1202 assertFalse("-1000", vf.isFastFormattable(-1000)); 1203 assertFalse("1000", vf.isFastFormattable(1000)); 1204 1205 precision.fMin.setIntDigitCount(4); 1206 assertFalse("-999", vf.isFastFormattable(-999)); 1207 assertFalse("999", vf.isFastFormattable(999)); 1208 assertFalse("-2147483647", vf.isFastFormattable(-2147483647)); 1209 assertFalse("2147483647", vf.isFastFormattable(2147483647)); 1210 } 1211 { 1212 // options set. 1213 DigitFormatterOptions options; 1214 ValueFormatter vf; 1215 vf.prepareFixedDecimalFormatting( 1216 formatter, grouping, precision, options); 1217 assertTrue("5125", vf.isFastFormattable(5125)); 1218 options.fAlwaysShowDecimal = TRUE; 1219 assertFalse("5125", vf.isFastFormattable(5125)); 1220 options.fAlwaysShowDecimal = FALSE; 1221 assertTrue("5125", vf.isFastFormattable(5125)); 1222 } 1223 { 1224 // test fraction digits 1225 FixedPrecision precision; 1226 ValueFormatter vf; 1227 vf.prepareFixedDecimalFormatting( 1228 formatter, grouping, precision, options); 1229 assertTrue("7127", vf.isFastFormattable(7127)); 1230 precision.fMin.setFracDigitCount(1); 1231 assertFalse("7127", vf.isFastFormattable(7127)); 1232 } 1233 { 1234 // test presence of significant digits 1235 FixedPrecision precision; 1236 ValueFormatter vf; 1237 vf.prepareFixedDecimalFormatting( 1238 formatter, grouping, precision, options); 1239 assertTrue("1049", vf.isFastFormattable(1049)); 1240 precision.fSignificant.setMin(1); 1241 assertFalse("1049", vf.isFastFormattable(1049)); 1242 } 1243 { 1244 // test presence of rounding increment 1245 FixedPrecision precision; 1246 ValueFormatter vf; 1247 vf.prepareFixedDecimalFormatting( 1248 formatter, grouping, precision, options); 1249 assertTrue("1099", vf.isFastFormattable(1099)); 1250 precision.fRoundingIncrement.set(2.3); 1251 assertFalse("1099", vf.isFastFormattable(1099)); 1252 } 1253 { 1254 // test scientific notation 1255 ScientificPrecision precision; 1256 SciFormatterOptions options; 1257 ValueFormatter vf; 1258 vf.prepareScientificFormatting( 1259 formatter, precision, options); 1260 assertFalse("1081", vf.isFastFormattable(1081)); 1261 } 1262 } 1263 1264 void NumberFormat2Test::TestDigitAffix() { 1265 DigitAffix affix; 1266 { 1267 affix.append("foo"); 1268 affix.append("--", UNUM_SIGN_FIELD); 1269 affix.append("%", UNUM_PERCENT_FIELD); 1270 NumberFormat2Test_Attributes expectedAttributes[] = { 1271 {UNUM_SIGN_FIELD, 3, 5}, 1272 {UNUM_PERCENT_FIELD, 5, 6}, 1273 {0, -1, 0}}; 1274 verifyAffix("foo--%", affix, expectedAttributes); 1275 } 1276 { 1277 affix.remove(); 1278 affix.append("USD", UNUM_CURRENCY_FIELD); 1279 affix.append(" "); 1280 NumberFormat2Test_Attributes expectedAttributes[] = { 1281 {UNUM_CURRENCY_FIELD, 0, 3}, 1282 {0, -1, 0}}; 1283 verifyAffix("USD ", affix, expectedAttributes); 1284 } 1285 { 1286 affix.setTo("%%", UNUM_PERCENT_FIELD); 1287 NumberFormat2Test_Attributes expectedAttributes[] = { 1288 {UNUM_PERCENT_FIELD, 0, 2}, 1289 {0, -1, 0}}; 1290 verifyAffix("%%", affix, expectedAttributes); 1291 } 1292 } 1293 1294 void NumberFormat2Test::TestPluralAffix() { 1295 UErrorCode status = U_ZERO_ERROR; 1296 PluralAffix part; 1297 part.setVariant("one", "Dollar", status); 1298 part.setVariant("few", "DollarFew", status); 1299 part.setVariant("other", "Dollars", status); 1300 PluralAffix dollar(part); 1301 PluralAffix percent(part); 1302 part.remove(); 1303 part.setVariant("one", "Percent", status); 1304 part.setVariant("many", "PercentMany", status); 1305 part.setVariant("other", "Percents", status); 1306 percent = part; 1307 part.remove(); 1308 part.setVariant("one", "foo", status); 1309 1310 PluralAffix pa; 1311 assertEquals("", "", pa.getOtherVariant().toString()); 1312 pa.append(dollar, UNUM_CURRENCY_FIELD, status); 1313 pa.append(" and "); 1314 pa.append(percent, UNUM_PERCENT_FIELD, status); 1315 pa.append("-", UNUM_SIGN_FIELD); 1316 1317 { 1318 // other 1319 NumberFormat2Test_Attributes expectedAttributes[] = { 1320 {UNUM_CURRENCY_FIELD, 0, 7}, 1321 {UNUM_PERCENT_FIELD, 12, 20}, 1322 {UNUM_SIGN_FIELD, 20, 21}, 1323 {0, -1, 0}}; 1324 verifyAffix( 1325 "Dollars and Percents-", 1326 pa.getByCategory("other"), 1327 expectedAttributes); 1328 } 1329 { 1330 // two which is same as other 1331 NumberFormat2Test_Attributes expectedAttributes[] = { 1332 {UNUM_CURRENCY_FIELD, 0, 7}, 1333 {UNUM_PERCENT_FIELD, 12, 20}, 1334 {UNUM_SIGN_FIELD, 20, 21}, 1335 {0, -1, 0}}; 1336 verifyAffix( 1337 "Dollars and Percents-", 1338 pa.getByCategory("two"), 1339 expectedAttributes); 1340 } 1341 { 1342 // bad which is same as other 1343 NumberFormat2Test_Attributes expectedAttributes[] = { 1344 {UNUM_CURRENCY_FIELD, 0, 7}, 1345 {UNUM_PERCENT_FIELD, 12, 20}, 1346 {UNUM_SIGN_FIELD, 20, 21}, 1347 {0, -1, 0}}; 1348 verifyAffix( 1349 "Dollars and Percents-", 1350 pa.getByCategory("bad"), 1351 expectedAttributes); 1352 } 1353 { 1354 // one 1355 NumberFormat2Test_Attributes expectedAttributes[] = { 1356 {UNUM_CURRENCY_FIELD, 0, 6}, 1357 {UNUM_PERCENT_FIELD, 11, 18}, 1358 {UNUM_SIGN_FIELD, 18, 19}, 1359 {0, -1, 0}}; 1360 verifyAffix( 1361 "Dollar and Percent-", 1362 pa.getByCategory("one"), 1363 expectedAttributes); 1364 } 1365 { 1366 // few 1367 NumberFormat2Test_Attributes expectedAttributes[] = { 1368 {UNUM_CURRENCY_FIELD, 0, 9}, 1369 {UNUM_PERCENT_FIELD, 14, 22}, 1370 {UNUM_SIGN_FIELD, 22, 23}, 1371 {0, -1, 0}}; 1372 verifyAffix( 1373 "DollarFew and Percents-", 1374 pa.getByCategory("few"), 1375 expectedAttributes); 1376 } 1377 { 1378 // many 1379 NumberFormat2Test_Attributes expectedAttributes[] = { 1380 {UNUM_CURRENCY_FIELD, 0, 7}, 1381 {UNUM_PERCENT_FIELD, 12, 23}, 1382 {UNUM_SIGN_FIELD, 23, 24}, 1383 {0, -1, 0}}; 1384 verifyAffix( 1385 "Dollars and PercentMany-", 1386 pa.getByCategory("many"), 1387 expectedAttributes); 1388 } 1389 assertTrue("", pa.hasMultipleVariants()); 1390 pa.remove(); 1391 pa.append("$$$", UNUM_CURRENCY_FIELD); 1392 assertFalse("", pa.hasMultipleVariants()); 1393 1394 } 1395 1396 void NumberFormat2Test::TestCurrencyAffixInfo() { 1397 CurrencyAffixInfo info; 1398 assertTrue("", info.isDefault()); 1399 UnicodeString expectedSymbol("\\u00a4"); 1400 UnicodeString expectedSymbolIso("\\u00a4\\u00a4"); 1401 UnicodeString expectedSymbols("\\u00a4\\u00a4\\u00a4"); 1402 assertEquals("", expectedSymbol.unescape(), info.getSymbol()); 1403 assertEquals("", expectedSymbolIso.unescape(), info.getISO()); 1404 assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("one").toString()); 1405 assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("other").toString()); 1406 assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("two").toString()); 1407 UErrorCode status = U_ZERO_ERROR; 1408 static UChar USD[] = {0x55, 0x53, 0x44, 0x0}; 1409 LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status)); 1410 if (!assertSuccess("", status)) { 1411 return; 1412 } 1413 info.set("en", rules.getAlias(), USD, status); 1414 assertEquals("", "$", info.getSymbol(), TRUE); 1415 assertEquals("", "USD", info.getISO(), TRUE); 1416 assertEquals("", "US dollar", info.getLong().getByCategory("one").toString(), TRUE); 1417 assertEquals("", "US dollars", info.getLong().getByCategory("other").toString(), TRUE); 1418 assertEquals("", "US dollars", info.getLong().getByCategory("two").toString(), TRUE); 1419 assertFalse("", info.isDefault()); 1420 info.set(NULL, NULL, NULL, status); 1421 assertTrue("", info.isDefault()); 1422 assertEquals("", expectedSymbol.unescape(), info.getSymbol()); 1423 assertEquals("", expectedSymbolIso.unescape(), info.getISO()); 1424 assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("one").toString()); 1425 assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("other").toString()); 1426 assertEquals("", expectedSymbols.unescape(), info.getLong().getByCategory("two").toString()); 1427 info.setSymbol("$"); 1428 assertFalse("", info.isDefault()); 1429 info.set(NULL, NULL, NULL, status); 1430 assertTrue("", info.isDefault()); 1431 info.setISO("USD"); 1432 assertFalse("", info.isDefault()); 1433 assertSuccess("", status); 1434 } 1435 1436 void NumberFormat2Test::TestAffixPattern() { 1437 static UChar chars[500]; 1438 for (int32_t i = 0; i < UPRV_LENGTHOF(chars); ++i) { 1439 chars[i] = (UChar) (i + 1); 1440 } 1441 AffixPattern first; 1442 first.add(AffixPattern::kPercent); 1443 first.addLiteral(chars, 0, 200); 1444 first.addLiteral(chars, 200, 300); 1445 first.addCurrency(2); 1446 first.addLiteral(chars, 0, 256); 1447 AffixPattern second; 1448 second.add(AffixPattern::kPercent); 1449 second.addLiteral(chars, 0, 300); 1450 second.addLiteral(chars, 300, 200); 1451 second.addCurrency(2); 1452 second.addLiteral(chars, 0, 150); 1453 second.addLiteral(chars, 150, 106); 1454 assertTrue("", first.equals(second)); 1455 AffixPatternIterator iter; 1456 second.remove(); 1457 assertFalse("", second.iterator(iter).nextToken()); 1458 assertTrue("", first.iterator(iter).nextToken()); 1459 assertEquals("", (int32_t)AffixPattern::kPercent, iter.getTokenType()); 1460 assertEquals("", 1, iter.getTokenLength()); 1461 assertTrue("", iter.nextToken()); 1462 UnicodeString str; 1463 assertEquals("", 500, iter.getLiteral(str).length()); 1464 assertEquals("", (int32_t)AffixPattern::kLiteral, iter.getTokenType()); 1465 assertEquals("", 500, iter.getTokenLength()); 1466 assertTrue("", iter.nextToken()); 1467 assertEquals("", (int32_t)AffixPattern::kCurrency, iter.getTokenType()); 1468 assertEquals("", 2, iter.getTokenLength()); 1469 assertTrue("", iter.nextToken()); 1470 assertEquals("", 256, iter.getLiteral(str).length()); 1471 assertEquals("", (int32_t)AffixPattern::kLiteral, iter.getTokenType()); 1472 assertEquals("", 256, iter.getTokenLength()); 1473 assertFalse("", iter.nextToken()); 1474 } 1475 1476 void NumberFormat2Test::TestAffixPatternDoubleQuote() { 1477 UnicodeString str("'Don''t'"); 1478 AffixPattern expected; 1479 // Don't 1480 static UChar chars[] = {0x44, 0x6F, 0x6E, 0x27, 0x74}; 1481 expected.addLiteral(chars, 0, UPRV_LENGTHOF(chars)); 1482 AffixPattern actual; 1483 UErrorCode status = U_ZERO_ERROR; 1484 AffixPattern::parseUserAffixString(str, actual, status); 1485 assertTrue("", expected.equals(actual)); 1486 UnicodeString formattedString; 1487 assertEquals("", "Don''t", actual.toUserString(formattedString)); 1488 assertSuccess("", status); 1489 } 1490 1491 void NumberFormat2Test::TestAffixPatternParser() { 1492 UErrorCode status = U_ZERO_ERROR; 1493 static UChar USD[] = {0x55, 0x53, 0x44, 0x0}; 1494 LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status)); 1495 DecimalFormatSymbols symbols("en", status); 1496 if (U_FAILURE(status)) { 1497 dataerrln("Error creating DecimalFormatSymbols - %s", u_errorName(status)); 1498 return; 1499 } 1500 AffixPatternParser parser(symbols); 1501 CurrencyAffixInfo currencyAffixInfo; 1502 currencyAffixInfo.set("en", rules.getAlias(), USD, status); 1503 PluralAffix affix; 1504 UnicodeString str("'--y'''dz'%'\\u00a4\\u00a4\\u00a4\\u00a4 y '\\u00a4\\u00a4\\u00a4 or '\\u00a4\\u00a4 but '\\u00a4"); 1505 str = str.unescape(); 1506 assertSuccess("", status); 1507 AffixPattern affixPattern; 1508 parser.parse( 1509 AffixPattern::parseAffixString(str, affixPattern, status), 1510 currencyAffixInfo, 1511 affix, 1512 status); 1513 UnicodeString formattedStr; 1514 affixPattern.toString(formattedStr); 1515 UnicodeString expectedFormattedStr("'--y''dz'%'\\u00a4\\u00a4\\u00a4\\u00a4 y '\\u00a4\\u00a4\\u00a4 or '\\u00a4\\u00a4 but '\\u00a4"); 1516 expectedFormattedStr = expectedFormattedStr.unescape(); 1517 assertEquals("1", expectedFormattedStr, formattedStr); 1518 AffixPattern userAffixPattern; 1519 UnicodeString userStr("-'-'y'''d'z%\\u00a4\\u00a4\\u00a4'\\u00a4' y \\u00a4\\u00a4\\u00a4 or \\u00a4\\u00a4 but \\u00a4"); 1520 userStr = userStr.unescape(); 1521 AffixPattern::parseUserAffixString(userStr, userAffixPattern, status), 1522 assertTrue("", affixPattern.equals(userAffixPattern)); 1523 AffixPattern userAffixPattern2; 1524 UnicodeString formattedUserStr; 1525 AffixPattern::parseUserAffixString( 1526 userAffixPattern.toUserString(formattedUserStr), 1527 userAffixPattern2, 1528 status); 1529 UnicodeString expectedFormattedUserStr( 1530 "-'-'y''dz%\\u00a4\\u00a4\\u00a4'\\u00a4' y \\u00a4\\u00a4\\u00a4 or \\u00a4\\u00a4 but \\u00a4"); 1531 assertEquals("2", expectedFormattedUserStr.unescape(), formattedUserStr); 1532 assertTrue("", userAffixPattern2.equals(userAffixPattern)); 1533 assertSuccess("", status); 1534 assertTrue("", affixPattern.usesCurrency()); 1535 assertTrue("", affixPattern.usesPercent()); 1536 assertFalse("", affixPattern.usesPermill()); 1537 assertTrue("", affix.hasMultipleVariants()); 1538 { 1539 // other 1540 NumberFormat2Test_Attributes expectedAttributes[] = { 1541 {UNUM_SIGN_FIELD, 0, 1}, 1542 {UNUM_PERCENT_FIELD, 6, 7}, 1543 {UNUM_CURRENCY_FIELD, 7, 17}, 1544 {UNUM_CURRENCY_FIELD, 21, 31}, 1545 {UNUM_CURRENCY_FIELD, 35, 38}, 1546 {UNUM_CURRENCY_FIELD, 43, 44}, 1547 {0, -1, 0}}; 1548 verifyAffix( 1549 "--y'dz%US dollars\\u00a4 y US dollars or USD but $", 1550 affix.getByCategory("other"), 1551 expectedAttributes); 1552 } 1553 { 1554 // one 1555 NumberFormat2Test_Attributes expectedAttributes[] = { 1556 {UNUM_SIGN_FIELD, 0, 1}, 1557 {UNUM_PERCENT_FIELD, 6, 7}, 1558 {UNUM_CURRENCY_FIELD, 7, 16}, 1559 {UNUM_CURRENCY_FIELD, 20, 29}, 1560 {UNUM_CURRENCY_FIELD, 33, 36}, 1561 {UNUM_CURRENCY_FIELD, 41, 42}, 1562 {0, -1, 0}}; 1563 verifyAffix( 1564 "--y'dz%US dollar\\u00a4 y US dollar or USD but $", 1565 affix.getByCategory("one"), 1566 expectedAttributes); 1567 } 1568 affix.remove(); 1569 str = "%'-"; 1570 affixPattern.remove(); 1571 parser.parse( 1572 AffixPattern::parseAffixString(str, affixPattern, status), 1573 currencyAffixInfo, 1574 affix, 1575 status); 1576 assertSuccess("", status); 1577 assertFalse("", affixPattern.usesCurrency()); 1578 assertFalse("", affixPattern.usesPercent()); 1579 assertFalse("", affixPattern.usesPermill()); 1580 assertFalse("", affix.hasMultipleVariants()); 1581 { 1582 // other 1583 NumberFormat2Test_Attributes expectedAttributes[] = { 1584 {UNUM_SIGN_FIELD, 1, 2}, 1585 {0, -1, 0}}; 1586 verifyAffix( 1587 "%-", 1588 affix.getByCategory("other"), 1589 expectedAttributes); 1590 } 1591 UnicodeString a4("\\u00a4"); 1592 AffixPattern scratchPattern; 1593 AffixPattern::parseAffixString(a4.unescape(), scratchPattern, status); 1594 assertFalse("", scratchPattern.usesCurrency()); 1595 1596 // Test really long string > 256 chars. 1597 str = "'\\u2030012345678901234567890123456789012345678901234567890123456789" 1598 "012345678901234567890123456789012345678901234567890123456789" 1599 "012345678901234567890123456789012345678901234567890123456789" 1600 "012345678901234567890123456789012345678901234567890123456789" 1601 "012345678901234567890123456789012345678901234567890123456789"; 1602 str = str.unescape(); 1603 affixPattern.remove(); 1604 affix.remove(); 1605 parser.parse( 1606 AffixPattern::parseAffixString(str, affixPattern, status), 1607 currencyAffixInfo, 1608 affix, 1609 status); 1610 assertSuccess("", status); 1611 assertFalse("", affixPattern.usesCurrency()); 1612 assertFalse("", affixPattern.usesPercent()); 1613 assertTrue("", affixPattern.usesPermill()); 1614 assertFalse("", affix.hasMultipleVariants()); 1615 { 1616 UnicodeString expected = 1617 "\\u2030012345678901234567890123456789012345678901234567890123456789" 1618 "012345678901234567890123456789012345678901234567890123456789" 1619 "012345678901234567890123456789012345678901234567890123456789" 1620 "012345678901234567890123456789012345678901234567890123456789" 1621 "012345678901234567890123456789012345678901234567890123456789"; 1622 expected = expected.unescape(); 1623 NumberFormat2Test_Attributes expectedAttributes[] = { 1624 {UNUM_PERMILL_FIELD, 0, 1}, 1625 {0, -1, 0}}; 1626 verifyAffix( 1627 expected, 1628 affix.getOtherVariant(), 1629 expectedAttributes); 1630 } 1631 } 1632 1633 void NumberFormat2Test::TestAffixPatternAppend() { 1634 AffixPattern pattern; 1635 UErrorCode status = U_ZERO_ERROR; 1636 UnicodeString patternStr("%\\u2030"); 1637 AffixPattern::parseUserAffixString( 1638 patternStr.unescape(), pattern, status); 1639 1640 AffixPattern appendPattern; 1641 UnicodeString appendPatternStr("-\\u00a4\\u00a4*"); 1642 AffixPattern::parseUserAffixString( 1643 appendPatternStr.unescape(), appendPattern, status); 1644 1645 AffixPattern expectedPattern; 1646 UnicodeString expectedPatternStr("%\\u2030-\\u00a4\\u00a4*"); 1647 AffixPattern::parseUserAffixString( 1648 expectedPatternStr.unescape(), expectedPattern, status); 1649 1650 assertTrue("", pattern.append(appendPattern).equals(expectedPattern)); 1651 assertSuccess("", status); 1652 } 1653 1654 void NumberFormat2Test::TestAffixPatternAppendAjoiningLiterals() { 1655 AffixPattern pattern; 1656 UErrorCode status = U_ZERO_ERROR; 1657 UnicodeString patternStr("%baaa"); 1658 AffixPattern::parseUserAffixString( 1659 patternStr, pattern, status); 1660 1661 AffixPattern appendPattern; 1662 UnicodeString appendPatternStr("caa%"); 1663 AffixPattern::parseUserAffixString( 1664 appendPatternStr, appendPattern, status); 1665 1666 AffixPattern expectedPattern; 1667 UnicodeString expectedPatternStr("%baaacaa%"); 1668 AffixPattern::parseUserAffixString( 1669 expectedPatternStr, expectedPattern, status); 1670 1671 assertTrue("", pattern.append(appendPattern).equals(expectedPattern)); 1672 assertSuccess("", status); 1673 } 1674 1675 void NumberFormat2Test::TestLargeIntValue() { 1676 VisibleDigits digits; 1677 { 1678 UErrorCode status = U_ZERO_ERROR; 1679 FixedPrecision precision; 1680 1681 // Last 18 digits for int values. 1682 verifyIntValue( 1683 223372036854775807LL, 1684 precision.initVisibleDigits(INT64_MAX, digits, status)); 1685 assertSuccess("INT64_MAX", status); 1686 } 1687 { 1688 UErrorCode status = U_ZERO_ERROR; 1689 FixedPrecision precision; 1690 precision.fMax.setIntDigitCount(5); 1691 1692 // Last 18 digits for int values. 1693 verifyIntValue( 1694 75807LL, 1695 precision.initVisibleDigits(INT64_MAX, digits, status)); 1696 verifySource(75807.0, digits); 1697 assertSuccess("75807", status); 1698 } 1699 { 1700 UErrorCode status = U_ZERO_ERROR; 1701 FixedPrecision precision; 1702 1703 // Last 18 digits for int values. 1704 verifyIntValue( 1705 223372036854775808LL, 1706 precision.initVisibleDigits(INT64_MIN, digits, status)); 1707 assertSuccess("INT64_MIN", status); 1708 } 1709 { 1710 UErrorCode status = U_ZERO_ERROR; 1711 FixedPrecision precision; 1712 precision.fMax.setIntDigitCount(5); 1713 1714 // Last 18 digits for int values. 1715 verifyIntValue( 1716 75808LL, 1717 precision.initVisibleDigits(INT64_MIN, digits, status)); 1718 verifySource(75808.0, digits); 1719 assertSuccess("75808", status); 1720 } 1721 1722 } 1723 1724 void NumberFormat2Test::TestIntInitVisibleDigits() { 1725 VisibleDigits digits; 1726 { 1727 UErrorCode status = U_ZERO_ERROR; 1728 FixedPrecision precision; 1729 verifyVisibleDigits( 1730 "13", 1731 FALSE, 1732 precision.initVisibleDigits((int64_t) 13LL, digits, status)); 1733 assertSuccess("13", status); 1734 } 1735 { 1736 UErrorCode status = U_ZERO_ERROR; 1737 FixedPrecision precision; 1738 verifyVisibleDigits( 1739 "17", 1740 TRUE, 1741 precision.initVisibleDigits((int64_t) -17LL, digits, status)); 1742 assertSuccess("-17", status); 1743 } 1744 { 1745 UErrorCode status = U_ZERO_ERROR; 1746 FixedPrecision precision; 1747 verifyVisibleDigits( 1748 "9223372036854775808", 1749 TRUE, 1750 precision.initVisibleDigits(INT64_MIN, digits, status)); 1751 assertSuccess("-9223372036854775808", status); 1752 } 1753 { 1754 UErrorCode status = U_ZERO_ERROR; 1755 FixedPrecision precision; 1756 verifyVisibleDigits( 1757 "9223372036854775807", 1758 FALSE, 1759 precision.initVisibleDigits(INT64_MAX, digits, status)); 1760 assertSuccess("9223372036854775807", status); 1761 } 1762 { 1763 UErrorCode status = U_ZERO_ERROR; 1764 FixedPrecision precision; 1765 verifyVisibleDigits( 1766 "31536000", 1767 TRUE, 1768 precision.initVisibleDigits((int64_t) -31536000LL, digits, status)); 1769 assertSuccess("-31536000", status); 1770 } 1771 { 1772 UErrorCode status = U_ZERO_ERROR; 1773 FixedPrecision precision; 1774 verifyVisibleDigits( 1775 "0", 1776 FALSE, 1777 precision.initVisibleDigits((int64_t) 0LL, digits, status)); 1778 assertSuccess("0", status); 1779 } 1780 { 1781 UErrorCode status = U_ZERO_ERROR; 1782 FixedPrecision precision; 1783 precision.fMin.setIntDigitCount(4); 1784 precision.fMin.setFracDigitCount(2); 1785 verifyVisibleDigits( 1786 "0000.00", 1787 FALSE, 1788 precision.initVisibleDigits((int64_t) 0LL, digits, status)); 1789 assertSuccess("0", status); 1790 } 1791 { 1792 UErrorCode status = U_ZERO_ERROR; 1793 FixedPrecision precision; 1794 precision.fMin.setIntDigitCount(4); 1795 precision.fMin.setFracDigitCount(2); 1796 verifyVisibleDigits( 1797 "0057.00", 1798 FALSE, 1799 precision.initVisibleDigits((int64_t) 57LL, digits, status)); 1800 assertSuccess("57", status); 1801 } 1802 { 1803 UErrorCode status = U_ZERO_ERROR; 1804 FixedPrecision precision; 1805 precision.fMin.setIntDigitCount(4); 1806 precision.fMin.setFracDigitCount(2); 1807 verifyVisibleDigits( 1808 "0057.00", 1809 TRUE, 1810 precision.initVisibleDigits((int64_t) -57LL, digits, status)); 1811 assertSuccess("-57", status); 1812 } 1813 { 1814 UErrorCode status = U_ZERO_ERROR; 1815 FixedPrecision precision; 1816 precision.fMax.setIntDigitCount(2); 1817 precision.fMin.setFracDigitCount(1); 1818 verifyVisibleDigits( 1819 "35.0", 1820 FALSE, 1821 precision.initVisibleDigits((int64_t) 235LL, digits, status)); 1822 assertSuccess("235", status); 1823 } 1824 { 1825 UErrorCode status = U_ZERO_ERROR; 1826 FixedPrecision precision; 1827 precision.fMax.setIntDigitCount(2); 1828 precision.fMin.setFracDigitCount(1); 1829 precision.fFailIfOverMax = TRUE; 1830 precision.initVisibleDigits((int64_t) 239LL, digits, status); 1831 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 1832 errln("239: Expected U_ILLEGAL_ARGUMENT_ERROR"); 1833 } 1834 } 1835 { 1836 UErrorCode status = U_ZERO_ERROR; 1837 FixedPrecision precision; 1838 precision.fSignificant.setMin(5); 1839 verifyVisibleDigits( 1840 "153.00", 1841 FALSE, 1842 precision.initVisibleDigits((int64_t) 153LL, digits, status)); 1843 assertSuccess("153", status); 1844 } 1845 { 1846 UErrorCode status = U_ZERO_ERROR; 1847 FixedPrecision precision; 1848 precision.fSignificant.setMax(2); 1849 precision.fExactOnly = TRUE; 1850 precision.initVisibleDigits((int64_t) 154LL, digits, status); 1851 if (status != U_FORMAT_INEXACT_ERROR) { 1852 errln("154: Expected U_FORMAT_INEXACT_ERROR"); 1853 } 1854 } 1855 { 1856 UErrorCode status = U_ZERO_ERROR; 1857 FixedPrecision precision; 1858 precision.fSignificant.setMax(5); 1859 verifyVisibleDigits( 1860 "150", 1861 FALSE, 1862 precision.initVisibleDigits((int64_t) 150LL, digits, status)); 1863 assertSuccess("150", status); 1864 } 1865 } 1866 1867 void NumberFormat2Test::TestIntInitVisibleDigitsToDigitList() { 1868 VisibleDigits digits; 1869 { 1870 UErrorCode status = U_ZERO_ERROR; 1871 FixedPrecision precision; 1872 precision.fRoundingIncrement.set(7.3); 1873 verifyVisibleDigits( 1874 "29.2", 1875 TRUE, 1876 precision.initVisibleDigits((int64_t) -30LL, digits, status)); 1877 assertSuccess("-29.2", status); 1878 } 1879 { 1880 UErrorCode status = U_ZERO_ERROR; 1881 FixedPrecision precision; 1882 precision.fRoundingIncrement.set(7.3); 1883 precision.fRoundingMode = DecimalFormat::kRoundFloor; 1884 verifyVisibleDigits( 1885 "36.5", 1886 TRUE, 1887 precision.initVisibleDigits((int64_t) -30LL, digits, status)); 1888 assertSuccess("-36.5", status); 1889 } 1890 { 1891 UErrorCode status = U_ZERO_ERROR; 1892 FixedPrecision precision; 1893 precision.fSignificant.setMax(3); 1894 precision.fRoundingMode = DecimalFormat::kRoundCeiling; 1895 verifyVisibleDigits( 1896 "1390", 1897 FALSE, 1898 precision.initVisibleDigits((int64_t) 1381LL, digits, status)); 1899 assertSuccess("1390", status); 1900 } 1901 { 1902 UErrorCode status = U_ZERO_ERROR; 1903 FixedPrecision precision; 1904 precision.fSignificant.setMax(1); 1905 precision.fRoundingMode = DecimalFormat::kRoundFloor; 1906 verifyVisibleDigits( 1907 "2000", 1908 TRUE, 1909 precision.initVisibleDigits((int64_t) -1381LL, digits, status)); 1910 assertSuccess("-2000", status); 1911 } 1912 } 1913 1914 void NumberFormat2Test::TestDoubleInitVisibleDigits() { 1915 VisibleDigits digits; 1916 { 1917 UErrorCode status = U_ZERO_ERROR; 1918 FixedPrecision precision; 1919 verifyVisibleDigits( 1920 "2.05", 1921 FALSE, 1922 precision.initVisibleDigits(2.05, digits, status)); 1923 assertSuccess("2.05", status); 1924 } 1925 { 1926 UErrorCode status = U_ZERO_ERROR; 1927 FixedPrecision precision; 1928 verifyVisibleDigits( 1929 "3547", 1930 FALSE, 1931 precision.initVisibleDigits(3547.0, digits, status)); 1932 assertSuccess("3547", status); 1933 } 1934 { 1935 UErrorCode status = U_ZERO_ERROR; 1936 FixedPrecision precision; 1937 precision.fMax.setFracDigitCount(2); 1938 precision.fMax.setIntDigitCount(1); 1939 precision.fFailIfOverMax = TRUE; 1940 precision.fExactOnly = TRUE; 1941 verifyVisibleDigits( 1942 "2.05", 1943 TRUE, 1944 precision.initVisibleDigits(-2.05, digits, status)); 1945 assertSuccess("-2.05", status); 1946 } 1947 { 1948 UErrorCode status = U_ZERO_ERROR; 1949 FixedPrecision precision; 1950 precision.fMax.setFracDigitCount(1); 1951 precision.fMax.setIntDigitCount(1); 1952 precision.fFailIfOverMax = TRUE; 1953 precision.fExactOnly = TRUE; 1954 precision.initVisibleDigits(-2.05, digits, status); 1955 if (status != U_FORMAT_INEXACT_ERROR) { 1956 errln("6245.3: Expected U_FORMAT_INEXACT_ERROR"); 1957 } 1958 } 1959 { 1960 UErrorCode status = U_ZERO_ERROR; 1961 FixedPrecision precision; 1962 precision.fMax.setFracDigitCount(2); 1963 precision.fMax.setIntDigitCount(0); 1964 precision.fFailIfOverMax = TRUE; 1965 precision.fExactOnly = TRUE; 1966 precision.initVisibleDigits(-2.05, digits, status); 1967 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 1968 errln("-2.05: Expected U_ILLEGAL_ARGUMENT_ERROR"); 1969 } 1970 } 1971 { 1972 UErrorCode status = U_ZERO_ERROR; 1973 FixedPrecision precision; 1974 precision.fMin.setIntDigitCount(5); 1975 precision.fMin.setFracDigitCount(2); 1976 precision.fExactOnly = TRUE; 1977 verifyVisibleDigits( 1978 "06245.30", 1979 FALSE, 1980 precision.initVisibleDigits(6245.3, digits, status)); 1981 assertSuccess("06245.30", status); 1982 } 1983 { 1984 UErrorCode status = U_ZERO_ERROR; 1985 FixedPrecision precision; 1986 precision.fSignificant.setMax(5); 1987 precision.fExactOnly = TRUE; 1988 verifyVisibleDigits( 1989 "6245.3", 1990 FALSE, 1991 precision.initVisibleDigits(6245.3, digits, status)); 1992 assertSuccess("6245.3", status); 1993 } 1994 { 1995 UErrorCode status = U_ZERO_ERROR; 1996 FixedPrecision precision; 1997 precision.fSignificant.setMax(4); 1998 precision.fExactOnly = TRUE; 1999 precision.initVisibleDigits(6245.3, digits, status); 2000 if (status != U_FORMAT_INEXACT_ERROR) { 2001 errln("6245.3: Expected U_FORMAT_INEXACT_ERROR"); 2002 } 2003 } 2004 { 2005 UErrorCode status = U_ZERO_ERROR; 2006 FixedPrecision precision; 2007 precision.fMax.setIntDigitCount(3); 2008 precision.fMin.setFracDigitCount(2); 2009 verifyVisibleDigits( 2010 "384.90", 2011 FALSE, 2012 precision.initVisibleDigits(2384.9, digits, status)); 2013 assertSuccess("380.00", status); 2014 } 2015 { 2016 UErrorCode status = U_ZERO_ERROR; 2017 FixedPrecision precision; 2018 precision.fMax.setIntDigitCount(3); 2019 precision.fMin.setFracDigitCount(2); 2020 precision.fFailIfOverMax = TRUE; 2021 precision.initVisibleDigits(2384.9, digits, status); 2022 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 2023 errln("2384.9: Expected U_ILLEGAL_ARGUMENT_ERROR"); 2024 } 2025 } 2026 } 2027 2028 void NumberFormat2Test::TestDoubleInitVisibleDigitsToDigitList() { 2029 VisibleDigits digits; 2030 { 2031 UErrorCode status = U_ZERO_ERROR; 2032 FixedPrecision precision; 2033 // 2.01 produces round off error when multiplied by powers of 2034 // 10 forcing the use of DigitList. 2035 verifyVisibleDigits( 2036 "2.01", 2037 TRUE, 2038 precision.initVisibleDigits(-2.01, digits, status)); 2039 assertSuccess("-2.01", status); 2040 } 2041 { 2042 UErrorCode status = U_ZERO_ERROR; 2043 FixedPrecision precision; 2044 precision.fSignificant.setMax(3); 2045 precision.fMin.setFracDigitCount(2); 2046 verifyVisibleDigits( 2047 "2380.00", 2048 FALSE, 2049 precision.initVisibleDigits(2385.0, digits, status)); 2050 assertSuccess("2380.00", status); 2051 } 2052 { 2053 UErrorCode status = U_ZERO_ERROR; 2054 FixedPrecision precision; 2055 precision.fMax.setFracDigitCount(2); 2056 verifyVisibleDigits( 2057 "45.83", 2058 TRUE, 2059 precision.initVisibleDigits(-45.8251, digits, status)); 2060 assertSuccess("45.83", status); 2061 } 2062 } 2063 2064 void NumberFormat2Test::TestDigitListInitVisibleDigits() { 2065 VisibleDigits digits; 2066 DigitList dlist; 2067 { 2068 UErrorCode status = U_ZERO_ERROR; 2069 FixedPrecision precision; 2070 precision.fMax.setIntDigitCount(3); 2071 precision.fMin.setFracDigitCount(2); 2072 precision.fFailIfOverMax = TRUE; 2073 dlist.set(2384.9); 2074 precision.initVisibleDigits(dlist, digits, status); 2075 if (status != U_ILLEGAL_ARGUMENT_ERROR) { 2076 errln("2384.9: Expected U_ILLEGAL_ARGUMENT_ERROR"); 2077 } 2078 } 2079 { 2080 UErrorCode status = U_ZERO_ERROR; 2081 FixedPrecision precision; 2082 precision.fSignificant.setMax(4); 2083 precision.fExactOnly = TRUE; 2084 dlist.set(6245.3); 2085 precision.initVisibleDigits(dlist, digits, status); 2086 if (status != U_FORMAT_INEXACT_ERROR) { 2087 errln("6245.3: Expected U_FORMAT_INEXACT_ERROR"); 2088 } 2089 } 2090 } 2091 2092 void NumberFormat2Test::TestSpecialInitVisibleDigits() { 2093 VisibleDigits digits; 2094 { 2095 UErrorCode status = U_ZERO_ERROR; 2096 FixedPrecision precision; 2097 precision.fSignificant.setMax(3); 2098 precision.fMin.setFracDigitCount(2); 2099 precision.initVisibleDigits(-uprv_getInfinity(), digits, status); 2100 assertFalse("", digits.isNaN()); 2101 assertTrue("", digits.isInfinite()); 2102 assertTrue("", digits.isNegative()); 2103 assertSuccess("-Inf", status); 2104 } 2105 { 2106 UErrorCode status = U_ZERO_ERROR; 2107 FixedPrecision precision; 2108 precision.initVisibleDigits(uprv_getInfinity(), digits, status); 2109 assertFalse("", digits.isNaN()); 2110 assertTrue("", digits.isInfinite()); 2111 assertFalse("", digits.isNegative()); 2112 assertSuccess("Inf", status); 2113 } 2114 { 2115 UErrorCode status = U_ZERO_ERROR; 2116 FixedPrecision precision; 2117 precision.initVisibleDigits(uprv_getNaN(), digits, status); 2118 assertTrue("", digits.isNaN()); 2119 assertSuccess("Inf", status); 2120 } 2121 } 2122 2123 void NumberFormat2Test::TestVisibleDigitsWithExponent() { 2124 VisibleDigitsWithExponent digits; 2125 { 2126 UErrorCode status = U_ZERO_ERROR; 2127 ScientificPrecision precision; 2128 precision.initVisibleDigitsWithExponent(389.256, digits, status); 2129 verifyVisibleDigitsWithExponent( 2130 "3.89256E2", FALSE, digits); 2131 assertSuccess("3.89256E2", status); 2132 } 2133 { 2134 UErrorCode status = U_ZERO_ERROR; 2135 ScientificPrecision precision; 2136 precision.initVisibleDigitsWithExponent(-389.256, digits, status); 2137 verifyVisibleDigitsWithExponent( 2138 "3.89256E2", TRUE, digits); 2139 assertSuccess("-3.89256E2", status); 2140 } 2141 { 2142 UErrorCode status = U_ZERO_ERROR; 2143 ScientificPrecision precision; 2144 precision.fMinExponentDigits = 3; 2145 precision.fMantissa.fMin.setIntDigitCount(1); 2146 precision.fMantissa.fMax.setIntDigitCount(3); 2147 precision.initVisibleDigitsWithExponent(12345.67, digits, status); 2148 verifyVisibleDigitsWithExponent( 2149 "12.34567E003", FALSE, digits); 2150 assertSuccess("12.34567E003", status); 2151 } 2152 { 2153 UErrorCode status = U_ZERO_ERROR; 2154 ScientificPrecision precision; 2155 precision.fMantissa.fRoundingIncrement.set(0.073); 2156 precision.fMantissa.fMin.setIntDigitCount(2); 2157 precision.fMantissa.fMax.setIntDigitCount(2); 2158 precision.initVisibleDigitsWithExponent(999.74, digits, status); 2159 verifyVisibleDigitsWithExponent( 2160 "10.001E2", FALSE, digits); 2161 assertSuccess("10.001E2", status); 2162 } 2163 } 2164 2165 void NumberFormat2Test::TestDigitAffixesAndPadding() { 2166 UErrorCode status = U_ZERO_ERROR; 2167 DecimalFormatSymbols symbols("en", status); 2168 if (!assertSuccess("", status)) { 2169 return; 2170 } 2171 DigitFormatter formatter(symbols); 2172 DigitGrouping grouping; 2173 grouping.fGrouping = 3; 2174 FixedPrecision precision; 2175 DigitFormatterOptions options; 2176 options.fAlwaysShowDecimal = TRUE; 2177 ValueFormatter vf; 2178 vf.prepareFixedDecimalFormatting( 2179 formatter, 2180 grouping, 2181 precision, 2182 options); 2183 DigitAffixesAndPadding aap; 2184 aap.fPositivePrefix.append("(+", UNUM_SIGN_FIELD); 2185 aap.fPositiveSuffix.append("+)", UNUM_SIGN_FIELD); 2186 aap.fNegativePrefix.append("(-", UNUM_SIGN_FIELD); 2187 aap.fNegativeSuffix.append("-)", UNUM_SIGN_FIELD); 2188 aap.fWidth = 10; 2189 aap.fPadPosition = DigitAffixesAndPadding::kPadBeforePrefix; 2190 { 2191 NumberFormat2Test_Attributes expectedAttributes[] = { 2192 {UNUM_SIGN_FIELD, 4, 6}, 2193 {UNUM_INTEGER_FIELD, 6, 7}, 2194 {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8}, 2195 {UNUM_SIGN_FIELD, 8, 10}, 2196 {0, -1, 0}}; 2197 verifyAffixesAndPaddingInt32( 2198 "****(+3.+)", 2199 aap, 2200 3, 2201 vf, 2202 NULL, 2203 expectedAttributes); 2204 } 2205 aap.fPadPosition = DigitAffixesAndPadding::kPadAfterPrefix; 2206 { 2207 NumberFormat2Test_Attributes expectedAttributes[] = { 2208 {UNUM_SIGN_FIELD, 0, 2}, 2209 {UNUM_INTEGER_FIELD, 6, 7}, 2210 {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8}, 2211 {UNUM_SIGN_FIELD, 8, 10}, 2212 {0, -1, 0}}; 2213 verifyAffixesAndPaddingInt32( 2214 "(+****3.+)", 2215 aap, 2216 3, 2217 vf, 2218 NULL, 2219 expectedAttributes); 2220 } 2221 aap.fPadPosition = DigitAffixesAndPadding::kPadBeforeSuffix; 2222 { 2223 NumberFormat2Test_Attributes expectedAttributes[] = { 2224 {UNUM_SIGN_FIELD, 0, 2}, 2225 {UNUM_INTEGER_FIELD, 2, 3}, 2226 {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4}, 2227 {UNUM_SIGN_FIELD, 8, 10}, 2228 {0, -1, 0}}; 2229 verifyAffixesAndPaddingInt32( 2230 "(+3.****+)", 2231 aap, 2232 3, 2233 vf, 2234 NULL, 2235 expectedAttributes); 2236 } 2237 aap.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix; 2238 { 2239 NumberFormat2Test_Attributes expectedAttributes[] = { 2240 {UNUM_SIGN_FIELD, 0, 2}, 2241 {UNUM_INTEGER_FIELD, 2, 3}, 2242 {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4}, 2243 {UNUM_SIGN_FIELD, 4, 6}, 2244 {0, -1, 0}}; 2245 verifyAffixesAndPaddingInt32( 2246 "(+3.+)****", 2247 aap, 2248 3, 2249 vf, 2250 NULL, 2251 expectedAttributes); 2252 } 2253 aap.fPadPosition = DigitAffixesAndPadding::kPadAfterSuffix; 2254 { 2255 DigitList digits; 2256 digits.set(-1234.5); 2257 NumberFormat2Test_Attributes expectedAttributes[] = { 2258 {UNUM_SIGN_FIELD, 0, 2}, 2259 {UNUM_GROUPING_SEPARATOR_FIELD, 3, 4}, 2260 {UNUM_INTEGER_FIELD, 2, 7}, 2261 {UNUM_DECIMAL_SEPARATOR_FIELD, 7, 8}, 2262 {UNUM_FRACTION_FIELD, 8, 9}, 2263 {UNUM_SIGN_FIELD, 9, 11}, 2264 {0, -1, 0}}; 2265 verifyAffixesAndPadding( 2266 "(-1,234.5-)", 2267 aap, 2268 digits, 2269 vf, 2270 NULL, 2271 expectedAttributes); 2272 } 2273 assertFalse("", aap.needsPluralRules()); 2274 2275 aap.fWidth = 0; 2276 aap.fPositivePrefix.remove(); 2277 aap.fPositiveSuffix.remove(); 2278 aap.fNegativePrefix.remove(); 2279 aap.fNegativeSuffix.remove(); 2280 2281 // Set up for plural currencies. 2282 aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD); 2283 { 2284 PluralAffix part; 2285 part.setVariant("one", " Dollar", status); 2286 part.setVariant("other", " Dollars", status); 2287 aap.fPositiveSuffix.append(part, UNUM_CURRENCY_FIELD, status); 2288 } 2289 aap.fNegativeSuffix = aap.fPositiveSuffix; 2290 2291 LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status)); 2292 if (!assertSuccess("", status)) { 2293 return; 2294 } 2295 2296 // Exercise the fastrack path 2297 { 2298 options.fAlwaysShowDecimal = FALSE; 2299 NumberFormat2Test_Attributes expectedAttributes[] = { 2300 {UNUM_SIGN_FIELD, 0, 1}, 2301 {UNUM_INTEGER_FIELD, 1, 3}, 2302 {UNUM_CURRENCY_FIELD, 3, 11}, 2303 {0, -1, 0}}; 2304 verifyAffixesAndPaddingInt32( 2305 "-45 Dollars", 2306 aap, 2307 -45, 2308 vf, 2309 NULL, 2310 expectedAttributes); 2311 options.fAlwaysShowDecimal = TRUE; 2312 } 2313 2314 // Now test plurals 2315 assertTrue("", aap.needsPluralRules()); 2316 { 2317 NumberFormat2Test_Attributes expectedAttributes[] = { 2318 {UNUM_INTEGER_FIELD, 0, 1}, 2319 {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, 2320 {UNUM_CURRENCY_FIELD, 2, 9}, 2321 {0, -1, 0}}; 2322 verifyAffixesAndPaddingInt32( 2323 "1. Dollar", 2324 aap, 2325 1, 2326 vf, 2327 rules.getAlias(), 2328 expectedAttributes); 2329 } 2330 { 2331 NumberFormat2Test_Attributes expectedAttributes[] = { 2332 {UNUM_SIGN_FIELD, 0, 1}, 2333 {UNUM_INTEGER_FIELD, 1, 2}, 2334 {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3}, 2335 {UNUM_CURRENCY_FIELD, 3, 10}, 2336 {0, -1, 0}}; 2337 verifyAffixesAndPaddingInt32( 2338 "-1. Dollar", 2339 aap, 2340 -1, 2341 vf, 2342 rules.getAlias(), 2343 expectedAttributes); 2344 } 2345 precision.fMin.setFracDigitCount(2); 2346 { 2347 NumberFormat2Test_Attributes expectedAttributes[] = { 2348 {UNUM_INTEGER_FIELD, 0, 1}, 2349 {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, 2350 {UNUM_FRACTION_FIELD, 2, 4}, 2351 {UNUM_CURRENCY_FIELD, 4, 12}, 2352 {0, -1, 0}}; 2353 verifyAffixesAndPaddingInt32( 2354 "1.00 Dollars", 2355 aap, 2356 1, 2357 vf, 2358 rules.getAlias(), 2359 expectedAttributes); 2360 } 2361 } 2362 2363 void NumberFormat2Test::TestPluralsAndRounding() { 2364 UErrorCode status = U_ZERO_ERROR; 2365 DecimalFormatSymbols symbols("en", status); 2366 if (!assertSuccess("", status)) { 2367 return; 2368 } 2369 DigitFormatter formatter(symbols); 2370 DigitGrouping grouping; 2371 FixedPrecision precision; 2372 precision.fSignificant.setMax(3); 2373 DigitFormatterOptions options; 2374 ValueFormatter vf; 2375 vf.prepareFixedDecimalFormatting( 2376 formatter, 2377 grouping, 2378 precision, 2379 options); 2380 DigitList digits; 2381 DigitAffixesAndPadding aap; 2382 // Set up for plural currencies. 2383 aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD); 2384 { 2385 PluralAffix part; 2386 part.setVariant("one", " Dollar", status); 2387 part.setVariant("other", " Dollars", status); 2388 aap.fPositiveSuffix.append(part, UNUM_CURRENCY_FIELD, status); 2389 } 2390 aap.fNegativeSuffix = aap.fPositiveSuffix; 2391 aap.fWidth = 14; 2392 LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status)); 2393 if (!assertSuccess("", status)) { 2394 return; 2395 } 2396 { 2397 digits.set(0.999); 2398 verifyAffixesAndPadding( 2399 "*0.999 Dollars", 2400 aap, 2401 digits, 2402 vf, 2403 rules.getAlias(), 2404 NULL); 2405 } 2406 { 2407 digits.set(0.9996); 2408 verifyAffixesAndPadding( 2409 "******1 Dollar", 2410 aap, 2411 digits, 2412 vf, 2413 rules.getAlias(), 2414 NULL); 2415 } 2416 { 2417 digits.set(1.004); 2418 verifyAffixesAndPadding( 2419 "******1 Dollar", 2420 aap, 2421 digits, 2422 vf, 2423 rules.getAlias(), 2424 NULL); 2425 } 2426 precision.fSignificant.setMin(2); 2427 { 2428 digits.set(0.9996); 2429 verifyAffixesAndPadding( 2430 "***1.0 Dollars", 2431 aap, 2432 digits, 2433 vf, 2434 rules.getAlias(), 2435 NULL); 2436 } 2437 { 2438 digits.set(1.004); 2439 verifyAffixesAndPadding( 2440 "***1.0 Dollars", 2441 aap, 2442 digits, 2443 vf, 2444 rules.getAlias(), 2445 NULL); 2446 } 2447 precision.fSignificant.setMin(0); 2448 { 2449 digits.set(-79.214); 2450 verifyAffixesAndPadding( 2451 "*-79.2 Dollars", 2452 aap, 2453 digits, 2454 vf, 2455 rules.getAlias(), 2456 NULL); 2457 } 2458 // No more sig digits just max fractions 2459 precision.fSignificant.setMax(0); 2460 precision.fMax.setFracDigitCount(4); 2461 { 2462 digits.set(79.213562); 2463 verifyAffixesAndPadding( 2464 "79.2136 Dollars", 2465 aap, 2466 digits, 2467 vf, 2468 rules.getAlias(), 2469 NULL); 2470 } 2471 2472 } 2473 2474 2475 void NumberFormat2Test::TestPluralsAndRoundingScientific() { 2476 UErrorCode status = U_ZERO_ERROR; 2477 DecimalFormatSymbols symbols("en", status); 2478 if (!assertSuccess("", status)) { 2479 return; 2480 } 2481 DigitFormatter formatter(symbols); 2482 ScientificPrecision precision; 2483 precision.fMantissa.fSignificant.setMax(4); 2484 SciFormatterOptions options; 2485 ValueFormatter vf; 2486 vf.prepareScientificFormatting( 2487 formatter, 2488 precision, 2489 options); 2490 DigitList digits; 2491 DigitAffixesAndPadding aap; 2492 aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD); 2493 { 2494 PluralAffix part; 2495 part.setVariant("one", " Meter", status); 2496 part.setVariant("other", " Meters", status); 2497 aap.fPositiveSuffix.append(part, UNUM_FIELD_COUNT, status); 2498 } 2499 aap.fNegativeSuffix = aap.fPositiveSuffix; 2500 LocalPointer<PluralRules> rules(PluralRules::forLocale("en", status)); 2501 if (!assertSuccess("", status)) { 2502 return; 2503 } 2504 { 2505 digits.set(0.99996); 2506 NumberFormat2Test_Attributes expectedAttributes[] = { 2507 {UNUM_INTEGER_FIELD, 0, 1}, 2508 {UNUM_EXPONENT_SYMBOL_FIELD, 1, 2}, 2509 {UNUM_EXPONENT_FIELD, 2, 3}, 2510 {0, -1, 0}}; 2511 verifyAffixesAndPadding( 2512 "1E0 Meters", 2513 aap, 2514 digits, 2515 vf, 2516 rules.getAlias(), 2517 expectedAttributes); 2518 } 2519 options.fMantissa.fAlwaysShowDecimal = TRUE; 2520 { 2521 digits.set(0.99996); 2522 NumberFormat2Test_Attributes expectedAttributes[] = { 2523 {UNUM_INTEGER_FIELD, 0, 1}, 2524 {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, 2525 {UNUM_EXPONENT_SYMBOL_FIELD, 2, 3}, 2526 {UNUM_EXPONENT_FIELD, 3, 4}, 2527 {0, -1, 0}}; 2528 verifyAffixesAndPadding( 2529 "1.E0 Meters", 2530 aap, 2531 digits, 2532 vf, 2533 rules.getAlias(), 2534 expectedAttributes); 2535 } 2536 { 2537 digits.set(-299792458.0); 2538 NumberFormat2Test_Attributes expectedAttributes[] = { 2539 {UNUM_SIGN_FIELD, 0, 1}, 2540 {UNUM_INTEGER_FIELD, 1, 2}, 2541 {UNUM_DECIMAL_SEPARATOR_FIELD, 2, 3}, 2542 {UNUM_FRACTION_FIELD, 3, 6}, 2543 {UNUM_EXPONENT_SYMBOL_FIELD, 6, 7}, 2544 {UNUM_EXPONENT_FIELD, 7, 8}, 2545 {0, -1, 0}}; 2546 verifyAffixesAndPadding( 2547 "-2.998E8 Meters", 2548 aap, 2549 digits, 2550 vf, 2551 rules.getAlias(), 2552 expectedAttributes); 2553 } 2554 precision.fMantissa.fSignificant.setMin(4); 2555 options.fExponent.fAlwaysShowSign = TRUE; 2556 precision.fMinExponentDigits = 3; 2557 { 2558 digits.set(3.0); 2559 NumberFormat2Test_Attributes expectedAttributes[] = { 2560 {UNUM_INTEGER_FIELD, 0, 1}, 2561 {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, 2562 {UNUM_FRACTION_FIELD, 2, 5}, 2563 {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6}, 2564 {UNUM_EXPONENT_SIGN_FIELD, 6, 7}, 2565 {UNUM_EXPONENT_FIELD, 7, 10}, 2566 {0, -1, 0}}; 2567 verifyAffixesAndPadding( 2568 "3.000E+000 Meters", 2569 aap, 2570 digits, 2571 vf, 2572 rules.getAlias(), 2573 expectedAttributes); 2574 } 2575 precision.fMantissa.fMax.setIntDigitCount(3); 2576 { 2577 digits.set(0.00025001); 2578 NumberFormat2Test_Attributes expectedAttributes[] = { 2579 {UNUM_INTEGER_FIELD, 0, 3}, 2580 {UNUM_DECIMAL_SEPARATOR_FIELD, 3, 4}, 2581 {UNUM_FRACTION_FIELD, 4, 5}, 2582 {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6}, 2583 {UNUM_EXPONENT_SIGN_FIELD, 6, 7}, 2584 {UNUM_EXPONENT_FIELD, 7, 10}, 2585 {0, -1, 0}}; 2586 verifyAffixesAndPadding( 2587 "250.0E-006 Meters", 2588 aap, 2589 digits, 2590 vf, 2591 rules.getAlias(), 2592 expectedAttributes); 2593 } 2594 { 2595 digits.set(0.0000025001); 2596 NumberFormat2Test_Attributes expectedAttributes[] = { 2597 {UNUM_INTEGER_FIELD, 0, 1}, 2598 {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, 2599 {UNUM_FRACTION_FIELD, 2, 5}, 2600 {UNUM_EXPONENT_SYMBOL_FIELD, 5, 6}, 2601 {UNUM_EXPONENT_SIGN_FIELD, 6, 7}, 2602 {UNUM_EXPONENT_FIELD, 7, 10}, 2603 {0, -1, 0}}; 2604 verifyAffixesAndPadding( 2605 "2.500E-006 Meters", 2606 aap, 2607 digits, 2608 vf, 2609 rules.getAlias(), 2610 expectedAttributes); 2611 } 2612 precision.fMantissa.fMax.setFracDigitCount(1); 2613 { 2614 digits.set(0.0000025499); 2615 NumberFormat2Test_Attributes expectedAttributes[] = { 2616 {UNUM_INTEGER_FIELD, 0, 1}, 2617 {UNUM_DECIMAL_SEPARATOR_FIELD, 1, 2}, 2618 {UNUM_FRACTION_FIELD, 2, 3}, 2619 {UNUM_EXPONENT_SYMBOL_FIELD, 3, 4}, 2620 {UNUM_EXPONENT_SIGN_FIELD, 4, 5}, 2621 {UNUM_EXPONENT_FIELD, 5, 8}, 2622 {0, -1, 0}}; 2623 verifyAffixesAndPadding( 2624 "2.5E-006 Meters", 2625 aap, 2626 digits, 2627 vf, 2628 rules.getAlias(), 2629 expectedAttributes); 2630 } 2631 precision.fMantissa.fMax.setIntDigitCount(1); 2632 precision.fMantissa.fMax.setFracDigitCount(2); 2633 { 2634 digits.set((int32_t)299792458); 2635 verifyAffixesAndPadding( 2636 "3.00E+008 Meters", 2637 aap, 2638 digits, 2639 vf, 2640 rules.getAlias(), 2641 NULL); 2642 } 2643 // clear significant digits 2644 precision.fMantissa.fSignificant.setMin(0); 2645 precision.fMantissa.fSignificant.setMax(0); 2646 2647 // set int and fraction digits 2648 precision.fMantissa.fMin.setFracDigitCount(2); 2649 precision.fMantissa.fMax.setFracDigitCount(4); 2650 precision.fMantissa.fMin.setIntDigitCount(2); 2651 precision.fMantissa.fMax.setIntDigitCount(3); 2652 { 2653 digits.set(-0.0000025300001); 2654 verifyAffixesAndPadding( 2655 "-253.00E-008 Meters", 2656 aap, 2657 digits, 2658 vf, 2659 rules.getAlias(), 2660 NULL); 2661 } 2662 { 2663 digits.set(-0.0000025300006); 2664 verifyAffixesAndPadding( 2665 "-253.0001E-008 Meters", 2666 aap, 2667 digits, 2668 vf, 2669 rules.getAlias(), 2670 NULL); 2671 } 2672 { 2673 digits.set(-0.000025300006); 2674 verifyAffixesAndPadding( 2675 "-25.30E-006 Meters", 2676 aap, 2677 digits, 2678 vf, 2679 rules.getAlias(), 2680 NULL); 2681 } 2682 } 2683 2684 2685 void NumberFormat2Test::TestRoundingIncrement() { 2686 UErrorCode status = U_ZERO_ERROR; 2687 DecimalFormatSymbols symbols("en", status); 2688 if (U_FAILURE(status)) { 2689 dataerrln("Error creating DecimalFormatSymbols - %s", u_errorName(status)); 2690 return; 2691 } 2692 DigitFormatter formatter(symbols); 2693 ScientificPrecision precision; 2694 SciFormatterOptions options; 2695 precision.fMantissa.fRoundingIncrement.set(0.25); 2696 precision.fMantissa.fSignificant.setMax(4); 2697 DigitGrouping grouping; 2698 ValueFormatter vf; 2699 2700 // fixed 2701 vf.prepareFixedDecimalFormatting( 2702 formatter, 2703 grouping, 2704 precision.fMantissa, 2705 options.fMantissa); 2706 DigitList digits; 2707 DigitAffixesAndPadding aap; 2708 aap.fNegativePrefix.append("-", UNUM_SIGN_FIELD); 2709 { 2710 digits.set(3.7); 2711 verifyAffixesAndPadding( 2712 "3.75", 2713 aap, 2714 digits, 2715 vf, 2716 NULL, NULL); 2717 } 2718 { 2719 digits.set(-7.4); 2720 verifyAffixesAndPadding( 2721 "-7.5", 2722 aap, 2723 digits, 2724 vf, 2725 NULL, NULL); 2726 } 2727 { 2728 digits.set(99.8); 2729 verifyAffixesAndPadding( 2730 "99.75", 2731 aap, 2732 digits, 2733 vf, 2734 NULL, NULL); 2735 } 2736 precision.fMantissa.fMin.setFracDigitCount(2); 2737 { 2738 digits.set(99.1); 2739 verifyAffixesAndPadding( 2740 "99.00", 2741 aap, 2742 digits, 2743 vf, 2744 NULL, NULL); 2745 } 2746 { 2747 digits.set(-639.65); 2748 verifyAffixesAndPadding( 2749 "-639.80", 2750 aap, 2751 digits, 2752 vf, 2753 NULL, NULL); 2754 } 2755 2756 precision.fMantissa.fMin.setIntDigitCount(2); 2757 // Scientific notation 2758 vf.prepareScientificFormatting( 2759 formatter, 2760 precision, 2761 options); 2762 { 2763 digits.set(-6396.5); 2764 verifyAffixesAndPadding( 2765 "-64.00E2", 2766 aap, 2767 digits, 2768 vf, 2769 NULL, NULL); 2770 } 2771 { 2772 digits.set(-0.00092374); 2773 verifyAffixesAndPadding( 2774 "-92.25E-5", 2775 aap, 2776 digits, 2777 vf, 2778 NULL, NULL); 2779 } 2780 precision.fMantissa.fMax.setIntDigitCount(3); 2781 { 2782 digits.set(-0.00092374); 2783 verifyAffixesAndPadding( 2784 "-923.80E-6", 2785 aap, 2786 digits, 2787 vf, 2788 NULL, NULL); 2789 } 2790 } 2791 2792 void NumberFormat2Test::TestToPatternScientific11648() { 2793 /* 2794 UErrorCode status = U_ZERO_ERROR; 2795 Locale en("en"); 2796 DecimalFormat2 fmt(en, "0.00", status); 2797 fmt.setScientificNotation(TRUE); 2798 UnicodeString pattern; 2799 // Fails, produces "0.00E" 2800 assertEquals("", "0.00E0", fmt.toPattern(pattern)); 2801 DecimalFormat fmt2(pattern, status); 2802 // Fails, bad pattern. 2803 assertSuccess("", status); 2804 */ 2805 } 2806 2807 void NumberFormat2Test::verifyAffixesAndPadding( 2808 const UnicodeString &expected, 2809 const DigitAffixesAndPadding &aaf, 2810 DigitList &digits, 2811 const ValueFormatter &vf, 2812 const PluralRules *optPluralRules, 2813 const NumberFormat2Test_Attributes *expectedAttributes) { 2814 UnicodeString appendTo; 2815 NumberFormat2Test_FieldPositionHandler handler; 2816 UErrorCode status = U_ZERO_ERROR; 2817 assertEquals( 2818 "", 2819 expected, 2820 aaf.format( 2821 digits, 2822 vf, 2823 handler, 2824 optPluralRules, 2825 appendTo, 2826 status)); 2827 if (!assertSuccess("", status)) { 2828 return; 2829 } 2830 if (expectedAttributes != NULL) { 2831 verifyAttributes(expectedAttributes, handler.attributes); 2832 } 2833 } 2834 2835 void NumberFormat2Test::verifyAffixesAndPaddingInt32( 2836 const UnicodeString &expected, 2837 const DigitAffixesAndPadding &aaf, 2838 int32_t value, 2839 const ValueFormatter &vf, 2840 const PluralRules *optPluralRules, 2841 const NumberFormat2Test_Attributes *expectedAttributes) { 2842 UnicodeString appendTo; 2843 NumberFormat2Test_FieldPositionHandler handler; 2844 UErrorCode status = U_ZERO_ERROR; 2845 assertEquals( 2846 "", 2847 expected, 2848 aaf.formatInt32( 2849 value, 2850 vf, 2851 handler, 2852 optPluralRules, 2853 appendTo, 2854 status)); 2855 if (!assertSuccess("", status)) { 2856 return; 2857 } 2858 if (expectedAttributes != NULL) { 2859 verifyAttributes(expectedAttributes, handler.attributes); 2860 } 2861 DigitList digits; 2862 digits.set(value); 2863 verifyAffixesAndPadding( 2864 expected, aaf, digits, vf, optPluralRules, expectedAttributes); 2865 } 2866 2867 void NumberFormat2Test::verifyAffix( 2868 const UnicodeString &expected, 2869 const DigitAffix &affix, 2870 const NumberFormat2Test_Attributes *expectedAttributes) { 2871 UnicodeString appendTo; 2872 NumberFormat2Test_FieldPositionHandler handler; 2873 assertEquals( 2874 "", 2875 expected.unescape(), 2876 affix.format(handler, appendTo)); 2877 if (expectedAttributes != NULL) { 2878 verifyAttributes(expectedAttributes, handler.attributes); 2879 } 2880 } 2881 2882 // Right now only works for positive values. 2883 void NumberFormat2Test::verifyDigitList( 2884 const UnicodeString &expected, 2885 const DigitList &digits) { 2886 DigitFormatter formatter; 2887 DigitGrouping grouping; 2888 VisibleDigits visibleDigits; 2889 FixedPrecision precision; 2890 precision.fMin.setIntDigitCount(0); 2891 DigitFormatterOptions options; 2892 UErrorCode status = U_ZERO_ERROR; 2893 DigitList dlCopy(digits); 2894 precision.initVisibleDigits( 2895 dlCopy, visibleDigits, status); 2896 if (!assertSuccess("", status)) { 2897 return; 2898 } 2899 verifyDigitFormatter( 2900 expected, 2901 formatter, 2902 visibleDigits, 2903 grouping, 2904 options, 2905 NULL); 2906 } 2907 2908 void NumberFormat2Test::verifyVisibleDigits( 2909 const UnicodeString &expected, 2910 UBool bNegative, 2911 const VisibleDigits &digits) { 2912 DigitFormatter formatter; 2913 DigitGrouping grouping; 2914 DigitFormatterOptions options; 2915 verifyDigitFormatter( 2916 expected, 2917 formatter, 2918 digits, 2919 grouping, 2920 options, 2921 NULL); 2922 if (digits.isNegative() != bNegative) { 2923 errln(expected + ": Wrong sign."); 2924 } 2925 if (digits.isNaN() || digits.isInfinite()) { 2926 errln(expected + ": Require real value."); 2927 } 2928 } 2929 2930 void NumberFormat2Test::verifyVisibleDigitsWithExponent( 2931 const UnicodeString &expected, 2932 UBool bNegative, 2933 const VisibleDigitsWithExponent &digits) { 2934 DigitFormatter formatter; 2935 SciFormatterOptions options; 2936 verifySciFormatter( 2937 expected, 2938 formatter, 2939 digits, 2940 options, 2941 NULL); 2942 if (digits.isNegative() != bNegative) { 2943 errln(expected + ": Wrong sign."); 2944 } 2945 if (digits.isNaN() || digits.isInfinite()) { 2946 errln(expected + ": Require real value."); 2947 } 2948 } 2949 2950 void NumberFormat2Test::verifySciFormatter( 2951 const UnicodeString &expected, 2952 const DigitFormatter &formatter, 2953 const VisibleDigitsWithExponent &digits, 2954 const SciFormatterOptions &options, 2955 const NumberFormat2Test_Attributes *expectedAttributes) { 2956 assertEquals( 2957 "", 2958 expected.countChar32(), 2959 formatter.countChar32(digits, options)); 2960 UnicodeString appendTo; 2961 NumberFormat2Test_FieldPositionHandler handler; 2962 assertEquals( 2963 "", 2964 expected, 2965 formatter.format( 2966 digits, 2967 options, 2968 handler, 2969 appendTo)); 2970 if (expectedAttributes != NULL) { 2971 verifyAttributes(expectedAttributes, handler.attributes); 2972 } 2973 } 2974 2975 void NumberFormat2Test::verifyPositiveIntDigitFormatter( 2976 const UnicodeString &expected, 2977 const DigitFormatter &formatter, 2978 int32_t value, 2979 int32_t minDigits, 2980 int32_t maxDigits, 2981 const NumberFormat2Test_Attributes *expectedAttributes) { 2982 IntDigitCountRange range(minDigits, maxDigits); 2983 UnicodeString appendTo; 2984 NumberFormat2Test_FieldPositionHandler handler; 2985 assertEquals( 2986 "", 2987 expected, 2988 formatter.formatPositiveInt32( 2989 value, 2990 range, 2991 handler, 2992 appendTo)); 2993 if (expectedAttributes != NULL) { 2994 verifyAttributes(expectedAttributes, handler.attributes); 2995 } 2996 } 2997 2998 void NumberFormat2Test::verifyDigitFormatter( 2999 const UnicodeString &expected, 3000 const DigitFormatter &formatter, 3001 const VisibleDigits &digits, 3002 const DigitGrouping &grouping, 3003 const DigitFormatterOptions &options, 3004 const NumberFormat2Test_Attributes *expectedAttributes) { 3005 assertEquals( 3006 "", 3007 expected.countChar32(), 3008 formatter.countChar32(digits, grouping, options)); 3009 UnicodeString appendTo; 3010 NumberFormat2Test_FieldPositionHandler handler; 3011 assertEquals( 3012 "", 3013 expected, 3014 formatter.format( 3015 digits, 3016 grouping, 3017 options, 3018 handler, 3019 appendTo)); 3020 if (expectedAttributes != NULL) { 3021 verifyAttributes(expectedAttributes, handler.attributes); 3022 } 3023 } 3024 3025 void NumberFormat2Test::verifySmallIntFormatter( 3026 const UnicodeString &expected, 3027 int32_t positiveValue, 3028 int32_t minDigits, 3029 int32_t maxDigits) { 3030 IntDigitCountRange range(minDigits, maxDigits); 3031 if (!SmallIntFormatter::canFormat(positiveValue, range)) { 3032 UnicodeString actual; 3033 assertEquals("", expected, actual); 3034 return; 3035 } 3036 UnicodeString actual; 3037 assertEquals("", expected, SmallIntFormatter::format(positiveValue, range, actual)); 3038 } 3039 3040 void NumberFormat2Test::verifyAttributes( 3041 const NumberFormat2Test_Attributes *expected, 3042 const NumberFormat2Test_Attributes *actual) { 3043 int32_t idx = 0; 3044 while (expected[idx].spos != -1 && actual[idx].spos != -1) { 3045 assertEquals("id", expected[idx].id, actual[idx].id); 3046 assertEquals("spos", expected[idx].spos, actual[idx].spos); 3047 assertEquals("epos", expected[idx].epos, actual[idx].epos); 3048 ++idx; 3049 } 3050 assertEquals( 3051 "expected and actual not same length", 3052 expected[idx].spos, 3053 actual[idx].spos); 3054 } 3055 3056 void NumberFormat2Test::verifyIntValue( 3057 int64_t expected, const VisibleDigits &digits) { 3058 double unusedSource; 3059 int64_t intValue; 3060 int64_t unusedF; 3061 int64_t unusedT; 3062 int32_t unusedV; 3063 UBool unusedHasIntValue; 3064 digits.getFixedDecimal( 3065 unusedSource, intValue, unusedF, 3066 unusedT, unusedV, unusedHasIntValue); 3067 assertEquals("", expected, intValue); 3068 } 3069 3070 void NumberFormat2Test::verifySource( 3071 double expected, const VisibleDigits &digits) { 3072 double source; 3073 int64_t unusedIntValue; 3074 int64_t unusedF; 3075 int64_t unusedT; 3076 int32_t unusedV; 3077 UBool unusedHasIntValue; 3078 digits.getFixedDecimal( 3079 source, unusedIntValue, unusedF, 3080 unusedT, unusedV, unusedHasIntValue); 3081 if (expected != source) { 3082 errln("Expected %f, got %f instead", expected, source); 3083 } 3084 } 3085 3086 extern IntlTest *createNumberFormat2Test() { 3087 return new NumberFormat2Test(); 3088 } 3089 3090 #endif /* !UCONFIG_NO_FORMATTING */ 3091
