| Quellcodebibliothek Statistik Leitseite products/Sources/formale Sprachen/Java/Openjdk/test/jdk/java/lang/Double/ (Sun/Oracle ©) Datei vom 13.11.2022 mit Größe 23 kB |
|
Quelle ParseDouble.java Sprache: JAVA |
|||||||||
|
/*
* Copyright (c) 2001, 2013, 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 4160406 4705734 4707389 4826774 4895911 4421494 6358355 7021568 7039369 4396272 * @summary Test for Double.parseDouble method and acceptance regex */ import java.math.BigDecimal; import java.math.BigInteger; import java.util.regex.*; public class ParseDouble { private static final BigDecimal HALF = BigDecimal.valueOf(0.5); private static void fail(String val, double n) { throw new RuntimeException("Double.parseDouble failed. String:" + val + " Result:" + n); } private static void check(String val) { double n = Double.parseDouble(val); boolean isNegativeN = n < 0 || n == 0 && 1/n < 0; double na = Math.abs(n); String s = val.trim().toLowerCase(); switch (s.charAt(s.length() - 1)) { case 'd': case 'f': s = s.substring(0, s.length() - 1); break; } boolean isNegative = false; if (s.charAt(0) == '+') { s = s.substring(1); } else if (s.charAt(0) == '-') { s = s.substring(1); isNegative = true; } if (s.equals("nan")) { if (!Double.isNaN(n)) { fail(val, n); } return; } if (Double.isNaN(n)) { fail(val, n); } if (isNegativeN != isNegative) fail(val, n); if (s.equals("infinity")) { if (na != Double.POSITIVE_INFINITY) { fail(val, n); } return; } BigDecimal bd; if (s.startsWith("0x")) { s = s.substring(2); int indP = s.indexOf('p'); long exp = Long.parseLong(s.substring(indP + 1)); int indD = s.indexOf('.'); String significand; if (indD >= 0) { significand = s.substring(0, indD) + s.substring(indD + 1, indP); exp -= 4*(indP - indD - 1); } else { significand = s.substring(0, indP); } bd = new BigDecimal(new BigInteger(significand, 16)); if (exp >= 0) { bd = bd.multiply(BigDecimal.valueOf(2).pow((int)exp)); } else { bd = bd.divide(BigDecimal.valueOf(2).pow((int)-exp)); } } else { bd = new BigDecimal(s); } BigDecimal l, u; if (Double.isInfinite(na)) { l = new BigDecimal(Double.MAX_VALUE).add(new BigDecimal(Math.ulp(Double.MAX_VALUE)). u = null; } else { l = new BigDecimal(na).subtract(new BigDecimal(Math.ulp(Math.nextUp(-na))).multiply( u = new BigDecimal(na).add(new BigDecimal(Math.ulp(n)).multiply(HALF)); } int cmpL = bd.compareTo(l); int cmpU = u != null ? bd.compareTo(u) : -1; if ((Double.doubleToLongBits(n) & 1) != 0) { if (cmpL <= 0 || cmpU >= 0) { fail(val, n); } } else { if (cmpL < 0 || cmpU > 0) { fail(val, n); } } } private static void check(String val, double expected) { double n = Double.parseDouble(val); if (n != expected) fail(val, n); check(val); } private static void rudimentaryTest() { check(new String(""+Double.MIN_VALUE), Double.MIN_VALUE); check(new String(""+Double.MAX_VALUE), Double.MAX_VALUE); check("10", (double) 10.0); check("10.0", (double) 10.0); check("10.01", (double) 10.01); check("-10", (double) -10.0); check("-10.00", (double) -10.0); check("-10.01", (double) -10.01); } static String badStrings[] = { "", "+", "-", "+e", "-e", "+e170", "-e170", // Make sure intermediate white space is not deleted. "1234 e10", "-1234 e10", // Control characters in the interior of a string are not legal "1\u0007e1", "1e\u00071", // NaN and infinity can't have trailing type suffices or exponents "NaNf", "NaNF", "NaNd", "NaND", "-NaNf", "-NaNF", "-NaNd", "-NaND", "+NaNf", "+NaNF", "+NaNd", "+NaND", "Infinityf", "InfinityF", "Infinityd", "InfinityD", "-Infinityf", "-InfinityF", "-Infinityd", "-InfinityD", "+Infinityf", "+InfinityF", "+Infinityd", "+InfinityD", "NaNe10", "-NaNe10", "+NaNe10", "Infinitye10", "-Infinitye10", "+Infinitye10", // Non-ASCII digits are not recognized "\u0661e\u0661", // 1e1 in Arabic-Indic digits "\u06F1e\u06F1", // 1e1 in Extended Arabic-Indic digits "\u0967e\u0967", // 1e1 in Devanagari digits // JCK test lex03592m3 ".", // JCK test lex03592m4 "e42", // JCK test lex03592m5 ".e42", // JCK test lex03592m6 "d", // JCK test lex03592m7 ".d", // JCK test lex03592m8 "e42d", // JCK test lex03592m9 ".e42d", // JCK test lex03593m10 "1A01.01125e-10d", // JCK test lex03593m11 "2;3.01125e-10d", // JCK test lex03593m12 "1_34.01125e-10d", // JCK test lex03593m14 "202..01125e-10d", // JCK test lex03593m15 "202,01125e-10d", // JCK test lex03593m16 "202.03b4e-10d", // JCK test lex03593m18 "202.06_3e-10d", // JCK test lex03593m20 "202.01125e-f0d", // JCK test lex03593m21 "202.01125e_3d", // JCK test lex03593m22 "202.01125e -5d", // JCK test lex03593m24 "202.01125e-10r", // JCK test lex03593m25 "202.01125e-10ff", // JCK test lex03593m26 "1234L.01", // JCK test lex03593m27 "12ee-2", // JCK test lex03593m28 "12e-2.2.2", // JCK test lex03593m29 "12.01e+", // JCK test lex03593m30 "12.01E", // Bad hexadecimal-style strings // Two leading zeros "00x1.0p1", // Must have hex specifier "1.0p1", "00010p1", "deadbeefp1", // Need an explicit fully-formed exponent "0x1.0p", "0x1.0", // Exponent must be in decimal "0x1.0pa", "0x1.0pf", // Exponent separated by "p" "0x1.0e22", "0x1.0e22", // Need a signifcand "0xp22" }; static String goodStrings[] = { "NaN", "+NaN", "-NaN", "Infinity", "+Infinity", "-Infinity", "1.1e-23f", ".1e-23f", "1e-23", "1f", "0", "-0", "+0", "00", "00", "-00", "+00", "0000000000", "-0000000000", "+0000000000", "1", "2", "1234", "-1234", "+1234", "2147483647", // Integer.MAX_VALUE "2147483648", "-2147483648", // Integer.MIN_VALUE "-2147483649", "16777215", "16777216", // 2^24 "16777217", "-16777215", "-16777216", // -2^24 "-16777217", "9007199254740991", "9007199254740992", // 2^53 "9007199254740993", "-9007199254740991", "-9007199254740992", // -2^53 "-9007199254740993", "9223372036854775807", "9223372036854775808", // Long.MAX_VALUE "9223372036854775809", "-9223372036854775808", "-9223372036854775809", // Long.MIN_VALUE "-9223372036854775810", // Culled from JCK test lex03591m1 "54.07140d", "7.01e-324d", "2147483647.01d", "1.2147483647f", "000000000000000000000000001.F", "1.00000000000000000000000000e-2F", // Culled from JCK test lex03592m2 "2.", ".0909", "122112217090.0", "7090e-5", "2.E-20", ".0909e42", "122112217090.0E+100", "7090f", "2.F", ".0909d", "122112217090.0D", "7090e-5f", "2.E-20F", ".0909e42d", "122112217090.0E+100D", // Culled from JCK test lex03594m31 -- unicode escapes "\u0035\u0031\u0034\u0039\u0032\u0033\u0036\u0037\u0038\u0030.1102E-209D", "1290873\u002E12301e100", "1.1E-10\u0066", // Culled from JCK test lex03595m1 "0.0E-10", "1E10", // Culled from JCK test lex03691m1 "0.f", "1f", "0.F", "1F", "0.12d", "1e-0d", "12.e+1D", "0e-0D", "12.e+01", "1e-01", // Good hex strings // Vary capitalization of separators. "0x1p1", "0X1p1", "0x1P1", "0X1P1", "0x1p1f", "0X1p1f", "0x1P1f", "0X1P1f", "0x1p1F", "0X1p1F", "0x1P1F", "0X1P1F", "0x1p1d", "0X1p1d", "0x1P1d", "0X1P1d", "0x1p1D", "0X1p1D", "0x1P1D", "0X1P1D", "-0x1p1", "-0X1p1", "-0x1P1", "-0X1P1", "-0x1p1f", "-0X1p1f", "-0x1P1f", "-0X1P1f", "-0x1p1F", "-0X1p1F", "-0x1P1F", "-0X1P1F", "-0x1p1d", "-0X1p1d", "-0x1P1d", "-0X1P1d", "-0x1p1D", "-0X1p1D", "-0x1P1D", "-0X1P1D", "0x1p-1", "0X1p-1", "0x1P-1", "0X1P-1", "0x1p-1f", "0X1p-1f", "0x1P-1f", "0X1P-1f", "0x1p-1F", "0X1p-1F", "0x1P-1F", "0X1P-1F", "0x1p-1d", "0X1p-1d", "0x1P-1d", "0X1P-1d", "0x1p-1D", "0X1p-1D", "0x1P-1D", "0X1P-1D", "-0x1p-1", "-0X1p-1", "-0x1P-1", "-0X1P-1", "-0x1p-1f", "-0X1p-1f", "-0x1P-1f", "-0X1P-1f", "-0x1p-1F", "-0X1p-1F", "-0x1P-1F", "-0X1P-1F", "-0x1p-1d", "-0X1p-1d", "-0x1P-1d", "-0X1P-1d", "-0x1p-1D", "-0X1p-1D", "-0x1P-1D", "-0X1P-1D", // Try different significand combinations "0xap1", "0xbp1", "0xcp1", "0xdp1", "0xep1", "0xfp1", "0x1p1", "0x.1p1", "0x1.1p1", "0x001p23", "0x00.1p1", "0x001.1p1", "0x100p1", "0x.100p1", "0x1.100p1", "0x00100p1", "0x00.100p1", "0x001.100p1", // Limits "1.7976931348623157E308", // Double.MAX_VALUE "4.9e-324", // Double.MIN_VALUE "2.2250738585072014e-308", // Double.MIN_NORMAL "2.2250738585072012e-308", // near Double.MIN_NORMAL "1.7976931348623158e+308", // near MAX_VALUE + ulp(MAX_VALUE)/2 "1.7976931348623159e+308", // near MAX_VALUE + ulp(MAX_VALUE) "2.4703282292062329e-324", // above MIN_VALUE/2 "2.4703282292062327e-324", // MIN_VALUE/2 "2.4703282292062325e-324", // below MIN_VALUE/2 // 1e308 with leading zeros "0.0000000000001e321", "00.000000000000000001e326", "00000.000000000000000001e326", "000.0000000000000000001e327", "0.00000000000000000001e328", }; static String paddedBadStrings[]; static String paddedGoodStrings[]; static { String pad = " \t\n\r\f\u0001\u000b\u001f"; paddedBadStrings = new String[badStrings.length]; for(int i = 0 ; i < badStrings.length; i++) paddedBadStrings[i] = pad + badStrings[i] + pad; paddedGoodStrings = new String[goodStrings.length]; for(int i = 0 ; i < goodStrings.length; i++) paddedGoodStrings[i] = pad + goodStrings[i] + pad; } /* * Throws an exception if <code>Input</code> is * <code>exceptionalInput</code> and {@link Double.parseDouble * parseDouble} does <em>not</em> throw an exception or if * <code>Input</code> is not <code>exceptionalInput</code> and * <code>parseDouble</code> throws an exception. This method does * not attempt to test whether the string is converted to the * proper value; just whether the input is accepted appropriately * or not. */ private static void testParsing(String [] input, boolean exceptionalInput) { for(int i = 0; i < input.length; i++) { double d; try { d = Double.parseDouble(input[i]); check(input[i]); } catch (NumberFormatException e) { if (! exceptionalInput) { throw new RuntimeException("Double.parseDouble rejected " + "good string `" + input[i] + "'."); } break; } if (exceptionalInput) { throw new RuntimeException("Double.parseDouble accepted " + "bad string `" + input[i] + "'."); } } } /* * Throws an exception if <code>Input</code> is * <code>exceptionalInput</code> and the regular expression * matches one of the strings or if <code>Input</code> is not * <code>exceptionalInput</code> and the regular expression fails * to match an input string. */ private static void testRegex(String [] input, boolean exceptionalInput) { /* * The regex below is taken from the JavaDoc for * Double.valueOf. */ final String Digits = "(\\p{Digit}+)"; final String HexDigits = "(\\p{XDigit}+)"; // an exponent is 'e' or 'E' followed by an optionally // signed decimal integer. final String Exp = "[eE][+-]?"+Digits; final String fpRegex = ("[\\x00-\\x20]*"+ // Optional leading "whitespace" "[+-]?(" + // Optional sign character "NaN|" + // "NaN" string "Infinity|" + // "Infinity" string // A floating-point string representing a finite positive // number without a leading sign has at most five basic pieces: // Digits . Digits ExponentPart FloatTypeSuffix // // Since this method allows integer-only strings as input // in addition to strings of floating-point literals, the // two sub-patterns below are simplifications of the grammar // productions from the Java Language Specification, 2nd // edition, section 3.10.2. // A decimal floating-point string representing a finite positive // number without a leading sign has at most five basic pieces: // Digits . Digits ExponentPart FloatTypeSuffix // // Since this method allows integer-only strings as input // in addition to strings of floating-point literals, the // two sub-patterns below are simplifications of the grammar // productions from the Java Language Specification, 2nd // edition, section 3.10.2. // Digits ._opt Digits_opt ExponentPart_opt FloatTypeSuffix_opt "(((("+Digits+"(\\.)?("+Digits+"?)("+Exp+")?)|"+ // . Digits ExponentPart_opt FloatTypeSuffix_opt "(\\.("+Digits+")("+Exp+")?))|"+ // Hexadecimal strings "((" + // 0[xX] HexDigits ._opt BinaryExponent FloatTypeSuffix_opt "(0[xX]" + HexDigits + "(\\.)?)|" + // 0[xX] HexDigits_opt . HexDigits BinaryExponent FloatTypeSuffix_opt "(0[xX]" + HexDigits + "?(\\.)" + HexDigits + ")" + ")[pP][+-]?" + Digits + "))" + "[fFdD]?))" + "[\\x00-\\x20]*");// Optional trailing "whitespace" Pattern fpPattern = Pattern.compile(fpRegex); for(int i = 0; i < input.length; i++) { Matcher m = fpPattern.matcher(input[i]); if (m.matches() != ! exceptionalInput) { throw new RuntimeException("Regular expression " + (exceptionalInput? "accepted bad": "rejected good") + " string `" + input[i] + "'."); } } } /** * For each subnormal power of two, test at boundaries of * region that should convert to that value. */ private static void testSubnormalPowers() { boolean failed = false; BigDecimal TWO = BigDecimal.valueOf(2); // An ulp is the same for all subnormal values BigDecimal ulp_BD = new BigDecimal(Double.MIN_VALUE); // Test subnormal powers of two (except Double.MIN_VALUE) for(int i = -1073; i <= -1022; i++) { double d = Math.scalb(1.0, i); /* * The region [d - ulp/2, d + ulp/2] should round to d. */ BigDecimal d_BD = new BigDecimal(d); BigDecimal lowerBound = d_BD.subtract(ulp_BD.divide(TWO)); BigDecimal upperBound = d_BD.add(ulp_BD.divide(TWO)); double convertedLowerBound = Double.parseDouble(lowerBound.toString()); double convertedUpperBound = Double.parseDouble(upperBound.toString()); if (convertedLowerBound != d) { failed = true; System.out.printf("2^%d lowerBound converts as %a %s%n", i, convertedLowerBound, lowerBound); } if (convertedUpperBound != d) { failed = true; System.out.printf("2^%d upperBound converts as %a %s%n", i, convertedUpperBound, upperBound); } } /* * Double.MIN_VALUE * The region ]0.5*Double.MIN_VALUE, 1.5*Double.MIN_VALUE[ should round to Double.MIN_VAL */ BigDecimal minValue = new BigDecimal(Double.MIN_VALUE); if (Double.parseDouble(minValue.multiply(new BigDecimal(0.5)).toString()) != 0.0) { failed = true; System.out.printf("0.5*MIN_VALUE doesn't convert 0%n"); } if (Double.parseDouble(minValue.multiply(new BigDecimal(0.50000000001)).toString() failed = true; System.out.printf("0.50000000001*MIN_VALUE doesn't convert to MIN_VALUE%n"); } if (Double.parseDouble(minValue.multiply(new BigDecimal(1.49999999999)).toString() failed = true; System.out.printf("1.49999999999*MIN_VALUE doesn't convert to MIN_VALUE%n"); } if (Double.parseDouble(minValue.multiply(new BigDecimal(1.5)).toString()) != 2*Doubl failed = true; System.out.printf("1.5*MIN_VALUE doesn't convert to 2*MIN_VALUE%n"); } if (failed) throw new RuntimeException("Inconsistent conversion"); } /** * For each power of two, test at boundaries of * region that should convert to that value. */ private static void testPowers() { for(int i = -1074; i <= +1023; i++) { double d = Math.scalb(1.0, i); BigDecimal d_BD = new BigDecimal(d); BigDecimal lowerBound = d_BD.subtract(new BigDecimal(Math.ulp(Math.nextUp(-d))).mult BigDecimal upperBound = d_BD.add(new BigDecimal(Math.ulp(d)).multiply(HALF)); check(lowerBound.toString()); check(upperBound.toString()); } check(new BigDecimal(Double.MAX_VALUE).add(new BigDecimal(Math.ulp(Double.MAX_VALU } private static void testStrictness() { final double expected = 0x0.0000008000000p-1022; // final double expected = 0x0.0000008000001p-1022; boolean failed = false; double conversion = 0.0; double sum = 0.0; // Prevent conversion from being optimized away //2^-1047 + 2^-1075 rounds to 2^-1047 String decimal = "6.631236871469758276785396630275967243399099947355303144249971758 for(int i = 0; i <= 12_000; i++) { conversion = Double.parseDouble(decimal); sum += conversion; if (conversion != expected) { failed = true; System.out.printf("Iteration %d converts as %a%n", i, conversion); } } System.out.println("Sum = " + sum); if (failed) throw new RuntimeException("Inconsistent conversion"); } public static void main(String[] args) throws Exception { rudimentaryTest(); testParsing(goodStrings, false); testParsing(paddedGoodStrings, false); testParsing(badStrings, true); testParsing(paddedBadStrings, true); testRegex(goodStrings, false); testRegex(paddedGoodStrings, false); testRegex(badStrings, true); testRegex(paddedBadStrings, true); testSubnormalPowers(); testPowers(); testStrictness(); } } ¤ Dauer der Verarbeitung: 0.16 Sekunden (vorverarbeitet) ¤*© Formatika GbR, Deutschland |
|
2026-03-28