797 lines
35 KiB
Java
797 lines
35 KiB
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
|
|
* @build GoldenDoubleValues GoldenFormattedValues
|
|
* @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).");
|
|
}
|
|
}
|
|
}
|