jdk/test/java/text/Format/DecimalFormat/TieRoundingTest.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
  *
  * This code is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License version 2 only, as
  * published by the Free Software Foundation.
  *
  * This code is distributed in the hope that it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  * version 2 for more details (a copy is included in the LICENSE file that
  * accompanied this code).
  *
  * You should have received a copy of the GNU General Public License version
  * 2 along with this work; if not, write to the Free Software Foundation,
  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  *
  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  * or visit www.oracle.com if you need additional information or have any
  * questions.
  */

 /* @test
  *
  * @bug 7131459 8039915
  * @summary test various situations of NumberFormat rounding when close to tie
  * @author Olivier Lagneau
  * @run main TieRoundingTest
  *
  */

 import java.math.BigDecimal;
 import java.math.BigInteger;
 import java.text.NumberFormat;
 import java.text.DecimalFormat;
 import java.math.RoundingMode;
 import java.util.Locale;

 public class TieRoundingTest {

     static int testCounter = 0;
     static int errorCounter = 0;
     static boolean allPassed = true;

     static void formatOutputTestDouble(NumberFormat nf,
                                        double doubleToTest,
                                        String tiePosition,
                                        String inputDigits,
                                        String expectedOutput) {

         int mfd = nf.getMaximumFractionDigits();
         RoundingMode rm = nf.getRoundingMode();
         String result = nf.format(doubleToTest);

         if (!result.equals(expectedOutput)) {
             System.out.println();
             System.out.println("========================================");
             System.out.println("***Failure : error formatting value from string : " +
                                inputDigits);
             System.out.println("NumberFormat pattern is  : " +
                                ((DecimalFormat ) nf).toPattern());
             System.out.println("Maximum number of fractional digits : " + mfd);
             System.out.println("Fractional rounding digit : " + (mfd + 1));
             System.out.println("Position of value relative to tie : " + tiePosition);
             System.out.println("Rounding Mode : " + rm);
             System.out.println("BigDecimal output : " +
                                new BigDecimal(doubleToTest).toString());
             System.out.println("FloatingDecimal output : " + doubleToTest);
             System.out.println(
                "Error. Formatted result different from expected." +
                "\nExpected output is : \"" + expectedOutput + "\"" +
                "\nFormated output is : \"" + result + "\"");
             System.out.println("========================================");
             System.out.println();

             errorCounter++;
             allPassed = false;
         } else {
             testCounter++;
             System.out.println("\nSuccess for double value : " + doubleToTest + " :");
             System.out.println(" Input digits :" + inputDigits +
                                ", BigDecimal value : " +
                                new BigDecimal(doubleToTest).toString());
             System.out.print(" Rounding mode: " + rm);
             System.out.print(", fract digits : " + mfd);
             System.out.print(", position : " + tiePosition + " tie");
             System.out.print(", result : " + result);
             System.out.println(", expected : " + expectedOutput);
         }
     }

     static void formatOutputTestLong(NumberFormat nf,
                                      long longToTest,
                                      String tiePosition,
                                      String inputDigits,
                                      String expectedOutput) {

         int mfd = nf.getMaximumFractionDigits();
         RoundingMode rm = nf.getRoundingMode();
         String result = nf.format(longToTest);

         if (!result.equals(expectedOutput)) {
             System.out.println();
             System.out.println("========================================");
             System.out.println("***Failure : error formatting value from string : " +
                                inputDigits);
             System.out.println("NumberFormat pattern is  : " +
                                ((DecimalFormat ) nf).toPattern());
             System.out.println("Maximum number of fractional digits : " + mfd);
             System.out.println("Fractional rounding digit : " + (mfd + 1));
             System.out.println("Position of value relative to tie : " + tiePosition);
             System.out.println("Rounding Mode : " + rm);
             System.out.println(
                "Error. Formatted result different from expected." +
                "\nExpected output is : \"" + expectedOutput + "\"" +
                "\nFormated output is : \"" + result + "\"");
             System.out.println("========================================");
             System.out.println();

             errorCounter++;
             allPassed = false;
         } else {
             testCounter++;
             System.out.print("Success. Long input :" + inputDigits);
             System.out.print(", rounding : " + rm);
             System.out.print(", fract digits : " + mfd);
             System.out.print(", tie position : " + tiePosition);
             System.out.println(", expected : " + expectedOutput);

         }
     }

     static void formatOutputTestObject(NumberFormat nf,
                                        Object someNumber,
                                        String tiePosition,
                                        String inputDigits,
                                        String expectedOutput) {

         int mfd = nf.getMaximumFractionDigits();
         RoundingMode rm = nf.getRoundingMode();
         String result = nf.format(someNumber);

         if (!result.equals(expectedOutput)) {
             System.out.println();
             System.out.println("========================================");
             System.out.println("***Failure : error formatting value from string : " +
                                inputDigits);
             System.out.println("NumberFormat pattern is  : " +
                                ((DecimalFormat ) nf).toPattern());
             System.out.println("Maximum number of fractional digits : " + mfd);
             System.out.println("Fractional rounding digit : " + (mfd + 1));
             System.out.println("Position of value relative to tie : " + tiePosition);
             System.out.println("Rounding Mode : " + rm);
             System.out.println("Number self output representation: " + someNumber);
             System.out.println(
                "Error. Formatted result different from expected." +
                "\nExpected output is : \"" + expectedOutput + "\"" +
                "\nFormated output is : \"" + result + "\"");
             System.out.println("========================================");
             System.out.println();

             errorCounter++;
             allPassed = false;
         } else {
             testCounter++;
             System.out.print("Success. Number input :" + inputDigits);
             System.out.print(", rounding : " + rm);
             System.out.print(", fract digits : " + mfd);
             System.out.print(", tie position : " + tiePosition);
             System.out.println(", expected : " + expectedOutput);
         }
     }

     public static void main(String[] args) {

         // The 3 HALF_* rounding modes are impacted by bugs 7131459, 8039915.
         // So we do not test the other rounding modes.
         RoundingMode[] roundingModes = {
             RoundingMode.HALF_DOWN,
             RoundingMode.HALF_EVEN,
             RoundingMode.HALF_UP
         };

         // Precise the relative position of input value against its closest tie.
         // The double values tested below for 3 and 5 fractional digits must follow
         // this scheme (position toward tie).
         String[] tieRelativePositions = {
             "below", "exact", "above",
             "below", "exact", "above",
             "below", "exact", "above",
             "below", "above", "above",
             "below", "below", "above",
             "below", "exact", "above"
         };

         // =============== Testing double (and thus float) value cases =========

         System.out.println("\n===== testing 3 digits rounding position =====");
         double[] values3FractDigits = {
             // unimpacting values close to tie, with less than 3 input fract digits
             1.115d, 1.125d, 1.135d,
             // HALF_* impacting close to tie values covering all 6 tie cases
             0.3115d, 0.3125d, 0.3135d,
             0.6865d, 0.6875d, 0.6885d,
             // specific HALF_UP close to tie values
             0.3124d, 0.3126d, 0.3128d,
             // specific HALF_DOWN close to tie values
             0.6864d, 0.6865d, 0.6868d,
             // unimpacting values close to tie, with more than 3 input fract digits
             1.46885d, 2.46875d, 1.46865d
         };

         String[] inputs3FractDigits = {
             "1.115d", "1.125d", "1.135d",
             "0.3115d", "0.3125d", "0.3135d",
             "0.6865d", "0.6875d", "0.6885d",
             "0.3124d", "0.3126d", "0.3128d",
             "0.6864d", "0.6865d", "0.6868d",
             "1.46885d", "2.46875d", "1.46865d"
         };

         String[][] expected3FractDigits = {
             {"1.115", "1.125", "1.135",
              "0.311", "0.312", "0.314",
              "0.686", "0.687", "0.689",
              "0.312", "0.313", "0.313",
              "0.686", "0.686", "0.687",
              "1.469", "2.469", "1.469"
             },
             {"1.115", "1.125", "1.135",
              "0.311", "0.312", "0.314",
              "0.686", "0.688", "0.689",
              "0.312", "0.313", "0.313",
              "0.686", "0.686", "0.687",
              "1.469", "2.469", "1.469"
             },
             {"1.115", "1.125", "1.135",
              "0.311", "0.313", "0.314",
              "0.686", "0.688", "0.689",
              "0.312", "0.313", "0.313",
              "0.686", "0.686", "0.687",
              "1.469", "2.469", "1.469"
             },
         };


         for (int r = 0; r < roundingModes.length; r++) {
             NumberFormat dfDefault = NumberFormat.getInstance(Locale.US);
             RoundingMode rmode = roundingModes[r];
             dfDefault.setRoundingMode(rmode);
             System.out.println("\n----- Now checking " + rmode +
                                " rounding mode -----");

             for (int i = 0; i < values3FractDigits.length; i++) {
                 double d = values3FractDigits[i];
                 String tiePosition = tieRelativePositions[i];
                 String input = inputs3FractDigits[i];
                 String expected = expected3FractDigits[r][i];

                 formatOutputTestDouble(dfDefault, d, tiePosition, input, expected);
             }
         }

         System.out.println("\n===== testing 5 digits rounding position =====");
         double[] values5FractDigits = {
             // unimpacting values close to tie, with less than 5 input fract digits
             1.3135d, 1.3125d, 1.3115d,
             // HALF_* impacting values close to tie, covering all 6 cases
             1.328115d, 1.328125d, 1.328135d,
             1.796865d, 1.796875d, 1.796885d,
             // specific HALF_UP close to tie values
             1.328124d, 1.798876d, 1.796889d,
             // specific HALF_DOWN close to tie values
             1.328114d, 1.796865d, 1.328138d,
             // unimpacting values close to tie, with more than 5 input fract digits
             1.3281149999999d, 1.75390625d, 1.7968750000001d
         };

         String[] inputs5FractDigits = {
             "1.3135d", "1.3125d", "1.3115d",
             "1.328115d", "1.328125d", "1.328135d",
             "1.796865d", "1.796875d", "1.796885d",
             "1.328124d", "1.798876d", "1.796889d",
             "1.328114d", "1.796865d", "1.328138d",
             "1.3281149999999d", "1.75390625d", "1.7968750000001d"
         };

         String[][] expected5FractDigits = {
             {"1.3135", "1.3125", "1.3115",
              "1.32811", "1.32812", "1.32814",
              "1.79686", "1.79687", "1.79689",
              "1.32812", "1.79888", "1.79689",
              "1.32811", "1.79686", "1.32814",
              "1.32811", "1.75391", "1.79688"
             },
             {"1.3135", "1.3125", "1.3115",
              "1.32811", "1.32812", "1.32814",
              "1.79686", "1.79688", "1.79689",
              "1.32812", "1.79888", "1.79689",
              "1.32811", "1.79686", "1.32814",
              "1.32811", "1.75391", "1.79688"
             },
             {"1.3135", "1.3125", "1.3115",
              "1.32811", "1.32813", "1.32814",
              "1.79686", "1.79688", "1.79689",
              "1.32812", "1.79888", "1.79689",
              "1.32811", "1.79686", "1.32814",
              "1.32811", "1.75391", "1.79688"
             }
         };


         for (int r = 0; r < roundingModes.length; r++) {
             DecimalFormat df5 = (DecimalFormat) NumberFormat.getInstance(Locale.US);
             RoundingMode rmode = roundingModes[r];
             df5.setRoundingMode(rmode);
             System.out.println("\n----- Now checking " + rmode +
                                " rounding mode -----");
             df5.applyPattern("#,###.#####");

             for (int i = 0; i < values5FractDigits.length; i++) {
                 double d = values5FractDigits[i];
                 String tiePosition = tieRelativePositions[i];
                 String input = inputs5FractDigits[i];
                 String expected = expected5FractDigits[r][i];

                 formatOutputTestDouble(df5, d, tiePosition, input, expected);
             }
         }

         // ==================== Testing long value cases ====================

         System.out.println("\n===== testing long values =====");
         long l = 123456789012345L;
         DecimalFormat dfLong = (DecimalFormat) NumberFormat.getInstance(Locale.US);
         String tiePosition = "exact";
         String input = "123456789012345L";
         String expected = "123,456,789,012,345";
         String result = dfLong.format(l);
         formatOutputTestLong(dfLong, l, tiePosition, input, expected);

         dfLong.applyPattern("0.###E0");
         expected = "1.235E14";
         formatOutputTestLong(dfLong, l, tiePosition, input, expected);

         l = 123450000000000L;
         input = "123450000000000L";
         expected = "1.234E14";
         formatOutputTestLong(dfLong, l, tiePosition, input, expected);

         l = 987750000000000L;
         input = "987750000000000L";
         expected = "9.878E14";
         formatOutputTestLong(dfLong, l, tiePosition, input, expected);

         dfLong.applyPattern("#,###.0E0");
         l = 987755000000000L;
         input = "987755000000000L";
         expected = "987.76E12";

         formatOutputTestLong(dfLong, l, tiePosition, input, expected);


         // ================= Testing BigInteger value cases =================

         System.out.println("\n===== testing BigInteger values =====");
         String stringValue = "12345678901234567890123456789012345";
         BigInteger bi = new BigInteger(stringValue);
         DecimalFormat dfBig = (DecimalFormat) NumberFormat.getInstance(Locale.US);
         tiePosition = "exact";
         input = stringValue;
         expected = "12,345,678,901,234,567,890,123,456,789,012,345";
         formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

         dfBig.applyPattern("0.###E0");
         expected = "1.235E34";
         formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

         stringValue = "12345000000000000000000000000000000";
         input = stringValue;
         bi = new BigInteger(stringValue);
         expected = "1.234E34";
         formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

         stringValue = "12345000000000000000000000000000001";
         input = stringValue;
         bi = new BigInteger(stringValue);
         expected = "1.235E34";
         formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

         stringValue = "98755000000000000000000000000000000";
         input = stringValue;
         bi = new BigInteger(stringValue);
         expected = "9.876E34";
         formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

         dfLong.applyPattern("#,###.0E0");
         stringValue = "98775500000000000000000000000000000";
         input = stringValue;
         expected = "987.76E34";

         // =============== Testing BigDecimal value cases ================

         System.out.println("\n===== testing BigDecimal values =====");
         dfBig = (DecimalFormat) NumberFormat.getInstance(Locale.US);

         stringValue = "0.68850000000000000088817841970012523233890533447265625";
         BigDecimal bd = new BigDecimal(stringValue);
         tiePosition = "exact";
         input = stringValue;
         expected = "0.689";
         formatOutputTestObject(dfBig, bd, tiePosition, input, expected);

         stringValue = "0.31149999999999999911182158029987476766109466552734375";
         bd = new BigDecimal(stringValue);
         dfBig.applyPattern("#,##0.####");
         tiePosition = "exact";
         input = stringValue;
         expected = "0.3115";
         formatOutputTestObject(dfBig, bd, tiePosition, input, expected);

         // ==================== Printing results and exiting ===================

         System.out.println();
         System.out.println("==> " + testCounter + " tests passed successfully");
         System.out.println("==> " + errorCounter + " tests failed");

         System.out.println();
         if (allPassed) {
             System.out.println(
                 "Success in formating all the values with the given parameters");
         } else {
             String s = "Test failed with " + errorCounter + " formating error(s).";
             System.out.println(s);
             throw new RuntimeException(s);
         }
     }
 }
	/*
	* Copyright (c) 2012, 2014, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	/* @test
	*
	* @bug 7131459 8039915
	* @summary test various situations of NumberFormat rounding when close to tie
	* @author Olivier Lagneau
	* @run main TieRoundingTest
	*
	*/

	import java.math.BigDecimal;
	import java.math.BigInteger;
	import java.text.NumberFormat;
	import java.text.DecimalFormat;
	import java.math.RoundingMode;
	import java.util.Locale;

	public class TieRoundingTest {

	static int testCounter = 0;
	static int errorCounter = 0;
	static boolean allPassed = true;

	static void formatOutputTestDouble(NumberFormat nf,
	double doubleToTest,
	String tiePosition,
	String inputDigits,
	String expectedOutput) {

	int mfd = nf.getMaximumFractionDigits();
	RoundingMode rm = nf.getRoundingMode();
	String result = nf.format(doubleToTest);

	if (!result.equals(expectedOutput)) {
	System.out.println();
	System.out.println("========================================");
	System.out.println("***Failure : error formatting value from string : " +
	inputDigits);
	System.out.println("NumberFormat pattern is : " +
	((DecimalFormat ) nf).toPattern());
	System.out.println("Maximum number of fractional digits : " + mfd);
	System.out.println("Fractional rounding digit : " + (mfd + 1));
	System.out.println("Position of value relative to tie : " + tiePosition);
	System.out.println("Rounding Mode : " + rm);
	System.out.println("BigDecimal output : " +
	new BigDecimal(doubleToTest).toString());
	System.out.println("FloatingDecimal output : " + doubleToTest);
	System.out.println(
	"Error. Formatted result different from expected." +
	"\nExpected output is : \"" + expectedOutput + "\"" +
	"\nFormated output is : \"" + result + "\"");
	System.out.println("========================================");
	System.out.println();

	errorCounter++;
	allPassed = false;
	} else {
	testCounter++;
	System.out.println("\nSuccess for double value : " + doubleToTest + " :");
	System.out.println(" Input digits :" + inputDigits +
	", BigDecimal value : " +
	new BigDecimal(doubleToTest).toString());
	System.out.print(" Rounding mode: " + rm);
	System.out.print(", fract digits : " + mfd);
	System.out.print(", position : " + tiePosition + " tie");
	System.out.print(", result : " + result);
	System.out.println(", expected : " + expectedOutput);
	}
	}

	static void formatOutputTestLong(NumberFormat nf,
	long longToTest,
	String tiePosition,
	String inputDigits,
	String expectedOutput) {

	int mfd = nf.getMaximumFractionDigits();
	RoundingMode rm = nf.getRoundingMode();
	String result = nf.format(longToTest);

	if (!result.equals(expectedOutput)) {
	System.out.println();
	System.out.println("========================================");
	System.out.println("***Failure : error formatting value from string : " +
	inputDigits);
	System.out.println("NumberFormat pattern is : " +
	((DecimalFormat ) nf).toPattern());
	System.out.println("Maximum number of fractional digits : " + mfd);
	System.out.println("Fractional rounding digit : " + (mfd + 1));
	System.out.println("Position of value relative to tie : " + tiePosition);
	System.out.println("Rounding Mode : " + rm);
	System.out.println(
	"Error. Formatted result different from expected." +
	"\nExpected output is : \"" + expectedOutput + "\"" +
	"\nFormated output is : \"" + result + "\"");
	System.out.println("========================================");
	System.out.println();

	errorCounter++;
	allPassed = false;
	} else {
	testCounter++;
	System.out.print("Success. Long input :" + inputDigits);
	System.out.print(", rounding : " + rm);
	System.out.print(", fract digits : " + mfd);
	System.out.print(", tie position : " + tiePosition);
	System.out.println(", expected : " + expectedOutput);

	}
	}

	static void formatOutputTestObject(NumberFormat nf,
	Object someNumber,
	String tiePosition,
	String inputDigits,
	String expectedOutput) {

	int mfd = nf.getMaximumFractionDigits();
	RoundingMode rm = nf.getRoundingMode();
	String result = nf.format(someNumber);

	if (!result.equals(expectedOutput)) {
	System.out.println();
	System.out.println("========================================");
	System.out.println("***Failure : error formatting value from string : " +
	inputDigits);
	System.out.println("NumberFormat pattern is : " +
	((DecimalFormat ) nf).toPattern());
	System.out.println("Maximum number of fractional digits : " + mfd);
	System.out.println("Fractional rounding digit : " + (mfd + 1));
	System.out.println("Position of value relative to tie : " + tiePosition);
	System.out.println("Rounding Mode : " + rm);
	System.out.println("Number self output representation: " + someNumber);
	System.out.println(
	"Error. Formatted result different from expected." +
	"\nExpected output is : \"" + expectedOutput + "\"" +
	"\nFormated output is : \"" + result + "\"");
	System.out.println("========================================");
	System.out.println();

	errorCounter++;
	allPassed = false;
	} else {
	testCounter++;
	System.out.print("Success. Number input :" + inputDigits);
	System.out.print(", rounding : " + rm);
	System.out.print(", fract digits : " + mfd);
	System.out.print(", tie position : " + tiePosition);
	System.out.println(", expected : " + expectedOutput);
	}
	}

	public static void main(String[] args) {

	// The 3 HALF_* rounding modes are impacted by bugs 7131459, 8039915.
	// So we do not test the other rounding modes.
	RoundingMode[] roundingModes = {
	RoundingMode.HALF_DOWN,
	RoundingMode.HALF_EVEN,
	RoundingMode.HALF_UP
	};

	// Precise the relative position of input value against its closest tie.
	// The double values tested below for 3 and 5 fractional digits must follow
	// this scheme (position toward tie).
	String[] tieRelativePositions = {
	"below", "exact", "above",
	"below", "exact", "above",
	"below", "exact", "above",
	"below", "above", "above",
	"below", "below", "above",
	"below", "exact", "above"
	};

	// =============== Testing double (and thus float) value cases =========

	System.out.println("\n===== testing 3 digits rounding position =====");
	double[] values3FractDigits = {
	// unimpacting values close to tie, with less than 3 input fract digits
	1.115d, 1.125d, 1.135d,
	// HALF_* impacting close to tie values covering all 6 tie cases
	0.3115d, 0.3125d, 0.3135d,
	0.6865d, 0.6875d, 0.6885d,
	// specific HALF_UP close to tie values
	0.3124d, 0.3126d, 0.3128d,
	// specific HALF_DOWN close to tie values
	0.6864d, 0.6865d, 0.6868d,
	// unimpacting values close to tie, with more than 3 input fract digits
	1.46885d, 2.46875d, 1.46865d
	};

	String[] inputs3FractDigits = {
	"1.115d", "1.125d", "1.135d",
	"0.3115d", "0.3125d", "0.3135d",
	"0.6865d", "0.6875d", "0.6885d",
	"0.3124d", "0.3126d", "0.3128d",
	"0.6864d", "0.6865d", "0.6868d",
	"1.46885d", "2.46875d", "1.46865d"
	};

	String[][] expected3FractDigits = {
	{"1.115", "1.125", "1.135",
	"0.311", "0.312", "0.314",
	"0.686", "0.687", "0.689",
	"0.312", "0.313", "0.313",
	"0.686", "0.686", "0.687",
	"1.469", "2.469", "1.469"
	},
	{"1.115", "1.125", "1.135",
	"0.311", "0.312", "0.314",
	"0.686", "0.688", "0.689",
	"0.312", "0.313", "0.313",
	"0.686", "0.686", "0.687",
	"1.469", "2.469", "1.469"
	},
	{"1.115", "1.125", "1.135",
	"0.311", "0.313", "0.314",
	"0.686", "0.688", "0.689",
	"0.312", "0.313", "0.313",
	"0.686", "0.686", "0.687",
	"1.469", "2.469", "1.469"
	},
	};


	for (int r = 0; r < roundingModes.length; r++) {
	NumberFormat dfDefault = NumberFormat.getInstance(Locale.US);
	RoundingMode rmode = roundingModes[r];
	dfDefault.setRoundingMode(rmode);
	System.out.println("\n----- Now checking " + rmode +
	" rounding mode -----");

	for (int i = 0; i < values3FractDigits.length; i++) {
	double d = values3FractDigits[i];
	String tiePosition = tieRelativePositions[i];
	String input = inputs3FractDigits[i];
	String expected = expected3FractDigits[r][i];

	formatOutputTestDouble(dfDefault, d, tiePosition, input, expected);
	}
	}

	System.out.println("\n===== testing 5 digits rounding position =====");
	double[] values5FractDigits = {
	// unimpacting values close to tie, with less than 5 input fract digits
	1.3135d, 1.3125d, 1.3115d,
	// HALF_* impacting values close to tie, covering all 6 cases
	1.328115d, 1.328125d, 1.328135d,
	1.796865d, 1.796875d, 1.796885d,
	// specific HALF_UP close to tie values
	1.328124d, 1.798876d, 1.796889d,
	// specific HALF_DOWN close to tie values
	1.328114d, 1.796865d, 1.328138d,
	// unimpacting values close to tie, with more than 5 input fract digits
	1.3281149999999d, 1.75390625d, 1.7968750000001d
	};

	String[] inputs5FractDigits = {
	"1.3135d", "1.3125d", "1.3115d",
	"1.328115d", "1.328125d", "1.328135d",
	"1.796865d", "1.796875d", "1.796885d",
	"1.328124d", "1.798876d", "1.796889d",
	"1.328114d", "1.796865d", "1.328138d",
	"1.3281149999999d", "1.75390625d", "1.7968750000001d"
	};

	String[][] expected5FractDigits = {
	{"1.3135", "1.3125", "1.3115",
	"1.32811", "1.32812", "1.32814",
	"1.79686", "1.79687", "1.79689",
	"1.32812", "1.79888", "1.79689",
	"1.32811", "1.79686", "1.32814",
	"1.32811", "1.75391", "1.79688"
	},
	{"1.3135", "1.3125", "1.3115",
	"1.32811", "1.32812", "1.32814",
	"1.79686", "1.79688", "1.79689",
	"1.32812", "1.79888", "1.79689",
	"1.32811", "1.79686", "1.32814",
	"1.32811", "1.75391", "1.79688"
	},
	{"1.3135", "1.3125", "1.3115",
	"1.32811", "1.32813", "1.32814",
	"1.79686", "1.79688", "1.79689",
	"1.32812", "1.79888", "1.79689",
	"1.32811", "1.79686", "1.32814",
	"1.32811", "1.75391", "1.79688"
	}
	};


	for (int r = 0; r < roundingModes.length; r++) {
	DecimalFormat df5 = (DecimalFormat) NumberFormat.getInstance(Locale.US);
	RoundingMode rmode = roundingModes[r];
	df5.setRoundingMode(rmode);
	System.out.println("\n----- Now checking " + rmode +
	" rounding mode -----");
	df5.applyPattern("#,###.#####");

	for (int i = 0; i < values5FractDigits.length; i++) {
	double d = values5FractDigits[i];
	String tiePosition = tieRelativePositions[i];
	String input = inputs5FractDigits[i];
	String expected = expected5FractDigits[r][i];

	formatOutputTestDouble(df5, d, tiePosition, input, expected);
	}
	}

	// ==================== Testing long value cases ====================

	System.out.println("\n===== testing long values =====");
	long l = 123456789012345L;
	DecimalFormat dfLong = (DecimalFormat) NumberFormat.getInstance(Locale.US);
	String tiePosition = "exact";
	String input = "123456789012345L";
	String expected = "123,456,789,012,345";
	String result = dfLong.format(l);
	formatOutputTestLong(dfLong, l, tiePosition, input, expected);

	dfLong.applyPattern("0.###E0");
	expected = "1.235E14";
	formatOutputTestLong(dfLong, l, tiePosition, input, expected);

	l = 123450000000000L;
	input = "123450000000000L";
	expected = "1.234E14";
	formatOutputTestLong(dfLong, l, tiePosition, input, expected);

	l = 987750000000000L;
	input = "987750000000000L";
	expected = "9.878E14";
	formatOutputTestLong(dfLong, l, tiePosition, input, expected);

	dfLong.applyPattern("#,###.0E0");
	l = 987755000000000L;
	input = "987755000000000L";
	expected = "987.76E12";

	formatOutputTestLong(dfLong, l, tiePosition, input, expected);


	// ================= Testing BigInteger value cases =================

	System.out.println("\n===== testing BigInteger values =====");
	String stringValue = "12345678901234567890123456789012345";
	BigInteger bi = new BigInteger(stringValue);
	DecimalFormat dfBig = (DecimalFormat) NumberFormat.getInstance(Locale.US);
	tiePosition = "exact";
	input = stringValue;
	expected = "12,345,678,901,234,567,890,123,456,789,012,345";
	formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

	dfBig.applyPattern("0.###E0");
	expected = "1.235E34";
	formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

	stringValue = "12345000000000000000000000000000000";
	input = stringValue;
	bi = new BigInteger(stringValue);
	expected = "1.234E34";
	formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

	stringValue = "12345000000000000000000000000000001";
	input = stringValue;
	bi = new BigInteger(stringValue);
	expected = "1.235E34";
	formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

	stringValue = "98755000000000000000000000000000000";
	input = stringValue;
	bi = new BigInteger(stringValue);
	expected = "9.876E34";
	formatOutputTestObject(dfBig, bi, tiePosition, input, expected);

	dfLong.applyPattern("#,###.0E0");
	stringValue = "98775500000000000000000000000000000";
	input = stringValue;
	expected = "987.76E34";

	// =============== Testing BigDecimal value cases ================

	System.out.println("\n===== testing BigDecimal values =====");
	dfBig = (DecimalFormat) NumberFormat.getInstance(Locale.US);

	stringValue = "0.68850000000000000088817841970012523233890533447265625";
	BigDecimal bd = new BigDecimal(stringValue);
	tiePosition = "exact";
	input = stringValue;
	expected = "0.689";
	formatOutputTestObject(dfBig, bd, tiePosition, input, expected);

	stringValue = "0.31149999999999999911182158029987476766109466552734375";
	bd = new BigDecimal(stringValue);
	dfBig.applyPattern("#,##0.####");
	tiePosition = "exact";
	input = stringValue;
	expected = "0.3115";
	formatOutputTestObject(dfBig, bd, tiePosition, input, expected);

	// ==================== Printing results and exiting ===================

	System.out.println();
	System.out.println("==> " + testCounter + " tests passed successfully");
	System.out.println("==> " + errorCounter + " tests failed");

	System.out.println();
	if (allPassed) {
	System.out.println(
	"Success in formating all the values with the given parameters");
	} else {
	String s = "Test failed with " + errorCounter + " formating error(s).";
	System.out.println(s);
	throw new RuntimeException(s);
	}
	}
	}