]> git.saurik.com Git - apple/icu.git/blob - icuSources/test/intltest/numberformat2test.cpp
projects / apple / icu.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
ICU-59117.0.1.tar.gz
[apple/icu.git] / icuSources / test / intltest / numberformat2test.cpp
1 // © 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(U_INT64_MAX, digits, status));
1685 assertSuccess("U_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(U_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(U_INT64_MIN, digits, status));
1707 assertSuccess("U_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(U_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(U_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(U_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 */
mirror of ICU