harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From py...@apache.org
Subject svn commit: r463240 - in /incubator/harmony/enhanced/classlib/trunk/modules/luni/src: main/java/org/apache/harmony/luni/util/FloatingPointParser.java test/java/org/apache/harmony/luni/tests/java/lang/FloatTest.java
Date Thu, 12 Oct 2006 13:10:33 GMT
Author: pyang
Date: Thu Oct 12 06:10:33 2006
New Revision: 463240

URL: http://svn.apache.org/viewvc?view=rev&rev=463240
Log:
Apply patch for HARMONY-1645([classlib][luni]Float.parseFloat() fails to parse HexString.)

Modified:
    incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/util/FloatingPointParser.java
    incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/FloatTest.java

Modified: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/util/FloatingPointParser.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/util/FloatingPointParser.java?view=diff&rev=463240&r1=463239&r2=463240
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/util/FloatingPointParser.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/main/java/org/apache/harmony/luni/util/FloatingPointParser.java
Thu Oct 12 06:10:33 2006
@@ -301,6 +301,12 @@
 		if ((last == 'y') || (last == 'N')) {
 			return parseFltName(s, length);
 		}
+        
+        // See if it could be a hexadecimal representation
+        if (s.toLowerCase().indexOf("0x") != -1) { //$NON-NLS-1$
+            return HexStringParser.parseFloat(s);
+        }
+        
 		StringExponentPair info = initialParse(s, length);
 
 		float result = parseFltImpl(info.s, info.e);

Modified: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/FloatTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/FloatTest.java?view=diff&rev=463240&r1=463239&r2=463240
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/FloatTest.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/FloatTest.java
Thu Oct 12 06:10:33 2006
@@ -403,6 +403,385 @@
         doTestCompareRawBits("1.0E+39", 0x7f800000, "Infinity");
         doTestCompareRawBits("-1.0E+39", 0xff800000, "-Infinity");
     }
+    
+    /**
+     * @tests java.lang.Float#parseFloat(java.lang.String)
+     */
+    public void test_parseFloat_LString_Unusual() {
+        float actual;
+        float expected;
+        
+        actual = Float.parseFloat("0x00000000000000000000000000000000000000000.0000000000000000000000000000000000000p0000000000000000000000000000000000");
+        assertEquals("Returned incorrect value", 0.0f, actual);
+                
+        actual = Float.parseFloat("+0Xfffff.fffffffffffffffffffffffffffffffp+99F");
+        assertEquals("Returned incorrect value", 6.64614E35f, actual);
+        
+        actual = Float.parseFloat("-0X.123456789abcdefp+99f");
+        assertEquals("Returned incorrect value", -4.5072022E28f, actual);
+        
+        actual = Float.parseFloat("-0X123456789abcdef.p+1f");
+        assertEquals("Returned incorrect value", -1.63971062E17f, actual);
+        
+        actual = Float.parseFloat("-0X000000000000000000000000000001abcdef.0000000000000000000000000001abefp00000000000000000000000000000000000000000004f");
+        assertEquals("Returned incorrect value", -4.48585472E8f, actual);
+        
+        actual = Float.parseFloat("0X0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234p600f");
+        assertEquals("Returned incorrect value", 5.907252E33f, actual);
+        
+        actual = Float.parseFloat("0x1.p9223372036854775807");
+        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual);
+        
+        actual = Float.parseFloat("0x1.p9223372036854775808");
+        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual);
+        
+        actual = Float.parseFloat("0x10.p9223372036854775808");
+        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual);
+        
+        actual = Float.parseFloat("0xabcd.ffffffffp+2000");
+        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual);
+        
+        actual = Float.parseFloat("0x1.p-9223372036854775808");
+        assertEquals("Returned incorrect value", 0.0f, actual);
+        
+        actual = Float.parseFloat("0x1.p-9223372036854775809");
+        assertEquals("Returned incorrect value", 0.0f, actual);
+        
+        actual = Float.parseFloat("0x.1p-9223372036854775809");
+        assertEquals("Returned incorrect value", 0.0f, actual);
+    }
+    
+    /**
+     * @tests java.lang.Float#parseFloat(java.lang.String)
+     */
+    public void test_parseFloat_LString_NormalPositiveExponent() {
+        int[] expecteds = {
+                0x3991a2b4,                0x43cc0247,                0x47909009,
+                0x4ac0c009,                0x4e109005,                0x5140c005,
+                0x5458d805,                0x57848402,                0x5a909002,
+                0x5da8a802,                0x60c0c002,                0x63cccc02,
+                0x66e4e402,                0x69f0f002,                0x6d048401,
+                0x70109001,                0x73169601,                0x76810810,
+                0x79840840,                0x7c8a08a0,                0x7f800000,
+                0x7f800000,                0x7f800000,                0x7f800000,
+                0x7f800000,
+        };
+        
+        for (int i = 0; i < expecteds.length; i++) {
+            int part = i * 6;
+            String inputString = "0x" + part + "." + part + "0123456789abcdefp" + part;
+
+            float actual = Float.parseFloat(inputString);
+            float expected = Float.intBitsToFloat(expecteds[i]);
+
+            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
+            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
+            String errorMsg = i + "th input string is:<" + inputString
+            + ">.The expected result should be:<" + expectedString
+            + ">, but was: <" + actualString + ">. ";
+            
+            assertEquals(errorMsg, expected, actual);
+        }
+    }
+    
+    /**
+     * @tests java.lang.Float#parseFloat(java.lang.String)
+     */
+    public void test_parseFloat_LString_NormalNegativeExponent() {
+        int[] expecteds = {
+                0x3991a2b4,
+                0x3d6e0247,
+                0x3aa0a009,
+                0x37848405,
+                0x3420a005,
+                0x30d4d405,
+                0x2d848402,
+                0x2a129202,
+                0x26acac02,
+                0x2346c602,
+                0x1fe0e002,
+                0x1c6eee02,
+                0x19048401,
+                0x15919101,
+                0x12189801,
+                0xf028828,
+                0xb890890,
+                0x80c88c8,
+                0x4930930,
+                0x1198998,
+                0x28028,
+                0x51c,
+                0xb,
+                0x0,
+                0x0,
+        };
+        
+        for (int i = 0; i < expecteds.length; i++) {
+            int part = i * 7;
+            String inputString = "0x" + part + "." + part + "0123456789abcdefp-"  + part;
+
+            float actual = Float.parseFloat(inputString);
+            float expected = Float.intBitsToFloat(expecteds[i]);
+            
+            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
+            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
+            String errorMsg = i + "th input string is:<" + inputString
+            + ">.The expected result should be:<" + expectedString
+            + ">, but was: <" + actualString + ">. ";
+            
+            assertEquals(errorMsg, expected, actual);
+        }
+    }
+    
+    /**
+     * @tests java.lang.Float#parseFloat(java.lang.String)
+     */
+    public void test_parseFloat_LString_MaxNormalBoundary() {
+        int[] expecteds ={
+                0x7f7fffff,
+                0x7f7fffff,
+                0x7f7fffff,
+                0x7f800000,
+                0x7f800000,
+                0x7f800000,
+                
+                0xff7fffff,
+                0xff7fffff,
+                0xff7fffff,
+                0xff800000,
+                0xff800000,
+                0xff800000,
+        };
+        
+        String[] inputs = {
+                "0x1.fffffep127",
+                "0x1.fffffe000000000000000000000000000000000000000000000001p127",
+                "0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
+                "0x1.ffffffp127",
+                "0x1.ffffff000000000000000000000000000000000000000000000001p127",
+                "0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
+                
+                "-0x1.fffffep127",
+                "-0x1.fffffe000000000000000000000000000000000000000000000001p127",
+                "-0x1.fffffeffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
+                "-0x1.ffffffp127",
+                "-0x1.ffffff000000000000000000000000000000000000000000000001p127",
+                "-0x1.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp127",
+        };
+        
+        for (int i = 0; i < inputs.length; i++) {
+            float actual = Float.parseFloat(inputs[i]);
+            float expected = Float.intBitsToFloat(expecteds[i]);
+            
+            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
+            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
+            String errorMsg = i + "th input string is:<" + inputs[i]
+            + ">.The expected result should be:<" + expectedString
+            + ">, but was: <" + actualString + ">. ";
+            
+            assertEquals(errorMsg, expected, actual);
+        }
+    }
+    
+    /**
+     * @tests java.lang.Float#parseFloat(java.lang.String)
+     */
+    public void test_parseFloat_LString_MinNormalBoundary() {
+        int expecteds[] = {
+                0x800000,
+                0x800000,
+                0x800000,
+                0x800000,
+                0x800001,
+                0x800001,
+                
+                0x80800000,
+                0x80800000,
+                0x80800000,
+                0x80800000,
+                0x80800001,
+                0x80800001,
+        };
+        
+        String inputs[] = {
+                "0x1.0p-126",
+                "0x1.00000000000000000000000000000000000000000000001p-126",
+                "0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                "0x1.000001p-126",
+                "0x1.000001000000000000000000000000000000000000000001p-126",
+                "0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                
+                "-0x1.0p-126",
+                "-0x1.00000000000000000000000000000000000000000000001p-126",
+                "-0x1.000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                "-0x1.000001p-126",
+                "-0x1.000001000000000000000000000000000000000000000001p-126",
+                "-0x1.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+        };
+        
+        for (int i = 0; i < inputs.length; i++) {
+            float actual = Float.parseFloat(inputs[i]);
+            float expected = Float.intBitsToFloat(expecteds[i]);
+            
+            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
+            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
+            String errorMsg = i + "th input string is:<" + inputs[i]
+            + ">.The expected result should be:<" + expectedString
+            + ">, but was: <" + actualString + ">. ";
+            
+            assertEquals(errorMsg, expected, actual);
+        }
+    }
+    
+    /**
+     * @tests java.lang.Float#parseFloat(java.lang.String)
+     */
+    public void test_parseFloat_LString_MaxSubNormalBoundary() {
+        int expecteds[] = {
+                0x7fffff,
+                0x7fffff,
+                0x7fffff,
+                0x800000,
+                0x800000,
+                0x800000,
+                
+                0x807fffff,
+                0x807fffff,
+                0x807fffff,
+                0x80800000,
+                0x80800000,
+                0x80800000,
+        };
+        
+        String inputs[] = {
+                "0x0.fffffep-126",
+                "0x0.fffffe000000000000000000000000000000000000000000000000000001p-126",
+                "0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                "0x0.ffffffp-126",
+                "0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126",
+                "0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                
+                "-0x0.fffffep-126",
+                "-0x0.fffffe000000000000000000000000000000000000000000000000000001p-126",
+                "-0x0.fffffefffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                "-0x0.ffffffp-126",
+                "-0x0.ffffff0000000000000000000000000000000000000000000000000000001p-126",
+                "-0x0.ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+        };
+        
+        for (int i = 0; i < inputs.length; i++) {
+            float actual = Float.parseFloat(inputs[i]);
+            float expected = Float.intBitsToFloat(expecteds[i]);
+            
+            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
+            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
+            String errorMsg = i + "th input string is:<" + inputs[i]
+            + ">.The expected result should be:<" + expectedString
+            + ">, but was: <" + actualString + ">. ";
+            
+            assertEquals(errorMsg, expected, actual);
+        }
+    }
+    
+    /**
+     * @tests java.lang.Float#parseFloat(java.lang.String)
+     */
+    public void test_parseFloat_LString_MinSubNormalBoundary() {
+        int expecteds[] = {
+                0x1,
+                0x1,
+                0x1,
+                0x2,
+                0x2,
+                0x2,
+                
+                0x80000001,
+                0x80000001,
+                0x80000001,
+                0x80000002,
+                0x80000002,
+                0x80000002,
+        };
+        
+        String inputs[] = {
+                "0x0.000002p-126",
+                "0x0.00000200000000000000000000000000000000000001p-126",
+                "0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                "0x0.000003p-126",
+                "0x0.000003000000000000000000000000000000000000001p-126",
+                "0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                
+                "-0x0.000002p-126",
+                "-0x0.00000200000000000000000000000000000000000001p-126",
+                "-0x0.000002ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                "-0x0.000003p-126",
+                "-0x0.000003000000000000000000000000000000000000001p-126",
+                "-0x0.000003ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+        };
+        
+        for (int i = 0; i < inputs.length; i++) {
+            float actual = Float.parseFloat(inputs[i]);
+            float expected = Float.intBitsToFloat(expecteds[i]);
+            
+            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
+            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
+            String errorMsg = i + "th input string is:<" + inputs[i]
+            + ">.The expected result should be:<" + expectedString
+            + ">, but was: <" + actualString + ">. ";
+            
+            assertEquals(errorMsg, expected, actual);
+        }
+    }
+
+    /**
+     * @tests java.lang.Float#parseFloat(java.lang.String)
+     */
+    public void test_parseFloat_LString_ZeroBoundary() {
+        int expecteds[] = {
+                0x0,
+                0x0,
+                0x0,
+                0x0,
+                0x1,
+                0x1,
+                
+                0x80000000,
+                0x80000000,
+                0x80000000,
+                0x80000000,
+                0x80000001,
+                0x80000001,
+        };
+        
+        String inputs[] = {
+                "0x0.000000000000000p-126",   
+                "0x0.000000000000000000000000000000000000000000000001p-126",
+                "0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                "0x0.000001p-126",
+                "0x0.000001000000000000000000000000000000000000000001p-126",
+                "0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                
+                "-0x0.000000000000000p-126",   
+                "-0x0.000000000000000000000000000000000000000000000001p-126",
+                "-0x0.000000fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+                "-0x0.000001p-126",
+                "-0x0.000001000000000000000000000000000000000000000001p-126",
+                "-0x0.000001fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffp-126",
+        };
+        
+        for (int i = 0; i < inputs.length; i++) {
+            float actual = Float.parseFloat(inputs[i]);
+            float expected = Float.intBitsToFloat(expecteds[i]);
+            
+            String expectedString = Integer.toHexString(Float.floatToIntBits(expected));
+            String actualString = Integer.toHexString(Float.floatToIntBits(actual));
+            String errorMsg = i + "th input string is:<" + inputs[i]
+            + ">.The expected result should be:<" + expectedString
+            + ">, but was: <" + actualString + ">. ";
+            
+            assertEquals(errorMsg, expected, actual);
+        }
+    }
 
     /**
      * @tests java.lang.Float#shortValue()



Mime
View raw message