| OLD | NEW |
|---|
| (Empty) |
| 1 /******************************************************************** | |
| 2 * COPYRIGHT: | |
| 3 * Copyright (c) 1997-2015, 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/currpinf.h" | |
| 14 #include "unicode/dcfmtsym.h" | |
| 15 #include "unicode/decimfmt.h" | |
| 16 #include "unicode/fmtable.h" | |
| 17 #include "unicode/localpointer.h" | |
| 18 #include "unicode/parseerr.h" | |
| 19 #include "unicode/stringpiece.h" | |
| 20 | |
| 21 #include "putilimp.h" | |
| 22 #include "plurrule_impl.h" | |
| 23 #include <stdio.h> | |
| 24 | |
| 25 // This is an API test, not a unit test. It doesn't test very many cases, and d
oesn't | |
| 26 // try to test the full functionality. It just calls each function in the class
and | |
| 27 // verifies that it works on a basic level. | |
| 28 | |
| 29 void IntlTestDecimalFormatAPI::runIndexedTest( int32_t index, UBool exec, const
char* &name, char* /*par*/ ) | |
| 30 { | |
| 31 if (exec) logln((UnicodeString)"TestSuite DecimalFormatAPI"); | |
| 32 switch (index) { | |
| 33 case 0: name = "DecimalFormat API test"; | |
| 34 if (exec) { | |
| 35 logln((UnicodeString)"DecimalFormat API test---"); logln((Un
icodeString)""); | |
| 36 UErrorCode status = U_ZERO_ERROR; | |
| 37 Locale saveLocale; | |
| 38 Locale::setDefault(Locale::getEnglish(), status); | |
| 39 if(U_FAILURE(status)) { | |
| 40 errln((UnicodeString)"ERROR: Could not set default local
e, test may not give correct results"); | |
| 41 } | |
| 42 testAPI(/*par*/); | |
| 43 Locale::setDefault(saveLocale, status); | |
| 44 } | |
| 45 break; | |
| 46 case 1: name = "Rounding test"; | |
| 47 if(exec) { | |
| 48 logln((UnicodeString)"DecimalFormat Rounding test---"); | |
| 49 testRounding(/*par*/); | |
| 50 } | |
| 51 break; | |
| 52 case 2: name = "Test6354"; | |
| 53 if(exec) { | |
| 54 logln((UnicodeString)"DecimalFormat Rounding Increment test---"); | |
| 55 testRoundingInc(/*par*/); | |
| 56 } | |
| 57 break; | |
| 58 case 3: name = "TestCurrencyPluralInfo"; | |
| 59 if(exec) { | |
| 60 logln((UnicodeString)"CurrencyPluralInfo API test---"); | |
| 61 TestCurrencyPluralInfo(); | |
| 62 } | |
| 63 break; | |
| 64 case 4: name = "TestScale"; | |
| 65 if(exec) { | |
| 66 logln((UnicodeString)"Scale test---"); | |
| 67 TestScale(); | |
| 68 } | |
| 69 break; | |
| 70 case 5: name = "TestFixedDecimal"; | |
| 71 if(exec) { | |
| 72 logln((UnicodeString)"TestFixedDecimal ---"); | |
| 73 TestFixedDecimal(); | |
| 74 } | |
| 75 break; | |
| 76 case 6: name = "TestBadFastpath"; | |
| 77 if(exec) { | |
| 78 logln((UnicodeString)"TestBadFastpath ---"); | |
| 79 TestBadFastpath(); | |
| 80 } | |
| 81 break; | |
| 82 case 7: name = "TestRequiredDecimalPoint"; | |
| 83 if(exec) { | |
| 84 logln((UnicodeString)"TestRequiredDecimalPoint ---"); | |
| 85 TestRequiredDecimalPoint(); | |
| 86 } | |
| 87 break; | |
| 88 default: name = ""; break; | |
| 89 } | |
| 90 } | |
| 91 | |
| 92 /** | |
| 93 * This test checks various generic API methods in DecimalFormat to achieve 100% | |
| 94 * API coverage. | |
| 95 */ | |
| 96 void IntlTestDecimalFormatAPI::testAPI(/*char *par*/) | |
| 97 { | |
| 98 UErrorCode status = U_ZERO_ERROR; | |
| 99 | |
| 100 // ======= Test constructors | |
| 101 | |
| 102 logln((UnicodeString)"Testing DecimalFormat constructors"); | |
| 103 | |
| 104 DecimalFormat def(status); | |
| 105 if(U_FAILURE(status)) { | |
| 106 errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s
", u_errorName(status)); | |
| 107 return; | |
| 108 } | |
| 109 | |
| 110 // bug 10864 | |
| 111 status = U_ZERO_ERROR; | |
| 112 DecimalFormat noGrouping("###0.##", status); | |
| 113 if (noGrouping.getGroupingSize() != 0) { | |
| 114 errln("Grouping size should be 0 for no grouping."); | |
| 115 } | |
| 116 noGrouping.setGroupingUsed(TRUE); | |
| 117 if (noGrouping.getGroupingSize() != 0) { | |
| 118 errln("Grouping size should still be 0."); | |
| 119 } | |
| 120 // end bug 10864 | |
| 121 | |
| 122 status = U_ZERO_ERROR; | |
| 123 const UnicodeString pattern("#,##0.# FF"); | |
| 124 DecimalFormat pat(pattern, status); | |
| 125 if(U_FAILURE(status)) { | |
| 126 errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern)"); | |
| 127 return; | |
| 128 } | |
| 129 | |
| 130 status = U_ZERO_ERROR; | |
| 131 DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getFrench()
, status); | |
| 132 if(U_FAILURE(status)) { | |
| 133 errln((UnicodeString)"ERROR: Could not create DecimalFormatSymbols (Fren
ch)"); | |
| 134 return; | |
| 135 } | |
| 136 | |
| 137 status = U_ZERO_ERROR; | |
| 138 DecimalFormat cust1(pattern, symbols, status); | |
| 139 if(U_FAILURE(status)) { | |
| 140 errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, sy
mbols*)"); | |
| 141 } | |
| 142 | |
| 143 status = U_ZERO_ERROR; | |
| 144 DecimalFormat cust2(pattern, *symbols, status); | |
| 145 if(U_FAILURE(status)) { | |
| 146 errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, sy
mbols)"); | |
| 147 } | |
| 148 | |
| 149 DecimalFormat copy(pat); | |
| 150 | |
| 151 // ======= Test clone(), assignment, and equality | |
| 152 | |
| 153 logln((UnicodeString)"Testing clone(), assignment and equality operators"); | |
| 154 | |
| 155 if( ! (copy == pat) || copy != pat) { | |
| 156 errln((UnicodeString)"ERROR: Copy constructor or == failed"); | |
| 157 } | |
| 158 | |
| 159 copy = cust1; | |
| 160 if(copy != cust1) { | |
| 161 errln((UnicodeString)"ERROR: Assignment (or !=) failed"); | |
| 162 } | |
| 163 | |
| 164 Format *clone = def.clone(); | |
| 165 if( ! (*clone == def) ) { | |
| 166 errln((UnicodeString)"ERROR: Clone() failed"); | |
| 167 } | |
| 168 delete clone; | |
| 169 | |
| 170 // ======= Test various format() methods | |
| 171 | |
| 172 logln((UnicodeString)"Testing various format() methods"); | |
| 173 | |
| 174 double d = -10456.0037; | |
| 175 int32_t l = 100000000; | |
| 176 Formattable fD(d); | |
| 177 Formattable fL(l); | |
| 178 | |
| 179 UnicodeString res1, res2, res3, res4; | |
| 180 FieldPosition pos1(0), pos2(0), pos3(0), pos4(0); | |
| 181 | |
| 182 res1 = def.format(d, res1, pos1); | |
| 183 logln( (UnicodeString) "" + (int32_t) d + " formatted to " + res1); | |
| 184 | |
| 185 res2 = pat.format(l, res2, pos2); | |
| 186 logln((UnicodeString) "" + (int32_t) l + " formatted to " + res2); | |
| 187 | |
| 188 status = U_ZERO_ERROR; | |
| 189 res3 = cust1.format(fD, res3, pos3, status); | |
| 190 if(U_FAILURE(status)) { | |
| 191 errln((UnicodeString)"ERROR: format(Formattable [double]) failed"); | |
| 192 } | |
| 193 logln((UnicodeString) "" + (int32_t) fD.getDouble() + " formatted to " + res
3); | |
| 194 | |
| 195 status = U_ZERO_ERROR; | |
| 196 res4 = cust2.format(fL, res4, pos4, status); | |
| 197 if(U_FAILURE(status)) { | |
| 198 errln((UnicodeString)"ERROR: format(Formattable [long]) failed"); | |
| 199 } | |
| 200 logln((UnicodeString) "" + fL.getLong() + " formatted to " + res4); | |
| 201 | |
| 202 // ======= Test parse() | |
| 203 | |
| 204 logln((UnicodeString)"Testing parse()"); | |
| 205 | |
| 206 UnicodeString text("-10,456.0037"); | |
| 207 Formattable result1, result2; | |
| 208 ParsePosition pos(0); | |
| 209 UnicodeString patt("#,##0.#"); | |
| 210 status = U_ZERO_ERROR; | |
| 211 pat.applyPattern(patt, status); | |
| 212 if(U_FAILURE(status)) { | |
| 213 errln((UnicodeString)"ERROR: applyPattern() failed"); | |
| 214 } | |
| 215 pat.parse(text, result1, pos); | |
| 216 if(result1.getType() != Formattable::kDouble && result1.getDouble() != d) { | |
| 217 errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text
); | |
| 218 } | |
| 219 logln(text + " parsed into " + (int32_t) result1.getDouble()); | |
| 220 | |
| 221 status = U_ZERO_ERROR; | |
| 222 pat.parse(text, result2, status); | |
| 223 if(U_FAILURE(status)) { | |
| 224 errln((UnicodeString)"ERROR: parse() failed"); | |
| 225 } | |
| 226 if(result2.getType() != Formattable::kDouble && result2.getDouble() != d) { | |
| 227 errln((UnicodeString)"ERROR: Roundtrip failed (via parse()) for " + text
); | |
| 228 } | |
| 229 logln(text + " parsed into " + (int32_t) result2.getDouble()); | |
| 230 | |
| 231 // ======= Test getters and setters | |
| 232 | |
| 233 logln((UnicodeString)"Testing getters and setters"); | |
| 234 | |
| 235 const DecimalFormatSymbols *syms = pat.getDecimalFormatSymbols(); | |
| 236 DecimalFormatSymbols *newSyms = new DecimalFormatSymbols(*syms); | |
| 237 def.setDecimalFormatSymbols(*newSyms); | |
| 238 def.adoptDecimalFormatSymbols(newSyms); // don't use newSyms after this | |
| 239 if( *(pat.getDecimalFormatSymbols()) != *(def.getDecimalFormatSymbols())) { | |
| 240 errln((UnicodeString)"ERROR: adopt or set DecimalFormatSymbols() failed"
); | |
| 241 } | |
| 242 | |
| 243 UnicodeString posPrefix; | |
| 244 pat.setPositivePrefix("+"); | |
| 245 posPrefix = pat.getPositivePrefix(posPrefix); | |
| 246 logln((UnicodeString)"Positive prefix (should be +): " + posPrefix); | |
| 247 if(posPrefix != "+") { | |
| 248 errln((UnicodeString)"ERROR: setPositivePrefix() failed"); | |
| 249 } | |
| 250 | |
| 251 UnicodeString negPrefix; | |
| 252 pat.setNegativePrefix("-"); | |
| 253 negPrefix = pat.getNegativePrefix(negPrefix); | |
| 254 logln((UnicodeString)"Negative prefix (should be -): " + negPrefix); | |
| 255 if(negPrefix != "-") { | |
| 256 errln((UnicodeString)"ERROR: setNegativePrefix() failed"); | |
| 257 } | |
| 258 | |
| 259 UnicodeString posSuffix; | |
| 260 pat.setPositiveSuffix("_"); | |
| 261 posSuffix = pat.getPositiveSuffix(posSuffix); | |
| 262 logln((UnicodeString)"Positive suffix (should be _): " + posSuffix); | |
| 263 if(posSuffix != "_") { | |
| 264 errln((UnicodeString)"ERROR: setPositiveSuffix() failed"); | |
| 265 } | |
| 266 | |
| 267 UnicodeString negSuffix; | |
| 268 pat.setNegativeSuffix("~"); | |
| 269 negSuffix = pat.getNegativeSuffix(negSuffix); | |
| 270 logln((UnicodeString)"Negative suffix (should be ~): " + negSuffix); | |
| 271 if(negSuffix != "~") { | |
| 272 errln((UnicodeString)"ERROR: setNegativeSuffix() failed"); | |
| 273 } | |
| 274 | |
| 275 int32_t multiplier = 0; | |
| 276 pat.setMultiplier(8); | |
| 277 multiplier = pat.getMultiplier(); | |
| 278 logln((UnicodeString)"Multiplier (should be 8): " + multiplier); | |
| 279 if(multiplier != 8) { | |
| 280 errln((UnicodeString)"ERROR: setMultiplier() failed"); | |
| 281 } | |
| 282 | |
| 283 int32_t groupingSize = 0; | |
| 284 pat.setGroupingSize(2); | |
| 285 groupingSize = pat.getGroupingSize(); | |
| 286 logln((UnicodeString)"Grouping size (should be 2): " + (int32_t) groupingSiz
e); | |
| 287 if(groupingSize != 2) { | |
| 288 errln((UnicodeString)"ERROR: setGroupingSize() failed"); | |
| 289 } | |
| 290 | |
| 291 pat.setDecimalSeparatorAlwaysShown(TRUE); | |
| 292 UBool tf = pat.isDecimalSeparatorAlwaysShown(); | |
| 293 logln((UnicodeString)"DecimalSeparatorIsAlwaysShown (should be TRUE) is " +
(UnicodeString) (tf ? "TRUE" : "FALSE")); | |
| 294 if(tf != TRUE) { | |
| 295 errln((UnicodeString)"ERROR: setDecimalSeparatorAlwaysShown() failed"); | |
| 296 } | |
| 297 // Added by Ken Liu testing set/isExponentSignAlwaysShown | |
| 298 pat.setExponentSignAlwaysShown(TRUE); | |
| 299 UBool esas = pat.isExponentSignAlwaysShown(); | |
| 300 logln((UnicodeString)"ExponentSignAlwaysShown (should be TRUE) is " + (Unico
deString) (esas ? "TRUE" : "FALSE")); | |
| 301 if(esas != TRUE) { | |
| 302 errln((UnicodeString)"ERROR: ExponentSignAlwaysShown() failed"); | |
| 303 } | |
| 304 | |
| 305 // Added by Ken Liu testing set/isScientificNotation | |
| 306 pat.setScientificNotation(TRUE); | |
| 307 UBool sn = pat.isScientificNotation(); | |
| 308 logln((UnicodeString)"isScientificNotation (should be TRUE) is " + (UnicodeS
tring) (sn ? "TRUE" : "FALSE")); | |
| 309 if(sn != TRUE) { | |
| 310 errln((UnicodeString)"ERROR: setScientificNotation() failed"); | |
| 311 } | |
| 312 | |
| 313 // Added by Ken Liu testing set/getMinimumExponentDigits | |
| 314 int8_t MinimumExponentDigits = 0; | |
| 315 pat.setMinimumExponentDigits(2); | |
| 316 MinimumExponentDigits = pat.getMinimumExponentDigits(); | |
| 317 logln((UnicodeString)"MinimumExponentDigits (should be 2) is " + (int8_t) Mi
nimumExponentDigits); | |
| 318 if(MinimumExponentDigits != 2) { | |
| 319 errln((UnicodeString)"ERROR: setMinimumExponentDigits() failed"); | |
| 320 } | |
| 321 | |
| 322 // Added by Ken Liu testing set/getRoundingIncrement | |
| 323 double RoundingIncrement = 0.0; | |
| 324 pat.setRoundingIncrement(2.0); | |
| 325 RoundingIncrement = pat.getRoundingIncrement(); | |
| 326 logln((UnicodeString)"RoundingIncrement (should be 2.0) is " + (double) Roun
dingIncrement); | |
| 327 if(RoundingIncrement != 2.0) { | |
| 328 errln((UnicodeString)"ERROR: setRoundingIncrement() failed"); | |
| 329 } | |
| 330 //end of Ken's Adding | |
| 331 | |
| 332 UnicodeString funkyPat; | |
| 333 funkyPat = pat.toPattern(funkyPat); | |
| 334 logln((UnicodeString)"Pattern is " + funkyPat); | |
| 335 | |
| 336 UnicodeString locPat; | |
| 337 locPat = pat.toLocalizedPattern(locPat); | |
| 338 logln((UnicodeString)"Localized pattern is " + locPat); | |
| 339 | |
| 340 // ======= Test applyPattern() | |
| 341 | |
| 342 logln((UnicodeString)"Testing applyPattern()"); | |
| 343 | |
| 344 UnicodeString p1("#,##0.0#;(#,##0.0#)"); | |
| 345 logln((UnicodeString)"Applying pattern " + p1); | |
| 346 status = U_ZERO_ERROR; | |
| 347 pat.applyPattern(p1, status); | |
| 348 if(U_FAILURE(status)) { | |
| 349 errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) st
atus); | |
| 350 } | |
| 351 UnicodeString s2; | |
| 352 s2 = pat.toPattern(s2); | |
| 353 logln((UnicodeString)"Extracted pattern is " + s2); | |
| 354 if(s2 != p1) { | |
| 355 errln((UnicodeString)"ERROR: toPattern() result did not match pattern ap
plied"); | |
| 356 } | |
| 357 | |
| 358 if(pat.getSecondaryGroupingSize() != 0) { | |
| 359 errln("FAIL: Secondary Grouping Size should be 0, not %d\n", pat.getSeco
ndaryGroupingSize()); | |
| 360 } | |
| 361 | |
| 362 if(pat.getGroupingSize() != 3) { | |
| 363 errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupi
ngSize()); | |
| 364 } | |
| 365 | |
| 366 UnicodeString p2("#,##,##0.0# FF;(#,##,##0.0# FF)"); | |
| 367 logln((UnicodeString)"Applying pattern " + p2); | |
| 368 status = U_ZERO_ERROR; | |
| 369 pat.applyLocalizedPattern(p2, status); | |
| 370 if(U_FAILURE(status)) { | |
| 371 errln((UnicodeString)"ERROR: applyPattern() failed with " + (int32_t) st
atus); | |
| 372 } | |
| 373 UnicodeString s3; | |
| 374 s3 = pat.toLocalizedPattern(s3); | |
| 375 logln((UnicodeString)"Extracted pattern is " + s3); | |
| 376 if(s3 != p2) { | |
| 377 errln((UnicodeString)"ERROR: toLocalizedPattern() result did not match p
attern applied"); | |
| 378 } | |
| 379 | |
| 380 status = U_ZERO_ERROR; | |
| 381 UParseError pe; | |
| 382 pat.applyLocalizedPattern(p2, pe, status); | |
| 383 if(U_FAILURE(status)) { | |
| 384 errln((UnicodeString)"ERROR: applyPattern((with ParseError)) failed with
" + (int32_t) status); | |
| 385 } | |
| 386 UnicodeString s4; | |
| 387 s4 = pat.toLocalizedPattern(s3); | |
| 388 logln((UnicodeString)"Extracted pattern is " + s4); | |
| 389 if(s4 != p2) { | |
| 390 errln((UnicodeString)"ERROR: toLocalizedPattern(with ParseErr) result di
d not match pattern applied"); | |
| 391 } | |
| 392 | |
| 393 if(pat.getSecondaryGroupingSize() != 2) { | |
| 394 errln("FAIL: Secondary Grouping Size should be 2, not %d\n", pat.getSeco
ndaryGroupingSize()); | |
| 395 } | |
| 396 | |
| 397 if(pat.getGroupingSize() != 3) { | |
| 398 errln("FAIL: Primary Grouping Size should be 3, not %d\n", pat.getGroupi
ngSize()); | |
| 399 } | |
| 400 | |
| 401 // ======= Test getStaticClassID() | |
| 402 | |
| 403 logln((UnicodeString)"Testing getStaticClassID()"); | |
| 404 | |
| 405 status = U_ZERO_ERROR; | |
| 406 NumberFormat *test = new DecimalFormat(status); | |
| 407 if(U_FAILURE(status)) { | |
| 408 errln((UnicodeString)"ERROR: Couldn't create a DecimalFormat"); | |
| 409 } | |
| 410 | |
| 411 if(test->getDynamicClassID() != DecimalFormat::getStaticClassID()) { | |
| 412 errln((UnicodeString)"ERROR: getDynamicClassID() didn't return the expec
ted value"); | |
| 413 } | |
| 414 | |
| 415 delete test; | |
| 416 } | |
| 417 | |
| 418 void IntlTestDecimalFormatAPI::TestCurrencyPluralInfo(){ | |
| 419 UErrorCode status = U_ZERO_ERROR; | |
| 420 | |
| 421 CurrencyPluralInfo *cpi = new CurrencyPluralInfo(status); | |
| 422 if(U_FAILURE(status)) { | |
| 423 errln((UnicodeString)"ERROR: CurrencyPluralInfo(UErrorCode) could not be
created"); | |
| 424 } | |
| 425 | |
| 426 CurrencyPluralInfo cpi1 = *cpi; | |
| 427 | |
| 428 if(cpi->getDynamicClassID() != CurrencyPluralInfo::getStaticClassID()){ | |
| 429 errln((UnicodeString)"ERROR: CurrencyPluralInfo::getDynamicClassID() did
n't return the expected value"); | |
| 430 } | |
| 431 | |
| 432 cpi->setCurrencyPluralPattern("","",status); | |
| 433 if(U_FAILURE(status)) { | |
| 434 errln((UnicodeString)"ERROR: CurrencyPluralInfo::setCurrencyPluralPatter
n"); | |
| 435 } | |
| 436 | |
| 437 cpi->setLocale(Locale::getCanada(), status); | |
| 438 if(U_FAILURE(status)) { | |
| 439 errln((UnicodeString)"ERROR: CurrencyPluralInfo::setLocale"); | |
| 440 } | |
| 441 | |
| 442 cpi->setPluralRules("",status); | |
| 443 if(U_FAILURE(status)) { | |
| 444 errln((UnicodeString)"ERROR: CurrencyPluralInfo::setPluralRules"); | |
| 445 } | |
| 446 | |
| 447 DecimalFormat *df = new DecimalFormat(status); | |
| 448 if(U_FAILURE(status)) { | |
| 449 errcheckln(status, "ERROR: Could not create DecimalFormat - %s", u_error
Name(status)); | |
| 450 return; | |
| 451 } | |
| 452 | |
| 453 df->adoptCurrencyPluralInfo(cpi); | |
| 454 | |
| 455 df->getCurrencyPluralInfo(); | |
| 456 | |
| 457 df->setCurrencyPluralInfo(cpi1); | |
| 458 | |
| 459 delete df; | |
| 460 } | |
| 461 | |
| 462 void IntlTestDecimalFormatAPI::testRounding(/*char *par*/) | |
| 463 { | |
| 464 UErrorCode status = U_ZERO_ERROR; | |
| 465 double Roundingnumber = 2.55; | |
| 466 double Roundingnumber1 = -2.55; | |
| 467 //+2.55 results -2.55 results | |
| 468 double result[]={ 3.0, -2.0, // kRoundCeiling 0, | |
| 469 2.0, -3.0, // kRoundFloor 1, | |
| 470 2.0, -2.0, // kRoundDown 2, | |
| 471 3.0, -3.0, // kRoundUp 3, | |
| 472 3.0, -3.0, // kRoundHalfEven 4, | |
| 473 3.0, -3.0, // kRoundHalfDown 5, | |
| 474 3.0, -3.0 // kRoundHalfUp 6 | |
| 475 }; | |
| 476 DecimalFormat pat(status); | |
| 477 if(U_FAILURE(status)) { | |
| 478 errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s",
u_errorName(status)); | |
| 479 return; | |
| 480 } | |
| 481 uint16_t mode; | |
| 482 uint16_t i=0; | |
| 483 UnicodeString message; | |
| 484 UnicodeString resultStr; | |
| 485 for(mode=0;mode < 7;mode++){ | |
| 486 pat.setRoundingMode((DecimalFormat::ERoundingMode)mode); | |
| 487 if(pat.getRoundingMode() != (DecimalFormat::ERoundingMode)mode){ | |
| 488 errln((UnicodeString)"SetRoundingMode or GetRoundingMode failed for
mode=" + mode); | |
| 489 } | |
| 490 | |
| 491 | |
| 492 //for +2.55 with RoundingIncrement=1.0 | |
| 493 pat.setRoundingIncrement(1.0); | |
| 494 pat.format(Roundingnumber, resultStr); | |
| 495 message= (UnicodeString)"Round() failed: round(" + (double)Roundingnumb
er + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=1
.0==>"); | |
| 496 verify(message, resultStr, result[i++]); | |
| 497 message.remove(); | |
| 498 resultStr.remove(); | |
| 499 | |
| 500 //for -2.55 with RoundingIncrement=1.0 | |
| 501 pat.format(Roundingnumber1, resultStr); | |
| 502 message= (UnicodeString)"Round() failed: round(" + (double)Roundingnumb
er1 + UnicodeString(",") + mode + UnicodeString(",FALSE) with RoundingIncrement=
1.0==>"); | |
| 503 verify(message, resultStr, result[i++]); | |
| 504 message.remove(); | |
| 505 resultStr.remove(); | |
| 506 } | |
| 507 | |
| 508 } | |
| 509 void IntlTestDecimalFormatAPI::verify(const UnicodeString& message, const Unicod
eString& got, double expected){ | |
| 510 logln((UnicodeString)message + got + (UnicodeString)" Expected : " + expecte
d); | |
| 511 UnicodeString expectedStr(""); | |
| 512 expectedStr=expectedStr + expected; | |
| 513 if(got != expectedStr ) { | |
| 514 errln((UnicodeString)"ERROR: " + message + got + (UnicodeString)" E
xpected : " + expectedStr); | |
| 515 } | |
| 516 } | |
| 517 | |
| 518 void IntlTestDecimalFormatAPI::verifyString(const UnicodeString& message, const
UnicodeString& got, UnicodeString& expected){ | |
| 519 logln((UnicodeString)message + got + (UnicodeString)" Expected : " + expecte
d); | |
| 520 if(got != expected ) { | |
| 521 errln((UnicodeString)"ERROR: " + message + got + (UnicodeString)" E
xpected : " + expected); | |
| 522 } | |
| 523 } | |
| 524 | |
| 525 void IntlTestDecimalFormatAPI::testRoundingInc(/*char *par*/) | |
| 526 { | |
| 527 UErrorCode status = U_ZERO_ERROR; | |
| 528 DecimalFormat pat(UnicodeString("#,##0.00"),status); | |
| 529 if(U_FAILURE(status)) { | |
| 530 errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s",
u_errorName(status)); | |
| 531 return; | |
| 532 } | |
| 533 | |
| 534 // get default rounding increment | |
| 535 double roundingInc = pat.getRoundingIncrement(); | |
| 536 if (roundingInc != 0.0) { | |
| 537 errln((UnicodeString)"ERROR: Rounding increment not zero"); | |
| 538 return; | |
| 539 } | |
| 540 | |
| 541 // With rounding now being handled by decNumber, we no longer | |
| 542 // set a rounding increment to enable non-default mode rounding, | |
| 543 // checking of which was the original point of this test. | |
| 544 | |
| 545 // set rounding mode with zero increment. Rounding | |
| 546 // increment should not be set by this operation | |
| 547 pat.setRoundingMode((DecimalFormat::ERoundingMode)0); | |
| 548 roundingInc = pat.getRoundingIncrement(); | |
| 549 if (roundingInc != 0.0) { | |
| 550 errln((UnicodeString)"ERROR: Rounding increment not zero after setRounding
Mode"); | |
| 551 return; | |
| 552 } | |
| 553 } | |
| 554 | |
| 555 void IntlTestDecimalFormatAPI::TestScale() | |
| 556 { | |
| 557 typedef struct TestData { | |
| 558 double inputValue; | |
| 559 int inputScale; | |
| 560 const char *expectedOutput; | |
| 561 } TestData; | |
| 562 | |
| 563 static TestData testData[] = { | |
| 564 { 100.0, 3, "100,000" }, | |
| 565 { 10034.0, -2, "100.34" }, | |
| 566 { 0.86, -3, "0.0009" }, | |
| 567 { -0.000455, 1, "-0%" }, | |
| 568 { -0.000555, 1, "-1%" }, | |
| 569 { 0.000455, 1, "0%" }, | |
| 570 { 0.000555, 1, "1%" }, | |
| 571 }; | |
| 572 | |
| 573 UErrorCode status = U_ZERO_ERROR; | |
| 574 DecimalFormat pat(status); | |
| 575 if(U_FAILURE(status)) { | |
| 576 errcheckln(status, "ERROR: Could not create DecimalFormat (default) - %s",
u_errorName(status)); | |
| 577 return; | |
| 578 } | |
| 579 | |
| 580 UnicodeString message; | |
| 581 UnicodeString resultStr; | |
| 582 UnicodeString exp; | |
| 583 UnicodeString percentPattern("#,##0%"); | |
| 584 pat.setMaximumFractionDigits(4); | |
| 585 | |
| 586 for(int32_t i=0; i < UPRV_LENGTHOF(testData); i++) { | |
| 587 if ( i > 2 ) { | |
| 588 pat.applyPattern(percentPattern,status); | |
| 589 } | |
| 590 pat.setAttribute(UNUM_SCALE,testData[i].inputScale,status); | |
| 591 pat.format(testData[i].inputValue, resultStr); | |
| 592 message = UnicodeString("Unexpected output for ") + testData[i].inputVal
ue + UnicodeString(" and scale ") + | |
| 593 testData[i].inputScale + UnicodeString(". Got: "); | |
| 594 exp = testData[i].expectedOutput; | |
| 595 verifyString(message, resultStr, exp); | |
| 596 message.remove(); | |
| 597 resultStr.remove(); | |
| 598 exp.remove(); | |
| 599 } | |
| 600 } | |
| 601 | |
| 602 | |
| 603 #define ASSERT_EQUAL(expect, actual) { char tmp[200]; sprintf(tmp, "(%g==%g)", (
double)(expect), (double)(actual)); \ | |
| 604 assertTrue(tmp, ((expect)==(actual)), FALSE, TRUE, __FILE__, __LINE__); } | |
| 605 | |
| 606 void IntlTestDecimalFormatAPI::TestFixedDecimal() { | |
| 607 UErrorCode status = U_ZERO_ERROR; | |
| 608 | |
| 609 LocalPointer<DecimalFormat> df(new DecimalFormat("###", status), status); | |
| 610 TEST_ASSERT_STATUS(status); | |
| 611 if (status == U_MISSING_RESOURCE_ERROR) { | |
| 612 return; | |
| 613 } | |
| 614 FixedDecimal fd = df->getFixedDecimal(44, status); | |
| 615 TEST_ASSERT_STATUS(status); | |
| 616 ASSERT_EQUAL(44, fd.source); | |
| 617 ASSERT_EQUAL(0, fd.visibleDecimalDigitCount); | |
| 618 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 619 | |
| 620 fd = df->getFixedDecimal(-44, status); | |
| 621 TEST_ASSERT_STATUS(status); | |
| 622 ASSERT_EQUAL(44, fd.source); | |
| 623 ASSERT_EQUAL(0, fd.visibleDecimalDigitCount); | |
| 624 ASSERT_EQUAL(TRUE, fd.isNegative); | |
| 625 | |
| 626 df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.00##", status), stat
us); | |
| 627 TEST_ASSERT_STATUS(status); | |
| 628 fd = df->getFixedDecimal(123.456, status); | |
| 629 TEST_ASSERT_STATUS(status); | |
| 630 ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v | |
| 631 ASSERT_EQUAL(456, fd.decimalDigits); // f | |
| 632 ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t | |
| 633 ASSERT_EQUAL(123, fd.intValue); // i | |
| 634 ASSERT_EQUAL(123.456, fd.source); // n | |
| 635 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 636 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 637 | |
| 638 fd = df->getFixedDecimal(-123.456, status); | |
| 639 TEST_ASSERT_STATUS(status); | |
| 640 ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v | |
| 641 ASSERT_EQUAL(456, fd.decimalDigits); // f | |
| 642 ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t | |
| 643 ASSERT_EQUAL(123, fd.intValue); // i | |
| 644 ASSERT_EQUAL(123.456, fd.source); // n | |
| 645 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 646 ASSERT_EQUAL(TRUE, fd.isNegative); | |
| 647 | |
| 648 // test max int digits | |
| 649 df->setMaximumIntegerDigits(2); | |
| 650 fd = df->getFixedDecimal(123.456, status); | |
| 651 TEST_ASSERT_STATUS(status); | |
| 652 ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v | |
| 653 ASSERT_EQUAL(456, fd.decimalDigits); // f | |
| 654 ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t | |
| 655 ASSERT_EQUAL(23, fd.intValue); // i | |
| 656 ASSERT_EQUAL(23.456, fd.source); // n | |
| 657 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 658 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 659 | |
| 660 fd = df->getFixedDecimal(-123.456, status); | |
| 661 TEST_ASSERT_STATUS(status); | |
| 662 ASSERT_EQUAL(3, fd.visibleDecimalDigitCount); // v | |
| 663 ASSERT_EQUAL(456, fd.decimalDigits); // f | |
| 664 ASSERT_EQUAL(456, fd.decimalDigitsWithoutTrailingZeros); // t | |
| 665 ASSERT_EQUAL(23, fd.intValue); // i | |
| 666 ASSERT_EQUAL(23.456, fd.source); // n | |
| 667 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 668 ASSERT_EQUAL(TRUE, fd.isNegative); | |
| 669 | |
| 670 // test max fraction digits | |
| 671 df->setMaximumIntegerDigits(2000000000); | |
| 672 df->setMaximumFractionDigits(2); | |
| 673 fd = df->getFixedDecimal(123.456, status); | |
| 674 TEST_ASSERT_STATUS(status); | |
| 675 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v | |
| 676 ASSERT_EQUAL(46, fd.decimalDigits); // f | |
| 677 ASSERT_EQUAL(46, fd.decimalDigitsWithoutTrailingZeros); // t | |
| 678 ASSERT_EQUAL(123, fd.intValue); // i | |
| 679 ASSERT_EQUAL(123.46, fd.source); // n | |
| 680 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 681 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 682 | |
| 683 fd = df->getFixedDecimal(-123.456, status); | |
| 684 TEST_ASSERT_STATUS(status); | |
| 685 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v | |
| 686 ASSERT_EQUAL(46, fd.decimalDigits); // f | |
| 687 ASSERT_EQUAL(46, fd.decimalDigitsWithoutTrailingZeros); // t | |
| 688 ASSERT_EQUAL(123, fd.intValue); // i | |
| 689 ASSERT_EQUAL(123.46, fd.source); // n | |
| 690 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 691 ASSERT_EQUAL(TRUE, fd.isNegative); | |
| 692 | |
| 693 // test esoteric rounding | |
| 694 df->setMaximumFractionDigits(6); | |
| 695 df->setRoundingIncrement(7.3); | |
| 696 | |
| 697 fd = df->getFixedDecimal(30.0, status); | |
| 698 TEST_ASSERT_STATUS(status); | |
| 699 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v | |
| 700 ASSERT_EQUAL(20, fd.decimalDigits); // f | |
| 701 ASSERT_EQUAL(2, fd.decimalDigitsWithoutTrailingZeros); // t | |
| 702 ASSERT_EQUAL(29, fd.intValue); // i | |
| 703 ASSERT_EQUAL(29.2, fd.source); // n | |
| 704 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 705 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 706 | |
| 707 fd = df->getFixedDecimal(-30.0, status); | |
| 708 TEST_ASSERT_STATUS(status); | |
| 709 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); // v | |
| 710 ASSERT_EQUAL(20, fd.decimalDigits); // f | |
| 711 ASSERT_EQUAL(2, fd.decimalDigitsWithoutTrailingZeros); // t | |
| 712 ASSERT_EQUAL(29, fd.intValue); // i | |
| 713 ASSERT_EQUAL(29.2, fd.source); // n | |
| 714 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 715 ASSERT_EQUAL(TRUE, fd.isNegative); | |
| 716 | |
| 717 df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###", status), status); | |
| 718 TEST_ASSERT_STATUS(status); | |
| 719 fd = df->getFixedDecimal(123.456, status); | |
| 720 TEST_ASSERT_STATUS(status); | |
| 721 ASSERT_EQUAL(0, fd.visibleDecimalDigitCount); | |
| 722 ASSERT_EQUAL(0, fd.decimalDigits); | |
| 723 ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); | |
| 724 ASSERT_EQUAL(123, fd.intValue); | |
| 725 ASSERT_EQUAL(TRUE, fd.hasIntegerValue); | |
| 726 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 727 | |
| 728 df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status)
; | |
| 729 TEST_ASSERT_STATUS(status); | |
| 730 fd = df->getFixedDecimal(123.01, status); | |
| 731 TEST_ASSERT_STATUS(status); | |
| 732 ASSERT_EQUAL(1, fd.visibleDecimalDigitCount); | |
| 733 ASSERT_EQUAL(0, fd.decimalDigits); | |
| 734 ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); | |
| 735 ASSERT_EQUAL(123, fd.intValue); | |
| 736 ASSERT_EQUAL(TRUE, fd.hasIntegerValue); | |
| 737 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 738 | |
| 739 df.adoptInsteadAndCheckErrorCode(new DecimalFormat("###.0", status), status)
; | |
| 740 TEST_ASSERT_STATUS(status); | |
| 741 fd = df->getFixedDecimal(123.06, status); | |
| 742 TEST_ASSERT_STATUS(status); | |
| 743 ASSERT_EQUAL(1, fd.visibleDecimalDigitCount); | |
| 744 ASSERT_EQUAL(1, fd.decimalDigits); | |
| 745 ASSERT_EQUAL(1, fd.decimalDigitsWithoutTrailingZeros); | |
| 746 ASSERT_EQUAL(123, fd.intValue); | |
| 747 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 748 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 749 | |
| 750 df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status)
; // Significant Digits | |
| 751 TEST_ASSERT_STATUS(status); | |
| 752 fd = df->getFixedDecimal(123, status); | |
| 753 TEST_ASSERT_STATUS(status); | |
| 754 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); | |
| 755 ASSERT_EQUAL(0, fd.decimalDigits); | |
| 756 ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); | |
| 757 ASSERT_EQUAL(123, fd.intValue); | |
| 758 ASSERT_EQUAL(TRUE, fd.hasIntegerValue); | |
| 759 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 760 | |
| 761 df.adoptInsteadAndCheckErrorCode(new DecimalFormat("@@@@@", status), status)
; // Significant Digits | |
| 762 TEST_ASSERT_STATUS(status); | |
| 763 fd = df->getFixedDecimal(1.23, status); | |
| 764 TEST_ASSERT_STATUS(status); | |
| 765 ASSERT_EQUAL(4, fd.visibleDecimalDigitCount); | |
| 766 ASSERT_EQUAL(2300, fd.decimalDigits); | |
| 767 ASSERT_EQUAL(23, fd.decimalDigitsWithoutTrailingZeros); | |
| 768 ASSERT_EQUAL(1, fd.intValue); | |
| 769 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 770 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 771 | |
| 772 fd = df->getFixedDecimal(uprv_getInfinity(), status); | |
| 773 TEST_ASSERT_STATUS(status); | |
| 774 ASSERT_EQUAL(TRUE, fd.isNanOrInfinity); | |
| 775 fd = df->getFixedDecimal(0.0, status); | |
| 776 ASSERT_EQUAL(FALSE, fd.isNanOrInfinity); | |
| 777 fd = df->getFixedDecimal(uprv_getNaN(), status); | |
| 778 ASSERT_EQUAL(TRUE, fd.isNanOrInfinity); | |
| 779 TEST_ASSERT_STATUS(status); | |
| 780 | |
| 781 // Test Big Decimal input. | |
| 782 // 22 digits before and after decimal, will exceed the precision of a double | |
| 783 // and force DecimalFormat::getFixedDecimal() to work with a digit list. | |
| 784 df.adoptInsteadAndCheckErrorCode( | |
| 785 new DecimalFormat("#####################0.00####################", statu
s), status); | |
| 786 TEST_ASSERT_STATUS(status); | |
| 787 Formattable fable("12.34", status); | |
| 788 TEST_ASSERT_STATUS(status); | |
| 789 fd = df->getFixedDecimal(fable, status); | |
| 790 TEST_ASSERT_STATUS(status); | |
| 791 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); | |
| 792 ASSERT_EQUAL(34, fd.decimalDigits); | |
| 793 ASSERT_EQUAL(34, fd.decimalDigitsWithoutTrailingZeros); | |
| 794 ASSERT_EQUAL(12, fd.intValue); | |
| 795 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 796 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 797 | |
| 798 fable.setDecimalNumber("12.345678901234567890123456789", status); | |
| 799 TEST_ASSERT_STATUS(status); | |
| 800 fd = df->getFixedDecimal(fable, status); | |
| 801 TEST_ASSERT_STATUS(status); | |
| 802 ASSERT_EQUAL(22, fd.visibleDecimalDigitCount); | |
| 803 ASSERT_EQUAL(345678901234567890LL, fd.decimalDigits); | |
| 804 ASSERT_EQUAL(34567890123456789LL, fd.decimalDigitsWithoutTrailingZeros); | |
| 805 ASSERT_EQUAL(12, fd.intValue); | |
| 806 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 807 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 808 | |
| 809 // On field overflow, Integer part is truncated on the left, fraction part o
n the right. | |
| 810 fable.setDecimalNumber("123456789012345678901234567890.123456789012345678901
234567890", status); | |
| 811 TEST_ASSERT_STATUS(status); | |
| 812 fd = df->getFixedDecimal(fable, status); | |
| 813 TEST_ASSERT_STATUS(status); | |
| 814 ASSERT_EQUAL(22, fd.visibleDecimalDigitCount); | |
| 815 ASSERT_EQUAL(123456789012345678LL, fd.decimalDigits); | |
| 816 ASSERT_EQUAL(123456789012345678LL, fd.decimalDigitsWithoutTrailingZeros); | |
| 817 ASSERT_EQUAL(345678901234567890LL, fd.intValue); | |
| 818 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 819 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 820 | |
| 821 // Digits way to the right of the decimal but within the format's precision
aren't truncated | |
| 822 fable.setDecimalNumber("1.0000000000000000000012", status); | |
| 823 TEST_ASSERT_STATUS(status); | |
| 824 fd = df->getFixedDecimal(fable, status); | |
| 825 TEST_ASSERT_STATUS(status); | |
| 826 ASSERT_EQUAL(22, fd.visibleDecimalDigitCount); | |
| 827 ASSERT_EQUAL(12, fd.decimalDigits); | |
| 828 ASSERT_EQUAL(12, fd.decimalDigitsWithoutTrailingZeros); | |
| 829 ASSERT_EQUAL(1, fd.intValue); | |
| 830 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 831 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 832 | |
| 833 // Digits beyond the precision of the format are rounded away | |
| 834 fable.setDecimalNumber("1.000000000000000000000012", status); | |
| 835 TEST_ASSERT_STATUS(status); | |
| 836 fd = df->getFixedDecimal(fable, status); | |
| 837 TEST_ASSERT_STATUS(status); | |
| 838 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); | |
| 839 ASSERT_EQUAL(0, fd.decimalDigits); | |
| 840 ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); | |
| 841 ASSERT_EQUAL(1, fd.intValue); | |
| 842 ASSERT_EQUAL(TRUE, fd.hasIntegerValue); | |
| 843 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 844 | |
| 845 // Negative numbers come through | |
| 846 fable.setDecimalNumber("-1.0000000000000000000012", status); | |
| 847 TEST_ASSERT_STATUS(status); | |
| 848 fd = df->getFixedDecimal(fable, status); | |
| 849 TEST_ASSERT_STATUS(status); | |
| 850 ASSERT_EQUAL(22, fd.visibleDecimalDigitCount); | |
| 851 ASSERT_EQUAL(12, fd.decimalDigits); | |
| 852 ASSERT_EQUAL(12, fd.decimalDigitsWithoutTrailingZeros); | |
| 853 ASSERT_EQUAL(1, fd.intValue); | |
| 854 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 855 ASSERT_EQUAL(TRUE, fd.isNegative); | |
| 856 | |
| 857 // MinFractionDigits from format larger than from number. | |
| 858 fable.setDecimalNumber("1000000000000000000000.3", status); | |
| 859 TEST_ASSERT_STATUS(status); | |
| 860 fd = df->getFixedDecimal(fable, status); | |
| 861 TEST_ASSERT_STATUS(status); | |
| 862 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); | |
| 863 ASSERT_EQUAL(30, fd.decimalDigits); | |
| 864 ASSERT_EQUAL(3, fd.decimalDigitsWithoutTrailingZeros); | |
| 865 ASSERT_EQUAL(100000000000000000LL, fd.intValue); | |
| 866 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 867 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 868 | |
| 869 fable.setDecimalNumber("1000000000000000050000.3", status); | |
| 870 TEST_ASSERT_STATUS(status); | |
| 871 fd = df->getFixedDecimal(fable, status); | |
| 872 TEST_ASSERT_STATUS(status); | |
| 873 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); | |
| 874 ASSERT_EQUAL(30, fd.decimalDigits); | |
| 875 ASSERT_EQUAL(3, fd.decimalDigitsWithoutTrailingZeros); | |
| 876 ASSERT_EQUAL(50000LL, fd.intValue); | |
| 877 ASSERT_EQUAL(FALSE, fd.hasIntegerValue); | |
| 878 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 879 | |
| 880 // Test some int64_t values that are out of the range of a double | |
| 881 fable.setInt64(4503599627370496LL); | |
| 882 TEST_ASSERT_STATUS(status); | |
| 883 fd = df->getFixedDecimal(fable, status); | |
| 884 TEST_ASSERT_STATUS(status); | |
| 885 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); | |
| 886 ASSERT_EQUAL(0, fd.decimalDigits); | |
| 887 ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); | |
| 888 ASSERT_EQUAL(4503599627370496LL, fd.intValue); | |
| 889 ASSERT_EQUAL(TRUE, fd.hasIntegerValue); | |
| 890 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 891 | |
| 892 fable.setInt64(4503599627370497LL); | |
| 893 TEST_ASSERT_STATUS(status); | |
| 894 fd = df->getFixedDecimal(fable, status); | |
| 895 TEST_ASSERT_STATUS(status); | |
| 896 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); | |
| 897 ASSERT_EQUAL(0, fd.decimalDigits); | |
| 898 ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); | |
| 899 ASSERT_EQUAL(4503599627370497LL, fd.intValue); | |
| 900 ASSERT_EQUAL(TRUE, fd.hasIntegerValue); | |
| 901 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 902 | |
| 903 fable.setInt64(9223372036854775807LL); | |
| 904 TEST_ASSERT_STATUS(status); | |
| 905 fd = df->getFixedDecimal(fable, status); | |
| 906 TEST_ASSERT_STATUS(status); | |
| 907 ASSERT_EQUAL(2, fd.visibleDecimalDigitCount); | |
| 908 ASSERT_EQUAL(0, fd.decimalDigits); | |
| 909 ASSERT_EQUAL(0, fd.decimalDigitsWithoutTrailingZeros); | |
| 910 // note: going through DigitList path to FixedDecimal, which is trimming | |
| 911 // int64_t fields to 18 digits. See ticket Ticket #10374 | |
| 912 // ASSERT_EQUAL(223372036854775807LL, fd.intValue); | |
| 913 if (!(fd.intValue == 223372036854775807LL || fd.intValue == 9223372036854775
807LL)) { | |
| 914 dataerrln("File %s, Line %d, fd.intValue = %lld", __FILE__, __LINE__, fd
.intValue); | |
| 915 } | |
| 916 ASSERT_EQUAL(TRUE, fd.hasIntegerValue); | |
| 917 ASSERT_EQUAL(FALSE, fd.isNegative); | |
| 918 | |
| 919 } | |
| 920 | |
| 921 void IntlTestDecimalFormatAPI::TestBadFastpath() { | |
| 922 UErrorCode status = U_ZERO_ERROR; | |
| 923 | |
| 924 LocalPointer<DecimalFormat> df(new DecimalFormat("###", status), status); | |
| 925 if (U_FAILURE(status)) { | |
| 926 dataerrln("Error creating new DecimalFormat - %s", u_errorName(status)); | |
| 927 return; | |
| 928 } | |
| 929 | |
| 930 UnicodeString fmt; | |
| 931 fmt.remove(); | |
| 932 assertEquals("Format 1234", "1234", df->format(1234, fmt)); | |
| 933 df->setGroupingUsed(FALSE); | |
| 934 fmt.remove(); | |
| 935 assertEquals("Format 1234", "1234", df->format(1234, fmt)); | |
| 936 df->setGroupingUsed(TRUE); | |
| 937 df->setGroupingSize(3); | |
| 938 fmt.remove(); | |
| 939 assertEquals("Format 1234 w/ grouping", "1,234", df->format(1234, fmt)); | |
| 940 } | |
| 941 | |
| 942 void IntlTestDecimalFormatAPI::TestRequiredDecimalPoint() { | |
| 943 UErrorCode status = U_ZERO_ERROR; | |
| 944 UnicodeString text("99"); | |
| 945 Formattable result1; | |
| 946 UnicodeString pat1("##.0000"); | |
| 947 UnicodeString pat2("00.0"); | |
| 948 | |
| 949 LocalPointer<DecimalFormat> df(new DecimalFormat(pat1, status), status); | |
| 950 if (U_FAILURE(status)) { | |
| 951 dataerrln("Error creating new DecimalFormat - %s", u_errorName(status)); | |
| 952 return; | |
| 953 } | |
| 954 | |
| 955 status = U_ZERO_ERROR; | |
| 956 df->applyPattern(pat1, status); | |
| 957 if(U_FAILURE(status)) { | |
| 958 errln((UnicodeString)"ERROR: applyPattern() failed"); | |
| 959 } | |
| 960 df->parse(text, result1, status); | |
| 961 if(U_FAILURE(status)) { | |
| 962 errln((UnicodeString)"ERROR: parse() failed"); | |
| 963 } | |
| 964 df->setDecimalPatternMatchRequired(TRUE); | |
| 965 df->parse(text, result1, status); | |
| 966 if(U_SUCCESS(status)) { | |
| 967 errln((UnicodeString)"ERROR: unexpected parse()"); | |
| 968 } | |
| 969 | |
| 970 | |
| 971 status = U_ZERO_ERROR; | |
| 972 df->applyPattern(pat2, status); | |
| 973 df->setDecimalPatternMatchRequired(FALSE); | |
| 974 if(U_FAILURE(status)) { | |
| 975 errln((UnicodeString)"ERROR: applyPattern(2) failed"); | |
| 976 } | |
| 977 df->parse(text, result1, status); | |
| 978 if(U_FAILURE(status)) { | |
| 979 errln((UnicodeString)"ERROR: parse(2) failed - " + u_errorName(status)); | |
| 980 } | |
| 981 df->setDecimalPatternMatchRequired(TRUE); | |
| 982 df->parse(text, result1, status); | |
| 983 if(U_SUCCESS(status)) { | |
| 984 errln((UnicodeString)"ERROR: unexpected parse(2)"); | |
| 985 } | |
| 986 } | |
| 987 | |
| 988 #endif /* #if !UCONFIG_NO_FORMATTING */ | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2435373002:
Delete source/test (Closed)
