/*
* Copyright (c) 1997, 2016, 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
* @summary round trip test NumberFormat
* @library /java/text/testlib
* @key randomness
*/
import java.text.*;
import java.util.*;
/**
* This class tests the round-trip behavior of NumberFormat, DecimalFormat, and DigitList.
* Round-trip behavior is tested by taking a numeric value and formatting it, then
* parsing the resulting string, and comparing this result with the original value.
* Two tests are applied: String preservation, and numeric preservation. String
* preservation is exact; numeric preservation is not. However, numeric preservation
* should extend to the few least-significant bits.
* //bug472
*/
public class NumberRoundTrip extends IntlTest {
static final boolean STRING_COMPARE = true;
static final boolean EXACT_NUMERIC_COMPARE = false;
static final double MAX_ERROR = 1e-14;
static boolean DEBUG = false;
static double max_numeric_error = 0;
static double min_numeric_error = 1;
String localeName, formatName;
public static void main(String[] args) throws Exception {
if (args.length > 0 && args[0].equals("-debug")) {
DEBUG = true;
String[] newargs = new String[args.length - 1];
System.arraycopy(args, 1, newargs, 0, newargs.length);
args = newargs;
}
new NumberRoundTrip().run(args);
}
public void TestNumberFormatRoundTrip() {
logln("Default Locale");
localeName = "Default Locale";
formatName = "getInstance";
doTest(NumberFormat.getInstance());
formatName = "getNumberInstance";
doTest(NumberFormat.getNumberInstance());
formatName = "getCurrencyInstance";
doTest(NumberFormat.getCurrencyInstance());
formatName = "getPercentInstance";
doTest(NumberFormat.getPercentInstance());
Locale[] loc = NumberFormat.getAvailableLocales();
for (int i=0; i<loc.length; ++i) {
logln(loc[i].getDisplayName());
localeName = loc[i].toString();
formatName = "getInstance";
doTest(NumberFormat.getInstance(loc[i]));
formatName = "getNumberInstance";
doTest(NumberFormat.getNumberInstance(loc[i]));
formatName = "getCurrencyInstance";
doTest(NumberFormat.getCurrencyInstance(loc[i]));
formatName = "getPercentInstance";
doTest(NumberFormat.getPercentInstance(loc[i]));
}
logln("Numeric error " +
min_numeric_error + " to " +
max_numeric_error);
}
public void doTest(NumberFormat fmt) {
doTest(fmt, Double.NaN);
doTest(fmt, Double.POSITIVE_INFINITY);
doTest(fmt, Double.NEGATIVE_INFINITY);
doTest(fmt, 500);
doTest(fmt, 0);
doTest(fmt, 5555555555555555L);
doTest(fmt, 55555555555555555L);
doTest(fmt, 9223372036854775807L);
doTest(fmt, 9223372036854775808.0);
doTest(fmt, -9223372036854775808L);
doTest(fmt, -9223372036854775809.0);
for (int i=0; i<2; ++i) {
doTest(fmt, randomDouble(1));
doTest(fmt, randomDouble(10000));
doTest(fmt, Math.floor(randomDouble(10000)));
doTest(fmt, randomDouble(1e50));
doTest(fmt, randomDouble(1e-50));
doTest(fmt, randomDouble(1e100));
// The use of double d such that isInfinite(100d) causes the
// numeric test to fail with percent formats (bug 4266589).
// Largest double s.t. 100d < Inf: d=1.7976931348623156E306
doTest(fmt, randomDouble(1e306));
doTest(fmt, randomDouble(1e-323));
doTest(fmt, randomDouble(1e-100));
}
}
/**
* Return a random value from -range..+range.
*/
public double randomDouble(double range) {
double a = Math.random();
return (2.0 * range * a) - range;
}
public void doTest(NumberFormat fmt, double value) {
doTest(fmt, Double.valueOf(value));
}
public void doTest(NumberFormat fmt, long value) {
doTest(fmt, Long.valueOf(value));
}
static double proportionalError(Number a, Number b) {
double aa = a.doubleValue(), bb = b.doubleValue();
double error = aa - bb;
if (aa != 0 && bb != 0) error /= aa;
return Math.abs(error);
}
public void doTest(NumberFormat fmt, Number value) {
fmt.setMaximumFractionDigits(Integer.MAX_VALUE);
String s = fmt.format(value), s2 = null;
Number n = null;
String err = "";
try {
if (DEBUG) logln(" " + value + " F> " + escape(s));
n = fmt.parse(s);
if (DEBUG) logln(" " + escape(s) + " P> " + n);
s2 = fmt.format(n);
if (DEBUG) logln(" " + n + " F> " + escape(s2));
if (STRING_COMPARE) {
if (!s.equals(s2)) {
if (fmt instanceof DecimalFormat) {
logln("Text mismatch: expected: " + s + ", got: " + s2 + " --- Try BigDecimal parsing.");
((DecimalFormat)fmt).setParseBigDecimal(true);
n = fmt.parse(s);
if (DEBUG) logln(" " + escape(s) + " P> " + n);
s2 = fmt.format(n);
if (DEBUG) logln(" " + n + " F> " + escape(s2));
((DecimalFormat)fmt).setParseBigDecimal(false);
if (!s.equals(s2)) {
err = "STRING ERROR(DecimalFormat): ";
}
} else {
err = "STRING ERROR(NumberFormat): ";
}
}
}
if (EXACT_NUMERIC_COMPARE) {
if (value.doubleValue() != n.doubleValue()) {
err += "NUMERIC ERROR: ";
}
} else {
// Compute proportional error
double error = proportionalError(value, n);
if (error > MAX_ERROR) {
err += "NUMERIC ERROR " + error + ": ";
}
if (error > max_numeric_error) max_numeric_error = error;
if (error < min_numeric_error) min_numeric_error = error;
}
String message = value + typeOf(value) + " F> " +
escape(s) + " P> " +
n + typeOf(n) + " F> " +
escape(s2);
if (err.length() > 0) {
errln("*** " + err + " with " +
formatName + " in " + localeName +
" " + message);
} else {
logln(message);
}
} catch (ParseException e) {
errln("*** " + e.toString() + " with " +
formatName + " in " + localeName);
}
}
static String typeOf(Number n) {
if (n instanceof Long) return " Long";
if (n instanceof Double) return " Double";
return " Number";
}
static String escape(String s) {
StringBuffer buf = new StringBuffer();
for (int i=0; i<s.length(); ++i) {
char c = s.charAt(i);
if (c < (char)0xFF) {
buf.append(c);
} else {
buf.append("\\U");
buf.append(Integer.toHexString((c & 0xF000) >> 12));
buf.append(Integer.toHexString((c & 0x0F00) >> 8));
buf.append(Integer.toHexString((c & 0x00F0) >> 4));
buf.append(Integer.toHexString(c & 0x000F));
}
}
return buf.toString();
}
}