/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.harmony.tests.java.text; import java.io.ObjectInputStream; import java.math.BigDecimal; import java.math.BigInteger; import java.math.RoundingMode; import java.text.AttributedCharacterIterator; import java.text.DecimalFormat; import java.text.DecimalFormatSymbols; import java.text.FieldPosition; import java.text.NumberFormat; import java.text.ParsePosition; import java.util.BitSet; import java.util.Currency; import java.util.Locale; import junit.framework.TestCase; import org.apache.harmony.testframework.serialization.SerializationTest; public class DecimalFormatTest extends TestCase { // https://code.google.com/p/android/issues/detail?id=59600 public void test_empty_NaN() throws Exception { DecimalFormatSymbols dfs = new DecimalFormatSymbols(); dfs.setNaN(""); DecimalFormat df = new DecimalFormat(); df.setDecimalFormatSymbols(dfs); df.format(Double.NaN); } public void testAttributedCharacterIterator() throws Exception { // Regression for http://issues.apache.org/jira/browse/HARMONY-333 AttributedCharacterIterator iterator = new DecimalFormat().formatToCharacterIterator(new Integer(1)); assertNotNull(iterator); assertFalse("attributes should exist", iterator.getAttributes().isEmpty()); } public void test_isParseBigDecimalLjava_lang_Boolean_isParseIntegerOnlyLjava_lang_Boolean() throws Exception { // parseBigDecimal default to false DecimalFormat form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); assertFalse(form.isParseBigDecimal()); form.setParseBigDecimal(true); assertTrue(form.isParseBigDecimal()); Number result = form.parse("123.123"); assertEquals(new BigDecimal("123.123"), result); form.setParseBigDecimal(false); assertFalse(form.isParseBigDecimal()); result = form.parse("123.123"); assertFalse(result instanceof BigDecimal); } public void test_isParseIntegerOnly() throws Exception { DecimalFormat format = new DecimalFormat(); assertFalse("Default value of isParseIntegerOnly is true", format.isParseIntegerOnly()); format.setParseIntegerOnly(true); assertTrue(format.isParseIntegerOnly()); Number result = format.parse("123.123"); assertEquals(new Long("123"), result); format.setParseIntegerOnly(false); assertFalse(format.isParseIntegerOnly()); result = format.parse("123.123"); assertEquals(new Double("123.123"), result); } // Test the type of the returned object public void test_parseLjava_lang_String_Ljava_text_ParsePosition() { DecimalFormat form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); Number number = form.parse("23.1", new ParsePosition(0)); assertTrue(number instanceof Double); // Test parsed object of type double when // parseBigDecimal is set to true form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); number = form.parse("23.1", new ParsePosition(0)); assertTrue(number instanceof Double); form.setParseBigDecimal(true); number = form.parse("23.1", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); assertEquals(new BigDecimal("23.1"), number); // When parseIntegerOnly set to true, all numbers will be parsed // into Long unless the value is out of the bound of Long or // some special values such as NaN or Infinity. form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); form.setParseIntegerOnly(true); number = form.parse("23.1f", new ParsePosition(0)); assertTrue(number instanceof Long); number = form.parse("23.0", new ParsePosition(0)); assertTrue(number instanceof Long); number = form.parse("-0.0", new ParsePosition(0)); assertTrue(number instanceof Long); assertTrue(new Long(0).equals(number)); // The last integers representable by long. number = form.parse("9223372036854775807.00", new ParsePosition(0)); assertEquals(Long.class, number.getClass()); number = form.parse("9223372036854775808.00", new ParsePosition(0)); assertEquals(Double.class, number.getClass()); // The first integers that need to be represented by double. number = form.parse("-9223372036854775808.00", new ParsePosition(0)); assertEquals(Long.class, number.getClass()); number = form.parse("-9223372036854775809.00", new ParsePosition(0)); assertEquals(Double.class, number.getClass()); // Even if parseIntegerOnly is set to true, NaN will be parsed to Double form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); form.setParseIntegerOnly(true); DecimalFormatSymbols symbols = new DecimalFormatSymbols(); number = form.parse(symbols.getNaN(), new ParsePosition(0)); assertTrue(number instanceof Double); // Even if parseIntegerOnly is set to true, Infinity will still be // parsed to Double form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); form.setParseIntegerOnly(true); symbols = new DecimalFormatSymbols(); number = form.parse(symbols.getInfinity(), new ParsePosition(0)); assertTrue(number instanceof Double); // ParseBigDecimal take precedence of parseBigInteger form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); form.setParseIntegerOnly(true); form.setParseBigDecimal(true); number = form.parse("23.1f", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); number = form.parse("23.0", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); number = form.parse("-92,233,720,368,547,758,080.00", new ParsePosition(0)); assertFalse(number instanceof BigInteger); assertTrue(number instanceof BigDecimal); // Test whether the parsed object is of type float. (To be specific, // they are of type Double) form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); number = form.parse("23.1f", new ParsePosition(0)); assertTrue(number instanceof Double); form.setParseBigDecimal(true); number = form.parse("23.1f", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); assertEquals(new BigDecimal("23.1"), number); // Integer will be parsed to Long, unless parseBigDecimal is set to true form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); number = form.parse("123", new ParsePosition(0)); assertTrue(number instanceof Long); form.setParseBigDecimal(true); number = form.parse("123", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); assertEquals(new BigDecimal("123"), number); // NaN will be parsed to Double, no matter parseBigDecimal set or not. form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); symbols = new DecimalFormatSymbols(); number = form.parse(symbols.getNaN() + "", new ParsePosition(0)); assertTrue(number instanceof Double); form.setParseBigDecimal(true); number = form.parse(symbols.getNaN() + "", new ParsePosition(0)); assertTrue(number instanceof Double); // Infinity will be parsed to Double, no matter parseBigDecimal set or // not. form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); symbols = new DecimalFormatSymbols(); number = form.parse(symbols.getInfinity(), new ParsePosition(0)); assertTrue(number instanceof Double); assertEquals("Infinity", number.toString()); // When set bigDecimal to true, the result of parsing infinity form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); symbols = new DecimalFormatSymbols(); form.setParseBigDecimal(true); number = form.parse(symbols.getInfinity(), new ParsePosition(0)); assertTrue(number instanceof Double); assertEquals("Infinity", number.toString()); // Negative infinity will be parsed to double no matter parseBigDecimal // set or not form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); symbols = new DecimalFormatSymbols(); number = form.parse("-" + symbols.getInfinity(), new ParsePosition(0)); assertTrue(number instanceof Double); assertEquals("-Infinity", number.toString()); // When set bigDecimal to true, the result of parsing minus infinity form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); symbols = new DecimalFormatSymbols(); form.setParseBigDecimal(true); number = form.parse("-" + symbols.getInfinity(), new ParsePosition(0)); assertTrue(number instanceof Double); assertEquals("-Infinity", number.toString()); // -0.0 will be parsed to different type according to the combination of // parseBigDecimal and parseIntegerOnly form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); // parseBigDecimal == true; // parseIntegerOnly == false; form.setParseBigDecimal(true); number = form.parse("-0", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); number = form.parse("-0.0", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); // parseBigDecimal == false; // parseIntegerOnly == true; form.setParseBigDecimal(false); form.setParseIntegerOnly(true); number = form.parse("-0", new ParsePosition(0)); assertTrue(number instanceof Long); number = form.parse("-0.0", new ParsePosition(0)); assertTrue(number instanceof Long); // parseBigDecimal == false; // parseIntegerOnly == false; form.setParseBigDecimal(false); form.setParseIntegerOnly(false); number = form.parse("-0", new ParsePosition(0)); assertTrue(number instanceof Double); number = form.parse("-0.0", new ParsePosition(0)); assertTrue(number instanceof Double); // parseBigDecimal == true; // parseIntegerOnly == true; // parseBigDecimal take precedence of parseBigInteger form.setParseBigDecimal(true); form.setParseIntegerOnly(true); number = form.parse("-0", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); number = form.parse("-0.0", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); number = form.parse("12.4", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); // When parseBigDecimal is set to false, no matter how massive the // mantissa part of a number is, the number will be parsed into Double form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); number = form.parse("9,223,372,036,854,775,808.00", new ParsePosition(0)); assertTrue(number instanceof Double); assertEquals("9.223372036854776E18", number.toString()); number = form.parse("-92,233,720,368,547,758,080.00", new ParsePosition(0)); assertTrue(number instanceof Double); assertEquals("-9.223372036854776E19", number.toString()); // When parseBigDecimal is set to true, if mantissa part of number // exceeds Long.MAX_VALUE, the number will be parsed into BigDecimal form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); form.setParseBigDecimal(true); number = form.parse("9,223,372,036,854,775,808.00", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); assertEquals(9.223372036854776E18, number.doubleValue(), 0); number = form.parse("-92,233,720,368,547,758,080.00", new ParsePosition(0)); assertTrue(number instanceof BigDecimal); assertEquals(-9.223372036854776E19, number.doubleValue(), 0); // The minimum value of Long will be parsed to Long when parseBigDecimal // is not set ParsePosition pos = new ParsePosition(0); DecimalFormat df = new DecimalFormat(); pos = new ParsePosition(0); Number nb = df.parse("" + Long.MIN_VALUE, pos); assertTrue(nb instanceof Long); // The maximum value of Long will be parsed to Long when parseBigDecimal // is set pos = new ParsePosition(0); df = new DecimalFormat(); pos = new ParsePosition(0); nb = df.parse("" + Long.MAX_VALUE, pos); assertTrue(nb instanceof Long); // When parsing invalid string( which is neither consist of digits nor // NaN/Infinity), a null will be returned. pos = new ParsePosition(0); df = new DecimalFormat(); try { nb = df.parse("invalid", pos); assertNull(nb); } catch (NullPointerException e) { fail("Should not throw NPE"); } } public void test_parseLjava_lang_String_Ljava_text_ParsePosition_2() { DecimalFormat form = (DecimalFormat) DecimalFormat.getInstance(Locale.US); form.setParseIntegerOnly(true); form.setParseBigDecimal(true); final String doubleMax2 = "359,538,626,972,463,141,629,054,847,463,408," + "713,596,141,135,051,689,993,197,834,953,606,314,521,560,057,077," + "521,179,117,265,533,756,343,080,917,907,028,764,928,468,642,653," + "778,928,365,536,935,093,407,075,033,972,099,821,153,102,564,152," + "490,980,180,778,657,888,151,737,016,910,267,884,609,166,473,806," + "445,896,331,617,118,664,246,696,549,595,652,408,289,446,337,476," + "354,361,838,599,762,500,808,052,368,249,716,736"; Number number = form.parse(doubleMax2, new ParsePosition(0)); assertTrue(number instanceof BigDecimal); BigDecimal result = (BigDecimal)number; assertEquals(new BigDecimal(Double.MAX_VALUE).add(new BigDecimal(Double.MAX_VALUE)), result); } public void test_getMaximumFractionDigits() { NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; // getMaximumFractionDigits of NumberFormat default to 3 // getMaximumFractionDigits of DecimalFormat default to 3 assertEquals(3, nform.getMaximumFractionDigits()); assertEquals(3, form.getMaximumFractionDigits()); // Greater than 340 (critical number used to distinguish // BigInteger and BigDecimal) nform.setMaximumFractionDigits(500); assertEquals(500, nform.getMaximumFractionDigits()); assertEquals(500, form.getMaximumFractionDigits()); form.setMaximumFractionDigits(500); assertEquals(500, nform.getMaximumFractionDigits()); assertEquals(500, form.getMaximumFractionDigits()); form.format(12.3); assertEquals(500, nform.getMaximumFractionDigits()); assertEquals(500, form.getMaximumFractionDigits()); } public void test_getMinimumFractionDigits() { NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; // getMinimumFractionDigits from NumberFormat (default to 0) // getMinimumFractionDigits from DecimalFormat (default to 0) assertEquals(0, nform.getMinimumFractionDigits()); assertEquals(0, form.getMinimumFractionDigits()); // Greater than 340 (critical number used to distinguish // BigInteger and BigDecimal) nform.setMinimumFractionDigits(500); assertEquals(500, nform.getMinimumFractionDigits()); assertEquals(500, form.getMinimumFractionDigits()); form.setMaximumFractionDigits(400); assertEquals(400, nform.getMinimumFractionDigits()); assertEquals(400, form.getMinimumFractionDigits()); } //FIXME This test fails on Harmony ClassLibrary public void test_getMaximumIntegerDigits() { final int maxIntDigit = 309; // When use default locale, in this case zh_CN // the returned instance of NumberFormat is a DecimalFormat DecimalFormat form = new DecimalFormat("00.###E0"); assertEquals(2, form.getMaximumIntegerDigits()); NumberFormat nform = DecimalFormat.getInstance(Locale.US); form = null; if (nform instanceof DecimalFormat) { form = (DecimalFormat) nform; } // Greater than 309 (critical number used to distinguish // BigInteger and BigDecimal) nform.setMaximumIntegerDigits(500); assertEquals(500, nform.getMaximumIntegerDigits()); assertEquals(500, form.getMaximumIntegerDigits()); form = new DecimalFormat("00.###E0"); assertEquals(2, form.getMaximumIntegerDigits()); form.setMaximumIntegerDigits(500); assertEquals(500, nform.getMaximumIntegerDigits()); assertEquals(500, form.getMaximumIntegerDigits()); form.format(12.3); assertEquals(500, nform.getMaximumIntegerDigits()); assertEquals(500, form.getMaximumIntegerDigits()); nform = DecimalFormat.getInstance(Locale.US); form = null; if (nform instanceof DecimalFormat) { form = (DecimalFormat) nform; } // getMaximumIntegerDigits from NumberFormat default to 309 // getMaximumIntegerDigits from DecimalFormat default to 309 // the following 2 assertions will fail on RI implementation, since the // implementation of ICU and RI are not identical. RI does not give // DecimalFormat an initial bound about its maximumIntegerDigits // (default to Integer.MAX_VALUE: 2147483647 ) assertEquals(maxIntDigit, nform.getMaximumIntegerDigits()); assertEquals(maxIntDigit, form.getMaximumIntegerDigits()); // regression test for HARMONY-878 assertTrue(new DecimalFormat("0\t'0'").getMaximumIntegerDigits() > 0); } public void test_getMinimumIntegerDigits() { final int minIntDigit = 1; NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; // getMaximumIntegerDigits from NumberFormat (default to 1) // getMaximumIntegerDigits from DecimalFormat (default to 1) assertEquals(minIntDigit, nform.getMinimumIntegerDigits()); assertEquals(minIntDigit, form.getMinimumIntegerDigits()); // Greater than 309 (critical number used to distinguish // BigInteger and BigDecimal) nform.setMinimumIntegerDigits(500); assertEquals(500, nform.getMinimumIntegerDigits()); assertEquals(500, form.getMinimumIntegerDigits()); form.setMaximumIntegerDigits(400); assertEquals(400, nform.getMinimumIntegerDigits()); assertEquals(400, form.getMinimumIntegerDigits()); } public void test_formatLjava_lang_Obj_Ljava_StringBuffer_Ljava_text_FieldPosition() { NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; // If Object(including null) is not of type Number, // IllegalArgumentException will be thrown out try { form.format(new Object(), new StringBuffer(), new FieldPosition(0)); fail("Should throw IAE"); } catch (IllegalArgumentException e) { // expected } try { form.format(null, new StringBuffer(), new FieldPosition(0)); fail("Should throw IAE"); } catch (IllegalArgumentException e) { // expected } // When StringBuffer == null || FieldPosition == null // NullPointerException will be thrown out. try { form.format(new Double(1.9), null, new FieldPosition(0)); fail("Should throw NPE"); } catch (NullPointerException e) { // expected } try { form.format(new Double(1.3), new StringBuffer(), null); fail("Should throw NPE"); } catch (NullPointerException e) { // expected } try { form.format(new Object(), new StringBuffer(), new FieldPosition(0)); fail(); } catch (IllegalArgumentException expected) { } FieldPosition pos; StringBuffer out; DecimalFormat format = (DecimalFormat) NumberFormat .getInstance(Locale.US); // format maxLong pos = new FieldPosition(0); out = format.format(new Long(Long.MAX_VALUE), new StringBuffer(), pos); assertTrue("Wrong result L1: " + out, out.toString().equals( "9,223,372,036,854,775,807")); // format minLong pos = new FieldPosition(0); out = format.format(new Long(Long.MIN_VALUE), new StringBuffer(), pos); assertTrue("Wrong result L2: " + out, out.toString().equals( "-9,223,372,036,854,775,808")); // format maxLong of type BigInteger pos = new FieldPosition(0); out = format.format(new java.math.BigInteger(String .valueOf(Long.MAX_VALUE)), new StringBuffer(), pos); assertTrue("Wrong result BI1: " + out, out.toString().equals( "9,223,372,036,854,775,807")); // format minLong of type BigInteger pos = new FieldPosition(0); out = format.format(new java.math.BigInteger(String .valueOf(Long.MIN_VALUE)), new StringBuffer(), pos); assertTrue("Wrong result BI2: " + out, out.toString().equals( "-9,223,372,036,854,775,808")); // format maxLong + 1 java.math.BigInteger big; pos = new FieldPosition(0); big = new java.math.BigInteger(String.valueOf(Long.MAX_VALUE)) .add(new java.math.BigInteger("1")); out = format.format(big, new StringBuffer(), pos); assertTrue("Wrong result BI3: " + out, out.toString().equals( "9,223,372,036,854,775,808")); // format minLong - 1 pos = new FieldPosition(0); big = new java.math.BigInteger(String.valueOf(Long.MIN_VALUE)) .add(new java.math.BigInteger("-1")); out = format.format(big, new StringBuffer(), pos); assertTrue("Wrong result BI4: " + out, out.toString().equals( "-9,223,372,036,854,775,809")); // format big decimal pos = new FieldPosition(0); out = format.format(new java.math.BigDecimal("51.348"), new StringBuffer(), pos); assertTrue("Wrong result BD1: " + out, out.toString().equals("51.348")); // format big decimal pos = new FieldPosition(0); out = format.format(new java.math.BigDecimal("51"), new StringBuffer(), pos); assertTrue("Wrong result BD2: " + out, out.toString().equals("51")); // format big decimal Double.MAX_VALUE * 2 java.math.BigDecimal bigDecimal; pos = new FieldPosition(0); final String doubleMax2 = "359,538,626,972,463,141,629,054,847,463,408," + "713,596,141,135,051,689,993,197,834,953,606,314,521,560,057,077," + "521,179,117,265,533,756,343,080,917,907,028,764,928,468,642,653," + "778,928,365,536,935,093,407,075,033,972,099,821,153,102,564,152," + "490,980,180,778,657,888,151,737,016,910,267,884,609,166,473,806," + "445,896,331,617,118,664,246,696,549,595,652,408,289,446,337,476," + "354,361,838,599,762,500,808,052,368,249,716,736"; bigDecimal = new BigDecimal(Double.MAX_VALUE).add(new BigDecimal( Double.MAX_VALUE)); out = format.format(bigDecimal, new StringBuffer(), pos); assertTrue("Wrong result BDmax2: " + out, out.toString().equals( doubleMax2)); // format big decimal Double.MIN_VALUE + Double.MIN_VALUE // and Double.MIN_VALUE - Double.MIN_VALUE pos = new FieldPosition(0); bigDecimal = new BigDecimal(Double.MIN_VALUE).add(new BigDecimal( Double.MIN_VALUE)); out = format.format(bigDecimal, new StringBuffer(), pos); bigDecimal = new BigDecimal(Float.MAX_VALUE).add(new BigDecimal( Float.MAX_VALUE)); out = format.format(bigDecimal, new StringBuffer(), pos); final String BDFloatMax2 = "680,564,693,277,057,719,623,408,366,969,033,850,880"; assertTrue("Wrong result BDFloatMax2: " + out, out.toString().equals( BDFloatMax2)); // format big decimal Float.MIN_VALUE + Float.MIN_VALUE // and Float.MIN_VALUE - Float.MIN_VALUE bigDecimal = new BigDecimal(Float.MIN_VALUE).add(new BigDecimal( Float.MIN_VALUE)); out = format.format(bigDecimal, new StringBuffer(), pos); final String BDFloatMin2 = "0"; bigDecimal = new BigDecimal(Float.MIN_VALUE).subtract(new BigDecimal( Float.MIN_VALUE)); out = format.format(bigDecimal, new StringBuffer(), pos); assertTrue("Wrong result BDFloatMax2: " + out, out.toString().equals( BDFloatMin2)); } public void test_setMaximumFractionDigitsLjava_lang_Integer() { NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; form.setMaximumFractionDigits(-2); assertEquals(0, form.getMaximumFractionDigits()); form.setMaximumFractionDigits(341); assertEquals(341, form.getMaximumFractionDigits()); } public void test_setMinimumFractionDigitsLjava_lang_Integer() { NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; form.setMinimumFractionDigits(-3); assertEquals(0, form.getMinimumFractionDigits()); form.setMinimumFractionDigits(310); assertEquals(310, form.getMinimumFractionDigits()); } public void test_setMaximumIntegerDigitsLjava_lang_Integer() { NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; form.setMaximumIntegerDigits(-3); assertEquals(0, form.getMaximumIntegerDigits()); form.setMaximumIntegerDigits(310); assertEquals(310, form.getMaximumIntegerDigits()); } public void test_setMinimumIntegerDigitsLjava_lang_Integer() { NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; form.setMinimumIntegerDigits(-3); assertEquals(0, form.getMinimumIntegerDigits()); form.setMinimumIntegerDigits(310); assertEquals(310, form.getMinimumIntegerDigits()); } // When MaxFractionDigits is set first and less than MinFractionDigits, max // will be changed to min value public void test_setMinimumFactionDigitsLjava_lang_Integer_setMaximumFractionDigitsLjava_lang_Integer() { NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; form.setMaximumFractionDigits(100); form.setMinimumFractionDigits(200); assertEquals(200, form.getMaximumFractionDigits()); assertEquals(200, form.getMinimumFractionDigits()); form.setMaximumIntegerDigits(100); form.setMinimumIntegerDigits(200); assertEquals(200, form.getMaximumIntegerDigits()); assertEquals(200, form.getMinimumIntegerDigits()); } // When MinFractionDigits is set first and less than MaxFractionDigits, min // will be changed to max value public void test_setMaximumFactionDigitsLjava_lang_Integer_setMinimumFractionDigitsLjava_lang_Integer() { NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; form.setMinimumFractionDigits(200); form.setMaximumFractionDigits(100); assertEquals(100, form.getMaximumFractionDigits()); assertEquals(100, form.getMinimumFractionDigits()); form.setMinimumIntegerDigits(200); form.setMaximumIntegerDigits(100); assertEquals(100, form.getMaximumIntegerDigits()); assertEquals(100, form.getMinimumIntegerDigits()); } public void test_equalsLjava_lang_Object() { DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance(Locale.US); DecimalFormat cloned = (DecimalFormat) format.clone(); cloned.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.US)); assertEquals(format, cloned); Currency c = Currency.getInstance(Locale.US); cloned.setCurrency(c); assertEquals(format, cloned); } public void test_getNegativePrefix() { DecimalFormat df = new DecimalFormat(); df.setNegativePrefix("--"); assertTrue("Incorrect negative prefix", df.getNegativePrefix().equals("--")); } public void test_getNegativeSuffix() { DecimalFormat df = new DecimalFormat(); df.setNegativeSuffix("&"); assertTrue("Incorrect negative suffix", df.getNegativeSuffix().equals("&")); } public void test_getPositivePrefix() { DecimalFormat df = new DecimalFormat(); df.setPositivePrefix("++"); assertTrue("Incorrect positive prefix", df.getPositivePrefix().equals("++")); } public void test_getPositiveSuffix() { DecimalFormat df = new DecimalFormat(); df.setPositiveSuffix("%"); assertTrue("Incorrect positive prefix", df.getPositiveSuffix().equals("%")); } public void test_setPositivePrefixLjava_lang_String() throws Exception { DecimalFormat format = new DecimalFormat(); assertEquals("", format.getPositivePrefix()); format.setPositivePrefix("PosPrf"); assertEquals("PosPrf", format.getPositivePrefix()); assertTrue(format.parse("PosPrf123.45").doubleValue() == 123.45); format.setPositivePrefix(""); assertEquals("", format.getPositivePrefix()); format.setPositivePrefix(null); assertNull(format.getPositivePrefix()); } public void test_setPositiveSuffixLjava_lang_String() throws Exception { DecimalFormat format = new DecimalFormat(); assertEquals("", format.getPositiveSuffix()); format.setPositiveSuffix("PosSfx"); assertEquals("PosSfx", format.getPositiveSuffix()); assertTrue(format.parse("123.45PosSfx").doubleValue() == 123.45); format.setPositiveSuffix(""); assertEquals("", format.getPositiveSuffix()); format.setPositiveSuffix(null); assertNull(format.getPositiveSuffix()); } public void test_setNegativePrefixLjava_lang_String() throws Exception { DecimalFormat format = new DecimalFormat(); assertEquals("-", format.getNegativePrefix()); format.setNegativePrefix("NegPrf"); assertEquals("NegPrf", format.getNegativePrefix()); assertTrue(format.parse("NegPrf123.45").doubleValue() == -123.45); format.setNegativePrefix(""); assertEquals("", format.getNegativePrefix()); format.setNegativePrefix(null); assertNull(format.getNegativePrefix()); } public void test_setNegativeSuffixLjava_lang_String() throws Exception { DecimalFormat format = new DecimalFormat(); assertEquals("", format.getNegativeSuffix()); format.setNegativeSuffix("NegSfx"); assertEquals("NegSfx", format.getNegativeSuffix()); assertTrue(format.parse("123.45NegPfx").doubleValue() == 123.45); format.setNegativeSuffix(""); assertEquals("", format.getNegativeSuffix()); format.setNegativeSuffix(null); assertNull(format.getNegativeSuffix()); } public void test_setGroupingUse() { DecimalFormat format = new DecimalFormat(); StringBuffer buf = new StringBuffer(); format.setGroupingUsed(false); format.format(new Long(1970), buf, new FieldPosition(0)); assertEquals("1970", buf.toString()); assertFalse(format.isGroupingUsed()); format.format(new Long(1970), buf, new FieldPosition(0)); assertEquals("19701970", buf.toString()); assertFalse(format.isGroupingUsed()); format.setGroupingUsed(true); format.format(new Long(1970), buf, new FieldPosition(0)); assertEquals("197019701,970", buf.toString()); assertTrue(format.isGroupingUsed()); } public void test_isGroupingUsed() { assertFalse(new DecimalFormat("####.##").isGroupingUsed()); assertFalse(new DecimalFormat("######.######").isGroupingUsed()); assertFalse(new DecimalFormat("000000.000000").isGroupingUsed()); assertFalse(new DecimalFormat("######.000000").isGroupingUsed()); assertFalse(new DecimalFormat("000000.######").isGroupingUsed()); assertFalse(new DecimalFormat(" ###.###").isGroupingUsed()); assertFalse(new DecimalFormat("$#####.######").isGroupingUsed()); assertFalse(new DecimalFormat("$$####.######").isGroupingUsed()); assertTrue(new DecimalFormat("###,####").isGroupingUsed()); } public void test_Constructor() { // Test for method java.text.DecimalFormat() // the constructor form that specifies a pattern is equal to the form // constructed with no pattern and applying that pattern using the // applyPattern call DecimalFormat format1 = new DecimalFormat(); format1.applyPattern("'$'1000.0000"); DecimalFormat format2 = new DecimalFormat(); format2.applyPattern("'$'1000.0000"); assertTrue("Constructed format did not match applied format object", format2.equals(format1)); DecimalFormat format3 = new DecimalFormat("'$'1000.0000"); assertTrue("Constructed format did not match applied format object", format3.equals(format1)); DecimalFormat format4 = new DecimalFormat("'$'8000.0000"); assertTrue("Constructed format did not match applied format object", !format4.equals(format1)); } public void test_ConstructorLjava_lang_String() { // Test for method java.text.DecimalFormat(java.lang.String) // the constructor form that specifies a pattern is equal to the form // constructed with no pattern and applying that pattern using the // applyPattern call DecimalFormat format = new DecimalFormat("'$'0000.0000"); DecimalFormat format1 = new DecimalFormat(); format1.applyPattern("'$'0000.0000"); assertTrue("Constructed format did not match applied format object", format.equals(format1)); new DecimalFormat("####.##"); new DecimalFormat("######.######"); new DecimalFormat("000000.000000"); new DecimalFormat("######.000000"); new DecimalFormat("000000.######"); new DecimalFormat(" ###.###"); new DecimalFormat("$#####.######"); new DecimalFormat("$$####.######"); new DecimalFormat("%#,##,###,####"); new DecimalFormat("#,##0.00;(#,##0.00)"); try { new DecimalFormat(null); fail(); } catch (NullPointerException expected) { } try { new DecimalFormat("%#,##,###,####'"); fail(); } catch (IllegalArgumentException expected) { } try { new DecimalFormat("#.##0.00"); fail(); } catch (IllegalArgumentException expected) { } } public void test_ConstructorLjava_lang_StringLjava_text_DecimalFormatSymbols() { // case 1: Try to construct object using correct pattern and format // symbols. DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.CANADA); DecimalFormat format1 = new DecimalFormat("'$'1000.0000", dfs); DecimalFormat format2 = new DecimalFormat(); format2.applyPattern("'$'1000.0000"); format2.setDecimalFormatSymbols(dfs); assertTrue("Constructed format did not match applied format object", format2.equals(format1)); assertTrue("Constructed format did not match applied format object", !format1.equals(new DecimalFormat("'$'1000.0000", new DecimalFormatSymbols(Locale.CHINA)))); // case 2: Try to construct object using null arguments. try { new DecimalFormat("'$'1000.0000", (DecimalFormatSymbols) null); fail(); } catch (NullPointerException expected) { } try { new DecimalFormat(null, new DecimalFormatSymbols()); fail(); } catch (NullPointerException expected) { } try { new DecimalFormat(null, (DecimalFormatSymbols) null); fail(); } catch (NullPointerException expected) { } // case 3: Try to construct object using incorrect pattern. try { new DecimalFormat("$'", new DecimalFormatSymbols()); fail(); } catch (IllegalArgumentException expected) { } } public void test_applyPatternLjava_lang_String() { DecimalFormat format = new DecimalFormat("#.#"); assertEquals("Wrong pattern 1", "#0.#", format.toPattern()); format = new DecimalFormat("#."); assertEquals("Wrong pattern 2", "#0.", format.toPattern()); format = new DecimalFormat("#"); assertEquals("Wrong pattern 3", "#", format.toPattern()); format = new DecimalFormat(".#"); assertEquals("Wrong pattern 4", "#.0", format.toPattern()); // Regression for HARMONY-6485 format = new DecimalFormat(); format.setMinimumIntegerDigits(0); format.setMinimumFractionDigits(0); format.setMaximumFractionDigits(0); format.applyPattern("00.0#"); assertEquals("Minimum integer digits not set", 2, format.getMinimumIntegerDigits()); assertEquals("Minimum fraction digits not set", 1, format.getMinimumFractionDigits()); assertEquals("Maximum fraction digits not set", 2, format.getMaximumFractionDigits()); try { format.applyPattern(null); fail(); } catch (NullPointerException expected) { } try { format.applyPattern("%#,##,###,####'"); fail(); } catch (IllegalArgumentException expected) { } try { format.applyPattern("#.##0.00"); fail(); } catch (IllegalArgumentException expected) { } } // AndroidOnly: icu supports 2 grouping sizes public void test_applyPatternLjava_lang_String2() { DecimalFormat decFormat = new DecimalFormat("#.#"); String[] patterns = { "####.##", "######.######", "000000.000000", "######.000000", "000000.######", " ###.###", "$#####.######", "$$####.######", "%#,##,###,####", "#,##0.00;(#,##0.00)", "##.##-E" }; String[] expResult = { "#0.##", "#0.######", "#000000.000000", "#.000000", "#000000.######", " #0.###", "$#0.######", "$$#0.######", "%#,###,####", // icu only. icu supports two grouping sizes "#,##0.00;(#,##0.00)", "#0.##-'E'" // icu only. E in the suffix does not need to be quoted. This is done automatically. }; for (int i = 0; i < patterns.length; i++) { decFormat.applyPattern(patterns[i]); String result = decFormat.toPattern(); assertEquals("Failed to apply following pattern: " + patterns[i] + "\n expected: " + expResult[i] + "\n returned: " + result, expResult[i], result); } } public void test_applyLocalizedPatternLjava_lang_String() throws Exception { DecimalFormat format = new DecimalFormat(); // case 1: Try to apply correct variants of pattern. format.applyLocalizedPattern("#.#"); assertEquals("Wrong pattern 1", "#0.#", format.toLocalizedPattern()); format.applyLocalizedPattern("#."); assertEquals("Wrong pattern 2", "#0.", format.toLocalizedPattern()); format.applyLocalizedPattern("#"); assertEquals("Wrong pattern 3", "#", format.toLocalizedPattern()); format.applyLocalizedPattern(".#"); assertEquals("Wrong pattern 4", "#.0", format.toLocalizedPattern()); // case 2: Try to apply malformed patten. try { format.applyLocalizedPattern("'#,#:#0.0#;(#)"); fail(); } catch (IllegalArgumentException expected) { } // case 3: Try to apply null pattern. try { format.applyLocalizedPattern((String) null); fail(); } catch (NullPointerException expected) { } } public void test_toPattern() { DecimalFormat format = new DecimalFormat(); format.applyPattern("#.#"); assertEquals("Wrong pattern 1", "#0.#", format.toPattern()); format.applyPattern("#."); assertEquals("Wrong pattern 2", "#0.", format.toPattern()); format.applyPattern("#"); assertEquals("Wrong pattern 3", "#", format.toPattern()); format.applyPattern(".#"); assertEquals("Wrong pattern 4", "#.0", format.toPattern()); } public void test_toLocalizedPattern() { DecimalFormat format = new DecimalFormat(); format.setDecimalFormatSymbols(new DecimalFormatSymbols(Locale.US)); format.applyLocalizedPattern("#.#"); assertEquals("Wrong pattern 1", "#0.#", format.toLocalizedPattern()); format.applyLocalizedPattern("#."); assertEquals("Wrong pattern 2", "#0.", format.toLocalizedPattern()); format.applyLocalizedPattern("#"); assertEquals("Wrong pattern 3", "#", format.toLocalizedPattern()); format.applyLocalizedPattern(".#"); assertEquals("Wrong pattern 4", "#.0", format.toLocalizedPattern()); } public void test_hashCode() { DecimalFormat df1 = new DecimalFormat(); DecimalFormat df2 = (DecimalFormat) df1.clone(); assertTrue("Hash codes of equals object are not equal", df2.hashCode() == df1.hashCode()); } public void test_clone() { DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance(Locale.US); DecimalFormat cloned = (DecimalFormat) format.clone(); assertEquals(cloned.getDecimalFormatSymbols(), format.getDecimalFormatSymbols()); format = new DecimalFormat("'$'0000.0000"); DecimalFormat format1 = (DecimalFormat) (format.clone()); // make sure the objects are equal assertTrue("Object's clone isn't equal!", format.equals(format1)); // change the content of the clone and make sure it's not equal anymore // verifies that it's data is now distinct from the original format1.applyPattern("'$'0000.####"); assertTrue("Object's changed clone should not be equal!", !format.equals(format1)); } private void compare(String testName, String format, String expected) { assertTrue(testName + " got: " + format + " expected: " + expected, format.equals(expected)); } // icu4c and the RI disagree about these patterns, and I'm not yet sure which is correct. public void test_formatDLjava_lang_StringBufferLjava_text_FieldPosition_problem_cases() { final DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US); DecimalFormat df; df = new DecimalFormat("##0.0E0", dfs); compare("##0.0E0: 123.0", df.format(123.0), "123E0"); compare("##0.0E0: 1234.0", df.format(1234.0), "1.234E3"); compare("##0.0E0: 12346.0", df.format(12346.0), "12.35E3"); df = new DecimalFormat("#00.0##E0", dfs); compare("#00.0##E0: 0.1", df.format(0.1), ".100E0"); compare("#00.0##E0: 0.12", df.format(0.12), ".120E0"); compare("#00.0##E0: 0.123", df.format(0.123), ".123E0"); compare("#00.0##E0: 0.1234", df.format(0.1234), ".1234E0"); compare("#00.0##E0: 0.1234567", df.format(0.1234567), ".123457E0"); compare("#00.0##E0: 0.01", df.format(0.01), "10.0E-3"); compare("#00.0##E0: 0.012", df.format(0.012), "12.0E-3"); compare("#00.0##E0: 0.0123", df.format(0.0123), "12.3E-3"); compare("#00.0##E0: 0.01234", df.format(0.01234), "12.34E-3"); compare("#00.0##E0: 0.01234567", df.format(0.01234567), "12.3457E-3"); compare("#00.0##E0: 0.001", df.format(0.001), "1.00E-3"); compare("#00.0##E0: 0.0012", df.format(0.0012), "1.20E-3"); compare("#00.0##E0: 0.00123", df.format(0.00123), "1.23E-3"); compare("#00.0##E0: 0.001234", df.format(0.001234), "1.234E-3"); compare("#00.0##E0: 0.001234567", df.format(0.001234567), "1.23457E-3"); compare("#00.0##E0: 0.0001", df.format(0.0001), "100E-6"); compare("#00.0##E0: 0.00012", df.format(0.00012), "120E-6"); compare("#00.0##E0: 0.000123", df.format(0.000123), "123E-6"); compare("#00.0##E0: 0.0001234", df.format(0.0001234), "123.4E-6"); compare("#00.0##E0: 0.0001234567", df.format(0.0001234567), "123.457E-6"); compare("#00.0##E0: 0.0", df.format(0.0), "0.00E0"); compare("#00.0##E0: 1.0", df.format(1.0), "1.00E0"); compare("#00.0##E0: 12.0", df.format(12.0), "12.0E0"); compare("#00.0##E0: 123.0", df.format(123.0), "123E0"); compare("#00.0##E0: 1234.0", df.format(1234.0), "1.234E3"); compare("#00.0##E0: 12345.0", df.format(12345.0), "12.345E3"); compare("#00.0##E0: 123456.0", df.format(123456.0), "123.456E3"); compare("#00.0##E0: 1234567.0", df.format(1234567.0), "1.23457E6"); compare("#00.0##E0: 12345678.0", df.format(12345678.0), "12.3457E6"); compare("#00.0##E0: 99999999.0", df.format(99999999.0), "100E6"); df = new DecimalFormat("#.0E0", dfs); compare("#.0E0: 0.0", df.format(0.0), ".0E0"); compare("#.0E0: 1.0", df.format(1.0), ".1E1"); compare("#.0E0: 12.0", df.format(12.0), ".12E2"); compare("#.0E0: 123.0", df.format(123.0), ".12E3"); compare("#.0E0: 1234.0", df.format(1234.0), ".12E4"); compare("#.0E0: 9999.0", df.format(9999.0), ".1E5"); df = new DecimalFormat("0.E0", dfs); compare("0.E0: 0.0", df.format(0.0), "0.E0"); compare("0.E0: 1.0", df.format(1.0), "1.E0"); compare("0.E0: 12.0", df.format(12.0), "1.E1"); compare("0.E0: 123.0", df.format(123.0), "1.E2"); compare("0.E0: 1234.0", df.format(1234.0), "1.E3"); compare("0.E0: 9999.0", df.format(9999.0), "1.E4"); df = new DecimalFormat("##0.00#E0", dfs); compare("##0.00#E0: 0.1", df.format(0.1), ".100E0"); compare("##0.00#E0: 0.1234567", df.format(0.1234567), ".123457E0"); compare("##0.00#E0: 0.9999999", df.format(0.9999999), "1.00E0"); compare("##0.00#E0: 0.01", df.format(0.01), "10.0E-3"); compare("##0.00#E0: 0.01234567", df.format(0.01234567), "12.3457E-3"); compare("##0.00#E0: 0.09999999", df.format(0.09999999), ".100E0"); compare("##0.00#E0: 0.001", df.format(0.001), "1.00E-3"); compare("##0.00#E0: 0.001234567", df.format(0.001234567), "1.23457E-3"); compare("##0.00#E0: 0.009999999", df.format(0.009999999), "10.0E-3"); compare("##0.00#E0: 0.0001", df.format(0.0001), "100E-6"); compare("##0.00#E0: 0.0001234567", df.format(0.0001234567), "123.457E-6"); compare("##0.00#E0: 0.0009999999", df.format(0.0009999999), "1.00E-3"); df = new DecimalFormat("###0.00#E0", dfs); compare("###0.00#E0: 0.1", df.format(0.1), ".100E0"); compare("###0.00#E0: 0.12345678", df.format(0.12345678), ".1234568E0"); compare("###0.00#E0: 0.99999999", df.format(0.99999999), "1.00E0"); compare("###0.00#E0: 0.01", df.format(0.01), "100E-4"); compare("###0.00#E0: 0.012345678", df.format(0.012345678), "123.4568E-4"); compare("###0.00#E0: 0.099999999", df.format(0.099999999), ".100E0"); compare("###0.00#E0: 0.001", df.format(0.001), "10.0E-4"); compare("###0.00#E0: 0.0012345678", df.format(0.0012345678), "12.34568E-4"); compare("###0.00#E0: 0.0099999999", df.format(0.0099999999), "100E-4"); compare("###0.00#E0: 0.0001", df.format(0.0001), "1.00E-4"); compare("###0.00#E0: 0.00012345678", df.format(0.00012345678), "1.234568E-4"); compare("###0.00#E0: 0.00099999999", df.format(0.00099999999), "10.0E-4"); compare("###0.00#E0: 0.00001", df.format(0.00001), "1000E-8"); compare("###0.00#E0: 0.000012345678", df.format(0.000012345678), "1234.568E-8"); compare("###0.00#E0: 0.000099999999", df.format(0.000099999999), "1.00E-4"); df = new DecimalFormat("###0.0#E0", dfs); compare("###0.0#E0: 0.1", df.format(0.1), ".10E0"); compare("###0.0#E0: 0.1234567", df.format(0.1234567), ".123457E0"); compare("###0.0#E0: 0.9999999", df.format(0.9999999), "1.0E0"); compare("###0.0#E0: 0.01", df.format(0.01), "100E-4"); compare("###0.0#E0: 0.01234567", df.format(0.01234567), "123.457E-4"); compare("###0.0#E0: 0.09999999", df.format(0.09999999), ".10E0"); compare("###0.0#E0: 0.001", df.format(0.001), "10E-4"); compare("###0.0#E0: 0.001234567", df.format(0.001234567), "12.3457E-4"); compare("###0.0#E0: 0.009999999", df.format(0.009999999), "100E-4"); compare("###0.0#E0: 0.0001", df.format(0.0001), "1.0E-4"); compare("###0.0#E0: 0.0001234567", df.format(0.0001234567), "1.23457E-4"); compare("###0.0#E0: 0.0009999999", df.format(0.0009999999), "10E-4"); compare("###0.0#E0: 0.00001", df.format(0.00001), "1000E-8"); compare("###0.0#E0: 0.00001234567", df.format(0.00001234567), "1234.57E-8"); compare("###0.0#E0: 0.00009999999", df.format(0.00009999999), "1.0E-4"); } public void test_formatDLjava_lang_StringBufferLjava_text_FieldPosition() { new Support_DecimalFormat( "test_formatDLjava_lang_StringBufferLjava_text_FieldPosition") .t_format_with_FieldPosition(); final DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US); DecimalFormat df = new DecimalFormat("00.0#E0", dfs); compare("00.0#E0: 0.0", df.format(0.0), "00.0E0"); compare("00.0#E0: 1.0", df.format(1.0), "10.0E-1"); compare("00.0#E0: 12.0", df.format(12.0), "12.0E0"); compare("00.0#E0: 123.0", df.format(123.0), "12.3E1"); compare("00.0#E0: 1234.0", df.format(1234.0), "12.34E2"); compare("00.0#E0: 12346.0", df.format(12346.0), "12.35E3"); compare("00.0#E0: 99999.0", df.format(99999.0), "10.0E4"); compare("00.0#E0: 1.2", df.format(1.2), "12.0E-1"); compare("00.0#E0: 12.3", df.format(12.3), "12.3E0"); compare("00.0#E0: 123.4", df.format(123.4), "12.34E1"); compare("00.0#E0: 1234.6", df.format(1234.6), "12.35E2"); compare("00.0#E0: 9999.9", df.format(9999.9), "10.0E3"); compare("00.0#E0: 0.1", df.format(0.1), "10.0E-2"); compare("00.0#E0: 0.12", df.format(0.12), "12.0E-2"); compare("00.0#E0: 0.123", df.format(0.123), "12.3E-2"); compare("00.0#E0: 0.1234", df.format(0.1234), "12.34E-2"); compare("00.0#E0: 0.12346", df.format(0.12346), "12.35E-2"); compare("00.0#E0: 0.99999", df.format(0.99999), "10.0E-1"); compare("00.0#E0: -1.0", df.format(-1.0), "-10.0E-1"); compare("00.0#E0: -12.0", df.format(-12.0), "-12.0E0"); compare("00.0#E0: -123.0", df.format(-123.0), "-12.3E1"); compare("00.0#E0: -1234.0", df.format(-1234.0), "-12.34E2"); compare("00.0#E0: -12346.0", df.format(-12346.0), "-12.35E3"); compare("00.0#E0: -99999.0", df.format(-99999.0), "-10.0E4"); df = new DecimalFormat("##0.0E0", dfs); compare("##0.0E0: 0.0", df.format(0.0), "0.0E0"); compare("##0.0E0: 1.0", df.format(1.0), "1.0E0"); compare("##0.0E0: 12.0", df.format(12.0), "12E0"); compare("##0.0E0: 99999.0", df.format(99999.0), "100E3"); compare("##0.0E0: 999999.0", df.format(999999.0), "1.0E6"); df = new DecimalFormat("0.#E0", dfs); compare("0.#E0: 0.0", df.format(0.0), "0E0"); compare("0.#E0: 1.0", df.format(1.0), "1E0"); compare("0.#E0: 12.0", df.format(12.0), "1.2E1"); compare("0.#E0: 123.0", df.format(123.0), "1.2E2"); compare("0.#E0: 1234.0", df.format(1234.0), "1.2E3"); compare("0.#E0: 9999.0", df.format(9999.0), "1E4"); df = new DecimalFormat(".0E0", dfs); compare(".0E0: 0.0", df.format(0.0), ".0E0"); compare(".0E0: 1.0", df.format(1.0), ".1E1"); compare(".0E0: 12.0", df.format(12.0), ".1E2"); compare(".0E0: 123.0", df.format(123.0), ".1E3"); compare(".0E0: 1234.0", df.format(1234.0), ".1E4"); compare(".0E0: 9999.0", df.format(9999.0), ".1E5"); String formatString = "##0.#"; df = new DecimalFormat(formatString, dfs); df.setMinimumFractionDigits(30); compare(formatString + ": 0.000000000000000000000000000000", df .format(0.0), "0.000000000000000000000000000000"); compare(formatString + ": -0.000000000000000000000000000000", df .format(-0.0), "-0.000000000000000000000000000000"); compare(formatString + ": 1.000000000000000000000000000000", df .format(1.0), "1.000000000000000000000000000000"); compare(formatString + ": -1.000000000000000000000000000000", df .format(-1.0), "-1.000000000000000000000000000000"); df = new DecimalFormat(formatString); df.setMaximumFractionDigits(30); compare(formatString + ": 0", df.format(0.0), "0"); compare(formatString + ": -0", df.format(-0.0), "-0"); compare(formatString + ": 1", df.format(1.0), "1"); compare(formatString + ": -1", df.format(-1.0), "-1"); } public void test_format_minus_zero() throws Exception { final DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US); DecimalFormat df = new DecimalFormat("00.0#E0", dfs); compare("00.0#E0: -0.0", df.format(-0.0), "-00.0E0"); df = new DecimalFormat("##0.0E0", dfs); compare("##0.0E0: -0.0", df.format(-0.0), "-0.0E0"); df = new DecimalFormat("#.0E0", dfs); compare("#.0E0: -0.0", df.format(-0.0), "-.0E0"); df = new DecimalFormat("0.#E0", dfs); compare("0.#E0: -0.0", df.format(-0.0), "-0E0"); df = new DecimalFormat(".0E0", dfs); compare(".0E0: -0.0", df.format(-0.0), "-.0E0"); } public void test_formatJLjava_lang_StringBufferLjava_text_FieldPosition() { final DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US); DecimalFormat df = new DecimalFormat("00.0#E0", dfs); assertEquals("00.0#E0: 0", "00.0E0", df.format(0)); assertEquals("00.0#E0: 1", "10.0E-1", df.format(1)); assertEquals("00.0#E0: 12", "12.0E0", df.format(12)); assertEquals("00.0#E0: 123", "12.3E1", df.format(123)); assertEquals("00.0#E0: 1234", "12.34E2", df.format(1234)); assertEquals("00.0#E0: 12346", "12.35E3", df.format(12346)); assertEquals("00.0#E0: 99999", "10.0E4", df.format(99999)); assertEquals("00.0#E0: -1", "-10.0E-1", df.format(-1)); assertEquals("00.0#E0: -12", "-12.0E0", df.format(-12)); assertEquals("00.0#E0: -123", "-12.3E1", df.format(-123)); assertEquals("00.0#E0: -1234", "-12.34E2", df.format(-1234)); assertEquals("00.0#E0: -12346", "-12.35E3", df.format(-12346)); assertEquals("00.0#E0: -99999", "-10.0E4", df.format(-99999)); df = new DecimalFormat("##0.0E0", dfs); assertEquals("##0.0E0: 0", "0.0E0", df.format(0)); assertEquals("##0.0E0: 1", "1.0E0", df.format(1)); assertEquals("##0.0E0: 12", "12E0", df.format(12)); assertEquals("##0.0E0: 123", "123E0", df.format(123)); assertEquals("##0.0E0: 1234", "1.234E3", df.format(1234)); assertEquals("##0.0E0: 12346", "12.35E3", df.format(12346)); assertEquals("##0.0E0: 99999", "100E3", df.format(99999)); assertEquals("##0.0E0: 999999", "1.0E6", df.format(999999)); df = new DecimalFormat("#00.0##E0", dfs); assertEquals("#00.0##E0: 0", "0.00E0", df.format(0)); assertEquals("#00.0##E0: 1", "1.00E0", df.format(1)); assertEquals("#00.0##E0: 12", "12.0E0", df.format(12)); assertEquals("#00.0##E0: 123", "123E0", df.format(123)); assertEquals("#00.0##E0: 1234", "1.234E3", df.format(1234)); assertEquals("#00.0##E0: 12345", "12.345E3", df.format(12345)); assertEquals("#00.0##E0: 123456", "123.456E3", df.format(123456)); assertEquals("#00.0##E0: 1234567", "1.23457E6", df.format(1234567)); assertEquals("#00.0##E0: 12345678", "12.3457E6", df.format(12345678)); assertEquals("#00.0##E0: 99999999", "100E6", df.format(99999999)); df = new DecimalFormat("#.0E0", dfs); assertEquals("#.0E0: 0", ".0E0", df.format(0)); assertEquals("#.0E0: 1", ".1E1", df.format(1)); assertEquals("#.0E0: 12", ".12E2", df.format(12)); assertEquals("#.0E0: 123", ".12E3", df.format(123)); assertEquals("#.0E0: 1234", ".12E4", df.format(1234)); assertEquals("#.0E0: 9999", ".1E5", df.format(9999)); df = new DecimalFormat("0.#E0", dfs); assertEquals("0.#E0: 0", "0E0", df.format(0)); assertEquals("0.#E0: 1", "1E0", df.format(1)); assertEquals("0.#E0: 12", "1.2E1", df.format(12)); assertEquals("0.#E0: 123", "1.2E2", df.format(123)); assertEquals("0.#E0: 1234", "1.2E3", df.format(1234)); assertEquals("0.#E0: 9999", "1E4", df.format(9999)); } public void test_formatToCharacterIteratorLjava_lang_Object() { try { // Regression for HARMONY-466 new DecimalFormat().formatToCharacterIterator(null); fail("NullPointerException expected"); } catch (NullPointerException e) { // expected } new Support_DecimalFormat( "test_formatToCharacterIteratorLjava_lang_Object") .t_formatToCharacterIterator(); } public void test_formatD() { DecimalFormat format = (DecimalFormat) NumberFormat.getInstance(Locale.ENGLISH); format.setGroupingUsed(false); format.setMaximumFractionDigits(400); for (int i = 0; i < 309; i++) { String tval = "1"; for (int j = 0; j < i; j++) tval += "0"; double d = Double.parseDouble(tval); String result = format.format(d); assertEquals(i + ") e:" + tval + " r:" + result, tval, result); } for (int i = 0; i < 322; i++) { String tval = "0."; for (int j = 0; j < i; j++) tval += "0"; tval += "1"; double d = Double.parseDouble(tval); String result = format.format(d); assertEquals(i + ") e:" + tval + " r:" + result, tval, result); } } public void test_formatD_2() { DecimalFormat format = (DecimalFormat) NumberFormat.getInstance(Locale.ENGLISH); format.setGroupingUsed(false); format.setMaximumFractionDigits(400); assertEquals("999999999999999", format.format(999999999999999.)); assertEquals("999999999999999.9", format.format(999999999999999.9)); assertEquals("99999999999999.98", format.format(99999999999999.99)); assertEquals("9999999999999.998", format.format(9999999999999.999)); assertEquals("999999999999.9999", format.format(999999999999.9999)); assertEquals("99999999999.99998", format.format(99999999999.99999)); assertEquals("9999999999.999998", format.format(9999999999.999999)); assertEquals("999999999.9999999", format.format(999999999.9999999)); assertEquals("99999999.99999999", format.format(99999999.99999999)); assertEquals("9999999.999999998", format.format(9999999.999999999)); assertEquals("99999.99999999999", format.format(99999.99999999999)); assertEquals("9999.999999999998", format.format(9999.999999999999)); assertEquals("999.9999999999999", format.format(999.9999999999999)); assertEquals("99.99999999999999", format.format(99.99999999999999)); assertEquals("9.999999999999998", format.format(9.999999999999999)); assertEquals("0.9999999999999999", format.format(.9999999999999999)); } public void test_formatD_3() { DecimalFormat format = (DecimalFormat) NumberFormat.getInstance(Locale.ENGLISH); format.setGroupingUsed(false); format.setMaximumFractionDigits(400); assertEquals("123456789012345", format.format(123456789012345.)); assertEquals("1", "12345678901234.5", format.format(12345678901234.5)); assertEquals("2", "1234567890123.25", format.format(1234567890123.25)); assertEquals("3", "999999999999.375", format.format(999999999999.375)); assertEquals("4", "99999999999.0625", format.format(99999999999.0625)); assertEquals("5", "9999999999.03125", format.format(9999999999.03125)); assertEquals("6", "999999999.015625", format.format(999999999.015625)); assertEquals("7", "99999999.0078125", format.format(99999999.0078125)); assertEquals("8", "9999999.00390625", format.format(9999999.00390625)); assertEquals("9", "999999.001953125", format.format(999999.001953125)); assertEquals("10", "9999.00048828125", format.format(9999.00048828125)); assertEquals("11", "999.000244140625", format.format(999.000244140625)); assertEquals("12", "99.0001220703125", format.format(99.0001220703125)); assertEquals("13", "9.00006103515625", format.format(9.00006103515625)); assertEquals("14", "0.000030517578125", format.format(0.000030517578125)); } public void test_getDecimalFormatSymbols() { DecimalFormat df = (DecimalFormat) NumberFormat.getInstance(Locale.ENGLISH); DecimalFormatSymbols dfs = df.getDecimalFormatSymbols(); assertTrue("Identical symbols", dfs != df.getDecimalFormatSymbols()); } public void test_getCurrency() { Currency currK = Currency.getInstance("KRW"); Currency currX = Currency.getInstance("XXX"); Currency currE = Currency.getInstance("EUR"); Currency curr01; DecimalFormat df = (DecimalFormat) NumberFormat .getCurrencyInstance(new Locale("ko", "KR")); assertTrue("Test1: Returned incorrect currency", df.getCurrency() == currK); df = (DecimalFormat) NumberFormat.getCurrencyInstance(new Locale("", "KR")); assertTrue("Test2: Returned incorrect currency", df.getCurrency() == currK); df = (DecimalFormat) NumberFormat.getCurrencyInstance(new Locale("ko", "")); assertTrue("Test3: Returned incorrect currency", df.getCurrency() == currX); df = (DecimalFormat) NumberFormat.getCurrencyInstance(new Locale("fr", "FR")); assertTrue("Test4: Returned incorrect currency", df.getCurrency() == currE); // Regression for HARMONY-1351 df = (DecimalFormat) NumberFormat.getCurrencyInstance(new Locale("QWERTY")); assertTrue("Test5: Returned incorrect currency", df.getCurrency() == currX); // JDK fails these tests since it doesn't have the PREEURO variant // df = (DecimalFormat)NumberFormat.getCurrencyInstance(new Locale("fr", // "FR","PREEURO")); // assertTrue("Test5: Returned incorrect currency", df.getCurrency() == // currF); } public void test_getGroupingSize() { DecimalFormat df = new DecimalFormat("###0.##"); assertEquals("Wrong unset size", 0, df.getGroupingSize()); df = new DecimalFormat("#,##0.##"); assertEquals("Wrong set size", 3, df.getGroupingSize()); df = new DecimalFormat("#,###,###0.##"); assertEquals("Wrong multiple set size", 4, df.getGroupingSize()); } public void test_getMultiplier() { final int defaultMultiplier = 1; NumberFormat nform = DecimalFormat.getInstance(Locale.US); DecimalFormat form = (DecimalFormat) nform; assertEquals(defaultMultiplier, form.getMultiplier()); DecimalFormat df = new DecimalFormat("###0.##"); assertEquals("Wrong unset multiplier", 1, df.getMultiplier()); df = new DecimalFormat("###0.##%"); assertEquals("Wrong percent multiplier", 100, df.getMultiplier()); df = new DecimalFormat("###0.##\u2030"); assertEquals("Wrong mille multiplier", 1000, df.getMultiplier()); } public void test_isDecimalSeparatorAlwaysShown() { DecimalFormat df = new DecimalFormat("###0.##"); assertTrue("Wrong unset value", !df.isDecimalSeparatorAlwaysShown()); df = new DecimalFormat("###0.00"); assertTrue("Wrong unset2 value", !df.isDecimalSeparatorAlwaysShown()); df = new DecimalFormat("###0."); assertTrue("Wrong set value", df.isDecimalSeparatorAlwaysShown()); } public void test_parseLjava_lang_StringLjava_text_ParsePosition() { DecimalFormat format = (DecimalFormat) NumberFormat .getNumberInstance(Locale.ENGLISH); ParsePosition pos = new ParsePosition(0); Number result = format.parse("9223372036854775807", pos); assertTrue("Wrong result type for Long.MAX_VALUE", result.getClass() == Long.class); assertTrue("Wrong result Long.MAX_VALUE", result.longValue() == Long.MAX_VALUE); pos = new ParsePosition(0); result = format.parse("-9223372036854775808", pos); assertTrue("Wrong result type for Long.MIN_VALUE", result.getClass() == Long.class); assertTrue("Wrong result Long.MIN_VALUE: " + result.longValue(), result .longValue() == Long.MIN_VALUE); pos = new ParsePosition(0); result = format.parse("9223372036854775808", pos); assertTrue("Wrong result type for Long.MAX_VALUE+1", result.getClass() == Double.class); assertTrue("Wrong result Long.MAX_VALUE + 1", result.doubleValue() == (double) Long.MAX_VALUE + 1); pos = new ParsePosition(0); result = format.parse("-9223372036854775809", pos); assertTrue("Wrong result type for Long.MIN_VALUE+1", result.getClass() == Double.class); assertTrue("Wrong result Long.MIN_VALUE - 1", result.doubleValue() == (double) Long.MIN_VALUE - 1); pos = new ParsePosition(0); result = format.parse("18446744073709551629", pos); assertTrue("Wrong result type for overflow", result.getClass() == Double.class); assertTrue("Wrong result for overflow", result.doubleValue() == 18446744073709551629d); pos = new ParsePosition(0); result = format.parse("42325917317067571199", pos); assertTrue("Wrong result type for overflow a: " + result, result .getClass() == Double.class); assertTrue("Wrong result for overflow a: " + result, result .doubleValue() == 42325917317067571199d); pos = new ParsePosition(0); result = format.parse("4232591731706757119E1", pos); assertTrue("Wrong result type for overflow b: " + result, result .getClass() == Double.class); assertTrue("Wrong result for overflow b: " + result, result .doubleValue() == 42325917317067571190d); pos = new ParsePosition(0); result = format.parse(".42325917317067571199E20", pos); assertTrue("Wrong result type for overflow c: " + result, result .getClass() == Double.class); assertTrue("Wrong result for overflow c: " + result, result .doubleValue() == 42325917317067571199d); pos = new ParsePosition(0); result = format.parse("922337203685477580.9E1", pos); assertTrue("Wrong result type for overflow d: " + result, result .getClass() == Double.class); assertTrue("Wrong result for overflow d: " + result, result .doubleValue() == 9223372036854775809d); pos = new ParsePosition(0); result = format.parse("9.223372036854775809E18", pos); assertTrue("Wrong result type for overflow e: " + result, result .getClass() == Double.class); assertTrue("Wrong result for overflow e: " + result, result .doubleValue() == 9223372036854775809d); } public void test_parse_with_multiplier() { DecimalFormat format = (DecimalFormat) NumberFormat.getNumberInstance(Locale.ENGLISH); Number result; format.setMultiplier(100); result = format.parse("9223372036854775807", new ParsePosition(0)); assertEquals("Wrong result type multiplier 100: " + result, Double.class, result.getClass()); assertEquals("Wrong result for multiplier 100: " + result, 92233720368547758.07d, result.doubleValue()); format.setMultiplier(1000); result = format.parse("9223372036854775807", new ParsePosition(0)); assertEquals("Wrong result type multiplier 1000: " + result, Double.class, result.getClass()); assertEquals("Wrong result for multiplier 1000: " + result, 9223372036854775.807d, result.doubleValue()); format.setMultiplier(10000); result = format.parse("9223372036854775807", new ParsePosition(0)); assertEquals("Wrong result type multiplier 10000: " + result, Double.class, result.getClass()); assertEquals("Wrong result for multiplier 10000: " + result, 922337203685477.5807d, result.doubleValue()); } public void test_setDecimalFormatSymbolsLjava_text_DecimalFormatSymbols() { DecimalFormat df = new DecimalFormat("###0.##"); DecimalFormatSymbols dfs = new DecimalFormatSymbols(); dfs.setDecimalSeparator('@'); df.setDecimalFormatSymbols(dfs); assertTrue("Not set", df.getDecimalFormatSymbols().equals(dfs)); assertEquals("Symbols not used", "1@2", df.format(1.2)); // The returned symbols may be cloned in two spots // 1. When set // 2. When returned DecimalFormat format = new DecimalFormat(); DecimalFormatSymbols symbols = new DecimalFormatSymbols(); format.setDecimalFormatSymbols(symbols); DecimalFormatSymbols symbolsOut = format.getDecimalFormatSymbols(); assertNotSame(symbols, symbolsOut); } public void test_setDecimalSeparatorAlwaysShownZ() { DecimalFormat df = new DecimalFormat("###0.##", new DecimalFormatSymbols(Locale.US)); assertEquals("Wrong default result", "5", df.format(5)); df.setDecimalSeparatorAlwaysShown(true); assertTrue("Not set", df.isDecimalSeparatorAlwaysShown()); assertEquals("Wrong set result", "7.", df.format(7)); } public void test_setCurrencyLjava_util_Currency() { Locale locale = Locale.CANADA; DecimalFormat df = ((DecimalFormat) NumberFormat .getCurrencyInstance(locale)); try { df.setCurrency(null); fail("Expected NullPointerException"); } catch (NullPointerException e) { } Currency currency = Currency.getInstance("AED"); df.setCurrency(currency); assertTrue("Returned incorrect currency", currency == df.getCurrency()); assertTrue("Returned incorrect currency symbol", currency.getSymbol( locale) .equals(df.getDecimalFormatSymbols().getCurrencySymbol())); assertTrue("Returned incorrect international currency symbol", currency .getCurrencyCode().equals( df.getDecimalFormatSymbols() .getInternationalCurrencySymbol())); } public void test_setGroupingSizeI() { DecimalFormat df = new DecimalFormat("###0.##", new DecimalFormatSymbols(Locale.ENGLISH)); df.setGroupingUsed(true); df.setGroupingSize(2); assertEquals("Value not set", 2, df.getGroupingSize()); String result = df.format(123); assertTrue("Invalid format:" + result, result.equals("1,23")); } public void test_setMaximumFractionDigitsI() { DecimalFormat df = new DecimalFormat("###0.##", new DecimalFormatSymbols(Locale.US)); df.setMaximumFractionDigits(3); assertEquals("Not set", 3, df.getMaximumFractionDigits()); assertEquals("Wrong maximum", "1.235", df.format(1.23456)); df.setMinimumFractionDigits(4); assertEquals("Not changed", 4, df.getMaximumFractionDigits()); assertEquals("Incorrect fraction", "456.0000", df.format(456)); } public void test_setMaximumIntegerDigitsI() { DecimalFormat df = new DecimalFormat("###0.##"); df.setMaximumIntegerDigits(2); assertEquals("Not set", 2, df.getMaximumIntegerDigits()); assertEquals("Wrong maximum", "34", df.format(1234)); df.setMinimumIntegerDigits(4); assertEquals("Not changed", 4, df.getMaximumIntegerDigits()); assertEquals("Incorrect integer", "0026", df.format(26)); } public void test_setMinimumFractionDigitsI() { DecimalFormat df = new DecimalFormat("###0.##", new DecimalFormatSymbols(Locale.US)); df.setMinimumFractionDigits(4); assertEquals("Not set", 4, df.getMinimumFractionDigits()); assertEquals("Wrong minimum", "1.2300", df.format(1.23)); df.setMaximumFractionDigits(2); assertEquals("Not changed", 2, df.getMinimumFractionDigits()); assertEquals("Incorrect fraction", "456.00", df.format(456)); } public void test_setMinimumIntegerDigitsI() { DecimalFormat df = new DecimalFormat("###0.##", new DecimalFormatSymbols(Locale.US)); df.setMinimumIntegerDigits(3); assertEquals("Not set", 3, df.getMinimumIntegerDigits()); assertEquals("Wrong minimum", "012", df.format(12)); df.setMaximumIntegerDigits(2); assertEquals("Not changed", 2, df.getMinimumIntegerDigits()); assertEquals("Incorrect integer", "00.7", df.format(0.7)); } public void test_setMultiplierI() { DecimalFormat df = new DecimalFormat("###0.##"); df.setMultiplier(10); assertEquals("Wrong multiplier", 10, df.getMultiplier()); assertEquals("Wrong format", "50", df.format(5)); assertEquals("Wrong parse", 5, df.parse("50", new ParsePosition(0)).intValue()); // regression test for HARMONY-879 df.setMultiplier(-1); assertEquals("Wrong multiplier for negative value", -1, df.getMultiplier()); } public void testSerializationSelf() throws Exception { SerializationTest.verifySelf(new DecimalFormat()); } public void test_serializationHarmonyRICompatible() throws Exception { NumberFormat nf = NumberFormat.getInstance(Locale.FRANCE); DecimalFormat df = null; if (!(nf instanceof DecimalFormat)) { throw new Error("This NumberFormat is not a DecimalFormat"); } df = (DecimalFormat) nf; ObjectInputStream oinput = null; DecimalFormat deserializedDF = null; try { oinput = new ObjectInputStream(this.getClass().getResource( "/serialization/org/apache/harmony/tests/java/text/DecimalFormat.ser").openStream()); deserializedDF = (DecimalFormat) oinput.readObject(); } finally { try { if (null != oinput) { oinput.close(); } } catch (Exception e) { // ignore } } assertEquals(df.getNegativePrefix(), deserializedDF.getNegativePrefix()); assertEquals(df.getNegativeSuffix(), deserializedDF.getNegativeSuffix()); assertEquals(df.getPositivePrefix(), deserializedDF.getPositivePrefix()); assertEquals(df.getPositiveSuffix(), deserializedDF.getPositiveSuffix()); assertEquals(df.getCurrency(), deserializedDF.getCurrency()); DecimalFormatSymbolsTest.assertDecimalFormatSymbolsRIFrance(deserializedDF.getDecimalFormatSymbols()); assertEquals(df.getGroupingSize(), df.getGroupingSize()); assertEquals(df.getMaximumFractionDigits(), deserializedDF .getMaximumFractionDigits()); assertEquals(df.getMaximumIntegerDigits(), deserializedDF .getMaximumIntegerDigits()); assertEquals(df.getMinimumFractionDigits(), deserializedDF .getMinimumFractionDigits()); assertEquals(df.getMinimumIntegerDigits(), deserializedDF .getMinimumIntegerDigits()); assertEquals(df.getMultiplier(), deserializedDF.getMultiplier()); // Deliberately omitted this assertion. Since different data resource // will cause the assertion fail. // assertEquals(df, deserializedDF); } public void testParseInfinityBigDecimalFalse() { // Regression test for HARMONY-106 DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance(); DecimalFormatSymbols symbols = new DecimalFormatSymbols(); Number number = format.parse(symbols.getInfinity(), new ParsePosition(0)); assertTrue(number instanceof Double); assertTrue(Double.isInfinite(number.doubleValue())); } public void testParseMinusInfinityBigDecimalFalse() { // Regression test for HARMONY-106 DecimalFormat format = (DecimalFormat) DecimalFormat.getInstance(); DecimalFormatSymbols symbols = new DecimalFormatSymbols(); Number number = format.parse("-" + symbols.getInfinity(), new ParsePosition(0)); assertTrue(number instanceof Double); assertTrue(Double.isInfinite(number.doubleValue())); } public void testSetDecimalFormatSymbolsAsNull(){ // Regression for HARMONY-1070 DecimalFormat format = (DecimalFormat)DecimalFormat.getInstance(); format.setDecimalFormatSymbols(null); } public void test_formatToCharacterIterator() throws Exception { AttributedCharacterIterator iterator; int[] runStarts; int[] runLimits; String result; char current; // BigInteger. iterator = new DecimalFormat().formatToCharacterIterator(new BigInteger("123456789")); runStarts = new int[] {0, 0, 0, 3, 4, 4, 4, 7, 8, 8, 8}; runLimits = new int[] {3, 3, 3, 4, 7, 7, 7, 8, 11, 11, 11}; result = "123,456,789"; current = iterator.current(); for (int i = 0; i < runStarts.length; i++) { assertEquals("wrong start @" + i, runStarts[i], iterator.getRunStart()); assertEquals("wrong limit @" + i, runLimits[i], iterator.getRunLimit()); assertEquals("wrong char @" + i, result.charAt(i), current); current = iterator.next(); } assertEquals(0, iterator.getBeginIndex()); assertEquals(11, iterator.getEndIndex()); // For BigDecimal with multiplier test. DecimalFormat df = new DecimalFormat(); df.setMultiplier(10); iterator = df.formatToCharacterIterator(new BigDecimal("12345678901234567890")); result = "123,456,789,012,345,678,900"; current = iterator.current(); for (int i = 0; i < result.length(); i++) { assertEquals("wrong char @" + i, result.charAt(i), current); current = iterator.next(); } // For BigDecimal with multiplier test. df = new DecimalFormat(); df.setMultiplier(-1); df.setMaximumFractionDigits(20); iterator = df.formatToCharacterIterator(new BigDecimal("1.23456789012345678901")); result = "-1.23456789012345678901"; current = iterator.current(); for (int i = 0; i < result.length(); i++) { assertEquals("wrong char @" + i, result.charAt(i), current); current = iterator.next(); } iterator = new DecimalFormat().formatToCharacterIterator(new BigDecimal("1.23456789E301")); runStarts = new int[] {0, 0, 2, 3, 3, 3, 6, 7, 7, 7, 10, 11, 11, 11, 14}; runLimits = new int[] {2, 2, 3, 6, 6, 6, 7, 10, 10, 10, 11, 14, 14, 14, 15}; result = "12,345,678,900,"; // 000,000,000,000.... current = iterator.current(); for (int i = 0; i < runStarts.length; i++) { assertEquals("wrong start @" + i, runStarts[i], iterator.getRunStart()); assertEquals("wrong limit @" + i, runLimits[i], iterator.getRunLimit()); assertEquals("wrong char @" + i, result.charAt(i), current); current = iterator.next(); } assertEquals(0, iterator.getBeginIndex()); assertEquals(402, iterator.getEndIndex()); iterator = new DecimalFormat().formatToCharacterIterator(new BigDecimal("1.2345678E4")); runStarts = new int[] {0, 0, 2, 3, 3, 3, 6, 7, 7, 7}; runLimits = new int[] {2, 2, 3, 6, 6, 6, 7, 10, 10, 10}; result = "12,345.678"; current = iterator.current(); for (int i = 0; i < runStarts.length; i++) { assertEquals("wrong start @" + i, runStarts[i], iterator.getRunStart()); assertEquals("wrong limit @" + i, runLimits[i], iterator.getRunLimit()); assertEquals("wrong char @" + i, result.charAt(i), current); current = iterator.next(); } assertEquals(0, iterator.getBeginIndex()); assertEquals(10, iterator.getEndIndex()); } public void test_formatToCharacterIterator_very_large() throws Exception { AttributedCharacterIterator iterator; int[] runStarts; int[] runLimits; String result; char current; Number number = new BigDecimal("1.23456789E1234"); assertEquals("1.23456789E+1234", number.toString()); iterator = new DecimalFormat().formatToCharacterIterator(number); runStarts = new int[] {0, 0, 2, 3, 3, 3, 6, 7, 7, 7, 10, 11, 11, 11, 14}; runLimits = new int[] {2, 2, 3, 6, 6, 6, 7, 10, 10, 10, 11, 14, 14, 14, 15}; result = "12,345,678,900,"; // 000,000,000,000.... current = iterator.current(); for (int i = 0; i < runStarts.length; i++) { assertEquals("wrong start @" + i, runStarts[i], iterator.getRunStart()); assertEquals("wrong limit @" + i, runLimits[i], iterator.getRunLimit()); assertEquals("wrong char @" + i, result.charAt(i), current); current = iterator.next(); } assertEquals(0, iterator.getBeginIndex()); assertEquals(1646, iterator.getEndIndex()); } public void test_formatToCharacterIteratorLjava_lang_Object__ArithmeticException() { DecimalFormat decimalFormat = (DecimalFormat) DecimalFormat .getInstance(Locale.US); decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); decimalFormat.setMaximumFractionDigits(0); try { // when rounding is needed, but RoundingMode is set to RoundingMode.UNNECESSARY, throw ArithmeticException decimalFormat.formatToCharacterIterator(new Double(1.5)); fail("ArithmeticException expected"); } catch (ArithmeticException e) { // expected } } public void test_formatDLjava_lang_StringBufferLjava_text_FieldPosition_ArithmeticException() { DecimalFormat decimalFormat = (DecimalFormat) DecimalFormat .getInstance(Locale.US); decimalFormat.setMaximumFractionDigits(0); decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); try { // when rounding is needed, but RoundingMode is set to RoundingMode.UNNECESSARY, throw ArithmeticException decimalFormat .format(11.5, new StringBuffer(), new FieldPosition(0)); fail("ArithmeticException expected"); } catch (ArithmeticException e) { // expected } } public void test_formatJLjava_lang_StringBufferLjava_text_FieldPosition_ArithmeticException() { final DecimalFormatSymbols dfs = new DecimalFormatSymbols(Locale.US); DecimalFormat decimalFormat = new DecimalFormat("00.0#E0", dfs); decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); try { // when rounding is needed, but RoundingMode is set to RoundingMode.UNNECESSARY, throw ArithmeticException decimalFormat.format(99999, new StringBuffer(), new FieldPosition(0)); fail("ArithmeticException expected"); } catch (ArithmeticException e) { // expected } } public void test_GetRoundingMode() { // get the default RoundingMode of this DecimalFormat DecimalFormat decimalFormat = (DecimalFormat) DecimalFormat .getInstance(Locale.US); // the default RoundingMode is HALF_EVEN assertEquals("Incorrect default RoundingMode", decimalFormat.getRoundingMode(), RoundingMode.HALF_EVEN); // set RoundingMode.HALF_DOWN of this DecimalFormat decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); assertEquals("Returned incorrect RoundingMode", decimalFormat .getRoundingMode(), RoundingMode.HALF_DOWN); } public void test_SetRoundingMode_Ljava_math_RoundingMode() { DecimalFormat decimalFormat = (DecimalFormat) DecimalFormat .getInstance(Locale.US); // ignore the fraction part of a given value decimalFormat.setMaximumFractionDigits(0); // set RoundingMode.HALF_DOWN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); String result = decimalFormat.format(11.3); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", "11", result); result = decimalFormat.format(11.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", "11", result); result = decimalFormat.format(11.6); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", "12", result); // set RoundingMode.CEILING of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.CEILING); result = decimalFormat.format(11.3); assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", "12", result); result = decimalFormat.format(-11.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", "-11", result); // set RoundingMode.DOWN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.DOWN); result = decimalFormat.format(11.3); assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", "11", result); result = decimalFormat.format(-11.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", "-11", result); result = decimalFormat.format(0); assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", "0", result); // set RoundingMode.FLOOR of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.FLOOR); result = decimalFormat.format(11.3); assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", "11", result); result = decimalFormat.format(-11.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", "-12", result); result = decimalFormat.format(0); assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", "0", result); // set RoundingMode.HALF_EVEN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_EVEN); result = decimalFormat.format(5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", "6", result); result = decimalFormat.format(-5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", "-6", result); result = decimalFormat.format(0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", "0", result); // set RoundingMode.HALF_UP of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_UP); result = decimalFormat.format(5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "6", result); result = decimalFormat.format(-5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "-6", result); result = decimalFormat.format(0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "0", result); result = decimalFormat.format(-0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "-0", result); // set RoundingMode.UP of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.UP); result = decimalFormat.format(5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "6", result); result = decimalFormat.format(-5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "-6", result); result = decimalFormat.format(0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "1", result); result = decimalFormat.format(-0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "-1", result); // set RoundingMode.UNNECESSARY of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); try { // when rounding is needed but RoundingMode is set to RoundingMode.UNNECESSARY, throw ArithmeticException result = decimalFormat.format(5.5); fail("ArithmeticException expected: RoundingMode.UNNECESSARY"); } catch (ArithmeticException e) { // expected } result = decimalFormat.format(1.0); assertEquals( "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", "1", result); result = decimalFormat.format(-1.0); assertEquals( "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", "-1", result); try { // when the given RoundingMode is null, throw NullPointerException decimalFormat.setRoundingMode(null); fail("NullPointerException expected"); } catch (NullPointerException e) { // expected } // set MaxFractionDigits to 3, test different DecimalFormat format // function with differnt RoundingMode decimalFormat.setMaximumFractionDigits(3); // set RoundingMode.HALF_DOWN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); result = decimalFormat.format(11.5653); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", "11.565", result); result = decimalFormat.format(11.5655); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", "11.565", result); result = decimalFormat.format(11.5656); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", "11.566", result); // set RoundingMode.CEILING of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.CEILING); result = decimalFormat.format(11.5653); assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", "11.566", result); result = decimalFormat.format(-11.5653); assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", "-11.565", result); // set RoundingMode.DOWN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.DOWN); result = decimalFormat.format(11.5653); assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", "11.565", result); result = decimalFormat.format(-11.5653); assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", "-11.565", result); result = decimalFormat.format(0); assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", "0", result); // set RoundingMode.FLOOR of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.FLOOR); result = decimalFormat.format(11.5653); assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", "11.565", result); result = decimalFormat.format(-11.5655); assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", "-11.566", result); result = decimalFormat.format(0); assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", "0", result); // set RoundingMode.HALF_EVEN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_EVEN); result = decimalFormat.format(11.5653); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", "11.565", result); result = decimalFormat.format(-11.5655); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", "-11.566", result); result = decimalFormat.format(11.5656); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", "11.566", result); // set RoundingMode.HALF_UP of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_UP); result = decimalFormat.format(11.5653); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "11.565", result); result = decimalFormat.format(-11.5655); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "-11.566", result); result = decimalFormat.format(11.5656); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "11.566", result); // set RoundingMode.UP of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.UP); result = decimalFormat.format(11.5653); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "11.566", result); result = decimalFormat.format(-11.5655); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "-11.566", result); // set RoundingMode.UNNECESSARY of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); result = decimalFormat.format(-11.565); assertEquals( "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", "-11.565", result); result = decimalFormat.format(11.565); assertEquals( "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", "11.565", result); // when setting MaxFractionDigits to negative value -2, default it as // zero, test different DecimalFormat format // function with differnt RoundingMode decimalFormat.setMaximumFractionDigits(-2); // set RoundingMode.HALF_DOWN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); result = decimalFormat.format(11.3); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", "11", result); result = decimalFormat.format(11.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", "11", result); result = decimalFormat.format(11.6); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_DOWN", "12", result); // set RoundingMode.CEILING of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.CEILING); result = decimalFormat.format(11.3); assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", "12", result); result = decimalFormat.format(-11.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.CEILING", "-11", result); // set RoundingMode.DOWN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.DOWN); result = decimalFormat.format(11.3); assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", "11", result); result = decimalFormat.format(-11.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", "-11", result); result = decimalFormat.format(0); assertEquals("Incorrect RoundingMode behavior: RoundingMode.DOWN", "0", result); // set RoundingMode.FLOOR of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.FLOOR); result = decimalFormat.format(11.3); assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", "11", result); result = decimalFormat.format(-11.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", "-12", result); result = decimalFormat.format(0); assertEquals("Incorrect RoundingMode behavior: RoundingMode.FLOOR", "0", result); // set RoundingMode.HALF_EVEN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_EVEN); result = decimalFormat.format(5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", "6", result); result = decimalFormat.format(-5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", "-6", result); result = decimalFormat.format(0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_EVEN", "0", result); // set RoundingMode.HALF_UP of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_UP); result = decimalFormat.format(5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "6", result); result = decimalFormat.format(-5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "-6", result); result = decimalFormat.format(0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "0", result); result = decimalFormat.format(-0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.HALF_UP", "-0", result); // set RoundingMode.UP of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.UP); result = decimalFormat.format(5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "6", result); result = decimalFormat.format(-5.5); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "-6", result); result = decimalFormat.format(0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "1", result); result = decimalFormat.format(-0.2); assertEquals("Incorrect RoundingMode behavior: RoundingMode.UP", "-1", result); // set RoundingMode.UNNECESSARY of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.UNNECESSARY); result = decimalFormat.format(1.0); assertEquals( "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", "1", result); result = decimalFormat.format(-1.0); assertEquals( "Incorrect RoundingMode behavior: RoundingMode.UNNECESSARY", "-1", result); // Regression for HARMONY-6485 // Test with applyPattern call after setRoundingMode // set RoundingMode.HALF_UP of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_UP); decimalFormat.applyPattern(".##"); result = decimalFormat.format(0.125); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".13", result); result = decimalFormat.format(0.255); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".26", result); result = decimalFormat.format(0.732); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".73", result); result = decimalFormat.format(0.467); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".47", result); // set RoundingMode.HALF_DOWN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_DOWN); decimalFormat.applyPattern(".##"); result = decimalFormat.format(0.125); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".12", result); result = decimalFormat.format(0.255); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".25", result); result = decimalFormat.format(0.732); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".73", result); result = decimalFormat.format(0.467); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".47", result); // set RoundingMode.UP of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.UP); decimalFormat.applyPattern(".##"); result = decimalFormat.format(0.125); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".13", result); result = decimalFormat.format(0.255); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".26", result); result = decimalFormat.format(0.732); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".74", result); result = decimalFormat.format(0.467); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".47", result); // set RoundingMode.DOWN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.DOWN); decimalFormat.applyPattern(".##"); result = decimalFormat.format(0.125); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".12", result); result = decimalFormat.format(0.255); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".25", result); result = decimalFormat.format(0.732); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".73", result); result = decimalFormat.format(0.467); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".46", result); // set RoundingMode.HALF_EVEN of this DecimalFormat and test its // behavior decimalFormat.setRoundingMode(RoundingMode.HALF_EVEN); decimalFormat.applyPattern(".##"); result = decimalFormat.format(0.125); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".12", result); result = decimalFormat.format(0.255); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".26", result); result = decimalFormat.format(0.732); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".73", result); result = decimalFormat.format(0.467); assertEquals( "Incorrect RoundingMode behavior after applyPattern", ".47", result); } }