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