stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

8042003: Update java/lang/Math tests to eliminate dependency on sun.misc.DoubleConsts and sun.misc.FloatConsts

Browse Source 
Reviewed-by: mchung, darcy
This commit is contained in:
Amy Lu 2014-08-22 14:56:09 -07:00 committed by Mandy Chung
parent 13da43d0d4
commit ff93fd2cce
17 changed files with 177 additions and 196 deletions

12
jdk/test/java/lang/Double/BitwiseConversion.java

@ -25,21 +25,23 @@
* @test
* @bug 5037596
* @summary Verify bitwise conversion works for non-canonical NaN values
* @library ../Math
* @build DoubleConsts
* @run main BitwiseConversion
* @author Joseph D. Darcy
*/
import static java.lang.Double.*;
import static sun.misc.DoubleConsts.*;
public class BitwiseConversion {
static int testNanCase(long x) {
int errors = 0;
// Strip out sign and exponent bits
long y = x & SIGNIF_BIT_MASK;
long y = x & DoubleConsts.SIGNIF_BIT_MASK;
double values[] = {
longBitsToDouble(EXP_BIT_MASK | y),
longBitsToDouble(SIGN_BIT_MASK | EXP_BIT_MASK | y)
longBitsToDouble(DoubleConsts.EXP_BIT_MASK | y),
longBitsToDouble(DoubleConsts.SIGN_BIT_MASK | DoubleConsts.EXP_BIT_MASK | y)
};
for(double value: values) {
@ -60,7 +62,7 @@ public class BitwiseConversion {
public static void main(String... argv) {
int errors = 0;
for (int i = 0; i < SIGNIFICAND_WIDTH-1; i++) {
for (int i = 0; i < DoubleConsts.SIGNIFICAND_WIDTH-1; i++) {
errors += testNanCase(1L<<i);
}

15
jdk/test/java/lang/Double/ParseHexFloatingPoint.java

@ -30,7 +30,6 @@
import java.util.regex.*;
import sun.misc.DoubleConsts;
public class ParseHexFloatingPoint {
private ParseHexFloatingPoint(){}
@ -158,8 +157,8 @@ public class ParseHexFloatingPoint {
}
long bigExponents [] = {
2*DoubleConsts.MAX_EXPONENT,
2*DoubleConsts.MIN_EXPONENT,
2*Double.MAX_EXPONENT,
2*Double.MIN_EXPONENT,
(long)Integer.MAX_VALUE-1,
(long)Integer.MAX_VALUE,
@ -226,11 +225,11 @@ public class ParseHexFloatingPoint {
new PairSD("0x1.000000000000001p-1075", Double.MIN_VALUE),
// More subnormal rounding tests
new PairSD("0x0.fffffffffffff7fffffp-1022", Math.nextDown(DoubleConsts.MIN_NORMAL)),
new PairSD("0x0.fffffffffffff8p-1022", DoubleConsts.MIN_NORMAL),
new PairSD("0x0.fffffffffffff800000001p-1022",DoubleConsts.MIN_NORMAL),
new PairSD("0x0.fffffffffffff80000000000000001p-1022",DoubleConsts.MIN_NORMAL),
new PairSD("0x1.0p-1022", DoubleConsts.MIN_NORMAL),
new PairSD("0x0.fffffffffffff7fffffp-1022", Math.nextDown(Double.MIN_NORMAL)),
new PairSD("0x0.fffffffffffff8p-1022", Double.MIN_NORMAL),
new PairSD("0x0.fffffffffffff800000001p-1022",Double.MIN_NORMAL),
new PairSD("0x0.fffffffffffff80000000000000001p-1022",Double.MIN_NORMAL),
new PairSD("0x1.0p-1022", Double.MIN_NORMAL),
// Large value and overflow rounding tests

6
jdk/test/java/lang/Double/ToHexString.java

@ -25,11 +25,13 @@
* @test
* @bug 4826774 4926547
* @summary Tests for {Float, Double}.toHexString methods
* @library ../Math
* @build DoubleConsts
* @run main ToHexString
* @author Joseph D. Darcy
*/
import java.util.regex.*;
import sun.misc.DoubleConsts;
public class ToHexString {
private ToHexString() {}
@ -83,7 +85,7 @@ public class ToHexString {
DoubleConsts.EXP_BIAS;
result.append("0x");
if (exponent == DoubleConsts.MIN_EXPONENT - 1) { // zero or subnormal
if (exponent == Double.MIN_EXPONENT - 1) { // zero or subnormal
if(signifString.equals("0000000000000")) {
result.append("0.0p0");
}

12
jdk/test/java/lang/Float/BitwiseConversion.java

@ -25,21 +25,23 @@
* @test
* @bug 5037596
* @summary Verify bitwise conversion works for non-canonical NaN values
* @library ../Math
* @build FloatConsts
* @run main BitwiseConversion
* @author Joseph D. Darcy
*/
import static java.lang.Float.*;
import static sun.misc.FloatConsts.*;
public class BitwiseConversion {
static int testNanCase(int x) {
int errors = 0;
// Strip out sign and exponent bits
int y = x & SIGNIF_BIT_MASK;
int y = x & FloatConsts.SIGNIF_BIT_MASK;
float values[] = {
intBitsToFloat(EXP_BIT_MASK | y),
intBitsToFloat(SIGN_BIT_MASK | EXP_BIT_MASK | y)
intBitsToFloat(FloatConsts.EXP_BIT_MASK | y),
intBitsToFloat(FloatConsts.SIGN_BIT_MASK | FloatConsts.EXP_BIT_MASK | y)
};
for(float value: values) {
@ -60,7 +62,7 @@ public class BitwiseConversion {
public static void main(String... argv) {
int errors = 0;
for (int i = 0; i < SIGNIFICAND_WIDTH-1; i++) {
for (int i = 0; i < FloatConsts.SIGNIFICAND_WIDTH-1; i++) {
errors += testNanCase(1<<i);
}

10
jdk/test/java/lang/Math/CeilAndFloorTests.java

@ -27,8 +27,6 @@
* @summary Check for correct implementation of Math.ceil and Math.floor
*/
import sun.misc.DoubleConsts;
public class CeilAndFloorTests {
private static int testCeilCase(double input, double expected) {
int failures = 0;
@ -139,10 +137,10 @@ public class CeilAndFloorTests {
double [][] testCases = {
{ Double.MIN_VALUE, 1.0},
{-Double.MIN_VALUE, -0.0},
{ Math.nextDown(DoubleConsts.MIN_NORMAL), 1.0},
{-Math.nextDown(DoubleConsts.MIN_NORMAL), -0.0},
{ DoubleConsts.MIN_NORMAL, 1.0},
{-DoubleConsts.MIN_NORMAL, -0.0},
{ Math.nextDown(Double.MIN_NORMAL), 1.0},
{-Math.nextDown(Double.MIN_NORMAL), -0.0},
{ Double.MIN_NORMAL, 1.0},
{-Double.MIN_NORMAL, -0.0},
{ 0.1, 1.0},
{-0.1, -0.0},

6
jdk/test/java/lang/Math/CubeRootTests.java

@ -28,8 +28,6 @@
* @author Joseph D. Darcy
*/
import sun.misc.DoubleConsts;
public class CubeRootTests {
private CubeRootTests(){}
@ -93,7 +91,7 @@ public class CubeRootTests {
}
// Test cbrt(2^(3n)) = 2^n.
for(int i = 18; i <= DoubleConsts.MAX_EXPONENT/3; i++) {
for(int i = 18; i <= Double.MAX_EXPONENT/3; i++) {
failures += testCubeRootCase(Math.scalb(1.0, 3*i),
Math.scalb(1.0, i) );
}
@ -240,7 +238,7 @@ public class CubeRootTests {
double pcNeighborsStrictCbrt[] = new double[5];
// Test near cbrt(2^(3n)) = 2^n.
for(int i = 18; i <= DoubleConsts.MAX_EXPONENT/3; i++) {
for(int i = 18; i <= Double.MAX_EXPONENT/3; i++) {
double pc = Math.scalb(1.0, 3*i);
pcNeighbors[2] = pc;

6
jdk/test/java/lang/Math/Expm1Tests.java

@ -28,8 +28,6 @@
* @author Joseph D. Darcy
*/
import sun.misc.DoubleConsts;
/*
* The Taylor expansion of expxm1(x) = exp(x) -1 is
*
@ -99,7 +97,7 @@ public class Expm1Tests {
}
// For x > 710, expm1(x) should be infinity
for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
for(int i = 10; i <= Double.MAX_EXPONENT; i++) {
double d = Math.scalb(2, i);
failures += testExpm1Case(d, infinityD);
}
@ -116,7 +114,7 @@ public class Expm1Tests {
reachedLimit);
}
for(int i = 7; i <= DoubleConsts.MAX_EXPONENT; i++) {
for(int i = 7; i <= Double.MAX_EXPONENT; i++) {
double d = -Math.scalb(2, i);
failures += testExpm1CaseWithUlpDiff(d, -1.0, 1, reachedLimit);
}

8
jdk/test/java/lang/Math/HyperbolicTests.java

@ -28,8 +28,6 @@
* @author Joseph D. Darcy
*/
import sun.misc.DoubleConsts;
public class HyperbolicTests {
private HyperbolicTests(){}
@ -342,7 +340,7 @@ public class HyperbolicTests {
// sinh(x) overflows for values greater than 710; in
// particular, it overflows for all 2^i, i > 10.
for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
for(int i = 10; i <= Double.MAX_EXPONENT; i++) {
double d = Math.scalb(2.0, i);
// Result and expected are the same.
@ -701,7 +699,7 @@ public class HyperbolicTests {
// cosh(x) overflows for values greater than 710; in
// particular, it overflows for all 2^i, i > 10.
for(int i = 10; i <= DoubleConsts.MAX_EXPONENT; i++) {
for(int i = 10; i <= Double.MAX_EXPONENT; i++) {
double d = Math.scalb(2.0, i);
// Result and expected are the same.
@ -996,7 +994,7 @@ public class HyperbolicTests {
failures += testTanhCaseWithUlpDiff(i, 1.0, 2.5);
}
for(int i = 5; i <= DoubleConsts.MAX_EXPONENT; i++) {
for(int i = 5; i <= Double.MAX_EXPONENT; i++) {
double d = Math.scalb(2.0, i);
failures += testTanhCaseWithUlpDiff(d, 1.0, 2.5);

6
jdk/test/java/lang/Math/HypotTests.java

@ -28,8 +28,6 @@
* @author Joseph D. Darcy
*/
import sun.misc.DoubleConsts;
public class HypotTests {
private HypotTests(){}
@ -87,7 +85,7 @@ public class HypotTests {
// Verify hypot(x, 0.0) is close to x over the entire exponent
// range.
for(int i = DoubleConsts.MIN_SUB_EXPONENT;
i <= DoubleConsts.MAX_EXPONENT;
i <= Double.MAX_EXPONENT;
i++) {
double input = Math.scalb(2, i);
failures += testHypotCase(input, 0.0, input);
@ -125,7 +123,7 @@ public class HypotTests {
for(int i = 0; i < 1000; i++) {
double d = rand.nextDouble();
// Scale d to have an exponent equal to MAX_EXPONENT -15
d = Math.scalb(d, DoubleConsts.MAX_EXPONENT
d = Math.scalb(d, Double.MAX_EXPONENT
-15 - Tests.ilogb(d));
for(int j = 0; j <= 13; j += 1) {
failures += testHypotCase(3*d, 4*d, 5*d, 2.5);

223
jdk/test/java/lang/Math/IeeeRecommendedTests.java

@ -28,9 +28,6 @@
* @author Joseph D. Darcy
*/
import sun.misc.DoubleConsts;
import sun.misc.FloatConsts;
public class IeeeRecommendedTests {
private IeeeRecommendedTests(){}
@ -54,7 +51,7 @@ public class IeeeRecommendedTests {
* Returns a floating-point power of two in the normal range.
*/
static double powerOfTwoD(int n) {
return Double.longBitsToDouble((((long)n + (long)DoubleConsts.MAX_EXPONENT) <<
return Double.longBitsToDouble((((long)n + (long)Double.MAX_EXPONENT) <<
(DoubleConsts.SIGNIFICAND_WIDTH-1))
& DoubleConsts.EXP_BIT_MASK);
}
@ -63,7 +60,7 @@ public class IeeeRecommendedTests {
* Returns a floating-point power of two in the normal range.
*/
static float powerOfTwoF(int n) {
return Float.intBitsToFloat(((n + FloatConsts.MAX_EXPONENT) <<
return Float.intBitsToFloat(((n + Float.MAX_EXPONENT) <<
(FloatConsts.SIGNIFICAND_WIDTH-1))
& FloatConsts.EXP_BIT_MASK);
}
@ -129,7 +126,7 @@ public class IeeeRecommendedTests {
+16.0f,
+Float.MIN_VALUE,
+Float_MAX_SUBNORMAL,
+FloatConsts.MIN_NORMAL,
+Float.MIN_NORMAL,
+Float.MAX_VALUE
};
@ -139,10 +136,10 @@ public class IeeeRecommendedTests {
0,
1,
4,
FloatConsts.MIN_EXPONENT - 1,
-FloatConsts.MAX_EXPONENT,
FloatConsts.MIN_EXPONENT,
FloatConsts.MAX_EXPONENT
Float.MIN_EXPONENT - 1,
-Float.MAX_EXPONENT,
Float.MIN_EXPONENT,
Float.MAX_EXPONENT
};
// Special value tests
@ -152,7 +149,7 @@ public class IeeeRecommendedTests {
// Normal exponent tests
for(int i = FloatConsts.MIN_EXPONENT; i <= FloatConsts.MAX_EXPONENT; i++) {
for(int i = Float.MIN_EXPONENT; i <= Float.MAX_EXPONENT; i++) {
int result;
// Create power of two
@ -175,7 +172,7 @@ public class IeeeRecommendedTests {
failures += testGetExponentCase(randFloat, i);
}
if (i > FloatConsts.MIN_EXPONENT) {
if (i > Float.MIN_EXPONENT) {
float po2minus = Math.nextAfter(po2,
Float.NEGATIVE_INFINITY);
failures += testGetExponentCase(po2minus, i-1);
@ -199,13 +196,13 @@ public class IeeeRecommendedTests {
i++, top *= 2.0f) {
failures += testGetExponentCase(top,
FloatConsts.MIN_EXPONENT - 1);
Float.MIN_EXPONENT - 1);
// Test largest value in next smaller binade
if (i >= 3) {// (i == 1) would test 0.0;
// (i == 2) would just retest MIN_VALUE
testGetExponentCase(Math.nextAfter(top, 0.0f),
FloatConsts.MIN_EXPONENT - 1);
Float.MIN_EXPONENT - 1);
if( i >= 10) {
// create a bit mask with (i-1) 1's in the low order
@ -217,7 +214,7 @@ public class IeeeRecommendedTests {
(rand.nextInt() & mask ) ) ;
failures += testGetExponentCase(randFloat,
FloatConsts.MIN_EXPONENT - 1);
Float.MIN_EXPONENT - 1);
}
}
}
@ -236,7 +233,7 @@ public class IeeeRecommendedTests {
+16.0,
+Double.MIN_VALUE,
+Double_MAX_SUBNORMAL,
+DoubleConsts.MIN_NORMAL,
+Double.MIN_NORMAL,
+Double.MAX_VALUE
};
@ -246,10 +243,10 @@ public class IeeeRecommendedTests {
0,
1,
4,
DoubleConsts.MIN_EXPONENT - 1,
-DoubleConsts.MAX_EXPONENT,
DoubleConsts.MIN_EXPONENT,
DoubleConsts.MAX_EXPONENT
Double.MIN_EXPONENT - 1,
-Double.MAX_EXPONENT,
Double.MIN_EXPONENT,
Double.MAX_EXPONENT
};
// Special value tests
@ -259,7 +256,7 @@ public class IeeeRecommendedTests {
// Normal exponent tests
for(int i = DoubleConsts.MIN_EXPONENT; i <= DoubleConsts.MAX_EXPONENT; i++) {
for(int i = Double.MIN_EXPONENT; i <= Double.MAX_EXPONENT; i++) {
int result;
// Create power of two
@ -282,7 +279,7 @@ public class IeeeRecommendedTests {
failures += testGetExponentCase(randFloat, i);
}
if (i > DoubleConsts.MIN_EXPONENT) {
if (i > Double.MIN_EXPONENT) {
double po2minus = Math.nextAfter(po2,
Double.NEGATIVE_INFINITY);
failures += testGetExponentCase(po2minus, i-1);
@ -306,13 +303,13 @@ public class IeeeRecommendedTests {
i++, top *= 2.0f) {
failures += testGetExponentCase(top,
DoubleConsts.MIN_EXPONENT - 1);
Double.MIN_EXPONENT - 1);
// Test largest value in next smaller binade
if (i >= 3) {// (i == 1) would test 0.0;
// (i == 2) would just retest MIN_VALUE
testGetExponentCase(Math.nextAfter(top, 0.0),
DoubleConsts.MIN_EXPONENT - 1);
Double.MIN_EXPONENT - 1);
if( i >= 10) {
// create a bit mask with (i-1) 1's in the low order
@ -324,7 +321,7 @@ public class IeeeRecommendedTests {
(rand.nextLong() & mask ) ) ;
failures += testGetExponentCase(randFloat,
DoubleConsts.MIN_EXPONENT - 1);
Double.MIN_EXPONENT - 1);
}
}
}
@ -400,15 +397,15 @@ public class IeeeRecommendedTests {
{Float_MAX_VALUEmm, infinityF, Float.MAX_VALUE},
{Float_MAX_VALUEmm, Float_MAX_VALUEmm, Float_MAX_VALUEmm},
{FloatConsts.MIN_NORMAL, infinityF, FloatConsts.MIN_NORMAL+
{Float.MIN_NORMAL, infinityF, Float.MIN_NORMAL+
Float.MIN_VALUE},
{FloatConsts.MIN_NORMAL, -infinityF, Float_MAX_SUBNORMAL},
{FloatConsts.MIN_NORMAL, 1.0f, FloatConsts.MIN_NORMAL+
{Float.MIN_NORMAL, -infinityF, Float_MAX_SUBNORMAL},
{Float.MIN_NORMAL, 1.0f, Float.MIN_NORMAL+
Float.MIN_VALUE},
{FloatConsts.MIN_NORMAL, -1.0f, Float_MAX_SUBNORMAL},
{FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL},
{Float.MIN_NORMAL, -1.0f, Float_MAX_SUBNORMAL},
{Float.MIN_NORMAL, Float.MIN_NORMAL, Float.MIN_NORMAL},
{Float_MAX_SUBNORMAL, FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL},
{Float_MAX_SUBNORMAL, Float.MIN_NORMAL, Float.MIN_NORMAL},
{Float_MAX_SUBNORMAL, Float_MAX_SUBNORMAL, Float_MAX_SUBNORMAL},
{Float_MAX_SUBNORMAL, 0.0f, Float_MAX_SUBNORMALmm},
@ -472,15 +469,15 @@ public class IeeeRecommendedTests {
{Double_MAX_VALUEmm, infinityD, Double.MAX_VALUE},
{Double_MAX_VALUEmm, Double_MAX_VALUEmm, Double_MAX_VALUEmm},
{DoubleConsts.MIN_NORMAL, infinityD, DoubleConsts.MIN_NORMAL+
{Double.MIN_NORMAL, infinityD, Double.MIN_NORMAL+
Double.MIN_VALUE},
{DoubleConsts.MIN_NORMAL, -infinityD, Double_MAX_SUBNORMAL},
{DoubleConsts.MIN_NORMAL, 1.0f, DoubleConsts.MIN_NORMAL+
{Double.MIN_NORMAL, -infinityD, Double_MAX_SUBNORMAL},
{Double.MIN_NORMAL, 1.0f, Double.MIN_NORMAL+
Double.MIN_VALUE},
{DoubleConsts.MIN_NORMAL, -1.0f, Double_MAX_SUBNORMAL},
{DoubleConsts.MIN_NORMAL, DoubleConsts.MIN_NORMAL,DoubleConsts.MIN_NORMAL},
{Double.MIN_NORMAL, -1.0f, Double_MAX_SUBNORMAL},
{Double.MIN_NORMAL, Double.MIN_NORMAL, Double.MIN_NORMAL},
{Double_MAX_SUBNORMAL, DoubleConsts.MIN_NORMAL,DoubleConsts.MIN_NORMAL},
{Double_MAX_SUBNORMAL, Double.MIN_NORMAL, Double.MIN_NORMAL},
{Double_MAX_SUBNORMAL, Double_MAX_SUBNORMAL, Double_MAX_SUBNORMAL},
{Double_MAX_SUBNORMAL, 0.0d, Double_MAX_SUBNORMALmm},
@ -529,15 +526,15 @@ public class IeeeRecommendedTests {
{NaNf, NaNf},
{-infinityF, -Float.MAX_VALUE},
{-Float.MAX_VALUE, -Float_MAX_VALUEmm},
{-FloatConsts.MIN_NORMAL, -Float_MAX_SUBNORMAL},
{-Float.MIN_NORMAL, -Float_MAX_SUBNORMAL},
{-Float_MAX_SUBNORMAL, -Float_MAX_SUBNORMALmm},
{-Float.MIN_VALUE, -0.0f},
{-0.0f, Float.MIN_VALUE},
{+0.0f, Float.MIN_VALUE},
{Float.MIN_VALUE, Float.MIN_VALUE*2},
{Float_MAX_SUBNORMALmm, Float_MAX_SUBNORMAL},
{Float_MAX_SUBNORMAL, FloatConsts.MIN_NORMAL},
{FloatConsts.MIN_NORMAL, FloatConsts.MIN_NORMAL+Float.MIN_VALUE},
{Float_MAX_SUBNORMAL, Float.MIN_NORMAL},
{Float.MIN_NORMAL, Float.MIN_NORMAL+Float.MIN_VALUE},
{Float_MAX_VALUEmm, Float.MAX_VALUE},
{Float.MAX_VALUE, infinityF},
{infinityF, infinityF}
@ -567,15 +564,15 @@ public class IeeeRecommendedTests {
{NaNd, NaNd},
{-infinityD, -Double.MAX_VALUE},
{-Double.MAX_VALUE, -Double_MAX_VALUEmm},
{-DoubleConsts.MIN_NORMAL, -Double_MAX_SUBNORMAL},
{-Double.MIN_NORMAL, -Double_MAX_SUBNORMAL},
{-Double_MAX_SUBNORMAL, -Double_MAX_SUBNORMALmm},
{-Double.MIN_VALUE, -0.0d},
{-0.0d, Double.MIN_VALUE},
{+0.0d, Double.MIN_VALUE},
{Double.MIN_VALUE, Double.MIN_VALUE*2},
{Double_MAX_SUBNORMALmm, Double_MAX_SUBNORMAL},
{Double_MAX_SUBNORMAL, DoubleConsts.MIN_NORMAL},
{DoubleConsts.MIN_NORMAL, DoubleConsts.MIN_NORMAL+Double.MIN_VALUE},
{Double_MAX_SUBNORMAL, Double.MIN_NORMAL},
{Double.MIN_NORMAL, Double.MIN_NORMAL+Double.MIN_VALUE},
{Double_MAX_VALUEmm, Double.MAX_VALUE},
{Double.MAX_VALUE, infinityD},
{infinityD, infinityD}
@ -607,16 +604,16 @@ public class IeeeRecommendedTests {
{-infinityF, -infinityF},
{-Float.MAX_VALUE, -infinityF},
{-Float_MAX_VALUEmm, -Float.MAX_VALUE},
{-Float_MAX_SUBNORMAL, -FloatConsts.MIN_NORMAL},
{-Float_MAX_SUBNORMAL, -Float.MIN_NORMAL},
{-Float_MAX_SUBNORMALmm, -Float_MAX_SUBNORMAL},
{-0.0f, -Float.MIN_VALUE},
{+0.0f, -Float.MIN_VALUE},
{Float.MIN_VALUE, 0.0f},
{Float.MIN_VALUE*2, Float.MIN_VALUE},
{Float_MAX_SUBNORMAL, Float_MAX_SUBNORMALmm},
{FloatConsts.MIN_NORMAL, Float_MAX_SUBNORMAL},
{FloatConsts.MIN_NORMAL+
Float.MIN_VALUE, FloatConsts.MIN_NORMAL},
{Float.MIN_NORMAL, Float_MAX_SUBNORMAL},
{Float.MIN_NORMAL+
Float.MIN_VALUE, Float.MIN_NORMAL},
{Float.MAX_VALUE, Float_MAX_VALUEmm},
{infinityF, Float.MAX_VALUE},
};
@ -646,16 +643,16 @@ public class IeeeRecommendedTests {
{-infinityD, -infinityD},
{-Double.MAX_VALUE, -infinityD},
{-Double_MAX_VALUEmm, -Double.MAX_VALUE},
{-Double_MAX_SUBNORMAL, -DoubleConsts.MIN_NORMAL},
{-Double_MAX_SUBNORMAL, -Double.MIN_NORMAL},
{-Double_MAX_SUBNORMALmm, -Double_MAX_SUBNORMAL},
{-0.0d, -Double.MIN_VALUE},
{+0.0d, -Double.MIN_VALUE},
{Double.MIN_VALUE, 0.0d},
{Double.MIN_VALUE*2, Double.MIN_VALUE},
{Double_MAX_SUBNORMAL, Double_MAX_SUBNORMALmm},
{DoubleConsts.MIN_NORMAL, Double_MAX_SUBNORMAL},
{DoubleConsts.MIN_NORMAL+
Double.MIN_VALUE, DoubleConsts.MIN_NORMAL},
{Double.MIN_NORMAL, Double_MAX_SUBNORMAL},
{Double.MIN_NORMAL+
Double.MIN_VALUE, Double.MIN_NORMAL},
{Double.MAX_VALUE, Double_MAX_VALUEmm},
{infinityD, Double.MAX_VALUE},
};
@ -689,7 +686,7 @@ public class IeeeRecommendedTests {
-Float.MAX_VALUE,
-3.0f,
-1.0f,
-FloatConsts.MIN_NORMAL,
-Float.MIN_NORMAL,
-Float_MAX_SUBNORMALmm,
-Float_MAX_SUBNORMAL,
-Float.MIN_VALUE,
@ -698,7 +695,7 @@ public class IeeeRecommendedTests {
Float.MIN_VALUE,
Float_MAX_SUBNORMALmm,
Float_MAX_SUBNORMAL,
FloatConsts.MIN_NORMAL,
Float.MIN_NORMAL,
1.0f,
3.0f,
Float_MAX_VALUEmm,
@ -739,7 +736,7 @@ public class IeeeRecommendedTests {
-Double.MAX_VALUE,
-3.0d,
-1.0d,
-DoubleConsts.MIN_NORMAL,
-Double.MIN_NORMAL,
-Double_MAX_SUBNORMALmm,
-Double_MAX_SUBNORMAL,
-Double.MIN_VALUE,
@ -748,7 +745,7 @@ public class IeeeRecommendedTests {
Double.MIN_VALUE,
Double_MAX_SUBNORMALmm,
Double_MAX_SUBNORMAL,
DoubleConsts.MIN_NORMAL,
Double.MIN_NORMAL,
1.0d,
3.0d,
Double_MAX_VALUEmm,
@ -790,7 +787,7 @@ public class IeeeRecommendedTests {
Float.MIN_VALUE,
Float_MAX_SUBNORMALmm,
Float_MAX_SUBNORMAL,
FloatConsts.MIN_NORMAL,
Float.MIN_NORMAL,
1.0f,
3.0f,
Float_MAX_VALUEmm,
@ -801,7 +798,7 @@ public class IeeeRecommendedTests {
-Float.MAX_VALUE,
-3.0f,
-1.0f,
-FloatConsts.MIN_NORMAL,
-Float.MIN_NORMAL,
-Float_MAX_SUBNORMALmm,
-Float_MAX_SUBNORMAL,
-Float.MIN_VALUE,
@ -864,7 +861,7 @@ public class IeeeRecommendedTests {
Double.MIN_VALUE,
Double_MAX_SUBNORMALmm,
Double_MAX_SUBNORMAL,
DoubleConsts.MIN_NORMAL,
Double.MIN_NORMAL,
1.0d,
3.0d,
Double_MAX_VALUEmm,
@ -875,7 +872,7 @@ public class IeeeRecommendedTests {
-Double.MAX_VALUE,
-3.0d,
-1.0d,
-DoubleConsts.MIN_NORMAL,
-Double.MIN_NORMAL,
-Double_MAX_SUBNORMALmm,
-Double_MAX_SUBNORMAL,
-Double.MIN_VALUE,
@ -964,7 +961,7 @@ public class IeeeRecommendedTests {
public static int testFloatScalb() {
int failures=0;
int MAX_SCALE = FloatConsts.MAX_EXPONENT + -FloatConsts.MIN_EXPONENT +
int MAX_SCALE = Float.MAX_EXPONENT + -Float.MIN_EXPONENT +
FloatConsts.SIGNIFICAND_WIDTH + 1;
@ -988,7 +985,7 @@ public class IeeeRecommendedTests {
3.0f*Float.MIN_VALUE,
Float_MAX_SUBNORMALmm,
Float_MAX_SUBNORMAL,
FloatConsts.MIN_NORMAL,
Float.MIN_NORMAL,
1.0f,
2.0f,
3.0f,
@ -998,8 +995,8 @@ public class IeeeRecommendedTests {
};
int [] oneMultiplyScalingFactors = {
FloatConsts.MIN_EXPONENT,
FloatConsts.MIN_EXPONENT+1,
Float.MIN_EXPONENT,
Float.MIN_EXPONENT+1,
-3,
-2,
-1,
@ -1007,8 +1004,8 @@ public class IeeeRecommendedTests {
1,
2,
3,
FloatConsts.MAX_EXPONENT-1,
FloatConsts.MAX_EXPONENT
Float.MAX_EXPONENT-1,
Float.MAX_EXPONENT
};
int [] manyScalingFactors = {
@ -1018,14 +1015,14 @@ public class IeeeRecommendedTests {
-MAX_SCALE,
-MAX_SCALE+1,
2*FloatConsts.MIN_EXPONENT-1, // -253
2*FloatConsts.MIN_EXPONENT, // -252
2*FloatConsts.MIN_EXPONENT+1, // -251
2*Float.MIN_EXPONENT-1, // -253
2*Float.MIN_EXPONENT, // -252
2*Float.MIN_EXPONENT+1, // -251
FloatConsts.MIN_EXPONENT - FloatConsts.SIGNIFICAND_WIDTH,
Float.MIN_EXPONENT - FloatConsts.SIGNIFICAND_WIDTH,
FloatConsts.MIN_SUB_EXPONENT,
-FloatConsts.MAX_EXPONENT, // -127
FloatConsts.MIN_EXPONENT, // -126
-Float.MAX_EXPONENT, // -127
Float.MIN_EXPONENT, // -126
-2,
-1,
@ -1033,13 +1030,13 @@ public class IeeeRecommendedTests {
1,
2,
FloatConsts.MAX_EXPONENT-1, // 126
FloatConsts.MAX_EXPONENT, // 127
FloatConsts.MAX_EXPONENT+1, // 128
Float.MAX_EXPONENT-1, // 126
Float.MAX_EXPONENT, // 127
Float.MAX_EXPONENT+1, // 128
2*FloatConsts.MAX_EXPONENT-1, // 253
2*FloatConsts.MAX_EXPONENT, // 254
2*FloatConsts.MAX_EXPONENT+1, // 255
2*Float.MAX_EXPONENT-1, // 253
2*Float.MAX_EXPONENT, // 254
2*Float.MAX_EXPONENT+1, // 255
MAX_SCALE-1,
MAX_SCALE,
@ -1086,7 +1083,7 @@ public class IeeeRecommendedTests {
// Create 2^MAX_EXPONENT
float twoToTheMaxExp = 1.0f; // 2^0
for(int i = 0; i < FloatConsts.MAX_EXPONENT; i++)
for(int i = 0; i < Float.MAX_EXPONENT; i++)
twoToTheMaxExp *=2.0f;
// Scale-up subnormal values until they all overflow
@ -1094,12 +1091,12 @@ public class IeeeRecommendedTests {
float scale = 1.0f; // 2^j
float value = subnormalTestCases[i];
for(int j=FloatConsts.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
for(int j=Float.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
int scaleFactor = j;
failures+=testScalbCase(value,
scaleFactor,
(Tests.ilogb(value) +j > FloatConsts.MAX_EXPONENT ) ?
(Tests.ilogb(value) +j > Float.MAX_EXPONENT ) ?
Math.copySign(infinityF, value) : // overflow
// calculate right answer
twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) );
@ -1172,7 +1169,7 @@ public class IeeeRecommendedTests {
public static int testDoubleScalb() {
int failures=0;
int MAX_SCALE = DoubleConsts.MAX_EXPONENT + -DoubleConsts.MIN_EXPONENT +
int MAX_SCALE = Double.MAX_EXPONENT + -Double.MIN_EXPONENT +
DoubleConsts.SIGNIFICAND_WIDTH + 1;
@ -1195,7 +1192,7 @@ public class IeeeRecommendedTests {
3.0d*Double.MIN_VALUE,
Double_MAX_SUBNORMALmm,
Double_MAX_SUBNORMAL,
DoubleConsts.MIN_NORMAL,
Double.MIN_NORMAL,
1.0d,
2.0d,
3.0d,
@ -1205,8 +1202,8 @@ public class IeeeRecommendedTests {
};
int [] oneMultiplyScalingFactors = {
DoubleConsts.MIN_EXPONENT,
DoubleConsts.MIN_EXPONENT+1,
Double.MIN_EXPONENT,
Double.MIN_EXPONENT+1,
-3,
-2,
-1,
@ -1214,8 +1211,8 @@ public class IeeeRecommendedTests {
1,
2,
3,
DoubleConsts.MAX_EXPONENT-1,
DoubleConsts.MAX_EXPONENT
Double.MAX_EXPONENT-1,
Double.MAX_EXPONENT
};
int [] manyScalingFactors = {
@ -1225,15 +1222,15 @@ public class IeeeRecommendedTests {
-MAX_SCALE,
-MAX_SCALE+1,
2*DoubleConsts.MIN_EXPONENT-1, // -2045
2*DoubleConsts.MIN_EXPONENT, // -2044
2*DoubleConsts.MIN_EXPONENT+1, // -2043
2*Double.MIN_EXPONENT-1, // -2045
2*Double.MIN_EXPONENT, // -2044
2*Double.MIN_EXPONENT+1, // -2043
DoubleConsts.MIN_EXPONENT, // -1022
DoubleConsts.MIN_EXPONENT - DoubleConsts.SIGNIFICAND_WIDTH,
Double.MIN_EXPONENT, // -1022
Double.MIN_EXPONENT - DoubleConsts.SIGNIFICAND_WIDTH,
DoubleConsts.MIN_SUB_EXPONENT,
-DoubleConsts.MAX_EXPONENT, // -1023
DoubleConsts.MIN_EXPONENT, // -1022
-Double.MAX_EXPONENT, // -1023
Double.MIN_EXPONENT, // -1022
-2,
-1,
@ -1241,13 +1238,13 @@ public class IeeeRecommendedTests {
1,
2,
DoubleConsts.MAX_EXPONENT-1, // 1022
DoubleConsts.MAX_EXPONENT, // 1023
DoubleConsts.MAX_EXPONENT+1, // 1024
Double.MAX_EXPONENT-1, // 1022
Double.MAX_EXPONENT, // 1023
Double.MAX_EXPONENT+1, // 1024
2*DoubleConsts.MAX_EXPONENT-1, // 2045
2*DoubleConsts.MAX_EXPONENT, // 2046
2*DoubleConsts.MAX_EXPONENT+1, // 2047
2*Double.MAX_EXPONENT-1, // 2045
2*Double.MAX_EXPONENT, // 2046
2*Double.MAX_EXPONENT+1, // 2047
MAX_SCALE-1,
MAX_SCALE,
@ -1294,7 +1291,7 @@ public class IeeeRecommendedTests {
// Create 2^MAX_EXPONENT
double twoToTheMaxExp = 1.0; // 2^0
for(int i = 0; i < DoubleConsts.MAX_EXPONENT; i++)
for(int i = 0; i < Double.MAX_EXPONENT; i++)
twoToTheMaxExp *=2.0;
// Scale-up subnormal values until they all overflow
@ -1302,12 +1299,12 @@ public class IeeeRecommendedTests {
double scale = 1.0; // 2^j
double value = subnormalTestCases[i];
for(int j=DoubleConsts.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
for(int j=Double.MAX_EXPONENT*2; j < MAX_SCALE; j++) { // MAX_SCALE -1 should cause overflow
int scaleFactor = j;
failures+=testScalbCase(value,
scaleFactor,
(Tests.ilogb(value) +j > DoubleConsts.MAX_EXPONENT ) ?
(Tests.ilogb(value) +j > Double.MAX_EXPONENT ) ?
Math.copySign(infinityD, value) : // overflow
// calculate right answer
twoToTheMaxExp*(twoToTheMaxExp*(scale*value)) );
@ -1345,7 +1342,7 @@ public class IeeeRecommendedTests {
double value = 0x1.000000000000bP-1;
expected = 0x0.2000000000001P-1022;
for(int i = 0; i < DoubleConsts.MAX_EXPONENT+2; i++) {
for(int i = 0; i < Double.MAX_EXPONENT+2; i++) {
failures+=testScalbCase(value,
-1024-i,
expected);
@ -1401,7 +1398,7 @@ public class IeeeRecommendedTests {
+16.0f,
+Float.MIN_VALUE,
+Float_MAX_SUBNORMAL,
+FloatConsts.MIN_NORMAL,
+Float.MIN_NORMAL,
+Float.MAX_VALUE
};
@ -1424,7 +1421,7 @@ public class IeeeRecommendedTests {
// Normal exponent tests
for(int i = FloatConsts.MIN_EXPONENT; i <= FloatConsts.MAX_EXPONENT; i++) {
for(int i = Float.MIN_EXPONENT; i <= Float.MAX_EXPONENT; i++) {
float expected;
// Create power of two
@ -1448,7 +1445,7 @@ public class IeeeRecommendedTests {
failures += testUlpCase(randFloat, expected);
}
if (i > FloatConsts.MIN_EXPONENT) {
if (i > Float.MIN_EXPONENT) {
float po2minus = Math.nextAfter(po2,
Float.NEGATIVE_INFINITY);
failures += testUlpCase(po2minus, expected/2.0f);
@ -1506,7 +1503,7 @@ public class IeeeRecommendedTests {
+16.0d,
+Double.MIN_VALUE,
+Double_MAX_SUBNORMAL,
+DoubleConsts.MIN_NORMAL,
+Double.MIN_NORMAL,
+Double.MAX_VALUE
};
@ -1529,7 +1526,7 @@ public class IeeeRecommendedTests {
// Normal exponent tests
for(int i = DoubleConsts.MIN_EXPONENT; i <= DoubleConsts.MAX_EXPONENT; i++) {
for(int i = Double.MIN_EXPONENT; i <= Double.MAX_EXPONENT; i++) {
double expected;
// Create power of two
@ -1553,7 +1550,7 @@ public class IeeeRecommendedTests {
failures += testUlpCase(randDouble, expected);
}
if (i > DoubleConsts.MIN_EXPONENT) {
if (i > Double.MIN_EXPONENT) {
double po2minus = Math.nextAfter(po2,
Double.NEGATIVE_INFINITY);
failures += testUlpCase(po2minus, expected/2.0f);
@ -1607,7 +1604,7 @@ public class IeeeRecommendedTests {
{NaNf, NaNf},
{-infinityF, -1.0f},
{-Float.MAX_VALUE, -1.0f},
{-FloatConsts.MIN_NORMAL, -1.0f},
{-Float.MIN_NORMAL, -1.0f},
{-1.0f, -1.0f},
{-2.0f, -1.0f},
{-Float_MAX_SUBNORMAL, -1.0f},
@ -1617,7 +1614,7 @@ public class IeeeRecommendedTests {
{Float.MIN_VALUE, 1.0f},
{Float_MAX_SUBNORMALmm, 1.0f},
{Float_MAX_SUBNORMAL, 1.0f},
{FloatConsts.MIN_NORMAL, 1.0f},
{Float.MIN_NORMAL, 1.0f},
{1.0f, 1.0f},
{2.0f, 1.0f},
{Float_MAX_VALUEmm, 1.0f},
@ -1641,7 +1638,7 @@ public class IeeeRecommendedTests {
{NaNd, NaNd},
{-infinityD, -1.0},
{-Double.MAX_VALUE, -1.0},
{-DoubleConsts.MIN_NORMAL, -1.0},
{-Double.MIN_NORMAL, -1.0},
{-1.0, -1.0},
{-2.0, -1.0},
{-Double_MAX_SUBNORMAL, -1.0},
@ -1651,7 +1648,7 @@ public class IeeeRecommendedTests {
{Double.MIN_VALUE, 1.0},
{Double_MAX_SUBNORMALmm, 1.0},
{Double_MAX_SUBNORMAL, 1.0},
{DoubleConsts.MIN_NORMAL, 1.0},
{Double.MIN_NORMAL, 1.0},
{1.0, 1.0},
{2.0, 1.0},
{Double_MAX_VALUEmm, 1.0},

4
jdk/test/java/lang/Math/Log10Tests.java

@ -28,8 +28,6 @@
* @author Joseph D. Darcy
*/
import sun.misc.DoubleConsts;
public class Log10Tests {
private Log10Tests(){}
@ -70,7 +68,7 @@ public class Log10Tests {
{Double.NEGATIVE_INFINITY, NaNd},
{-8.0, NaNd},
{-1.0, NaNd},
{-DoubleConsts.MIN_NORMAL, NaNd},
{-Double.MIN_NORMAL, NaNd},
{-Double.MIN_VALUE, NaNd},
{-0.0, -infinityD},
{+0.0, -infinityD},

4
jdk/test/java/lang/Math/Log1pTests.java

@ -28,8 +28,6 @@
* @author Joseph D. Darcy
*/
import sun.misc.DoubleConsts;
public class Log1pTests {
private Log1pTests(){}
@ -93,7 +91,7 @@ public class Log1pTests {
}
// For x > 2^53 log1p(x) ~= log(x)
for(int i = 53; i <= DoubleConsts.MAX_EXPONENT; i++) {
for(int i = 53; i <= Double.MAX_EXPONENT; i++) {
double d = Math.scalb(2, i);
failures += testLog1pCaseWithUlpDiff(d, StrictMath.log(d), 2.001);
}

6
jdk/test/java/lang/Math/Rint.java

@ -27,8 +27,6 @@
* @summary Check for correct implementation of Math.rint(double)
*/
import sun.misc.DoubleConsts;
public class Rint {
static int testRintCase(double input, double expected) {
@ -51,8 +49,8 @@ public class Rint {
double [][] testCases = {
{0.0, 0.0},
{Double.MIN_VALUE, 0.0},
{Math.nextDown(DoubleConsts.MIN_NORMAL), 0.0},
{DoubleConsts.MIN_NORMAL, 0.0},
{Math.nextDown(Double.MIN_NORMAL), 0.0},
{Double.MIN_NORMAL, 0.0},
{0.2, 0.0},

27
jdk/test/java/lang/Math/Tests.java

@ -30,9 +30,6 @@
* and finally the expected result.
*/
import sun.misc.FloatConsts;
import sun.misc.DoubleConsts;
public class Tests {
private Tests(){}; // do not instantiate
@ -81,13 +78,13 @@ public class Tests {
int exponent = Math.getExponent(d);
switch (exponent) {
case DoubleConsts.MAX_EXPONENT+1: // NaN or infinity
case Double.MAX_EXPONENT+1: // NaN or infinity
if( Double.isNaN(d) )
return (1<<30); // 2^30
else // infinite value
return (1<<28); // 2^28
case DoubleConsts.MIN_EXPONENT-1: // zero or subnormal
case Double.MIN_EXPONENT-1: // zero or subnormal
if(d == 0.0) {
return -(1<<28); // -(2^28)
}
@ -117,14 +114,14 @@ public class Tests {
}
exponent++;
assert( exponent >=
DoubleConsts.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1) &&
exponent < DoubleConsts.MIN_EXPONENT);
Double.MIN_EXPONENT - (DoubleConsts.SIGNIFICAND_WIDTH-1) &&
exponent < Double.MIN_EXPONENT);
return exponent;
}
default:
assert( exponent >= DoubleConsts.MIN_EXPONENT &&
exponent <= DoubleConsts.MAX_EXPONENT);
assert( exponent >= Double.MIN_EXPONENT &&
exponent <= Double.MAX_EXPONENT);
return exponent;
}
}
@ -150,13 +147,13 @@ public class Tests {
int exponent = Math.getExponent(f);
switch (exponent) {
case FloatConsts.MAX_EXPONENT+1: // NaN or infinity
case Float.MAX_EXPONENT+1: // NaN or infinity
if( Float.isNaN(f) )
return (1<<30); // 2^30
else // infinite value
return (1<<28); // 2^28
case FloatConsts.MIN_EXPONENT-1: // zero or subnormal
case Float.MIN_EXPONENT-1: // zero or subnormal
if(f == 0.0f) {
return -(1<<28); // -(2^28)
}
@ -186,14 +183,14 @@ public class Tests {
}
exponent++;
assert( exponent >=
FloatConsts.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1) &&
exponent < FloatConsts.MIN_EXPONENT);
Float.MIN_EXPONENT - (FloatConsts.SIGNIFICAND_WIDTH-1) &&
exponent < Float.MIN_EXPONENT);
return exponent;
}
default:
assert( exponent >= FloatConsts.MIN_EXPONENT &&
exponent <= FloatConsts.MAX_EXPONENT);
assert( exponent >= Float.MIN_EXPONENT &&
exponent <= Float.MAX_EXPONENT);
return exponent;
}
}

11
jdk/test/java/util/Formatter/BasicDouble.java

@ -36,9 +36,6 @@ import java.math.BigInteger;
import java.text.DateFormatSymbols;
import java.util.*;
import sun.misc.DoubleConsts;
import static java.util.Calendar.*;
@ -1313,12 +1310,12 @@ public class BasicDouble extends Basic {
test("%.1a", "-0x1.0p0", -1.0);
test("%.11a", "0x1.80000000000p1", 3.0);
test("%.1a", "0x1.8p1", 3.0);
test("%.11a", "0x1.00000000000p-1022", DoubleConsts.MIN_NORMAL);
test("%.1a", "0x1.0p-1022", DoubleConsts.MIN_NORMAL);
test("%.11a", "0x1.00000000000p-1022", Double.MIN_NORMAL);
test("%.1a", "0x1.0p-1022", Double.MIN_NORMAL);
test("%.11a", "0x1.00000000000p-1022",
Math.nextDown(DoubleConsts.MIN_NORMAL));
Math.nextDown(Double.MIN_NORMAL));
test("%.1a", "0x1.0p-1022",
Math.nextDown(DoubleConsts.MIN_NORMAL));
Math.nextDown(Double.MIN_NORMAL));
test("%.11a", "0x1.ffffffffffep-1023", 0x0.fffffffffffp-1022);
test("%.1a", "0x1.0p-1022", 0x0.fffffffffffp-1022);
test("%.30a", "0x0.000000000000100000000000000000p-1022", Double.MIN_VALUE);

14
jdk/test/sun/misc/FloatingDecimal/OldFloatingDecimalForTest.java

@ -23,8 +23,6 @@
//package sun.misc;
import sun.misc.DoubleConsts;
import sun.misc.FloatConsts;
import java.util.regex.*;
public class OldFloatingDecimalForTest{
@ -2217,12 +2215,12 @@ public class OldFloatingDecimalForTest{
// Check for overflow and update exponent accordingly.
if (exponent > DoubleConsts.MAX_EXPONENT) { // Infinite result
if (exponent > Double.MAX_EXPONENT) { // Infinite result
// overflow to properly signed infinity
return new OldFloatingDecimalForTest(sign * Double.POSITIVE_INFINITY);
} else { // Finite return value
if (exponent <= DoubleConsts.MAX_EXPONENT && // (Usually) normal result
exponent >= DoubleConsts.MIN_EXPONENT) {
if (exponent <= Double.MAX_EXPONENT && // (Usually) normal result
exponent >= Double.MIN_EXPONENT) {
// The result returned in this block cannot be a
// zero or subnormal; however after the
@ -2242,7 +2240,7 @@ public class OldFloatingDecimalForTest{
(DoubleConsts.SIGNIF_BIT_MASK & significand);
} else { // Subnormal or zero
// (exponent < DoubleConsts.MIN_EXPONENT)
// (exponent < Double.MIN_EXPONENT)
if (exponent < (DoubleConsts.MIN_SUB_EXPONENT -1 )) {
// No way to round back to nonzero value
@ -2282,7 +2280,7 @@ public class OldFloatingDecimalForTest{
// Now, discard the bits
significand = significand >> bitsDiscarded;
significand = (( ((long)(DoubleConsts.MIN_EXPONENT -1) + // subnorm exp.
significand = (( ((long)(Double.MIN_EXPONENT -1) + // subnorm exp.
(long)DoubleConsts.EXP_BIAS) <<
(DoubleConsts.SIGNIFICAND_WIDTH-1))
& DoubleConsts.EXP_BIT_MASK) |
@ -2350,7 +2348,7 @@ public class OldFloatingDecimalForTest{
* information must be preserved (i.e. case 1).
*/
if ((exponent >= FloatConsts.MIN_SUB_EXPONENT-1) &&
(exponent <= FloatConsts.MAX_EXPONENT ) ){
(exponent <= Float.MAX_EXPONENT ) ){
// Outside above exponent range, the float value
// will be zero or infinity.

3
jdk/test/sun/misc/FloatingDecimal/TestFloatingDecimal.java

@ -58,6 +58,9 @@ public class sun.misc.FloatingDecimal {
* @test
* @bug 7032154
* @summary unit tests of sun.misc.FloatingDecimal
* @library ../../../java/lang/Math
* @build DoubleConsts FloatConsts
* @run main TestFloatingDecimal
* @author Brian Burkhalter
*/
public class TestFloatingDecimal {