undefect. CWE-407 — 63 sites patched across 27 ecosystems
Authors: russell@unturf.com · brackishbert@gmail.com · foxhop.net · TimeHexOn.com Patches, unit tests, benchmarks, whitepaper, and outreach briefs. Public domain — no copyright claimed. Use freely.
This commit is contained in:
commit
0a580b313d
70422 changed files with 17213626 additions and 0 deletions
350
test/jdk/java/lang/Float/ParseFloat.java
Normal file
350
test/jdk/java/lang/Float/ParseFloat.java
Normal file
|
|
@ -0,0 +1,350 @@
|
|||
/*
|
||||
* Copyright (c) 1998, 2025, 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 8366017
|
||||
* @summary Tests for Float.parseFloat method (use -DallRoundtrips=true
|
||||
* to additionally check all non-negative, non-NaN float->String->float
|
||||
* roundtrips)
|
||||
*/
|
||||
|
||||
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
|
||||
"\uD835\uDFD9e\uD835\uDFD9" // 1e1 in Mathematical Alphanumeric Symbols
|
||||
};
|
||||
|
||||
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 (String s : input) {
|
||||
try {
|
||||
Float.parseFloat(s);
|
||||
check(s);
|
||||
} catch (NumberFormatException e) {
|
||||
if (!exceptionalInput) {
|
||||
throw new RuntimeException("Float.parseFloat rejected " +
|
||||
"good string `" + s +
|
||||
"'.");
|
||||
}
|
||||
continue;
|
||||
}
|
||||
if (exceptionalInput) {
|
||||
throw new RuntimeException("Float.parseFloat accepted " +
|
||||
"bad string `" + s +
|
||||
"'.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* 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());
|
||||
}
|
||||
|
||||
private static final int N = Float.floatToIntBits(Float.POSITIVE_INFINITY);
|
||||
|
||||
/* Tests all non-negative, non-NaN float->String->float roundtrips. */
|
||||
private static void testAllRoundtrips() {
|
||||
for (int i = 0; i <= N; ++i) {
|
||||
float v = Float.intBitsToFloat(i);
|
||||
String s = Float.toString(v);
|
||||
float v0 = Float.parseFloat(s);
|
||||
if (v != v0) {
|
||||
fail(s, v0);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private static final String ALL_ROUNDTRIPS_PROP = "allRoundtrips";
|
||||
|
||||
public static void main(String[] args) throws Exception {
|
||||
rudimentaryTest();
|
||||
|
||||
testParsing(goodStrings, false);
|
||||
testParsing(paddedGoodStrings, false);
|
||||
testParsing(badStrings, true);
|
||||
testParsing(paddedBadStrings, true);
|
||||
|
||||
testPowers();
|
||||
|
||||
if (Boolean.getBoolean(ALL_ROUNDTRIPS_PROP)) {
|
||||
testAllRoundtrips();
|
||||
}
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue