RoundingAndPropertyTest.java

/*
 * Copyright (c) 2012, 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 7050528
 * @summary Test java.text.DecimalFormat fast-path for format(double...)
 * @author Olivier Lagneau
 * @run main RoundingAndPropertyTest
 *
 */

/* -----------------------------------------------------------------------------
 * Note :
 *  Since fast-path algorithm   does not modify  any feature  of DecimalFormat,
 *  some tests or  values in this program  may have to be adapted/added/removed
 *  when any change has been done in the fast-path source  code, because the
 *  conditions for exercising fast-path may change.
 *
 *  This is specially true if the set of constraints to fall in the fast-path
 *  case is relaxed in any manner.
 *
 * Usage :
 *  - Run main without any argument to test against a set of golden values and
 *    associated results hard-coded in the source code. That will do the tests
 *    described below
 *    See below comment section named "Description".
 *
 *  or
 *
 *  - Run main with string argument "-gengold" to output source code of
 *    GoldenFormattedValues.java class file with the jdk version used while
 *    generating the code.
 *    See below comment section named : "Modifying Golden Values".
 *
 *  In case of error while running the test, a Runtime exception is generated
 *  providing the numbers of errors detected (format of golden values checks and
 *  property changes checks), and the program exit.
 *
 * Description :
 *
 *  This test first checks that localization of digits is done correctly when
 *  calling DecimalFormat.format() on the array of values DecimalLocalizationValues
 *  found in GoldenDoubleValues, using the locale FullLocalizationTestLocale
 *  (from GoldenDoubleValues) that implies localization of digits. it checks the
 *  the results against expected returned string. In case of formatting error,
 *  it provides a message informing which value was wrongly formatted.
 *
 *  Then it checks the results of  calling NumberFormat.format(double) on a set
 *  of  predefined golden values and  checks results against expected returned
 *  string.  It does this both for the  decimal case, with an instance returned
 *  NumberFormat.getInstance() call and for the currency case, with an instance
 *  returned by NumberFormat.getCurrencyInstance(). Almost all the tested  double
 *  values satisfy the constraints assumed by the fast-path algorithm for
 *  format(double ...). Some  are voluntarily outside the scope of fast-path to
 *  check that the algorithm correctly eliminate them. In case of formatting
 *  error a message provides information on the golden value raising the error
 *  (value, exact decimal value (using BidDecimal), expected result, formatted result).
 *
 *  Last  the test checks the status and  behavior of a DecimalFormat instance
 *  when changing  properties that  make this  instance  satisfy/invalidate its
 *  fast-path status, depending on the predefined  set of fast-path constraints.
 *
 *  The golden  results are predefined arrays  of  int[] containing the unicode
 *  ints of the chars  in  the expected  formatted  string, when  using  locale
 *  provided in  GoldenDoubleValues class. The   results are those obtained  by
 *  using a reference jdk  version (for example  one that does not contains the
 *  DecimalFormat fast-path algorithm, like jdk80-b25).
 *
 *  The double values from which we get golden results are stored inside two
 *  arrays of double values:
 *  - DecimalGoldenValues  for testing NumberFormat.getInstance().
 *  - CurrencyGoldenValues for testing NumberFormat.getCurrencyInstance().
 *  These arrays are located in GoldenDoubleValues.java source file.
 *
 *  For each double value in the arrays above, there is an associated golden
 *  result. These results are stored in arrays of int[]:
 *  - DecimalGoldenFormattedValues  for expected decimal golden results.
 *  - CurrencyGoldenFormattedValues for expected currency golden results.
 *  - DecimalDigitsLocalizedFormattedValues for expected localized digit results.
 *
 *  We store the results in int[] arrays containing the expected unicode values
 *  because the  compiler that will compile the  containing java file may use a
 *  different locale than the one registered in GoldenDoubleValues.java.  These
 *  arrays are  located in  a  separate GoldenFormattedValues.java  source file
 *  that is generated  by  RoundingAndPropertyTest using  "-gengold"  parameter.
 *  See below "Modifying Golden Values".
 *
 *  The golden value arrays can be expanded, modified ... to test additional
 *  or different double values. In that case, the source file of class
 *  GoldenFormattedValues must be regenerated to replace the existing one..
 *
 * Modifying Golden Values :
 *
 *  In order to ease further modification of the list of double values checked
 *  and associated golden results, the test includes the method
 *  generatesGoldenFormattedValuesClass() that writes on standard output stream
 *  the source code for GoldenFormattedValues class that includes the expected
 *  results arrays.
 *
 *  Here are the steps to follow for updating/modifying golden values and results:
 *   1- Edit GoldenDoubleValues.java to add/remove/modify golden or localization
 *      values.
 *   2- Run main with "-gengold" string argument with a target jdk.
 *      (at the creation of this test file, the target jdk used was jdk1.8.0-ea).
 *   2- Copy this java code that has been writen on standard output and replace
 *      GoldenFormattedValues.java contents by the generated output.
 *   3- Check that this updated code compiles.
 *  [4]- If needed replaces existing GoldenDoubleValues and GoldenFormattedValues
 *      files in jdk/test section, respectively by the one modified at step 1 and
 *      generated at step 2.
 * -----------------------------------------------------------------------------
 */

import java.util.*;
import java.text.NumberFormat;
import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
import java.math.RoundingMode;
import java.math.BigDecimal;


public class RoundingAndPropertyTest {


    // Prints on standard output stream the unicode values of chars as a
    // comma-separated list of int values
    private static void printUnicodeValuesArray(char[] chars) {
        for (int i = 0; i < chars.length; i++) {
            System.out.print((int) chars[i]);
            if (i != (chars.length - 1))
                System.out.print(", ");
        }
    }

    // Converts given array of unicode values as an array of chars.
    // Returns this converted array.
    private static char[] getCharsFromUnicodeArray(int[] unicodeValues) {
        char[] chars = new char[unicodeValues.length];

        for (int i = 0; i < unicodeValues.length; i++) {
            chars[i] = (char) unicodeValues[i];
        }
        return chars;
    }

    /* Prints on standard output stream the java code of resulting
     * GoldenFormattedValues class for the golden values found in
     * class GoldenDoubleValues.
     */
    private static void generatesGoldenFormattedValuesClass() {

        String fourWhiteSpaces    = "    ";
        String eightWhiteSpaces   = "        ";

        // Prints header without Copyright header.
        System.out.println("/* This is a machine generated file - Please DO NOT EDIT !");
        System.out.println(" * Change RoundingAndPropertyTest instead,");
        System.out.println(" * and run with \"-gengold\" argument to regenerate (without copyright header).");
        System.out.println(" */");
        System.out.println();

        System.out.println("/* This file contains the set of result Strings expected from calling inside");
        System.out.println(" * RoundingAndPropertyTest the method NumberFormat.format() upon the set of");
        System.out.println(" * double values provided in GoldenDoubleValues.java. It contains three arrays,");
        System.out.println(" * each containing arrays of unicode values representing the expected string");
        System.out.println(" * result when calling format() on the corresponding (i.e. same index) double");
        System.out.println(" * value found in GoldenDoubleValues arrays :");
        System.out.println(" * - DecimalDigitsLocalizedFormattedValues corresponds to DecimalLocalizationValues,");
        System.out.println(" *   when using FullLocalizationTestLocale to format.");
        System.out.println(" * - DecimalGoldenFormattedValues corresponds to DecimalGoldenValues, when used");
        System.out.println(" *   in the decimal pattern case together with TestLocale.");
        System.out.println(" * - CurrencyGoldenFormattedValues corresponds to CurrencyGoldenValues. when used");
        System.out.println(" *   in the currency pattern case together with TestLocale.");
        System.out.println(" * Please see documentation in RoundingAndPropertyTest.java for more details.");
        System.out.println(" *");
        System.out.println(" * This file generated by running RoundingAndPropertyTest with \"-gengold\" argument.");
        System.out.println(" */");
        System.out.println();

        // Prints beginning of class GoldenFormattedValues.
        System.out.println("class GoldenFormattedValues {");
        System.out.println();
        System.out.println(
            fourWhiteSpaces +
            "// The formatted values below were generated from golden values");
        System.out.print(
            fourWhiteSpaces +
            "// listed in GoldenDoubleValues.java,");
        System.out.println(" using the following jvm version :");
        System.out.println(
            fourWhiteSpaces + "//   " +
            System.getProperty("java.vendor") +
            " " +
            System.getProperty("java.vm.name") +
            " " +
            System.getProperty("java.version"));
        System.out.println(
            fourWhiteSpaces +
            "//   locale for golden double values : " + GoldenDoubleValues.TestLocale);
        System.out.println(
            fourWhiteSpaces +
            "//   locale for testing digit localization : " + GoldenDoubleValues.FullLocalizationTestLocale);
        System.out.println();

        // Prints the expected results when digit localization happens
        System.out.println(
            fourWhiteSpaces +
            "// The array of int[] unicode values storing the expected results");
        System.out.print(
            fourWhiteSpaces +
            "// when experiencing full localization of digits");
        System.out.println(" on DecimalLocalizationValues.");
        System.out.println(
            fourWhiteSpaces +
            "static int[][] DecimalDigitsLocalizedFormattedValues = {");
        NumberFormat df =
            NumberFormat.getInstance(GoldenDoubleValues.FullLocalizationTestLocale);
        for (int i = 0;
             i < GoldenDoubleValues.DecimalLocalizationValues.length;
             i++) {
            double d = GoldenDoubleValues.DecimalLocalizationValues[i];
            String formatted = df.format(d);
            char[] decFmtChars = formatted.toCharArray();

            System.out.print(eightWhiteSpaces + "{ ");
            printUnicodeValuesArray(decFmtChars);
            System.out.println(" },");
        }
        System.out.println(fourWhiteSpaces + "};");
        System.out.println();

        // Prints the golden expected results for the decimal pattern case
        System.out.println(
            fourWhiteSpaces +
            "// The array of int[] unicode values storing the expected results");
        System.out.print(
            fourWhiteSpaces +
            "// when calling Decimal.format(double)");
        System.out.println(" on the decimal GoldenDoubleValues.");
        System.out.println(
            fourWhiteSpaces +
            "static int[][] DecimalGoldenFormattedValues = {");
        df = NumberFormat.getInstance(GoldenDoubleValues.TestLocale);
        for (int i = 0;
             i < GoldenDoubleValues.DecimalGoldenValues.length;
             i++) {
            double d = GoldenDoubleValues.DecimalGoldenValues[i];
            String formatted = df.format(d);
            char[] decFmtChars = formatted.toCharArray();

            System.out.print(eightWhiteSpaces + "{ ");
            printUnicodeValuesArray(decFmtChars);
            System.out.println(" },");
        }
        System.out.println(fourWhiteSpaces + "};");
        System.out.println();

        // Prints the golden expected results for the currency pattern case
        System.out.println(
            fourWhiteSpaces +
            "// The array of int[] unicode values storing the expected results");
        System.out.print(
            fourWhiteSpaces +
            "// when calling Decimal.format(double)");
        System.out.println(" on the currency GoldenDoubleValues.");
        System.out.println(
            fourWhiteSpaces +
            "static int[][] CurrencyGoldenFormattedValues = {");
        NumberFormat cf =
            NumberFormat.getCurrencyInstance(GoldenDoubleValues.TestLocale);
        for (int i = 0;
             i < GoldenDoubleValues.CurrencyGoldenValues.length;
             i++) {
            double d = GoldenDoubleValues.CurrencyGoldenValues[i];
            String formatted = cf.format(d);
            char[] decFmtChars = formatted.toCharArray();

            System.out.print(eightWhiteSpaces + "{ ");
            printUnicodeValuesArray(decFmtChars);
            System.out.println(" },");
        }
        System.out.println(fourWhiteSpaces + "};");
        System.out.println();

        // Prints end of GoldenFormattedValues class.
        System.out.println("}");
    }

    private static int testLocalizationValues() {

        DecimalFormat df = (DecimalFormat)
            NumberFormat.getInstance(GoldenDoubleValues.FullLocalizationTestLocale);

        double[] localizationValues = GoldenDoubleValues.DecimalLocalizationValues;
        int size = localizationValues.length;
        int successCounter = 0;
        int failureCounter = 0;
        for (int i = 0; i < size; i++) {

            double d = localizationValues[i];
            String formatted = df.format(d);

            char[] expectedUnicodeArray =
                getCharsFromUnicodeArray(
                    GoldenFormattedValues.DecimalDigitsLocalizedFormattedValues[i]);
            String expected = new String(expectedUnicodeArray);

            if (!formatted.equals(expected)) {
                failureCounter++;
                System.out.println(
                    "--- Localization error for value d = " + d +
                    ". Exact value = " + new BigDecimal(d).toString() +
                    ". Expected result = " + expected +
                    ". Output result = " + formatted);
            } else successCounter++;
        }
        System.out.println("Checked positively " + successCounter +
                           " golden decimal values out of " + size +
                           " tests. There were " + failureCounter +
                           " format failure");

        return failureCounter;
    }

    private static int testGoldenValues(java.text.DecimalFormat df,
                                        java.text.DecimalFormat cf) {

        double[] goldenDecimalValues = GoldenDoubleValues.DecimalGoldenValues;
        int decimalSize = goldenDecimalValues.length;
        int decimalSuccessCounter = 0;
        int decimalFailureCounter = 0;
        for (int i = 0; i < decimalSize; i++) {

            double d = goldenDecimalValues[i];
            String formatted = df.format(d);

            char[] expectedUnicodeArray =
                getCharsFromUnicodeArray(
                    GoldenFormattedValues.DecimalGoldenFormattedValues[i]);
            String expected = new String(expectedUnicodeArray);

            if (!formatted.equals(expected)) {
                decimalFailureCounter++;
                System.out.println(
                    "--- Error for golden value d = " + d +
                    ". Exact value = " + new BigDecimal(d).toString() +
                    ". Expected result = " + expected +
                    ". Output result = " + formatted);
            } else decimalSuccessCounter++;
        }
        System.out.println("Checked positively " + decimalSuccessCounter +
                           " golden decimal values out of " + decimalSize +
                           " tests. There were " + decimalFailureCounter +
                           " format failure");

        double[] goldenCurrencyValues = GoldenDoubleValues.CurrencyGoldenValues;
        int currencySize = goldenCurrencyValues.length;
        int currencySuccessCounter = 0;
        int currencyFailureCounter = 0;
        for (int i = 0; i < currencySize; i++) {
            double d = goldenCurrencyValues[i];
            String formatted = cf.format(d);

            char[] expectedUnicodeArray =
                getCharsFromUnicodeArray(
                    GoldenFormattedValues.CurrencyGoldenFormattedValues[i]);
            String expected = new String(expectedUnicodeArray);

            if (!formatted.equals(expected)) {
                currencyFailureCounter++;
                System.out.println(
                    "--- Error for golden value d = " + d +
                    ". Exact value = " + new BigDecimal(d).toString() +
                    ". Expected result = " + expected +
                    ". Output result = " + formatted);
            } else currencySuccessCounter++;
        }
        System.out.println("Checked positively " + currencySuccessCounter +
                           " golden currency values out of " + currencySize +
                           " tests. There were " + currencyFailureCounter +
                           " format failure");

        return (decimalFailureCounter + currencyFailureCounter);
    }

    // Checks that the two passed s1 and s2 string are equal, and prints
    // out message in case of error.
    private static boolean resultsEqual(String propertyName,
                                        String s1,
                                        String s2) {

        boolean equality = s1.equals(s2);
        if (!equality)
            System.out.println(
                "\n*** Error while reverting to default " +
                propertyName + " property.\n" +
                "    initial output = " + s1 +
                ". reverted output = " + s2 + ".");
        else System.out.println(" Test passed.");

        return equality;

    }

    /* This methods checks the behaviour of the management of properties
     * of a DecimalFormat instance that satisfies fast-path constraints.
     *
     * It does this by comparing the results of the format(double) output
     * obtained from initial fast-path state with the output provided by
     * the same instance that has been pushed and exercised outside
     * fast-path rules and finally "reverted" to its initial fast-path state.
     *
     * The schema of actions is this :
     *  - Call format(double) on a known DecimalFormat fast-path instance,
     *    and store this result.
     *  - Record the current state of a given property.
     *  - Change the property to invalidate the fast-path state.
     *  - Call again format(double) on the instance.
     *  - Revert state of property to validate again fast-path context.
     *  - Call format(double) again.
     *  - Check that first and last call to format(double) provide same result
     *  - Record failure if any.
     *  - Do the same for another property with the same instance.
     * So all the property changes are chained one after the other on only the
     * same instance.
     *
     * Some properties that currently do not influence the fast-path state
     * are also tested. This is not useful with current fast-path source
     * but is here for testing the whole set of properties. This is the case
     * for prefixes and suffixes, and parseBigDecimal properties.
     */
    private static int testSettersAndFastPath(DecimalFormat df,
                                               boolean isCurrency) {

        final double d1 = GoldenDoubleValues.PROPERTY_CHECK_POSITIVE_VALUE;
        final double d2 = GoldenDoubleValues.PROPERTY_CHECK_NEGATIVE_VALUE;

        int errors = 0;
        boolean testSucceeded = false;
        String firstFormatResult;
        String secondFormatResult;
        String propertyName;

        // ---- positivePrefix property test ----
        testSucceeded = false;
        propertyName = "positivePrefix";
        System.out.print("Checking " + propertyName + " property.");
        String initialPrefix = df.getPositivePrefix();
        firstFormatResult = df.format(d1);
        df.setPositivePrefix("positivePrefix:");
        df.format(d1);
        df.setPositivePrefix(initialPrefix);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- positiveSuffix property test ----
        testSucceeded = false;
        propertyName = "positiveSuffix";
        System.out.print("Checking " + propertyName + " property.");
        String initialSuffix = df.getPositiveSuffix();
        firstFormatResult = df.format(d1);
        df.setPositiveSuffix("positiveSuffix:");
        df.format(d1);
        df.setPositiveSuffix(initialSuffix);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName,firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- negativePrefix property test ----
        testSucceeded = false;
        propertyName = "negativePrefix";
        System.out.print("Checking " + propertyName + " property.");
        initialPrefix = df.getNegativePrefix();
        firstFormatResult = df.format(d1);
        df.setNegativePrefix("negativePrefix:");
        df.format(d1);
        df.setNegativePrefix(initialPrefix);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- negativeSuffix property test ----
        testSucceeded = false;
        propertyName = "negativeSuffix";
        System.out.print("Checking " + propertyName + " property.");
        initialSuffix = df.getNegativeSuffix();
        firstFormatResult = df.format(d1);
        df.setNegativeSuffix("negativeSuffix:");
        df.format(d1);
        df.setNegativeSuffix(initialSuffix);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- multiplier property test ----
        testSucceeded = false;
        propertyName = "multiplier";
        System.out.print("Checking " + propertyName + " property.");
        int initialMultiplier = df.getMultiplier();
        firstFormatResult = df.format(d1);
        df.setMultiplier(10);
        df.format(d1);
        df.setMultiplier(initialMultiplier);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- groupingUsed property test ----
        testSucceeded = false;
        propertyName = "groupingUsed";
        System.out.print("Checking " + propertyName + " property.");
        boolean initialGroupingUsed = df.isGroupingUsed();
        firstFormatResult = df.format(d1);
        df.setGroupingUsed(!initialGroupingUsed);
        df.format(d1);
        df.setGroupingUsed(initialGroupingUsed);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- groupingSize property test ----
        testSucceeded = false;
        propertyName = "groupingSize";
        System.out.print("Checking " + propertyName + " property.");
        int initialGroupingSize = df.getGroupingSize();
        firstFormatResult = df.format(d1);
        df.setGroupingSize(initialGroupingSize + 1);
        df.format(d1);
        df.setGroupingSize(initialGroupingSize);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- decimalSeparatorAlwaysShown property test ----
        testSucceeded = false;
        propertyName = "decimalSeparatorAlwaysShown";
        System.out.print("Checking " + propertyName + " property.");
        boolean initialDSShown = df.isDecimalSeparatorAlwaysShown();
        firstFormatResult = df.format(d1);
        df.setDecimalSeparatorAlwaysShown(!initialDSShown);
        df.format(d1);
        df.setDecimalSeparatorAlwaysShown(initialDSShown);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- parseBigDecimal property test ----
        testSucceeded = false;
        propertyName = "parseBigDecimal";
        System.out.print("Checking " + propertyName + " property.");
        boolean initialParseBigdecimal = df.isParseBigDecimal();
        firstFormatResult = df.format(d1);
        df.setParseBigDecimal(!initialParseBigdecimal);
        df.format(d1);
        df.setParseBigDecimal(initialParseBigdecimal);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- maximumIntegerDigits property test ----
        testSucceeded = false;
        propertyName = "maximumIntegerDigits";
        System.out.print("Checking " + propertyName + " property.");
        int initialMaxIDs = df.getMaximumIntegerDigits();
        firstFormatResult = df.format(d1);
        df.setMaximumIntegerDigits(8);
        df.format(d1);
        df.setMaximumIntegerDigits(initialMaxIDs);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- minimumIntegerDigits property test ----
        testSucceeded = false;
        propertyName = "minimumIntegerDigits";
        System.out.print("Checking " + propertyName + " property.");
        int initialMinIDs = df.getMinimumIntegerDigits();
        firstFormatResult = df.format(d1);
        df.setMinimumIntegerDigits(2);
        df.format(d1);
        df.setMinimumIntegerDigits(initialMinIDs);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- maximumFractionDigits property test ----
        testSucceeded = false;
        propertyName = "maximumFractionDigits";
        System.out.print("Checking " + propertyName + " property.");
        firstFormatResult = df.format(d1);
        df.setMaximumFractionDigits(8);
        df.format(d1);
        if (isCurrency) {
            df.setMinimumFractionDigits(2);
            df.setMaximumFractionDigits(2);
        } else {
            df.setMinimumFractionDigits(0);
            df.setMaximumFractionDigits(3);
        }
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- minimumFractionDigits property test ----
        testSucceeded = false;
        propertyName = "minimumFractionDigits";
        System.out.print("Checking " + propertyName + " property.");
        firstFormatResult = df.format(d1);
        df.setMinimumFractionDigits(1);
        df.format(d1);
        if (isCurrency) {
            df.setMinimumFractionDigits(2);
            df.setMaximumFractionDigits(2);
        } else {
            df.setMinimumFractionDigits(0);
            df.setMaximumFractionDigits(3);
        }
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- currency property test ----
        testSucceeded = false;
        propertyName = "currency";
        System.out.print("Checking " + propertyName + " property.");
        Currency initialCurrency = df.getCurrency();
        Currency japanCur = java.util.Currency.getInstance(Locale.JAPAN);
        firstFormatResult = df.format(d1);
        df.setCurrency(japanCur);
        df.format(d1);
        df.setCurrency(initialCurrency);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- roundingMode property test ----
        testSucceeded = false;
        propertyName = "roundingMode";
        System.out.print("Checking " + propertyName + " property.");
        RoundingMode initialRMode = df.getRoundingMode();
        firstFormatResult = df.format(d1);
        df.setRoundingMode(RoundingMode.HALF_UP);
        df.format(d1);
        df.setRoundingMode(RoundingMode.HALF_EVEN);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        // ---- decimalFormatSymbols property test ----
        testSucceeded = false;
        propertyName = "decimalFormatSymbols";
        System.out.print("Checking " + propertyName + " property.");
        DecimalFormatSymbols initialDecimalFormatSymbols = df.getDecimalFormatSymbols();
        firstFormatResult = df.format(d1);
        Locale bizarreLocale = new Locale("fr", "FR");
        DecimalFormatSymbols unusualSymbols = new DecimalFormatSymbols(bizarreLocale);
        unusualSymbols.setDecimalSeparator('@');
        unusualSymbols.setGroupingSeparator('|');
        df.setDecimalFormatSymbols(unusualSymbols);
        df.format(d1);
        df.setDecimalFormatSymbols(initialDecimalFormatSymbols);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        testSucceeded = false;
        System.out.print("Checking " + propertyName + " property.");
        initialDecimalFormatSymbols = df.getDecimalFormatSymbols();
        firstFormatResult = df.format(d1);
        Locale japanLocale = Locale.JAPAN;
        unusualSymbols = new DecimalFormatSymbols(japanLocale);
        unusualSymbols.setDecimalSeparator('9');
        unusualSymbols.setGroupingSeparator('0');
        df.setDecimalFormatSymbols(unusualSymbols);
        df.format(d1);
        df.setDecimalFormatSymbols(initialDecimalFormatSymbols);
        secondFormatResult = df.format(d1);
        testSucceeded =
            resultsEqual(propertyName, firstFormatResult, secondFormatResult);
        if (!testSucceeded)
            errors++;

        return errors;
    }

    // Main for RoundingAndPropertyTest. We test first the golden values,
    // and then the property setters and getters.
    public static void main(String[] args) {

        if ((args.length >= 1) &&
            (args[0].equals("-gengold")))
            generatesGoldenFormattedValuesClass();
        else {
            System.out.println("\nChecking correctness of formatting with digit localization.");
            System.out.println("=============================================================");
            int localizationErrors = testLocalizationValues();
            if (localizationErrors != 0)
                System.out.println("*** Failure in localization tests : " +
                                   localizationErrors + " errors detected ");
            else System.out.println(" Tests for full localization of digits all passed.");

            DecimalFormat df = (DecimalFormat)
                NumberFormat.getInstance(GoldenDoubleValues.TestLocale);
            DecimalFormat cf = (DecimalFormat)
                NumberFormat.getCurrencyInstance(GoldenDoubleValues.TestLocale);

            System.out.println("\nChecking correctness of formating for golden values.");
            System.out.println("=============================================================");
            int goldenValuesErrors = testGoldenValues(df,cf);
            if (goldenValuesErrors != 0)
                System.out.println("*** Failure in goldenValues tests : " +
                                   goldenValuesErrors + " errors detected ");
            else System.out.println(" Tests for golden values all passed.");

            System.out.println("\nChecking behavior of property changes for decimal case.");
            System.out.println("=============================================================");
            int decimalTestsErrors = testSettersAndFastPath(df, false);
            if (decimalTestsErrors != 0)
                System.out.println("*** Failure in decimal property changes tests : " +
                                   decimalTestsErrors + " errors detected ");
            else System.out.println(" Tests for decimal property changes all passed.");

            System.out.println("\nChecking behavior of property changes for currency case.");
            System.out.println("=============================================================");
            int currencyTestsErrors = testSettersAndFastPath(cf, true);
            if (currencyTestsErrors != 0)
                System.out.println("*** Failure in currency property changes tests : " +
                                   currencyTestsErrors + " errors detected ");
            else System.out.println(" Tests for currency property chamges all passed.");

            if ((localizationErrors > 0) ||
                (goldenValuesErrors > 0) ||
                (decimalTestsErrors > 0) ||
                (currencyTestsErrors > 0))
                throw new RuntimeException(
                    "Failed with " +
                    (localizationErrors + goldenValuesErrors +
                     decimalTestsErrors + currencyTestsErrors) +
                    " error(s).");
        }
    }
}