1/* 2 * Licensed to the Apache Software Foundation (ASF) under one or more 3 * contributor license agreements. See the NOTICE file distributed with 4 * this work for additional information regarding copyright ownership. 5 * The ASF licenses this file to You under the Apache License, Version 2.0 6 * (the "License"); you may not use this file except in compliance with 7 * the License. You may obtain a copy of the License at 8 * 9 * http://www.apache.org/licenses/LICENSE-2.0 10 * 11 * Unless required by applicable law or agreed to in writing, software 12 * distributed under the License is distributed on an "AS IS" BASIS, 13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 14 * See the License for the specific language governing permissions and 15 * limitations under the License. 16 */ 17 18package org.apache.harmony.text.tests.java.text; 19 20import java.io.ObjectInputStream; 21import java.math.BigDecimal; 22import java.math.BigInteger; 23import java.math.RoundingMode; 24import java.text.AttributedCharacterIterator; 25import java.text.DecimalFormat; 26import java.text.DecimalFormatSymbols; 27import java.text.FieldPosition; 28import java.text.NumberFormat; 29import java.text.ParsePosition; 30import java.util.BitSet; 31import java.util.Currency; 32import java.util.Locale; 33 34import junit.framework.TestCase; 35 36import org.apache.harmony.testframework.serialization.SerializationTest; 37 38 39public class DecimalFormatTest extends TestCase { 40 41 public void testAttributedCharacterIterator() throws Exception { 42 // Regression for http://issues.apache.org/jira/browse/HARMONY-333 43 AttributedCharacterIterator iterator = new DecimalFormat().formatToCharacterIterator(new Integer(1)); 44 assertNotNull(iterator); 45 assertFalse("attributes should exist", iterator.getAttributes().isEmpty()); 46 } 47 48 /* 49 * Test the getter and setter of parseBigDecimal and parseIntegerOnly and 50 * test the default value of them. 51 */ 52 public void test_isParseBigDecimalLjava_lang_Boolean_isParseIntegerOnlyLjava_lang_Boolean() { 53 54 // parseBigDecimal default to false 55 DecimalFormat form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 56 assertFalse(form.isParseBigDecimal()); 57 form.setParseBigDecimal(true); 58 assertTrue(form.isParseBigDecimal()); 59 form.setParseBigDecimal(false); 60 assertFalse(form.isParseBigDecimal()); 61 62 // parseIntegerOnly default to false 63 assertFalse(form.isParseIntegerOnly()); 64 } 65 66 // Test the type of the returned object 67 68 public void test_parseLjava_lang_String_Ljava_text_ParsePosition() { 69 DecimalFormat form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 70 Number number = form.parse("23.1", new ParsePosition(0)); 71 assertTrue(number instanceof Double); 72 73 // Test parsed object of type double when 74 // parseBigDecimal is set to true 75 76 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 77 number = form.parse("23.1", new ParsePosition(0)); 78 assertTrue(number instanceof Double); 79 80 form.setParseBigDecimal(true); 81 number = form.parse("23.1", new ParsePosition(0)); 82 83 assertTrue(number instanceof BigDecimal); 84 assertEquals(new BigDecimal("23.1"), number); 85 86 // When parseIntegerOnly set to true, all float numbers will be parsed 87 // into Long. 88 // With the exception that, the value is out of the bound of Long or 89 // some special values such as NaN or Infinity. 90 91 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 92 form.setParseIntegerOnly(true); 93 number = form.parse("23.1f", new ParsePosition(0)); 94 95 assertTrue(number instanceof Long); 96 97 number = form.parse("23.0", new ParsePosition(0)); 98 assertTrue(number instanceof Long); 99 100 number = form.parse("-0.0", new ParsePosition(0)); 101 assertTrue(number instanceof Long); 102 assertTrue(new Long(0).equals(number)); 103 104 number = form.parse("-9,223,372,036,854,775,8080.00", 105 new ParsePosition(0)); 106 assertTrue(number instanceof Double); 107 108 // Even if parseIntegerOnly is set to true, NaN will be parsed to Double 109 110 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 111 form.setParseIntegerOnly(true); 112 DecimalFormatSymbols symbols = new DecimalFormatSymbols(); 113 number = form.parse(symbols.getNaN(), new ParsePosition(0)); 114 assertTrue(number instanceof Double); 115 116 // Even if parseIntegerOnly is set to true, Infinity will still be 117 // parsed to Double 118 119 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 120 form.setParseIntegerOnly(true); 121 symbols = new DecimalFormatSymbols(); 122 number = form.parse(symbols.getInfinity(), new ParsePosition(0)); 123 assertTrue(number instanceof Double); 124 125 // ParseBigDecimal take precedence of parseBigInteger 126 127 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 128 form.setParseIntegerOnly(true); 129 form.setParseBigDecimal(true); 130 131 number = form.parse("23.1f", new ParsePosition(0)); 132 133 assertTrue(number instanceof BigDecimal); 134 135 number = form.parse("23.0", new ParsePosition(0)); 136 assertTrue(number instanceof BigDecimal); 137 138 number = form.parse("-9,223,372,036,854,775,8080.00", 139 new ParsePosition(0)); 140 assertFalse(number instanceof BigInteger); 141 assertTrue(number instanceof BigDecimal); 142 143 // Test whether the parsed object is of type float. (To be specific, 144 // they are of type Double) 145 146 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 147 148 number = form.parse("23.1f", new ParsePosition(0)); 149 assertTrue(number instanceof Double); 150 151 form.setParseBigDecimal(true); 152 number = form.parse("23.1f", new ParsePosition(0)); 153 assertTrue(number instanceof BigDecimal); 154 assertEquals(new BigDecimal("23.1"), number); 155 156 // Integer will be parsed to Long, unless parseBigDecimal is set to true 157 158 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 159 160 number = form.parse("123", new ParsePosition(0)); 161 assertTrue(number instanceof Long); 162 163 form.setParseBigDecimal(true); 164 number = form.parse("123", new ParsePosition(0)); 165 assertTrue(number instanceof BigDecimal); 166 assertEquals(new BigDecimal("123"), number); 167 168 // NaN will be parsed to Double, no matter parseBigDecimal set or not. 169 170 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 171 symbols = new DecimalFormatSymbols(); 172 number = form.parse(symbols.getNaN() + "", new ParsePosition(0)); 173 assertTrue(number instanceof Double); 174 175 form.setParseBigDecimal(true); 176 number = form.parse(symbols.getNaN() + "", new ParsePosition(0)); 177 assertTrue(number instanceof Double); 178 179 // Infinity will be parsed to Double, no matter parseBigDecimal set or 180 // not. 181 182 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 183 symbols = new DecimalFormatSymbols(); 184 185 number = form.parse(symbols.getInfinity(), new ParsePosition(0)); 186 187 assertTrue(number instanceof Double); 188 assertEquals("Infinity", number.toString()); 189 // When set bigDecimal to true, the result of parsing infinity 190 191 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 192 symbols = new DecimalFormatSymbols(); 193 form.setParseBigDecimal(true); 194 195 number = form.parse(symbols.getInfinity(), new ParsePosition(0)); 196 assertTrue(number instanceof Double); 197 assertEquals("Infinity", number.toString()); 198 199 // Negative infinity will be parsed to double no matter parseBigDecimal 200 // set or not 201 202 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 203 symbols = new DecimalFormatSymbols(); 204 205 number = form.parse("-" + symbols.getInfinity(), new ParsePosition(0)); 206 207 assertTrue(number instanceof Double); 208 assertEquals("-Infinity", number.toString()); 209 210 // When set bigDecimal to true, the result of parsing minus infinity 211 212 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 213 symbols = new DecimalFormatSymbols(); 214 form.setParseBigDecimal(true); 215 216 number = form.parse("-" + symbols.getInfinity(), new ParsePosition(0)); 217 218 assertTrue(number instanceof Double); 219 assertEquals("-Infinity", number.toString()); 220 221 // -0.0 will be parsed to different type according to the combination of 222 // parseBigDecimal and parseIntegerOnly 223 224 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 225 226 // parseBigDecimal == true; 227 // parseIntegerOnly == false; 228 form.setParseBigDecimal(true); 229 number = form.parse("-0", new ParsePosition(0)); 230 assertTrue(number instanceof BigDecimal); 231 232 number = form.parse("-0.0", new ParsePosition(0)); 233 assertTrue(number instanceof BigDecimal); 234 235 // parseBigDecimal == false; 236 // parseIntegerOnly == true; 237 form.setParseBigDecimal(false); 238 form.setParseIntegerOnly(true); 239 number = form.parse("-0", new ParsePosition(0)); 240 241 assertTrue(number instanceof Long); 242 243 number = form.parse("-0.0", new ParsePosition(0)); 244 assertTrue(number instanceof Long); 245 246 // parseBigDecimal == false; 247 // parseIntegerOnly == false; 248 form.setParseBigDecimal(false); 249 form.setParseIntegerOnly(false); 250 number = form.parse("-0", new ParsePosition(0)); 251 assertTrue(number instanceof Double); 252 253 number = form.parse("-0.0", new ParsePosition(0)); 254 assertTrue(number instanceof Double); 255 256 // parseBigDecimal == true; 257 // parseIntegerOnly == true; 258 // parseBigDecimal take precedence of parseBigInteger 259 form.setParseBigDecimal(true); 260 form.setParseIntegerOnly(true); 261 number = form.parse("-0", new ParsePosition(0)); 262 assertTrue(number instanceof BigDecimal); 263 264 number = form.parse("-0.0", new ParsePosition(0)); 265 assertTrue(number instanceof BigDecimal); 266 267 number = form.parse("12.4", new ParsePosition(0)); 268 assertTrue(number instanceof BigDecimal); 269 270 // When parseBigDecimal is set to false, no matter how massive the 271 // mantissa part of a number is, the number will be parsed into Double 272 273 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 274 275 number = form.parse("9,223,372,036,854,775,808.00", 276 new ParsePosition(0)); 277 278 assertTrue(number instanceof Double); 279 assertEquals("9.223372036854776E18", number.toString()); 280 281 number = form.parse("-9,223,372,036,854,775,8080.00", 282 new ParsePosition(0)); 283 assertTrue(number instanceof Double); 284 assertEquals("-9.223372036854776E19", number.toString()); 285 286 // When parseBigDecimal is set to true, if mantissa part of number 287 // exceeds Long.MAX_VALUE, the number will be parsed into BigDecimal 288 289 form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 290 291 form.setParseBigDecimal(true); 292 number = form.parse("9,223,372,036,854,775,808.00", 293 new ParsePosition(0)); 294 295 assertTrue(number instanceof BigDecimal); 296 297 assertEquals(9.223372036854776E18, number.doubleValue(), 0); 298 299 number = form.parse("-9,223,372,036,854,775,8080.00", 300 new ParsePosition(0)); 301 302 assertTrue(number instanceof BigDecimal); 303 assertEquals(-9.223372036854776E19, number.doubleValue(), 0); 304 305 // The minimum value of Long will be parsed to Long when parseBigDecimal 306 // is not set 307 308 ParsePosition pos = new ParsePosition(0); 309 DecimalFormat df = new DecimalFormat(); 310 pos = new ParsePosition(0); 311 Number nb = df.parse("" + Long.MIN_VALUE, pos); 312 assertTrue(nb instanceof Long); 313 314 // The maximum value of Long will be parsed to Long when parseBigDecimal 315 // is set 316 pos = new ParsePosition(0); 317 df = new DecimalFormat(); 318 pos = new ParsePosition(0); 319 nb = df.parse("" + Long.MAX_VALUE, pos); 320 assertTrue(nb instanceof Long); 321 322 // When parsing invalid string( which is neither consist of digits nor 323 // NaN/Infinity), a null will be returned. 324 325 pos = new ParsePosition(0); 326 df = new DecimalFormat(); 327 try { 328 nb = df.parse("invalid", pos); 329 assertNull(nb); 330 } catch (NullPointerException e) { 331 fail("Should not throw NPE"); 332 } 333 } 334 335 public void test_getMaximumFractionDigits() { 336 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 337 DecimalFormat form = (DecimalFormat) nform; 338 339 // getMaximumFractionDigits of NumberFormat default to 3 340 // getMaximumFractionDigits of DecimalFormat default to 3 341 assertEquals(3, nform.getMaximumFractionDigits()); 342 assertEquals(3, form.getMaximumFractionDigits()); 343 344 // Greater than 340 (critical number used to distinguish 345 // BigInteger and BigDecimal) 346 nform.setMaximumFractionDigits(500); 347 assertEquals(500, nform.getMaximumFractionDigits()); 348 assertEquals(500, form.getMaximumFractionDigits()); 349 350 form.setMaximumFractionDigits(500); 351 assertEquals(500, nform.getMaximumFractionDigits()); 352 assertEquals(500, form.getMaximumFractionDigits()); 353 354 form.format(12.3); 355 assertEquals(500, nform.getMaximumFractionDigits()); 356 assertEquals(500, form.getMaximumFractionDigits()); 357 } 358 359 public void test_getMinimumFractionDigits() { 360 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 361 DecimalFormat form = (DecimalFormat) nform; 362 363 // getMinimumFractionDigits from NumberFormat (default to 0) 364 // getMinimumFractionDigits from DecimalFormat (default to 0) 365 assertEquals(0, nform.getMinimumFractionDigits()); 366 assertEquals(0, form.getMinimumFractionDigits()); 367 368 // Greater than 340 (critical number used to distinguish 369 // BigInteger and BigDecimal) 370 nform.setMinimumFractionDigits(500); 371 assertEquals(500, nform.getMinimumFractionDigits()); 372 assertEquals(500, form.getMinimumFractionDigits()); 373 374 form.setMaximumFractionDigits(400); 375 assertEquals(400, nform.getMinimumFractionDigits()); 376 assertEquals(400, form.getMinimumFractionDigits()); 377 } 378 379 //FIXME This test fails on Harmony ClassLibrary 380 public void test_getMaximumIntegerDigits() { 381 final int maxIntDigit = 309; 382 383 // When use default locale, in this case zh_CN 384 // the returned instance of NumberFormat is a DecimalFormat 385 DecimalFormat form = new DecimalFormat("00.###E0"); 386 assertEquals(2, form.getMaximumIntegerDigits()); 387 388 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 389 form = null; 390 if (nform instanceof DecimalFormat) { 391 form = (DecimalFormat) nform; 392 } 393 394 // Greater than 309 (critical number used to distinguish 395 // BigInteger and BigDecimal) 396 nform.setMaximumIntegerDigits(500); 397 assertEquals(500, nform.getMaximumIntegerDigits()); 398 assertEquals(500, form.getMaximumIntegerDigits()); 399 400 form = new DecimalFormat("00.###E0"); 401 assertEquals(2, form.getMaximumIntegerDigits()); 402 403 form.setMaximumIntegerDigits(500); 404 assertEquals(500, nform.getMaximumIntegerDigits()); 405 assertEquals(500, form.getMaximumIntegerDigits()); 406 form.format(12.3); 407 assertEquals(500, nform.getMaximumIntegerDigits()); 408 assertEquals(500, form.getMaximumIntegerDigits()); 409 410 nform = DecimalFormat.getInstance(Locale.US); 411 form = null; 412 if (nform instanceof DecimalFormat) { 413 form = (DecimalFormat) nform; 414 } 415 // getMaximumIntegerDigits from NumberFormat default to 309 416 // getMaximumIntegerDigits from DecimalFormat default to 309 417 // the following 2 assertions will fail on RI implementation, since the 418 // implementation of ICU and RI are not identical. RI does not give 419 // DecimalFormat an initial bound about its maximumIntegerDigits 420 // (default to Integer.MAX_VALUE: 2147483647 ) 421 assertEquals(maxIntDigit, nform.getMaximumIntegerDigits()); 422 assertEquals(maxIntDigit, form.getMaximumIntegerDigits()); 423 424 // regression test for HARMONY-878 425 assertTrue(new DecimalFormat("0\t'0'").getMaximumIntegerDigits() > 0); 426 } 427 428 public void test_getMinimumIntegerDigits() { 429 final int minIntDigit = 1; 430 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 431 DecimalFormat form = (DecimalFormat) nform; 432 433 // getMaximumIntegerDigits from NumberFormat (default to 1) 434 // getMaximumIntegerDigits from DecimalFormat (default to 1) 435 assertEquals(minIntDigit, nform.getMinimumIntegerDigits()); 436 assertEquals(minIntDigit, form.getMinimumIntegerDigits()); 437 438 // Greater than 309 (critical number used to distinguish 439 // BigInteger and BigDecimal) 440 nform.setMinimumIntegerDigits(500); 441 assertEquals(500, nform.getMinimumIntegerDigits()); 442 assertEquals(500, form.getMinimumIntegerDigits()); 443 444 form.setMaximumIntegerDigits(400); 445 assertEquals(400, nform.getMinimumIntegerDigits()); 446 assertEquals(400, form.getMinimumIntegerDigits()); 447 448 } 449 450 public void test_formatLjava_lang_Obj_Ljava_StringBuffer_Ljava_text_FieldPosition() { 451 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 452 DecimalFormat form = (DecimalFormat) nform; 453 454 // If Object(including null) is not of type Number, 455 // IllegalArgumentException will be thrown out 456 try { 457 form.format(new Object(), new StringBuffer(), new FieldPosition(0)); 458 fail("Should throw IAE"); 459 } catch (IllegalArgumentException e) { 460 // expected 461 } 462 try { 463 form.format(null, new StringBuffer(), new FieldPosition(0)); 464 fail("Should throw IAE"); 465 } catch (IllegalArgumentException e) { 466 // expected 467 } 468 469 // When StringBuffer == null || FieldPosition == null 470 // NullPointerException will be thrown out. 471 try { 472 form.format(new Double(1.9), null, new FieldPosition(0)); 473 fail("Should throw NPE"); 474 } catch (NullPointerException e) { 475 // expected 476 } 477 478 try { 479 form.format(new Double(1.3), new StringBuffer(), null); 480 fail("Should throw NPE"); 481 } catch (NullPointerException e) { 482 // expected 483 } 484 485 try { 486 form.format(new Double(1.4), null, null); 487 fail("Should throw NPE"); 488 } catch (NullPointerException e) { 489 // expected 490 } 491 492 try { 493 form.format(new Object(), null, null); 494 fail("Should throw IllegalArgumentException"); 495 } catch (IllegalArgumentException e) { 496 // expected 497 } 498 499 FieldPosition pos; 500 StringBuffer out; 501 DecimalFormat format = (DecimalFormat) NumberFormat 502 .getInstance(Locale.US); 503 504 // format maxLong 505 pos = new FieldPosition(0); 506 out = format.format(new Long(Long.MAX_VALUE), new StringBuffer(), pos); 507 assertTrue("Wrong result L1: " + out, out.toString().equals( 508 "9,223,372,036,854,775,807")); 509 510 // format minLong 511 pos = new FieldPosition(0); 512 out = format.format(new Long(Long.MIN_VALUE), new StringBuffer(), pos); 513 assertTrue("Wrong result L2: " + out, out.toString().equals( 514 "-9,223,372,036,854,775,808")); 515 516 // format maxLong of type BigInteger 517 pos = new FieldPosition(0); 518 out = format.format(new java.math.BigInteger(String 519 .valueOf(Long.MAX_VALUE)), new StringBuffer(), pos); 520 assertTrue("Wrong result BI1: " + out, out.toString().equals( 521 "9,223,372,036,854,775,807")); 522 523 // format minLong of type BigInteger 524 pos = new FieldPosition(0); 525 out = format.format(new java.math.BigInteger(String 526 .valueOf(Long.MIN_VALUE)), new StringBuffer(), pos); 527 assertTrue("Wrong result BI2: " + out, out.toString().equals( 528 "-9,223,372,036,854,775,808")); 529 530 // format maxLong + 1 531 java.math.BigInteger big; 532 pos = new FieldPosition(0); 533 big = new java.math.BigInteger(String.valueOf(Long.MAX_VALUE)) 534 .add(new java.math.BigInteger("1")); 535 out = format.format(big, new StringBuffer(), pos); 536 assertTrue("Wrong result BI3: " + out, out.toString().equals( 537 "9,223,372,036,854,775,808")); 538 539 // format minLong - 1 540 pos = new FieldPosition(0); 541 big = new java.math.BigInteger(String.valueOf(Long.MIN_VALUE)) 542 .add(new java.math.BigInteger("-1")); 543 out = format.format(big, new StringBuffer(), pos); 544 assertTrue("Wrong result BI4: " + out, out.toString().equals( 545 "-9,223,372,036,854,775,809")); 546 547 // format big decimal 548 pos = new FieldPosition(0); 549 out = format.format(new java.math.BigDecimal("51.348"), 550 new StringBuffer(), pos); 551 assertTrue("Wrong result BD1: " + out, out.toString().equals("51.348")); 552 553 // format big decimal 554 pos = new FieldPosition(0); 555 out = format.format(new java.math.BigDecimal("51"), new StringBuffer(), 556 pos); 557 assertTrue("Wrong result BD2: " + out, out.toString().equals("51")); 558 559 // format big decimal Double.MAX_VALUE * 2 560 java.math.BigDecimal bigDecimal; 561 pos = new FieldPosition(0); 562 final String doubleMax2 = "359,538,626,972,463,141,629,054,847,463,408," 563 + "713,596,141,135,051,689,993,197,834,953,606,314,521,560,057,077," 564 + "521,179,117,265,533,756,343,080,917,907,028,764,928,468,642,653," 565 + "778,928,365,536,935,093,407,075,033,972,099,821,153,102,564,152," 566 + "490,980,180,778,657,888,151,737,016,910,267,884,609,166,473,806," 567 + "445,896,331,617,118,664,246,696,549,595,652,408,289,446,337,476," 568 + "354,361,838,599,762,500,808,052,368,249,716,736"; 569 bigDecimal = new BigDecimal(Double.MAX_VALUE).add(new BigDecimal( 570 Double.MAX_VALUE)); 571 out = format.format(bigDecimal, new StringBuffer(), pos); 572 assertTrue("Wrong result BDmax2: " + out, out.toString().equals( 573 doubleMax2)); 574 575 // format big decimal Double.MIN_VALUE + Double.MIN_VALUE 576 // and Double.MIN_VALUE - Double.MIN_VALUE 577 pos = new FieldPosition(0); 578 579 bigDecimal = new BigDecimal(Double.MIN_VALUE).add(new BigDecimal( 580 Double.MIN_VALUE)); 581 out = format.format(bigDecimal, new StringBuffer(), pos); 582 583 bigDecimal = new BigDecimal(Float.MAX_VALUE).add(new BigDecimal( 584 Float.MAX_VALUE)); 585 out = format.format(bigDecimal, new StringBuffer(), pos); 586 final String BDFloatMax2 = "680,564,693,277,057,719,623,408,366,969,033,850,880"; 587 assertTrue("Wrong result BDFloatMax2: " + out, out.toString().equals( 588 BDFloatMax2)); 589 // format big decimal Float.MIN_VALUE + Float.MIN_VALUE 590 // and Float.MIN_VALUE - Float.MIN_VALUE 591 bigDecimal = new BigDecimal(Float.MIN_VALUE).add(new BigDecimal( 592 Float.MIN_VALUE)); 593 out = format.format(bigDecimal, new StringBuffer(), pos); 594 final String BDFloatMin2 = "0"; 595 596 bigDecimal = new BigDecimal(Float.MIN_VALUE).subtract(new BigDecimal( 597 Float.MIN_VALUE)); 598 out = format.format(bigDecimal, new StringBuffer(), pos); 599 600 assertTrue("Wrong result BDFloatMax2: " + out, out.toString().equals( 601 BDFloatMin2)); 602 603 } 604 605 public void test_setMaximumFractionDigitsLjava_lang_Integer() { 606 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 607 DecimalFormat form = (DecimalFormat) nform; 608 609 form.setMaximumFractionDigits(-2); 610 assertEquals(0, form.getMaximumFractionDigits()); 611 612 form.setMaximumFractionDigits(341); 613 assertEquals(341, form.getMaximumFractionDigits()); 614 } 615 616 public void test_setMinimumFractionDigitsLjava_lang_Integer() { 617 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 618 DecimalFormat form = (DecimalFormat) nform; 619 620 form.setMinimumFractionDigits(-3); 621 assertEquals(0, form.getMinimumFractionDigits()); 622 623 form.setMinimumFractionDigits(310); 624 assertEquals(310, form.getMinimumFractionDigits()); 625 } 626 627 public void test_setMaximumIntegerDigitsLjava_lang_Integer() { 628 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 629 DecimalFormat form = (DecimalFormat) nform; 630 631 form.setMaximumIntegerDigits(-3); 632 assertEquals(0, form.getMaximumIntegerDigits()); 633 634 form.setMaximumIntegerDigits(310); 635 assertEquals(310, form.getMaximumIntegerDigits()); 636 } 637 638 public void test_setMinimumIntegerDigitsLjava_lang_Integer() { 639 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 640 DecimalFormat form = (DecimalFormat) nform; 641 642 form.setMinimumIntegerDigits(-3); 643 assertEquals(0, form.getMinimumIntegerDigits()); 644 645 form.setMinimumIntegerDigits(310); 646 assertEquals(310, form.getMinimumIntegerDigits()); 647 } 648 649 // When MaxFractionDigits is set first and less than MinFractionDigits, max 650 // will be changed to min value 651 public void test_setMinimumFactionDigitsLjava_lang_Integer_setMaximumFractionDigitsLjava_lang_Integer() { 652 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 653 DecimalFormat form = (DecimalFormat) nform; 654 655 form.setMaximumFractionDigits(100); 656 form.setMinimumFractionDigits(200); 657 658 assertEquals(200, form.getMaximumFractionDigits()); 659 assertEquals(200, form.getMinimumFractionDigits()); 660 661 form.setMaximumIntegerDigits(100); 662 form.setMinimumIntegerDigits(200); 663 664 assertEquals(200, form.getMaximumIntegerDigits()); 665 assertEquals(200, form.getMinimumIntegerDigits()); 666 } 667 668 // When MinFractionDigits is set first and less than MaxFractionDigits, min 669 // will be changed to max value 670 public void test_setMaximumFactionDigitsLjava_lang_Integer_setMinimumFractionDigitsLjava_lang_Integer() { 671 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 672 DecimalFormat form = (DecimalFormat) nform; 673 674 form.setMinimumFractionDigits(200); 675 form.setMaximumFractionDigits(100); 676 677 assertEquals(100, form.getMaximumFractionDigits()); 678 assertEquals(100, form.getMinimumFractionDigits()); 679 680 form.setMinimumIntegerDigits(200); 681 form.setMaximumIntegerDigits(100); 682 683 assertEquals(100, form.getMaximumIntegerDigits()); 684 assertEquals(100, form.getMinimumIntegerDigits()); 685 } 686 687 public void test_equalsLjava_lang_Object() { 688 DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 689 DecimalFormat cloned = (DecimalFormat) format.clone(); 690 cloned.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.US)); 691 assertEquals(format, cloned); 692 693 Currency c = Currency.getInstance(Locale.US); 694 cloned.setCurrency(c); 695 696 assertEquals(format, cloned); 697 } 698 699 public void test_setPositivePrefixLjava_lang_String() { 700 DecimalFormat format = new DecimalFormat(); 701 assertEquals("", format.getPositivePrefix()); 702 } 703 704 public void test_setPositiveSuffixLjava_lang_String() { 705 DecimalFormat format = new DecimalFormat(); 706 assertEquals("", format.getPositiveSuffix()); 707 } 708 709 public void test_setNegativePrefixLjava_lang_String() { 710 DecimalFormat format = new DecimalFormat(); 711 assertEquals("-", format.getNegativePrefix()); 712 } 713 714 public void test_setNegativeSuffixLjava_lang_String() { 715 DecimalFormat format = new DecimalFormat(); 716 assertEquals("", format.getNegativeSuffix()); 717 } 718 719 public void test_setGroupingUse() { 720 DecimalFormat format = new DecimalFormat(); 721 StringBuffer buf = new StringBuffer(); 722 format.setGroupingUsed(false); 723 format.format(new Long(1970), buf, new FieldPosition(0)); 724 assertEquals("1970", buf.toString()); 725 assertFalse(format.isGroupingUsed()); 726 } 727 728 /** 729 * @tests java.text.DecimalFormat#DecimalFormat(java.lang.String) 730 */ 731 public void test_ConstructorLjava_lang_String() { 732 // Test for method java.text.DecimalFormat(java.lang.String) 733 // the constructor form that specifies a pattern is equal to the form 734 // constructed with no pattern and applying that pattern using the 735 // applyPattern call 736 DecimalFormat format = new DecimalFormat("'$'0000.0000"); 737 DecimalFormat format1 = new DecimalFormat(); 738 format1.applyPattern("'$'0000.0000"); 739 assertTrue("Constructed format did not match applied format object", 740 format.equals(format1)); 741 } 742 743 /** 744 * @tests java.text.DecimalFormat#applyPattern(java.lang.String) 745 */ 746 public void test_applyPatternLjava_lang_String() { 747 DecimalFormat format = new DecimalFormat("#.#"); 748 assertEquals("Wrong pattern 1", "#0.#", format.toPattern()); 749 format = new DecimalFormat("#."); 750 assertEquals("Wrong pattern 2", "#0.", format.toPattern()); 751 format = new DecimalFormat("#"); 752 assertEquals("Wrong pattern 3", "#", format.toPattern()); 753 format = new DecimalFormat(".#"); 754 assertEquals("Wrong pattern 4", "#.0", format.toPattern()); 755 // Regression for HARMONY-6485 756 format = new DecimalFormat(); 757 format.setMinimumIntegerDigits(0); 758 format.setMinimumFractionDigits(0); 759 format.setMaximumFractionDigits(0); 760 format.applyPattern("00.0#"); 761 assertEquals("Minimum integer digits not set", 2, format.getMinimumIntegerDigits()); 762 assertEquals("Minimum fraction digits not set", 1, format.getMinimumFractionDigits()); 763 assertEquals("Maximum fraction digits not set", 2, format.getMaximumFractionDigits()); 764 765 } 766 767 /** 768 * @tests java.text.DecimalFormat#clone() 769 */ 770 public void test_clone() { 771 DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance(Locale.US); 772 DecimalFormat cloned = (DecimalFormat) format.clone(); 773 assertEquals(cloned.getDecimalFormatSymbols(), format 774 .getDecimalFormatSymbols()); 775 776 format = new DecimalFormat("'$'0000.0000"); 777 DecimalFormat format1 = (DecimalFormat) (format.clone()); 778 // make sure the objects are equal 779 assertTrue("Object's clone isn't equal!", format.equals(format1)); 780 // change the content of the clone and make sure it's not equal anymore 781 // verifies that it's data is now distinct from the original 782 format1.applyPattern("'$'0000.####"); 783 assertTrue("Object's changed clone should not be equal!", !format 784 .equals(format1)); 785 } 786 787 private void compare(String testName, String format, String expected) { 788 assertTrue(testName + " got: " + format + " expected: " + expected, 789 format.equals(expected)); 790 } 791 792 private boolean compare(int count, String format, String expected) { 793 boolean result = format.equals(expected); 794 if (!result) 795 System.out.println("Failure test: " + count + " got: " + format 796 + " expected: " + expected); 797 return result; 798 } 799 800 /** 801 * @tests java.text.DecimalFormat#format(double, java.lang.StringBuffer, 802 * java.text.FieldPosition) 803 */ 804 //FIXME This test fails on Harmony ClassLibrary 805 public void test_formatDLjava_lang_StringBufferLjava_text_FieldPosition() { 806 new Support_DecimalFormat( 807 "test_formatDLjava_lang_StringBufferLjava_text_FieldPosition") 808 .t_format_with_FieldPosition(); 809 810 int failCount = 0; 811 BitSet failures = new BitSet(); 812 813 final DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US); 814 815 DecimalFormat df = new DecimalFormat("00.0#E0", dfs); 816 compare("00.0#E0: 0.0", df.format(0.0), "00.0E0"); 817 compare("00.0#E0: 1.0", df.format(1.0), "10.0E-1"); 818 compare("00.0#E0: 12.0", df.format(12.0), "12.0E0"); 819 compare("00.0#E0: 123.0", df.format(123.0), "12.3E1"); 820 compare("00.0#E0: 1234.0", df.format(1234.0), "12.34E2"); 821 compare("00.0#E0: 12346.0", df.format(12346.0), "12.35E3"); 822 compare("00.0#E0: 99999.0", df.format(99999.0), "10.0E4"); 823 compare("00.0#E0: 1.2", df.format(1.2), "12.0E-1"); 824 compare("00.0#E0: 12.3", df.format(12.3), "12.3E0"); 825 compare("00.0#E0: 123.4", df.format(123.4), "12.34E1"); 826 compare("00.0#E0: 1234.6", df.format(1234.6), "12.35E2"); 827 compare("00.0#E0: 9999.9", df.format(9999.9), "10.0E3"); 828 compare("00.0#E0: 0.1", df.format(0.1), "10.0E-2"); 829 compare("00.0#E0: 0.12", df.format(0.12), "12.0E-2"); 830 compare("00.0#E0: 0.123", df.format(0.123), "12.3E-2"); 831 compare("00.0#E0: 0.1234", df.format(0.1234), "12.34E-2"); 832 compare("00.0#E0: 0.12346", df.format(0.12346), "12.35E-2"); 833 compare("00.0#E0: 0.99999", df.format(0.99999), "10.0E-1"); 834 compare("00.0#E0: -0.0", df.format(-0.0), "-00.0E0"); 835 compare("00.0#E0: -1.0", df.format(-1.0), "-10.0E-1"); 836 compare("00.0#E0: -12.0", df.format(-12.0), "-12.0E0"); 837 compare("00.0#E0: -123.0", df.format(-123.0), "-12.3E1"); 838 compare("00.0#E0: -1234.0", df.format(-1234.0), "-12.34E2"); 839 compare("00.0#E0: -12346.0", df.format(-12346.0), "-12.35E3"); 840 compare("00.0#E0: -99999.0", df.format(-99999.0), "-10.0E4"); 841 842 df = new DecimalFormat("##0.0E0", dfs); 843 compare("##0.0E0: -0.0", df.format(-0.0), "-0.0E0"); 844 compare("##0.0E0: 0.0", df.format(0.0), "0.0E0"); 845 compare("##0.0E0: 1.0", df.format(1.0), "1.0E0"); 846 compare("##0.0E0: 12.0", df.format(12.0), "12E0"); 847 compare("##0.0E0: 123.0", df.format(123.0), "123E0"); 848 compare("##0.0E0: 1234.0", df.format(1234.0), "1.234E3"); 849 compare("##0.0E0: 12346.0", df.format(12346.0), "12.35E3"); 850 // Fails in JDK 1.2.2 851 if (!compare(failCount, df.format(99999.0), "100E3")) 852 failures.set(failCount); 853 failCount++; 854 compare("##0.0E0: 999999.0", df.format(999999.0), "1.0E6"); 855 856 df = new DecimalFormat("#00.0##E0", dfs); 857 compare("#00.0##E0: 0.1", df.format(0.1), ".100E0"); 858 compare("#00.0##E0: 0.12", df.format(0.12), ".120E0"); 859 compare("#00.0##E0: 0.123", df.format(0.123), ".123E0"); 860 compare("#00.0##E0: 0.1234", df.format(0.1234), ".1234E0"); 861 compare("#00.0##E0: 0.1234567", df.format(0.1234567), ".123457E0"); 862 compare("#00.0##E0: 0.01", df.format(0.01), "10.0E-3"); 863 compare("#00.0##E0: 0.012", df.format(0.012), "12.0E-3"); 864 compare("#00.0##E0: 0.0123", df.format(0.0123), "12.3E-3"); 865 compare("#00.0##E0: 0.01234", df.format(0.01234), "12.34E-3"); 866 compare("#00.0##E0: 0.01234567", df.format(0.01234567), "12.3457E-3"); 867 compare("#00.0##E0: 0.001", df.format(0.001), "1.00E-3"); 868 compare("#00.0##E0: 0.0012", df.format(0.0012), "1.20E-3"); 869 compare("#00.0##E0: 0.00123", df.format(0.00123), "1.23E-3"); 870 compare("#00.0##E0: 0.001234", df.format(0.001234), "1.234E-3"); 871 compare("#00.0##E0: 0.001234567", df.format(0.001234567), "1.23457E-3"); 872 compare("#00.0##E0: 0.0001", df.format(0.0001), "100E-6"); 873 compare("#00.0##E0: 0.00012", df.format(0.00012), "120E-6"); 874 compare("#00.0##E0: 0.000123", df.format(0.000123), "123E-6"); 875 compare("#00.0##E0: 0.0001234", df.format(0.0001234), "123.4E-6"); 876 compare("#00.0##E0: 0.0001234567", df.format(0.0001234567), 877 "123.457E-6"); 878 879 // Fails in JDK 1.2.2 880 if (!compare(failCount, df.format(0.0), "0.00E0")) 881 failures.set(failCount); 882 failCount++; 883 compare("#00.0##E0: 1.0", df.format(1.0), "1.00E0"); 884 compare("#00.0##E0: 12.0", df.format(12.0), "12.0E0"); 885 compare("#00.0##E0: 123.0", df.format(123.0), "123E0"); 886 compare("#00.0##E0: 1234.0", df.format(1234.0), "1.234E3"); 887 compare("#00.0##E0: 12345.0", df.format(12345.0), "12.345E3"); 888 compare("#00.0##E0: 123456.0", df.format(123456.0), "123.456E3"); 889 compare("#00.0##E0: 1234567.0", df.format(1234567.0), "1.23457E6"); 890 compare("#00.0##E0: 12345678.0", df.format(12345678.0), "12.3457E6"); 891 compare("#00.0##E0: 99999999.0", df.format(99999999.0), "100E6"); 892 893 df = new DecimalFormat("#.0E0", dfs); 894 compare("#.0E0: -0.0", df.format(-0.0), "-.0E0"); 895 compare("#.0E0: 0.0", df.format(0.0), ".0E0"); 896 compare("#.0E0: 1.0", df.format(1.0), ".1E1"); 897 compare("#.0E0: 12.0", df.format(12.0), ".12E2"); 898 compare("#.0E0: 123.0", df.format(123.0), ".12E3"); 899 compare("#.0E0: 1234.0", df.format(1234.0), ".12E4"); 900 compare("#.0E0: 9999.0", df.format(9999.0), ".1E5"); 901 902 df = new DecimalFormat("0.#E0", dfs); 903 compare("0.#E0: -0.0", df.format(-0.0), "-0E0"); 904 compare("0.#E0: 0.0", df.format(0.0), "0E0"); 905 compare("0.#E0: 1.0", df.format(1.0), "1E0"); 906 compare("0.#E0: 12.0", df.format(12.0), "1.2E1"); 907 compare("0.#E0: 123.0", df.format(123.0), "1.2E2"); 908 compare("0.#E0: 1234.0", df.format(1234.0), "1.2E3"); 909 compare("0.#E0: 9999.0", df.format(9999.0), "1E4"); 910 911 df = new DecimalFormat(".0E0", dfs); 912 compare(".0E0: -0.0", df.format(-0.0), "-.0E0"); 913 compare(".0E0: 0.0", df.format(0.0), ".0E0"); 914 compare(".0E0: 1.0", df.format(1.0), ".1E1"); 915 compare(".0E0: 12.0", df.format(12.0), ".1E2"); 916 compare(".0E0: 123.0", df.format(123.0), ".1E3"); 917 compare(".0E0: 1234.0", df.format(1234.0), ".1E4"); 918 compare(".0E0: 9999.0", df.format(9999.0), ".1E5"); 919 920 df = new DecimalFormat("0.E0", dfs); 921 // Fails in JDK 1.2.2 922 if (!compare(failCount, df.format(0.0), "0.E0")) 923 failures.set(failCount); 924 failCount++; 925 if (!compare(failCount, df.format(1.0), "1.E0")) 926 failures.set(failCount); 927 failCount++; 928 if (!compare(failCount, df.format(12.0), "1.E1")) 929 failures.set(failCount); 930 failCount++; 931 if (!compare(failCount, df.format(123.0), "1.E2")) 932 failures.set(failCount); 933 failCount++; 934 if (!compare(failCount, df.format(1234.0), "1.E3")) 935 failures.set(failCount); 936 failCount++; 937 if (!compare(failCount, df.format(9999.0), "1.E4")) 938 failures.set(failCount); 939 failCount++; 940 941 df = new DecimalFormat("##0.00#E0", dfs); 942 compare("##0.00#E0: 0.1", df.format(0.1), ".100E0"); 943 compare("##0.00#E0: 0.1234567", df.format(0.1234567), ".123457E0"); 944 compare("##0.00#E0: 0.9999999", df.format(0.9999999), "1.00E0"); 945 compare("##0.00#E0: 0.01", df.format(0.01), "10.0E-3"); 946 compare("##0.00#E0: 0.01234567", df.format(0.01234567), "12.3457E-3"); 947 compare("##0.00#E0: 0.09999999", df.format(0.09999999), ".100E0"); 948 compare("##0.00#E0: 0.001", df.format(0.001), "1.00E-3"); 949 compare("##0.00#E0: 0.001234567", df.format(0.001234567), "1.23457E-3"); 950 compare("##0.00#E0: 0.009999999", df.format(0.009999999), "10.0E-3"); 951 compare("##0.00#E0: 0.0001", df.format(0.0001), "100E-6"); 952 compare("##0.00#E0: 0.0001234567", df.format(0.0001234567), 953 "123.457E-6"); 954 compare("##0.00#E0: 0.0009999999", df.format(0.0009999999), "1.00E-3"); 955 956 df = new DecimalFormat("###0.00#E0", dfs); 957 compare("###0.00#E0: 0.1", df.format(0.1), ".100E0"); 958 compare("###0.00#E0: 0.12345678", df.format(0.12345678), ".1234568E0"); 959 compare("###0.00#E0: 0.99999999", df.format(0.99999999), "1.00E0"); 960 compare("###0.00#E0: 0.01", df.format(0.01), "100E-4"); 961 compare("###0.00#E0: 0.012345678", df.format(0.012345678), 962 "123.4568E-4"); 963 compare("###0.00#E0: 0.099999999", df.format(0.099999999), ".100E0"); 964 compare("###0.00#E0: 0.001", df.format(0.001), "10.0E-4"); 965 compare("###0.00#E0: 0.0012345678", df.format(0.0012345678), 966 "12.34568E-4"); 967 compare("###0.00#E0: 0.0099999999", df.format(0.0099999999), "100E-4"); 968 compare("###0.00#E0: 0.0001", df.format(0.0001), "1.00E-4"); 969 compare("###0.00#E0: 0.00012345678", df.format(0.00012345678), 970 "1.234568E-4"); 971 compare("###0.00#E0: 0.00099999999", df.format(0.00099999999), 972 "10.0E-4"); 973 // Fails in JDK 1.2.2 974 if (!compare(failCount, df.format(0.00001), "1000E-8")) 975 failures.set(failCount); 976 failCount++; 977 compare("###0.00#E0: 0.000012345678", df.format(0.000012345678), 978 "1234.568E-8"); 979 compare("###0.00#E0: 0.000099999999", df.format(0.000099999999), 980 "1.00E-4"); 981 982 df = new DecimalFormat("###0.0#E0", dfs); 983 compare("###0.0#E0: 0.1", df.format(0.1), ".10E0"); 984 compare("###0.0#E0: 0.1234567", df.format(0.1234567), ".123457E0"); 985 compare("###0.0#E0: 0.9999999", df.format(0.9999999), "1.0E0"); 986 // Fails in JDK 1.2.2 987 if (!compare(failCount, df.format(0.01), "100E-4")) 988 failures.set(failCount); 989 failCount++; 990 compare("###0.0#E0: 0.01234567", df.format(0.01234567), "123.457E-4"); 991 compare("###0.0#E0: 0.09999999", df.format(0.09999999), ".10E0"); 992 compare("###0.0#E0: 0.001", df.format(0.001), "10E-4"); 993 compare("###0.0#E0: 0.001234567", df.format(0.001234567), "12.3457E-4"); 994 // Fails in JDK 1.2.2 995 if (!compare(failCount, df.format(0.009999999), "100E-4")) 996 failures.set(failCount); 997 failCount++; 998 compare("###0.0#E0: 0.0001", df.format(0.0001), "1.0E-4"); 999 compare("###0.0#E0: 0.0001234567", df.format(0.0001234567), 1000 "1.23457E-4"); 1001 compare("###0.0#E0: 0.0009999999", df.format(0.0009999999), "10E-4"); 1002 // Fails in JDK 1.2.2 1003 if (!compare(failCount, df.format(0.00001), "1000E-8")) 1004 failures.set(failCount); 1005 failCount++; 1006 compare("###0.0#E0: 0.00001234567", df.format(0.00001234567), 1007 "1234.57E-8"); 1008 compare("###0.0#E0: 0.00009999999", df.format(0.00009999999), "1.0E-4"); 1009 1010 assertTrue("Failed " + failures + " of " + failCount, 1011 failures.length() == 0); 1012 1013 String formatString = "##0.#"; 1014 df = new DecimalFormat(formatString, dfs); 1015 df.setMinimumFractionDigits(30); 1016 compare(formatString + ": 0.000000000000000000000000000000", df 1017 .format(0.0), "0.000000000000000000000000000000"); 1018 compare(formatString + ": -0.000000000000000000000000000000", df 1019 .format(-0.0), "-0.000000000000000000000000000000"); 1020 compare(formatString + ": 1.000000000000000000000000000000", df 1021 .format(1.0), "1.000000000000000000000000000000"); 1022 compare(formatString + ": -1.000000000000000000000000000000", df 1023 .format(-1.0), "-1.000000000000000000000000000000"); 1024 1025 df = new DecimalFormat(formatString); 1026 df.setMaximumFractionDigits(30); 1027 compare(formatString + ": 0", df.format(0.0), "0"); 1028 compare(formatString + ": -0", df.format(-0.0), "-0"); 1029 compare(formatString + ": 1", df.format(1.0), "1"); 1030 compare(formatString + ": -1", df.format(-1.0), "-1"); 1031 } 1032 1033 /** 1034 * @tests java.text.DecimalFormat#format(long, java.lang.StringBuffer, 1035 * java.text.FieldPosition) 1036 */ 1037 //FIXME This test fails on Harmony ClassLibrary 1038 public void test_formatJLjava_lang_StringBufferLjava_text_FieldPosition() { 1039 int failCount = 0; 1040 BitSet failures = new BitSet(); 1041 1042 final DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US); 1043 1044 DecimalFormat df = new DecimalFormat("00.0#E0", dfs); 1045 assertEquals("00.0#E0: 0", "00.0E0", df.format(0)); 1046 assertEquals("00.0#E0: 1", "10.0E-1", df.format(1)); 1047 assertEquals("00.0#E0: 12", "12.0E0", df.format(12)); 1048 assertEquals("00.0#E0: 123", "12.3E1", df.format(123)); 1049 assertEquals("00.0#E0: 1234", "12.34E2", df.format(1234)); 1050 assertEquals("00.0#E0: 12346", "12.35E3", df.format(12346)); 1051 assertEquals("00.0#E0: 99999", "10.0E4", df.format(99999)); 1052 assertEquals("00.0#E0: -1", "-10.0E-1", df.format(-1)); 1053 assertEquals("00.0#E0: -12", "-12.0E0", df.format(-12)); 1054 assertEquals("00.0#E0: -123", "-12.3E1", df.format(-123)); 1055 assertEquals("00.0#E0: -1234", "-12.34E2", df.format(-1234)); 1056 assertEquals("00.0#E0: -12346", "-12.35E3", df.format(-12346)); 1057 assertEquals("00.0#E0: -99999", "-10.0E4", df.format(-99999)); 1058 1059 df = new DecimalFormat("##0.0E0", dfs); 1060 assertEquals("##0.0E0: 0", "0.0E0", df.format(0)); 1061 assertEquals("##0.0E0: 1", "1.0E0", df.format(1)); 1062 assertEquals("##0.0E0: 12", "12E0", df.format(12)); 1063 assertEquals("##0.0E0: 123", "123E0", df.format(123)); 1064 assertEquals("##0.0E0: 1234", "1.234E3", df.format(1234)); 1065 assertEquals("##0.0E0: 12346", "12.35E3", df.format(12346)); 1066 // Fails in JDK 1.2.2 1067 if (!df.format(99999).equals("100E3")) 1068 failures.set(failCount); 1069 failCount++; 1070 assertEquals("##0.0E0: 999999", "1.0E6", df.format(999999)); 1071 1072 df = new DecimalFormat("#00.0##E0", dfs); 1073 // Fails in JDK 1.2.2 1074 if (!df.format(0).equals("0.00E0")) 1075 failures.set(failCount); 1076 failCount++; 1077 assertEquals("#00.0##E0: 1", "1.00E0", df.format(1)); 1078 assertEquals("#00.0##E0: 12", "12.0E0", df.format(12)); 1079 assertEquals("#00.0##E0: 123", "123E0", df.format(123)); 1080 assertEquals("#00.0##E0: 1234", "1.234E3", df.format(1234)); 1081 assertEquals("#00.0##E0: 12345", "12.345E3", df.format(12345)); 1082 assertEquals("#00.0##E0: 123456", "123.456E3", df.format(123456)); 1083 assertEquals("#00.0##E0: 1234567", "1.23457E6", df.format(1234567)); 1084 assertEquals("#00.0##E0: 12345678", "12.3457E6", df.format(12345678)); 1085 assertEquals("#00.0##E0: 99999999", "100E6", df.format(99999999)); 1086 1087 df = new DecimalFormat("#.0E0", dfs); 1088 assertEquals("#.0E0: 0", ".0E0", df.format(0)); 1089 assertEquals("#.0E0: 1", ".1E1", df.format(1)); 1090 assertEquals("#.0E0: 12", ".12E2", df.format(12)); 1091 assertEquals("#.0E0: 123", ".12E3", df.format(123)); 1092 assertEquals("#.0E0: 1234", ".12E4", df.format(1234)); 1093 assertEquals("#.0E0: 9999", ".1E5", df.format(9999)); 1094 1095 df = new DecimalFormat("0.#E0", dfs); 1096 assertEquals("0.#E0: 0", "0E0", df.format(0)); 1097 assertEquals("0.#E0: 1", "1E0", df.format(1)); 1098 assertEquals("0.#E0: 12", "1.2E1", df.format(12)); 1099 assertEquals("0.#E0: 123", "1.2E2", df.format(123)); 1100 assertEquals("0.#E0: 1234", "1.2E3", df.format(1234)); 1101 assertEquals("0.#E0: 9999", "1E4", df.format(9999)); 1102 1103 assertTrue("Failed " + failures + " of " + failCount, 1104 failures.length() == 0); 1105 } 1106 1107 /** 1108 * @tests java.text.DecimalFormat#formatToCharacterIterator(java.lang.Object) 1109 */ 1110 //FIXME This test fails on Harmony ClassLibrary 1111 public void test_formatToCharacterIteratorLjava_lang_Object() { 1112 1113 try { 1114 // Regression for HARMONY-466 1115 new DecimalFormat().formatToCharacterIterator(null); 1116 fail("NullPointerException expected"); 1117 } catch (NullPointerException e) { 1118 // expected 1119 } 1120 1121 new Support_DecimalFormat( 1122 "test_formatToCharacterIteratorLjava_lang_Object") 1123 .t_formatToCharacterIterator(); 1124 } 1125 1126 /** 1127 * @tests java.text.DecimalFormat#format(double) 1128 */ 1129 public void test_formatD() { 1130 DecimalFormat format = (DecimalFormat) NumberFormat 1131 .getInstance(Locale.ENGLISH); 1132 format.setGroupingUsed(false); 1133 format.setMaximumFractionDigits(400); 1134 for (int i = 0; i < 309; i++) { 1135 String tval = "1"; 1136 for (int j = 0; j < i; j++) 1137 tval += "0"; 1138 double d = Double.parseDouble(tval); 1139 String result = format.format(d); 1140 assertEquals(i + ") e:" + tval + " r:" + result, tval, result); 1141 } 1142 for (int i = 0; i < 322; i++) { 1143 String tval = "0."; 1144 for (int j = 0; j < i; j++) 1145 tval += "0"; 1146 tval += "1"; 1147 double d = Double.parseDouble(tval); 1148 String result = format.format(d); 1149 assertEquals(i + ") e:" + tval + " r:" + result, tval, result); 1150 } 1151 assertEquals("999999999999999", format.format(999999999999999.)); 1152 assertEquals("1", "999999999999999.9", format.format(999999999999999.9)); 1153 assertEquals("2", "99999999999999.98", format.format(99999999999999.99)); 1154 assertEquals("3", "9999999999999.998", format.format(9999999999999.999)); 1155 assertEquals("4", "999999999999.9999", format.format(999999999999.9999)); 1156 assertEquals("5", "99999999999.99998", format.format(99999999999.99999)); 1157 assertEquals("6", "9999999999.999998", format.format(9999999999.999999)); 1158 assertEquals("7", "999999999.9999999", format.format(999999999.9999999)); 1159 assertEquals("8", "99999999.99999999", format.format(99999999.99999999)); 1160 assertEquals("9", "9999999.999999998", format.format(9999999.999999999)); 1161 assertEquals("10", "99999.99999999999", format 1162 .format(99999.99999999999)); 1163 assertEquals("11", "9999.999999999998", format 1164 .format(9999.999999999999)); 1165 assertEquals("12", "999.9999999999999", format 1166 .format(999.9999999999999)); 1167 assertEquals("13", "99.99999999999999", format 1168 .format(99.99999999999999)); 1169 assertEquals("14", "9.999999999999998", format 1170 .format(9.999999999999999)); 1171 assertEquals("15", "0.9999999999999999", format 1172 .format(.9999999999999999)); 1173 } 1174 1175 /** 1176 * @tests java.text.DecimalFormat#getDecimalFormatSymbols() 1177 */ 1178 public void test_getDecimalFormatSymbols() { 1179 DecimalFormat df = (DecimalFormat) NumberFormat 1180 .getInstance(Locale.ENGLISH); 1181 DecimalFormatSymbols dfs = df.getDecimalFormatSymbols(); 1182 assertTrue("Identical symbols", dfs != df.getDecimalFormatSymbols()); 1183 } 1184 1185 /** 1186 * @tests java.text.DecimalFormat#getCurrency() 1187 */ 1188 //FIXME This test fails on Harmony ClassLibrary 1189 public void test_getCurrency() { 1190 Currency currK = Currency.getInstance("KRW"); 1191 Currency currX = Currency.getInstance("XXX"); 1192 Currency currE = Currency.getInstance("EUR"); 1193 Currency curr01; 1194 1195 DecimalFormat df = (DecimalFormat) NumberFormat 1196 .getCurrencyInstance(new Locale("ko", "KR")); 1197 assertTrue("Test1: Returned incorrect currency", 1198 df.getCurrency() == currK); 1199 1200 df = (DecimalFormat) NumberFormat.getCurrencyInstance(new Locale("", 1201 "KR")); 1202 assertTrue("Test2: Returned incorrect currency", 1203 df.getCurrency() == currK); 1204 1205 df = (DecimalFormat) NumberFormat.getCurrencyInstance(new Locale("ko", 1206 "")); 1207 assertTrue("Test3: Returned incorrect currency", 1208 df.getCurrency() == currX); 1209 1210 df = (DecimalFormat) NumberFormat.getCurrencyInstance(new Locale("fr", 1211 "FR")); 1212 assertTrue("Test4: Returned incorrect currency", 1213 df.getCurrency() == currE); 1214 1215 // Regression for HARMONY-1351 1216 df = (DecimalFormat) NumberFormat.getCurrencyInstance(new Locale("QWERTY")); 1217 assertTrue("Test5: Returned incorrect currency", 1218 df.getCurrency() == currX); 1219 1220 // JDK fails these tests since it doesn't have the PREEURO variant 1221 // df = (DecimalFormat)NumberFormat.getCurrencyInstance(new Locale("fr", 1222 // "FR","PREEURO")); 1223 // assertTrue("Test5: Returned incorrect currency", df.getCurrency() == 1224 // currF); 1225 } 1226 1227 /** 1228 * @tests java.text.DecimalFormat#getGroupingSize() 1229 */ 1230 public void test_getGroupingSize() { 1231 DecimalFormat df = new DecimalFormat("###0.##"); 1232 assertEquals("Wrong unset size", 0, df.getGroupingSize()); 1233 df = new DecimalFormat("#,##0.##"); 1234 assertEquals("Wrong set size", 3, df.getGroupingSize()); 1235 df = new DecimalFormat("#,###,###0.##"); 1236 assertEquals("Wrong multiple set size", 4, df.getGroupingSize()); 1237 } 1238 1239 /** 1240 * @tests java.text.DecimalFormat#getMultiplier() 1241 */ 1242 public void test_getMultiplier() { 1243 final int defaultMultiplier = 1; 1244 NumberFormat nform = DecimalFormat.getInstance(Locale.US); 1245 DecimalFormat form = (DecimalFormat) nform; 1246 assertEquals(defaultMultiplier, form.getMultiplier()); 1247 1248 DecimalFormat df = new DecimalFormat("###0.##"); 1249 assertEquals("Wrong unset multiplier", 1, df.getMultiplier()); 1250 df = new DecimalFormat("###0.##%"); 1251 assertEquals("Wrong percent multiplier", 100, df.getMultiplier()); 1252 df = new DecimalFormat("###0.##\u2030"); 1253 assertEquals("Wrong mille multiplier", 1000, df.getMultiplier()); 1254 } 1255 1256 /** 1257 * @tests java.text.DecimalFormat#isDecimalSeparatorAlwaysShown() 1258 */ 1259 public void test_isDecimalSeparatorAlwaysShown() { 1260 DecimalFormat df = new DecimalFormat("###0.##"); 1261 assertTrue("Wrong unset value", !df.isDecimalSeparatorAlwaysShown()); 1262 df = new DecimalFormat("###0.00"); 1263 assertTrue("Wrong unset2 value", !df.isDecimalSeparatorAlwaysShown()); 1264 df = new DecimalFormat("###0."); 1265 assertTrue("Wrong set value", df.isDecimalSeparatorAlwaysShown()); 1266 } 1267 1268 /** 1269 * @tests java.text.DecimalFormat#parse(java.lang.String, 1270 * java.text.ParsePosition) 1271 */ 1272 //FIXME This test fails on Harmony ClassLibrary 1273 public void test_parseLjava_lang_StringLjava_text_ParsePosition() { 1274 DecimalFormat format = (DecimalFormat) NumberFormat 1275 .getNumberInstance(Locale.ENGLISH); 1276 ParsePosition pos = new ParsePosition(0); 1277 Number result = format.parse("9223372036854775807", pos); 1278 assertTrue("Wrong result type for Long.MAX_VALUE", 1279 result.getClass() == Long.class); 1280 assertTrue("Wrong result Long.MAX_VALUE", 1281 result.longValue() == Long.MAX_VALUE); 1282 pos = new ParsePosition(0); 1283 result = format.parse("-9223372036854775808", pos); 1284 assertTrue("Wrong result type for Long.MIN_VALUE", 1285 result.getClass() == Long.class); 1286 assertTrue("Wrong result Long.MIN_VALUE: " + result.longValue(), result 1287 .longValue() == Long.MIN_VALUE); 1288 pos = new ParsePosition(0); 1289 result = format.parse("9223372036854775808", pos); 1290 assertTrue("Wrong result type for Long.MAX_VALUE+1", 1291 result.getClass() == Double.class); 1292 assertTrue("Wrong result Long.MAX_VALUE + 1", 1293 result.doubleValue() == (double) Long.MAX_VALUE + 1); 1294 pos = new ParsePosition(0); 1295 result = format.parse("-9223372036854775809", pos); 1296 assertTrue("Wrong result type for Long.MIN_VALUE+1", 1297 result.getClass() == Double.class); 1298 assertTrue("Wrong result Long.MIN_VALUE - 1", 1299 result.doubleValue() == (double) Long.MIN_VALUE - 1); 1300 1301 pos = new ParsePosition(0); 1302 result = format.parse("18446744073709551629", pos); 1303 assertTrue("Wrong result type for overflow", 1304 result.getClass() == Double.class); 1305 assertTrue("Wrong result for overflow", 1306 result.doubleValue() == 18446744073709551629d); 1307 1308 pos = new ParsePosition(0); 1309 result = format.parse("42325917317067571199", pos); 1310 assertTrue("Wrong result type for overflow a: " + result, result 1311 .getClass() == Double.class); 1312 assertTrue("Wrong result for overflow a: " + result, result 1313 .doubleValue() == 42325917317067571199d); 1314 pos = new ParsePosition(0); 1315 result = format.parse("4232591731706757119E1", pos); 1316 assertTrue("Wrong result type for overflow b: " + result, result 1317 .getClass() == Double.class); 1318 assertTrue("Wrong result for overflow b: " + result, result 1319 .doubleValue() == 42325917317067571190d); 1320 pos = new ParsePosition(0); 1321 result = format.parse(".42325917317067571199E20", pos); 1322 assertTrue("Wrong result type for overflow c: " + result, result 1323 .getClass() == Double.class); 1324 assertTrue("Wrong result for overflow c: " + result, result 1325 .doubleValue() == 42325917317067571199d); 1326 pos = new ParsePosition(0); 1327 result = format.parse("922337203685477580.9E1", pos); 1328 assertTrue("Wrong result type for overflow d: " + result, result 1329 .getClass() == Double.class); 1330 assertTrue("Wrong result for overflow d: " + result, result 1331 .doubleValue() == 9223372036854775809d); 1332 pos = new ParsePosition(0); 1333 result = format.parse("9.223372036854775809E18", pos); 1334 assertTrue("Wrong result type for overflow e: " + result, result 1335 .getClass() == Double.class); 1336 assertTrue("Wrong result for overflow e: " + result, result 1337 .doubleValue() == 9223372036854775809d); 1338 1339 // test parse with multipliers 1340 format.setMultiplier(100); 1341 result = format.parse("9223372036854775807", new ParsePosition(0)); 1342 assertTrue("Wrong result type multiplier 100: " + result, result 1343 .getClass() == Long.class); 1344 assertTrue("Wrong result for multiplier 100: " + result, result 1345 .longValue() == 92233720368547758L); 1346 1347 format.setMultiplier(1000); 1348 result = format.parse("9223372036854775807", new ParsePosition(0)); 1349 assertTrue("Wrong result type multiplier 1000: " + result, result 1350 .getClass() == Long.class); 1351 assertTrue("Wrong result for multiplier 1000: " + result, result 1352 .longValue() == 9223372036854776L); 1353 1354 format.setMultiplier(10000); 1355 result = format.parse("9223372036854775807", new ParsePosition(0)); 1356 assertTrue("Wrong result type multiplier 10000: " + result, result 1357 .getClass() == Double.class); 1358 assertTrue("Wrong result for multiplier 10000: " + result, result 1359 .doubleValue() == 922337203685477.5807d); 1360 1361 } 1362 1363 /** 1364 * @tests java.text.DecimalFormat#setDecimalFormatSymbols(java.text.DecimalFormatSymbols) 1365 */ 1366 public void test_setDecimalFormatSymbolsLjava_text_DecimalFormatSymbols() { 1367 DecimalFormat df = new DecimalFormat("###0.##"); 1368 DecimalFormatSymbols dfs = new DecimalFormatSymbols(); 1369 dfs.setDecimalSeparator('@'); 1370 df.setDecimalFormatSymbols(dfs); 1371 assertTrue("Not set", df.getDecimalFormatSymbols().equals(dfs)); 1372 assertEquals("Symbols not used", "1@2", df.format(1.2)); 1373 1374 // The returned symbols may be cloned in two spots 1375 // 1. When set 1376 // 2. When returned 1377 DecimalFormat format = new DecimalFormat(); 1378 DecimalFormatSymbols symbols = new DecimalFormatSymbols(); 1379 format.setDecimalFormatSymbols(symbols); 1380 DecimalFormatSymbols symbolsOut = format.getDecimalFormatSymbols(); 1381 assertNotSame(symbols, symbolsOut); 1382 } 1383 1384 /** 1385 * @tests java.text.DecimalFormat#setDecimalSeparatorAlwaysShown(boolean) 1386 */ 1387 public void test_setDecimalSeparatorAlwaysShownZ() { 1388 DecimalFormat df = new DecimalFormat("###0.##", 1389 new DecimalFormatSymbols(Locale.US)); 1390 assertEquals("Wrong default result", "5", df.format(5)); 1391 df.setDecimalSeparatorAlwaysShown(true); 1392 assertTrue("Not set", df.isDecimalSeparatorAlwaysShown()); 1393 assertEquals("Wrong set result", "7.", df.format(7)); 1394 } 1395 1396 /** 1397 * @tests java.text.DecimalFormat#setCurrency(java.util.Currency) 1398 */ 1399 public void test_setCurrencyLjava_util_Currency() { 1400 Locale locale = Locale.CANADA; 1401 DecimalFormat df = ((DecimalFormat) NumberFormat 1402 .getCurrencyInstance(locale)); 1403 1404 try { 1405 df.setCurrency(null); 1406 fail("Expected NullPointerException"); 1407 } catch (NullPointerException e) { 1408 } 1409 1410 Currency currency = Currency.getInstance("AED"); 1411 df.setCurrency(currency); 1412 assertTrue("Returned incorrect currency", currency == df.getCurrency()); 1413 assertTrue("Returned incorrect currency symbol", currency.getSymbol( 1414 locale) 1415 .equals(df.getDecimalFormatSymbols().getCurrencySymbol())); 1416 assertTrue("Returned incorrect international currency symbol", currency 1417 .getCurrencyCode().equals( 1418 df.getDecimalFormatSymbols() 1419 .getInternationalCurrencySymbol())); 1420 } 1421 1422 /** 1423 * @tests java.text.DecimalFormat#setGroupingSize(int) 1424 */ 1425 public void test_setGroupingSizeI() { 1426 DecimalFormat df = new DecimalFormat("###0.##", 1427 new DecimalFormatSymbols(Locale.ENGLISH)); 1428 df.setGroupingUsed(true); 1429 df.setGroupingSize(2); 1430 assertEquals("Value not set", 2, df.getGroupingSize()); 1431 String result = df.format(123); 1432 assertTrue("Invalid format:" + result, result.equals("1,23")); 1433 } 1434 1435 /** 1436 * @tests java.text.DecimalFormat#setMaximumFractionDigits(int) 1437 */ 1438 public void test_setMaximumFractionDigitsI() { 1439 DecimalFormat df = new DecimalFormat("###0.##", 1440 new DecimalFormatSymbols(Locale.US)); 1441 df.setMaximumFractionDigits(3); 1442 assertEquals("Not set", 3, df.getMaximumFractionDigits()); 1443 assertEquals("Wrong maximum", "1.235", df.format(1.23456)); 1444 df.setMinimumFractionDigits(4); 1445 assertEquals("Not changed", 4, df.getMaximumFractionDigits()); 1446 assertEquals("Incorrect fraction", "456.0000", df.format(456)); 1447 } 1448 1449 /** 1450 * @tests java.text.DecimalFormat#setMaximumIntegerDigits(int) 1451 */ 1452 public void test_setMaximumIntegerDigitsI() { 1453 DecimalFormat df = new DecimalFormat("###0.##"); 1454 df.setMaximumIntegerDigits(2); 1455 assertEquals("Not set", 2, df.getMaximumIntegerDigits()); 1456 assertEquals("Wrong maximum", "34", df.format(1234)); 1457 df.setMinimumIntegerDigits(4); 1458 assertEquals("Not changed", 4, df.getMaximumIntegerDigits()); 1459 assertEquals("Incorrect integer", "0026", df.format(26)); 1460 } 1461 1462 /** 1463 * @tests java.text.DecimalFormat#setMinimumFractionDigits(int) 1464 */ 1465 public void test_setMinimumFractionDigitsI() { 1466 DecimalFormat df = new DecimalFormat("###0.##", 1467 new DecimalFormatSymbols(Locale.US)); 1468 df.setMinimumFractionDigits(4); 1469 assertEquals("Not set", 4, df.getMinimumFractionDigits()); 1470 assertEquals("Wrong minimum", "1.2300", df.format(1.23)); 1471 df.setMaximumFractionDigits(2); 1472 assertEquals("Not changed", 2, df.getMinimumFractionDigits()); 1473 assertEquals("Incorrect fraction", "456.00", df.format(456)); 1474 } 1475 1476 /** 1477 * @tests java.text.DecimalFormat#setMinimumIntegerDigits(int) 1478 */ 1479 public void test_setMinimumIntegerDigitsI() { 1480 DecimalFormat df = new DecimalFormat("###0.##", 1481 new DecimalFormatSymbols(Locale.US)); 1482 df.setMinimumIntegerDigits(3); 1483 assertEquals("Not set", 3, df.getMinimumIntegerDigits()); 1484 assertEquals("Wrong minimum", "012", df.format(12)); 1485 df.setMaximumIntegerDigits(2); 1486 assertEquals("Not changed", 2, df.getMinimumIntegerDigits()); 1487 assertEquals("Incorrect integer", "00.7", df.format(0.7)); 1488 } 1489 1490 /** 1491 * @tests java.text.DecimalFormat#setMultiplier(int) 1492 */ 1493 //FIXME This test fails on Harmony ClassLibrary 1494 public void test_setMultiplierI() { 1495 DecimalFormat df = new DecimalFormat("###0.##"); 1496 df.setMultiplier(10); 1497 assertEquals("Wrong multiplier", 10, df.getMultiplier()); 1498 assertEquals("Wrong format", "50", df.format(5)); 1499 assertEquals("Wrong parse", 5, df.parse("50", new ParsePosition(0)) 1500 .intValue()); 1501 1502 // regression test for HARMONY-879 1503 df.setMultiplier(-1); 1504 assertEquals("Wrong multiplier for negative value", -1, df.getMultiplier()); 1505 } 1506 1507 /** 1508 * @tests serialization/deserialization compatibility. 1509 */ 1510 public void testSerializationSelf() throws Exception { 1511 SerializationTest.verifySelf(new DecimalFormat()); 1512 } 1513 1514 /** 1515 * @tests serialization compatibility with RI 1516 */ 1517 public void test_serializationHarmonyRICompatible() throws Exception { 1518 NumberFormat nf = NumberFormat.getInstance(Locale.FRANCE); 1519 1520 DecimalFormat df = null; 1521 if (!(nf instanceof DecimalFormat)) { 1522 throw new Error("This NumberFormat is not a DecimalFormat"); 1523 1524 } 1525 df = (DecimalFormat) nf; 1526 1527 ObjectInputStream oinput = null; 1528 1529 DecimalFormat deserializedDF = null; 1530 1531 try { 1532 oinput = new ObjectInputStream(this.getClass().getResource( 1533 "/serialization/java/text/DecimalFormat.ser").openStream()); 1534 deserializedDF = (DecimalFormat) oinput.readObject(); 1535 } finally { 1536 try { 1537 if (null != oinput) { 1538 oinput.close(); 1539 } 1540 } catch (Exception e) { 1541 // ignore 1542 } 1543 } 1544 1545 assertEquals(df.getNegativePrefix(), deserializedDF.getNegativePrefix()); 1546 assertEquals(df.getNegativeSuffix(), deserializedDF.getNegativeSuffix()); 1547 assertEquals(df.getPositivePrefix(), deserializedDF.getPositivePrefix()); 1548 assertEquals(df.getPositiveSuffix(), deserializedDF.getPositiveSuffix()); 1549 assertEquals(df.getCurrency(), deserializedDF.getCurrency()); 1550 1551 DecimalFormatSymbolsTest.assertDecimalFormatSymbolsRIFrance(deserializedDF.getDecimalFormatSymbols()); 1552 1553 assertEquals(df.getGroupingSize(), df.getGroupingSize()); 1554 assertEquals(df.getMaximumFractionDigits(), deserializedDF 1555 .getMaximumFractionDigits()); 1556 1557 assertEquals(df.getMaximumIntegerDigits(), deserializedDF 1558 .getMaximumIntegerDigits()); 1559 1560 assertEquals(df.getMinimumFractionDigits(), deserializedDF 1561 .getMinimumFractionDigits()); 1562 assertEquals(df.getMinimumIntegerDigits(), deserializedDF 1563 .getMinimumIntegerDigits()); 1564 assertEquals(df.getMultiplier(), deserializedDF.getMultiplier()); 1565 1566 // Deliberately omitted this assertion. Since different data resource 1567 // will cause the assertion fail. 1568 // assertEquals(df, deserializedDF); 1569 1570 } 1571 1572 /** 1573 * Test whether DecimalFormat can parse Positive infinity correctly 1574 */ 1575 public void testParseInfinityBigDecimalFalse() { 1576 // Regression test for HARMONY-106 1577 DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance(); 1578 DecimalFormatSymbols symbols = new DecimalFormatSymbols(); 1579 Number number = format.parse(symbols.getInfinity(), 1580 new ParsePosition(0)); 1581 assertTrue(number instanceof Double); 1582 assertTrue(Double.isInfinite(number.doubleValue())); 1583 } 1584 1585 /** 1586 * Test whether DecimalFormat can parse Negative infinity correctly 1587 */ 1588 public void testParseMinusInfinityBigDecimalFalse() { 1589 // Regression test for HARMONY-106 1590 DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance(); 1591 DecimalFormatSymbols symbols = new DecimalFormatSymbols(); 1592 Number number = format.parse("-" + symbols.getInfinity(), 1593 new ParsePosition(0)); 1594 assertTrue(number instanceof Double); 1595 assertTrue(Double.isInfinite(number.doubleValue())); 1596 } 1597 1598 /** 1599 * Test if setDecimalFormatSymbols method wont throw NullPointerException 1600 * when it is called with null parameter. 1601 */ 1602 public void testSetDecimalFormatSymbolsAsNull(){ 1603 // Regression for HARMONY-1070 1604 DecimalFormat format = (DecimalFormat)DecimalFormat.getInstance(); 1605 format.setDecimalFormatSymbols(null); 1606 } 1607 1608 /** 1609 * @tests java.text.DecimalFormat#formatToCharacterIterator(java.lang.Object) 1610 */ 1611 public void test_formatToCharacterIteratorLjava_lang_Object__ArithmeticException() { 1612 DecimalFormat decimalFormat = (DecimalFormat) DecimalFormat 1613 .getInstance(Locale.US); 1614 decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); 1615 decimalFormat.setMaximumFractionDigits(0); 1616 try { 1617 // when rounding is needed, but RoundingMode is set to RoundingMode.UNNECESSARY, throw ArithmeticException 1618 decimalFormat.formatToCharacterIterator(new Double(1.5)); 1619 fail("ArithmeticException expected"); 1620 } catch (ArithmeticException e) { 1621 // expected 1622 } 1623 } 1624 1625 /** 1626 * @tests java.text.DecimalFormat#format(double, java.lang.StringBuffer, 1627 * java.text.FieldPosition) 1628 */ 1629 public void test_formatDLjava_lang_StringBufferLjava_text_FieldPosition_ArithmeticException() { 1630 DecimalFormat decimalFormat = (DecimalFormat) DecimalFormat 1631 .getInstance(Locale.US); 1632 decimalFormat.setMaximumFractionDigits(0); 1633 decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); 1634 1635 try { 1636 // when rounding is needed, but RoundingMode is set to RoundingMode.UNNECESSARY, throw ArithmeticException 1637 decimalFormat 1638 .format(11.5, new StringBuffer(), new FieldPosition(0)); 1639 fail("ArithmeticException expected"); 1640 } catch (ArithmeticException e) { 1641 // expected 1642 } 1643 } 1644 1645 /** 1646 * @tests java.text.DecimalFormat#format(long, java.lang.StringBuffer, 1647 * java.text.FieldPosition) 1648 */ 1649 public void test_formatJLjava_lang_StringBufferLjava_text_FieldPosition_ArithmeticException() { 1650 1651 final DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US); 1652 DecimalFormat decimalFormat = new DecimalFormat("00.0#E0", dfs); 1653 1654 decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); 1655 try { 1656 // when rounding is needed, but RoundingMode is set to RoundingMode.UNNECESSARY, throw ArithmeticException 1657 decimalFormat.format(99999, new StringBuffer(), 1658 new FieldPosition(0)); 1659 fail("ArithmeticException expected"); 1660 } catch (ArithmeticException e) { 1661 // expected 1662 } 1663 } 1664 1665 /** 1666 * @tests java.text.DecimalFormat#getRoundingMode() 1667 */ 1668 public void test_GetRoundingMode() { 1669 1670 // get the default RoundingMode of this DecimalFormat 1671 DecimalFormat decimalFormat = (DecimalFormat) DecimalFormat 1672 .getInstance(Locale.US); 1673 1674 // the default RoundingMode is HALF_EVEN 1675 assertEquals("Incorrect default RoundingMode", decimalFormat.getRoundingMode(), RoundingMode.HALF_EVEN); 1676 1677 // set RoundingMode.HALF_DOWN of this DecimalFormat 1678 decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); 1679 assertEquals("Returned incorrect RoundingMode", decimalFormat 1680 .getRoundingMode(), RoundingMode.HALF_DOWN); 1681 1682 } 1683 1684 /** 1685 * @tests java.text.DecimalFormat#setRoundingMode(java.math.RoundingMode) 1686 */ 1687 public void test_SetRoudingMode_Ljava_math_RoundingMode() { 1688 DecimalFormat decimalFormat = (DecimalFormat) DecimalFormat 1689 .getInstance(Locale.US); 1690 // ignore the fraction part of a given value 1691 decimalFormat.setMaximumFractionDigits(0); 1692 1693 // set RoundingMode.HALF_DOWN of this DecimalFormat and test its 1694 // behavior 1695 decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); 1696 String result = decimalFormat.format(11.3); 1697 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", 1698 "11", result); 1699 1700 result = decimalFormat.format(11.5); 1701 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", 1702 "11", result); 1703 1704 result = decimalFormat.format(11.6); 1705 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", 1706 "12", result); 1707 1708 // set RoundingMode.CEILING of this DecimalFormat and test its 1709 // behavior 1710 decimalFormat.setRoundingMode(RoundingMode.CEILING); 1711 result = decimalFormat.format(11.3); 1712 assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", 1713 "12", result); 1714 1715 result = decimalFormat.format(-11.5); 1716 assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", 1717 "-11", result); 1718 1719 // set RoundingMode.DOWN of this DecimalFormat and test its 1720 // behavior 1721 decimalFormat.setRoundingMode(RoundingMode.DOWN); 1722 result = decimalFormat.format(11.3); 1723 assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", 1724 "11", result); 1725 1726 result = decimalFormat.format(-11.5); 1727 assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", 1728 "-11", result); 1729 1730 result = decimalFormat.format(0); 1731 assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", 1732 "0", result); 1733 1734 // set RoundingMode.FLOOR of this DecimalFormat and test its 1735 // behavior 1736 decimalFormat.setRoundingMode(RoundingMode.FLOOR); 1737 result = decimalFormat.format(11.3); 1738 assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", 1739 "11", result); 1740 1741 result = decimalFormat.format(-11.5); 1742 assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", 1743 "-12", result); 1744 1745 result = decimalFormat.format(0); 1746 assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", 1747 "0", result); 1748 1749 // set RoundingMode.HALF_EVEN of this DecimalFormat and test its 1750 // behavior 1751 decimalFormat.setRoundingMode(RoundingMode.HALF_EVEN); 1752 result = decimalFormat.format(5.5); 1753 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", 1754 "6", result); 1755 1756 result = decimalFormat.format(-5.5); 1757 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", 1758 "-6", result); 1759 1760 result = decimalFormat.format(0.2); 1761 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", 1762 "0", result); 1763 1764 // set RoundingMode.HALF_UP of this DecimalFormat and test its 1765 // behavior 1766 decimalFormat.setRoundingMode(RoundingMode.HALF_UP); 1767 result = decimalFormat.format(5.5); 1768 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 1769 "6", result); 1770 1771 result = decimalFormat.format(-5.5); 1772 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 1773 "-6", result); 1774 1775 result = decimalFormat.format(0.2); 1776 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 1777 "0", result); 1778 1779 // the following assertion will fail on RI implementation, since the 1780 // implementation of ICU and RI are not identical. 1781 result = decimalFormat.format(-0.2); 1782 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 1783 "0", result); 1784 1785 // set RoundingMode.UP of this DecimalFormat and test its 1786 // behavior 1787 decimalFormat.setRoundingMode(RoundingMode.UP); 1788 result = decimalFormat.format(5.5); 1789 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 1790 "6", result); 1791 1792 result = decimalFormat.format(-5.5); 1793 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 1794 "-6", result); 1795 1796 result = decimalFormat.format(0.2); 1797 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 1798 "1", result); 1799 1800 result = decimalFormat.format(-0.2); 1801 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 1802 "-1", result); 1803 1804 // set RoundingMode.UNNECESSARY of this DecimalFormat and test its 1805 // behavior 1806 decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); 1807 1808 try { 1809 // when rounding is needed but RoundingMode is set to RoundingMode.UNNECESSARY, throw ArithmeticException 1810 result = decimalFormat.format(5.5); 1811 fail("ArithmeticException expected: RoundingMode.UNNECESSARY"); 1812 } catch (ArithmeticException e) { 1813 // expected 1814 } 1815 1816 result = decimalFormat.format(1.0); 1817 assertEquals( 1818 "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", 1819 "1", result); 1820 1821 result = decimalFormat.format(-1.0); 1822 assertEquals( 1823 "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", 1824 "-1", result); 1825 1826 try { 1827 // when the given RoundingMode is null, throw NullPointerException 1828 decimalFormat.setRoundingMode(null); 1829 fail("NullPointerException expected"); 1830 } catch (NullPointerException e) { 1831 // expected 1832 } 1833 1834 // set MaxFractionDigits to 3, test different DecimalFormat format 1835 // function with differnt RoundingMode 1836 decimalFormat.setMaximumFractionDigits(3); 1837 1838 // set RoundingMode.HALF_DOWN of this DecimalFormat and test its 1839 // behavior 1840 decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); 1841 result = decimalFormat.format(11.5653); 1842 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", 1843 "11.565", result); 1844 1845 result = decimalFormat.format(11.5655); 1846 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", 1847 "11.565", result); 1848 1849 result = decimalFormat.format(11.5656); 1850 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", 1851 "11.566", result); 1852 1853 // set RoundingMode.CEILING of this DecimalFormat and test its 1854 // behavior 1855 decimalFormat.setRoundingMode(RoundingMode.CEILING); 1856 result = decimalFormat.format(11.5653); 1857 assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", 1858 "11.566", result); 1859 1860 result = decimalFormat.format(-11.5653); 1861 assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", 1862 "-11.565", result); 1863 1864 // set RoundingMode.DOWN of this DecimalFormat and test its 1865 // behavior 1866 decimalFormat.setRoundingMode(RoundingMode.DOWN); 1867 result = decimalFormat.format(11.5653); 1868 assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", 1869 "11.565", result); 1870 1871 result = decimalFormat.format(-11.5653); 1872 assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", 1873 "-11.565", result); 1874 1875 result = decimalFormat.format(0); 1876 assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", 1877 "0", result); 1878 1879 // set RoundingMode.FLOOR of this DecimalFormat and test its 1880 // behavior 1881 decimalFormat.setRoundingMode(RoundingMode.FLOOR); 1882 result = decimalFormat.format(11.5653); 1883 assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", 1884 "11.565", result); 1885 1886 result = decimalFormat.format(-11.5655); 1887 assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", 1888 "-11.566", result); 1889 1890 result = decimalFormat.format(0); 1891 assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", 1892 "0", result); 1893 1894 // set RoundingMode.HALF_EVEN of this DecimalFormat and test its 1895 // behavior 1896 decimalFormat.setRoundingMode(RoundingMode.HALF_EVEN); 1897 result = decimalFormat.format(11.5653); 1898 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", 1899 "11.565", result); 1900 1901 result = decimalFormat.format(-11.5655); 1902 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", 1903 "-11.566", result); 1904 1905 result = decimalFormat.format(11.5656); 1906 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", 1907 "11.566", result); 1908 1909 // set RoundingMode.HALF_UP of this DecimalFormat and test its 1910 // behavior 1911 decimalFormat.setRoundingMode(RoundingMode.HALF_UP); 1912 result = decimalFormat.format(11.5653); 1913 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 1914 "11.565", result); 1915 1916 result = decimalFormat.format(-11.5655); 1917 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 1918 "-11.566", result); 1919 1920 result = decimalFormat.format(11.5656); 1921 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 1922 "11.566", result); 1923 1924 // set RoundingMode.UP of this DecimalFormat and test its 1925 // behavior 1926 decimalFormat.setRoundingMode(RoundingMode.UP); 1927 result = decimalFormat.format(11.5653); 1928 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 1929 "11.566", result); 1930 1931 result = decimalFormat.format(-11.5655); 1932 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 1933 "-11.566", result); 1934 1935 // set RoundingMode.UNNECESSARY of this DecimalFormat and test its 1936 // behavior 1937 decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); 1938 result = decimalFormat.format(-11.565); 1939 assertEquals( 1940 "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", 1941 "-11.565", result); 1942 1943 result = decimalFormat.format(11.565); 1944 assertEquals( 1945 "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", 1946 "11.565", result); 1947 1948 // when setting MaxFractionDigits to negative value -2, default it as 1949 // zero, test different DecimalFormat format 1950 // function with differnt RoundingMode 1951 decimalFormat.setMaximumFractionDigits(-2); 1952 1953 // set RoundingMode.HALF_DOWN of this DecimalFormat and test its 1954 // behavior 1955 decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); 1956 result = decimalFormat.format(11.3); 1957 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", 1958 "11", result); 1959 1960 result = decimalFormat.format(11.5); 1961 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", 1962 "11", result); 1963 1964 result = decimalFormat.format(11.6); 1965 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", 1966 "12", result); 1967 1968 // set RoundingMode.CEILING of this DecimalFormat and test its 1969 // behavior 1970 decimalFormat.setRoundingMode(RoundingMode.CEILING); 1971 result = decimalFormat.format(11.3); 1972 assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", 1973 "12", result); 1974 1975 result = decimalFormat.format(-11.5); 1976 assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", 1977 "-11", result); 1978 1979 // set RoundingMode.DOWN of this DecimalFormat and test its 1980 // behavior 1981 decimalFormat.setRoundingMode(RoundingMode.DOWN); 1982 result = decimalFormat.format(11.3); 1983 assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", 1984 "11", result); 1985 1986 result = decimalFormat.format(-11.5); 1987 assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", 1988 "-11", result); 1989 1990 result = decimalFormat.format(0); 1991 assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", 1992 "0", result); 1993 1994 // set RoundingMode.FLOOR of this DecimalFormat and test its 1995 // behavior 1996 decimalFormat.setRoundingMode(RoundingMode.FLOOR); 1997 result = decimalFormat.format(11.3); 1998 assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", 1999 "11", result); 2000 2001 result = decimalFormat.format(-11.5); 2002 assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", 2003 "-12", result); 2004 2005 result = decimalFormat.format(0); 2006 assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", 2007 "0", result); 2008 2009 // set RoundingMode.HALF_EVEN of this DecimalFormat and test its 2010 // behavior 2011 decimalFormat.setRoundingMode(RoundingMode.HALF_EVEN); 2012 result = decimalFormat.format(5.5); 2013 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", 2014 "6", result); 2015 2016 result = decimalFormat.format(-5.5); 2017 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", 2018 "-6", result); 2019 2020 result = decimalFormat.format(0.2); 2021 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", 2022 "0", result); 2023 2024 // set RoundingMode.HALF_UP of this DecimalFormat and test its 2025 // behavior 2026 decimalFormat.setRoundingMode(RoundingMode.HALF_UP); 2027 result = decimalFormat.format(5.5); 2028 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 2029 "6", result); 2030 2031 result = decimalFormat.format(-5.5); 2032 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 2033 "-6", result); 2034 2035 result = decimalFormat.format(0.2); 2036 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 2037 "0", result); 2038 2039 result = decimalFormat.format(-0.2); 2040 assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", 2041 "0", result); 2042 2043 // set RoundingMode.UP of this DecimalFormat and test its 2044 // behavior 2045 decimalFormat.setRoundingMode(RoundingMode.UP); 2046 result = decimalFormat.format(5.5); 2047 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 2048 "6", result); 2049 2050 result = decimalFormat.format(-5.5); 2051 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 2052 "-6", result); 2053 2054 result = decimalFormat.format(0.2); 2055 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 2056 "1", result); 2057 2058 result = decimalFormat.format(-0.2); 2059 assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", 2060 "-1", result); 2061 2062 // set RoundingMode.UNNECESSARY of this DecimalFormat and test its 2063 // behavior 2064 decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); 2065 2066 result = decimalFormat.format(1.0); 2067 assertEquals( 2068 "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", 2069 "1", result); 2070 2071 result = decimalFormat.format(-1.0); 2072 assertEquals( 2073 "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", 2074 "-1", result); 2075 2076 // Regression for HARMONY-6485 2077 // Test with applyPattern call after setRoundingMode 2078 2079 // set RoundingMode.HALF_UP of this DecimalFormat and test its 2080 // behavior 2081 decimalFormat.setRoundingMode(RoundingMode.HALF_UP); 2082 decimalFormat.applyPattern(".##"); 2083 result = decimalFormat.format(0.125); 2084 assertEquals( 2085 "Incorrect RoundingMode behavior after applyPattern", 2086 ".13", result); 2087 result = decimalFormat.format(0.255); 2088 assertEquals( 2089 "Incorrect RoundingMode behavior after applyPattern", 2090 ".26", result); 2091 result = decimalFormat.format(0.732); 2092 assertEquals( 2093 "Incorrect RoundingMode behavior after applyPattern", 2094 ".73", result); 2095 result = decimalFormat.format(0.467); 2096 assertEquals( 2097 "Incorrect RoundingMode behavior after applyPattern", 2098 ".47", result); 2099 2100 // set RoundingMode.HALF_DOWN of this DecimalFormat and test its 2101 // behavior 2102 decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); 2103 decimalFormat.applyPattern(".##"); 2104 result = decimalFormat.format(0.125); 2105 assertEquals( 2106 "Incorrect RoundingMode behavior after applyPattern", 2107 ".12", result); 2108 result = decimalFormat.format(0.255); 2109 assertEquals( 2110 "Incorrect RoundingMode behavior after applyPattern", 2111 ".25", result); 2112 result = decimalFormat.format(0.732); 2113 assertEquals( 2114 "Incorrect RoundingMode behavior after applyPattern", 2115 ".73", result); 2116 result = decimalFormat.format(0.467); 2117 assertEquals( 2118 "Incorrect RoundingMode behavior after applyPattern", 2119 ".47", result); 2120 2121 // set RoundingMode.UP of this DecimalFormat and test its 2122 // behavior 2123 decimalFormat.setRoundingMode(RoundingMode.UP); 2124 decimalFormat.applyPattern(".##"); 2125 result = decimalFormat.format(0.125); 2126 assertEquals( 2127 "Incorrect RoundingMode behavior after applyPattern", 2128 ".13", result); 2129 result = decimalFormat.format(0.255); 2130 assertEquals( 2131 "Incorrect RoundingMode behavior after applyPattern", 2132 ".26", result); 2133 result = decimalFormat.format(0.732); 2134 assertEquals( 2135 "Incorrect RoundingMode behavior after applyPattern", 2136 ".74", result); 2137 result = decimalFormat.format(0.467); 2138 assertEquals( 2139 "Incorrect RoundingMode behavior after applyPattern", 2140 ".47", result); 2141 2142 // set RoundingMode.DOWN of this DecimalFormat and test its 2143 // behavior 2144 decimalFormat.setRoundingMode(RoundingMode.DOWN); 2145 decimalFormat.applyPattern(".##"); 2146 result = decimalFormat.format(0.125); 2147 assertEquals( 2148 "Incorrect RoundingMode behavior after applyPattern", 2149 ".12", result); 2150 result = decimalFormat.format(0.255); 2151 assertEquals( 2152 "Incorrect RoundingMode behavior after applyPattern", 2153 ".25", result); 2154 result = decimalFormat.format(0.732); 2155 assertEquals( 2156 "Incorrect RoundingMode behavior after applyPattern", 2157 ".73", result); 2158 result = decimalFormat.format(0.467); 2159 assertEquals( 2160 "Incorrect RoundingMode behavior after applyPattern", 2161 ".46", result); 2162 2163 // set RoundingMode.HALF_EVEN of this DecimalFormat and test its 2164 // behavior 2165 decimalFormat.setRoundingMode(RoundingMode.HALF_EVEN); 2166 decimalFormat.applyPattern(".##"); 2167 result = decimalFormat.format(0.125); 2168 assertEquals( 2169 "Incorrect RoundingMode behavior after applyPattern", 2170 ".12", result); 2171 result = decimalFormat.format(0.255); 2172 assertEquals( 2173 "Incorrect RoundingMode behavior after applyPattern", 2174 ".26", result); 2175 result = decimalFormat.format(0.732); 2176 assertEquals( 2177 "Incorrect RoundingMode behavior after applyPattern", 2178 ".73", result); 2179 result = decimalFormat.format(0.467); 2180 assertEquals( 2181 "Incorrect RoundingMode behavior after applyPattern", 2182 ".47", result); 2183 } 2184} 2185