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