test/jdk/java/lang/Float/ParseFloat.java - platform/libcore - Git at Google

 /*
  * Copyright (c) 1998, 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 6358355 7032154
  * @summary Tests for Float.parseFloat method
  */

 import java.math.BigDecimal;
 import java.math.BigInteger;

 public class ParseFloat {

     private static final BigDecimal HALF = BigDecimal.valueOf(0.5);

     private static void fail(String val, float n) {
         throw new RuntimeException("Float.parseFloat failed. String:" +
                                                 val + " Result:" + n);
     }

     private static void check(String val) {
         float n = Float.parseFloat(val);
         boolean isNegativeN = n < 0 || n == 0 && 1/n < 0;
         float 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 (!Float.isNaN(n)) {
                 fail(val, n);
             }
             return;
         }
         if (Float.isNaN(n)) {
             fail(val, n);
         }
         if (isNegativeN != isNegative)
             fail(val, n);
         if (s.equals("infinity")) {
             if (na != Float.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 (Float.isInfinite(na)) {
             l = new BigDecimal(Float.MAX_VALUE).add(new BigDecimal(Math.ulp(Float.MAX_VALUE)).multiply(HALF));
             u = null;
         } else {
             l = new BigDecimal(na).subtract(new BigDecimal(Math.ulp(-Math.nextUp(-na))).multiply(HALF));
             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 ((Float.floatToIntBits(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, float expected) {
         float n = Float.parseFloat(val);
         if (n != expected)
             fail(val, n);
         check(val);
     }

     private static void rudimentaryTest() {
         check(new String(""+Float.MIN_VALUE), Float.MIN_VALUE);
         check(new String(""+Float.MAX_VALUE), Float.MAX_VALUE);

         check("10",     (float)  10.0);
         check("10.0",   (float)  10.0);
         check("10.01",  (float)  10.01);

         check("-10",    (float) -10.0);
         check("-10.00", (float) -10.0);
         check("-10.01", (float) -10.01);

         // bug 6358355
         check("144115196665790480", 0x1.000002p57f);
         check("144115196665790481", 0x1.000002p57f);
         check("0.050000002607703203", 0.05f);
         check("0.050000002607703204", 0.05f);
         check("0.050000002607703205", 0.05f);
         check("0.050000002607703206", 0.05f);
         check("0.050000002607703207", 0.05f);
         check("0.050000002607703208", 0.05f);
         check("0.050000002607703209", 0.050000004f);
     }

     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
     };

     static String goodStrings[] = {
         "NaN",
         "+NaN",
         "-NaN",
         "Infinity",
         "+Infinity",
         "-Infinity",
         "1.1e-23f",
         ".1e-23f",
         "1e-23",
         "1f",
         "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"
     };

     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 Float.parseFloat
      * parseFloat} does <em>not</em> throw an exception or if
      * <code>Input</code> is not <code>exceptionalInput</code> and
      * <code>parseFloat</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 = Float.parseFloat(input[i]);
                 check(input[i]);
             }
             catch (NumberFormatException e) {
                 if (! exceptionalInput) {
                     throw new RuntimeException("Float.parseFloat rejected " +
                                                "good string `" + input[i] +
                                                "'.");
                 }
                 break;
             }
             if (exceptionalInput) {
                 throw new RuntimeException("Float.parseFloat accepted " +
                                            "bad string `" + input[i] +
                                            "'.");
             }
         }
     }

     /**
      * For each power of two, test at boundaries of
      * region that should convert to that value.
      */
     private static void testPowers() {
         for(int i = -149; i <= +127; i++) {
             float f = Math.scalb(1.0f, i);
             BigDecimal f_BD = new BigDecimal(f);

             BigDecimal lowerBound = f_BD.subtract(new BigDecimal(Math.ulp(-Math.nextUp(-f))).multiply(HALF));
             BigDecimal upperBound = f_BD.add(new BigDecimal(Math.ulp(f)).multiply(HALF));

             check(lowerBound.toString());
             check(upperBound.toString());
         }
         check(new BigDecimal(Float.MAX_VALUE).add(new BigDecimal(Math.ulp(Float.MAX_VALUE)).multiply(HALF)).toString());
     }

     public static void main(String[] args) throws Exception {
         rudimentaryTest();

         testParsing(goodStrings, false);
         testParsing(paddedGoodStrings, false);
         testParsing(badStrings, true);
         testParsing(paddedBadStrings, true);

         testPowers();
     }
 }
	/*
	* Copyright (c) 1998, 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 6358355 7032154
	* @summary Tests for Float.parseFloat method
	*/

	import java.math.BigDecimal;
	import java.math.BigInteger;

	public class ParseFloat {

	private static final BigDecimal HALF = BigDecimal.valueOf(0.5);

	private static void fail(String val, float n) {
	throw new RuntimeException("Float.parseFloat failed. String:" +
	val + " Result:" + n);
	}

	private static void check(String val) {
	float n = Float.parseFloat(val);
	boolean isNegativeN = n < 0 \|\| n == 0 && 1/n < 0;
	float 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 (!Float.isNaN(n)) {
	fail(val, n);
	}
	return;
	}
	if (Float.isNaN(n)) {
	fail(val, n);
	}
	if (isNegativeN != isNegative)
	fail(val, n);
	if (s.equals("infinity")) {
	if (na != Float.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 (Float.isInfinite(na)) {
	l = new BigDecimal(Float.MAX_VALUE).add(new BigDecimal(Math.ulp(Float.MAX_VALUE)).multiply(HALF));
	u = null;
	} else {
	l = new BigDecimal(na).subtract(new BigDecimal(Math.ulp(-Math.nextUp(-na))).multiply(HALF));
	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 ((Float.floatToIntBits(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, float expected) {
	float n = Float.parseFloat(val);
	if (n != expected)
	fail(val, n);
	check(val);
	}

	private static void rudimentaryTest() {
	check(new String(""+Float.MIN_VALUE), Float.MIN_VALUE);
	check(new String(""+Float.MAX_VALUE), Float.MAX_VALUE);

	check("10", (float) 10.0);
	check("10.0", (float) 10.0);
	check("10.01", (float) 10.01);

	check("-10", (float) -10.0);
	check("-10.00", (float) -10.0);
	check("-10.01", (float) -10.01);

	// bug 6358355
	check("144115196665790480", 0x1.000002p57f);
	check("144115196665790481", 0x1.000002p57f);
	check("0.050000002607703203", 0.05f);
	check("0.050000002607703204", 0.05f);
	check("0.050000002607703205", 0.05f);
	check("0.050000002607703206", 0.05f);
	check("0.050000002607703207", 0.05f);
	check("0.050000002607703208", 0.05f);
	check("0.050000002607703209", 0.050000004f);
	}

	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
	};

	static String goodStrings[] = {
	"NaN",
	"+NaN",
	"-NaN",
	"Infinity",
	"+Infinity",
	"-Infinity",
	"1.1e-23f",
	".1e-23f",
	"1e-23",
	"1f",
	"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"
	};

	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 Float.parseFloat
	* parseFloat} does <em>not</em> throw an exception or if
	* <code>Input</code> is not <code>exceptionalInput</code> and
	* <code>parseFloat</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 = Float.parseFloat(input[i]);
	check(input[i]);
	}
	catch (NumberFormatException e) {
	if (! exceptionalInput) {
	throw new RuntimeException("Float.parseFloat rejected " +
	"good string `" + input[i] +
	"'.");
	}
	break;
	}
	if (exceptionalInput) {
	throw new RuntimeException("Float.parseFloat accepted " +
	"bad string `" + input[i] +
	"'.");
	}
	}
	}

	/**
	* For each power of two, test at boundaries of
	* region that should convert to that value.
	*/
	private static void testPowers() {
	for(int i = -149; i <= +127; i++) {
	float f = Math.scalb(1.0f, i);
	BigDecimal f_BD = new BigDecimal(f);

	BigDecimal lowerBound = f_BD.subtract(new BigDecimal(Math.ulp(-Math.nextUp(-f))).multiply(HALF));
	BigDecimal upperBound = f_BD.add(new BigDecimal(Math.ulp(f)).multiply(HALF));

	check(lowerBound.toString());
	check(upperBound.toString());
	}
	check(new BigDecimal(Float.MAX_VALUE).add(new BigDecimal(Math.ulp(Float.MAX_VALUE)).multiply(HALF)).toString());
	}

	public static void main(String[] args) throws Exception {
	rudimentaryTest();

	testParsing(goodStrings, false);
	testParsing(paddedGoodStrings, false);
	testParsing(badStrings, true);
	testParsing(paddedBadStrings, true);

	testPowers();
	}
	}