harmony-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ndbe...@apache.org
Subject svn commit: r464314 - in /incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang: CharacterTest.java DoubleTest.java FloatTest.java
Date Sun, 15 Oct 2006 22:38:57 GMT
Author: ndbeyer
Date: Sun Oct 15 15:38:56 2006
New Revision: 464314

URL: http://svn.apache.org/viewvc?view=rev&rev=464314
Log:
Cleanup tests -
* DoubleTest, FloatTest: use double/float JUnit assertions
* CharacterTest: remove unnecessary casts, etc

Modified:
    incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CharacterTest.java
    incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/DoubleTest.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/test/java/org/apache/harmony/luni/tests/java/lang/CharacterTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CharacterTest.java?view=diff&rev=464314&r1=464313&r2=464314
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CharacterTest.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/CharacterTest.java
Sun Oct 15 15:38:56 2006
@@ -636,7 +636,6 @@
      * @tests java.lang.Character#Character(char)
      */
     public void test_ConstructorC() {
-        // Test for method java.lang.Character(char)
         assertEquals("Constructor failed", 'T', new Character('T').charValue());
     }
 
@@ -644,7 +643,6 @@
      * @tests java.lang.Character#charValue()
      */
     public void test_charValue() {
-        // Test for method char java.lang.Character.charValue()
         assertEquals("Incorrect char value returned", 'T', new Character('T')
                 .charValue());
     }
@@ -653,8 +651,6 @@
      * @tests java.lang.Character#compareTo(java.lang.Character)
      */
     public void test_compareToLjava_lang_Character() {
-        // Test for method int
-        // java.lang.Character.compareTo(java.lang.Character)
         Character c = new Character('c');
         Character x = new Character('c');
         Character y = new Character('b');
@@ -673,7 +669,6 @@
      * @tests java.lang.Character#digit(char, int)
      */
     public void test_digitCI() {
-        // Test for method int java.lang.Character.digit(char, int)
         assertEquals("Returned incorrect digit", 1, Character.digit('1', 10));
         assertEquals("Returned incorrect digit", 15, Character.digit('F', 16));
     }
@@ -709,8 +704,6 @@
      * @tests java.lang.Character#forDigit(int, int)
      */
     public void test_forDigitII() {
-        // Test for method char java.lang.Character.forDigit(int, int)
-
         char hexChars[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
                 'a', 'b', 'c', 'd', 'e', 'f' };
         for (int i = 0; i < hexChars.length; i++) {
@@ -732,7 +725,6 @@
      * @tests java.lang.Character#getNumericValue(char)
      */
     public void test_getNumericValueC() {
-        // Test for method int java.lang.Character.getNumericValue(char)
         assertEquals("Returned incorrect numeric value 1", 1, Character
                 .getNumericValue('1'));
         assertEquals("Returned incorrect numeric value 2", 15, Character
@@ -785,7 +777,6 @@
      * @tests java.lang.Character#getType(char)
      */
     public void test_getTypeC() {
-        // Test for method int java.lang.Character.getType(char)
         assertTrue("Returned incorrect type for: \n",
                 Character.getType('\n') == Character.CONTROL);
         assertTrue("Returned incorrect type for: 1",
@@ -921,7 +912,6 @@
      * @tests java.lang.Character#hashCode()
      */
     public void test_hashCode() {
-        // Test for method int java.lang.Character.hashCode()
         assertEquals("Incorrect hash returned",
                 89, new Character('Y').hashCode());
     }
@@ -930,7 +920,6 @@
      * @tests java.lang.Character#isDefined(char)
      */
     public void test_isDefinedC() {
-        // Test for method boolean java.lang.Character.isDefined(char)
         assertTrue("Defined character returned false", Character.isDefined('v'));
         assertTrue("Defined character returned false", Character
                 .isDefined('\u6039'));
@@ -953,7 +942,6 @@
      * @tests java.lang.Character#isDigit(char)
      */
     public void test_isDigitC() {
-        // Test for method boolean java.lang.Character.isDigit(char)
         assertTrue("Digit returned false", Character.isDigit('1'));
         assertTrue("Non-Digit returned false", !Character.isDigit('A'));
     }
@@ -997,8 +985,6 @@
      * @tests java.lang.Character#isIdentifierIgnorable(char)
      */
     public void test_isIdentifierIgnorableC() {
-        // Test for method boolean
-        // java.lang.Character.isIdentifierIgnorable(char)
         assertTrue("Ignorable whitespace returned false", Character
                 .isIdentifierIgnorable('\u0007'));
         assertTrue("Ignorable non - whitespace  control returned false",
@@ -1101,8 +1087,6 @@
      * @tests java.lang.Character#isJavaIdentifierPart(char)
      */
     public void test_isJavaIdentifierPartC() {
-        // Test for method boolean
-        // java.lang.Character.isJavaIdentifierPart(char)
         assertTrue("letter returned false", Character.isJavaIdentifierPart('l'));
         assertTrue("currency returned false", Character
                 .isJavaIdentifierPart('$'));
@@ -1166,8 +1150,6 @@
      * @tests java.lang.Character#isJavaIdentifierStart(char)
      */
     public void test_isJavaIdentifierStartC() {
-        // Test for method boolean
-        // java.lang.Character.isJavaIdentifierStart(char)
         assertTrue("letter returned false", Character
                 .isJavaIdentifierStart('l'));
         assertTrue("currency returned false", Character
@@ -1219,7 +1201,6 @@
      */
     @SuppressWarnings("deprecation")
     public void test_isJavaLetterC() {
-        // Test for method boolean java.lang.Character.isJavaLetter(char)
         assertTrue("letter returned false", Character.isJavaLetter('l'));
         assertTrue("currency returned false", Character.isJavaLetter('$'));
         assertTrue("connecting char returned false", Character
@@ -1236,7 +1217,6 @@
      */
     @SuppressWarnings("deprecation")
     public void test_isJavaLetterOrDigitC() {
-        // Test for method boolean java.lang.Character.isJavaLetterOrDigit(char)
         assertTrue("letter returned false", Character.isJavaLetterOrDigit('l'));
         assertTrue("currency returned false", Character
                 .isJavaLetterOrDigit('$'));
@@ -1250,7 +1230,6 @@
      * @tests java.lang.Character#isLetter(char)
      */
     public void test_isLetterC() {
-        // Test for method boolean java.lang.Character.isLetter(char)
         assertTrue("Letter returned false", Character.isLetter('L'));
         assertTrue("Non-Letter returned true", !Character.isLetter('9'));
     }
@@ -1275,7 +1254,6 @@
      * @tests java.lang.Character#isLetterOrDigit(char)
      */
     public void test_isLetterOrDigitC() {
-        // Test for method boolean java.lang.Character.isLetterOrDigit(char)
         assertTrue("Digit returned false", Character.isLetterOrDigit('9'));
         assertTrue("Letter returned false", Character.isLetterOrDigit('K'));
         assertTrue("Control returned true", !Character.isLetterOrDigit('\n'));
@@ -1308,7 +1286,6 @@
      * @tests java.lang.Character#isLowerCase(char)
      */
     public void test_isLowerCaseC() {
-        // Test for method boolean java.lang.Character.isLowerCase(char)
         assertTrue("lower returned false", Character.isLowerCase('a'));
         assertTrue("upper returned true", !Character.isLowerCase('T'));
     }
@@ -1342,7 +1319,6 @@
      * @tests java.lang.Character#isSpaceChar(char)
      */
     public void test_isSpaceCharC() {
-        // Test for method boolean java.lang.Character.isSpaceChar(char)
         assertTrue("space returned false", Character.isSpaceChar('\u0020'));
         assertTrue("non-space returned true", !Character.isSpaceChar('\n'));
     }
@@ -1367,8 +1343,6 @@
      * @tests java.lang.Character#isTitleCase(char)
      */
     public void test_isTitleCaseC() {
-        // Test for method boolean java.lang.Character.isTitleCase(char)
-
         char[] tChars = { (char) 0x01c5, (char) 0x01c8, (char) 0x01cb,
                 (char) 0x01f2, (char) 0x1f88, (char) 0x1f89, (char) 0x1f8a,
                 (char) 0x1f8b, (char) 0x1f8c, (char) 0x1f8d, (char) 0x1f8e,
@@ -1415,8 +1389,6 @@
      * @tests java.lang.Character#isUnicodeIdentifierPart(char)
      */
     public void test_isUnicodeIdentifierPartC() {
-        // Test for method boolean
-        // java.lang.Character.isUnicodeIdentifierPart(char)
         assertTrue("'a' returned false", Character.isUnicodeIdentifierPart('a'));
         assertTrue("'2' returned false", Character.isUnicodeIdentifierPart('2'));
         assertTrue("'+' returned true", !Character.isUnicodeIdentifierPart('+'));
@@ -1473,8 +1445,6 @@
      * @tests java.lang.Character#isUnicodeIdentifierStart(char)
      */
     public void test_isUnicodeIdentifierStartC() {
-        // Test for method boolean
-        // java.lang.Character.isUnicodeIdentifierStart(char)
         assertTrue("'a' returned false", Character
                 .isUnicodeIdentifierStart('a'));
         assertTrue("'2' returned true", !Character
@@ -1515,7 +1485,6 @@
      * @tests java.lang.Character#isUpperCase(char)
      */
     public void test_isUpperCaseC() {
-        // Test for method boolean java.lang.Character.isUpperCase(char)
         assertTrue("Incorrect case value", !Character.isUpperCase('t'));
         assertTrue("Incorrect case value", Character.isUpperCase('T'));
     }
@@ -1539,7 +1508,6 @@
      * @tests java.lang.Character#isWhitespace(char)
      */
     public void test_isWhitespaceC() {
-        // Test for method boolean java.lang.Character.isWhitespace(char)
         assertTrue("space returned false", Character.isWhitespace('\n'));
         assertTrue("non-space returned true", !Character.isWhitespace('T'));
     }
@@ -1601,7 +1569,6 @@
      * @tests java.lang.Character#toLowerCase(char)
      */
     public void test_toLowerCaseC() {
-        // Test for method char java.lang.Character.toLowerCase(char)
         assertEquals("Failed to change case", 't', Character.toLowerCase('T'));
     }
     
@@ -1609,7 +1576,7 @@
      * @tests java.lang.Character#toLowerCase(int)
      */
     public void test_toLowerCase_I() {
-        assertEquals((int)'t', Character.toLowerCase((int)'T'));
+        assertEquals('t', Character.toLowerCase((int)'T'));
         
         assertEquals(0x10428, Character.toLowerCase(0x10400));
         assertEquals(0x10428, Character.toLowerCase(0x10428));
@@ -1623,16 +1590,13 @@
      * @tests java.lang.Character#toString()
      */
     public void test_toString() {
-        // Test for method java.lang.String java.lang.Character.toString()
-        assertEquals("Incorrect String returned", "T", new Character('T').toString()
-                );
+        assertEquals("Incorrect String returned", "T", new Character('T').toString());
     }
 
     /**
      * @tests java.lang.Character#toTitleCase(char)
      */
     public void test_toTitleCaseC() {
-        // Test for method char java.lang.Character.toTitleCase(char)
         assertEquals("Incorrect title case for a",
                 'A', Character.toTitleCase('a'));
         assertEquals("Incorrect title case for A",
@@ -1645,9 +1609,9 @@
      * @tests java.lang.Character#toTitleCase(int)
      */
     public void test_toTitleCase_I() {
-        assertEquals((int)'A', Character.toTitleCase((int)'a'));
-        assertEquals((int)'A', Character.toTitleCase((int)'A'));
-        assertEquals((int)'1', Character.toTitleCase((int)'1'));
+        assertEquals('A', Character.toTitleCase((int)'a'));
+        assertEquals('A', Character.toTitleCase((int)'A'));
+        assertEquals('1', Character.toTitleCase((int)'1'));
         
         assertEquals(0x10400, Character.toTitleCase(0x10428));
         assertEquals(0x10400, Character.toTitleCase(0x10400));
@@ -1673,9 +1637,9 @@
      * @tests java.lang.Character#toUpperCase(int)
      */
     public void test_toUpperCase_I() {
-        assertEquals((int)'A', Character.toUpperCase((int)'a'));
-        assertEquals((int)'A', Character.toUpperCase((int)'A'));
-        assertEquals((int)'1', Character.toUpperCase((int)'1'));
+        assertEquals('A', Character.toUpperCase((int)'a'));
+        assertEquals('A', Character.toUpperCase((int)'A'));
+        assertEquals('1', Character.toUpperCase((int)'1'));
         
         assertEquals(0x10400, Character.toUpperCase(0x10428));
         assertEquals(0x10400, Character.toUpperCase(0x10400));
@@ -1688,7 +1652,6 @@
      * @tests java.lang.Character#getDirectionality(int)
      */
     public void test_isDirectionaliy_I(){
-        //assertTrue(false);
         assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character
                 .getDirectionality(0xFFFE));
         assertEquals(Character.DIRECTIONALITY_UNDEFINED, Character

Modified: incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/DoubleTest.java
URL: http://svn.apache.org/viewvc/incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/DoubleTest.java?view=diff&rev=464314&r1=464313&r2=464314
==============================================================================
--- incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/DoubleTest.java
(original)
+++ incubator/harmony/enhanced/classlib/trunk/modules/luni/src/test/java/org/apache/harmony/luni/tests/java/lang/DoubleTest.java
Sun Oct 15 15:38:56 2006
@@ -630,80 +630,80 @@
         double expected;
 
         actual = Double.parseDouble("0x0.0p0D");
-        assertEquals("Returned incorrect value", 0.0d, actual);
+        assertEquals("Returned incorrect value", 0.0d, actual, 0.0D);
 
         actual = Double.parseDouble("0xa.ap+9d");
-        assertEquals("Returned incorrect value", 5440.0d, actual);
+        assertEquals("Returned incorrect value", 5440.0d, actual, 0.0D);
 
         actual = Double.parseDouble("+0Xb.10ap8");
-        assertEquals("Returned incorrect value", 2832.625d, actual);
+        assertEquals("Returned incorrect value", 2832.625d, actual, 0.0D);
 
         actual = Double.parseDouble("-0X.a0P2D");
-        assertEquals("Returned incorrect value", -2.5d, actual);
+        assertEquals("Returned incorrect value", -2.5d, actual, 0.0D);
 
         actual = Double.parseDouble("\r 0x22.1p2d \t");
-        assertEquals("Returned incorrect value", 136.25d, actual);
+        assertEquals("Returned incorrect value", 136.25d, actual, 0.0D);
 
         actual = Double.parseDouble("0x1.0p-1");
-        assertEquals("Returned incorrect value", 0.5, actual);
+        assertEquals("Returned incorrect value", 0.5, actual, 0.0D);
 
         actual = Double
                 .parseDouble("0x00000000000000000000000000000000001.0p-1");
-        assertEquals("Returned incorrect value", 0.5, actual);
+        assertEquals("Returned incorrect value", 0.5, actual, 0.0D);
 
          actual = Double.parseDouble("0x1.0p-00000000000000000000000000001");
-         assertEquals("Returned incorrect value", 0.5, actual);
+         assertEquals("Returned incorrect value", 0.5, actual, 0.0D);
 
         actual = Double.parseDouble("0x.100000000000000000000000000000000p1");
-        assertEquals("Returned incorrect value", 0.125, actual);
+        assertEquals("Returned incorrect value", 0.125, actual, 0.0D);
 
         actual = Double.parseDouble("0x0.0p999999999999999999999999999999999999999999999999999999999999999");
-        assertEquals("Returned incorrect value", 0.0, actual);
+        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
         
         actual = Double.parseDouble("0xf1.0p9999999999999999999999999999999999999999999999999999999999999999");
-        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual);
+        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
 
         actual = Double.parseDouble("0xffffffffffffffffffffffffffffffffffff.ffffffffffffffffffffffffffffffffffffffffffffffp1");
         expected = Double.longBitsToDouble(0x4900000000000000L);
-        assertEquals("Returned incorrect value", expected, actual);
+        assertEquals("Returned incorrect value", expected, actual, 0.0D);
         
         actual = Double.parseDouble("0x0.000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001p1600");
         expected = Double.longBitsToDouble(0x7f30000000000000L);
-        assertEquals("Returned incorrect value", expected, actual);
+        assertEquals("Returned incorrect value", expected, actual, 0.0D);
         
         actual = Double.parseDouble("0x0.0p-999999999999999999999999999999999999999999999999999999");
-        assertEquals("Returned incorrect value", 0.0, actual);
+        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
         
         actual = Double.parseDouble("0xf1.0p-9999999999999999999999999999999999999999999999999999999999999999");
-        assertEquals("Returned incorrect value", 0.0, actual);
+        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
         
         actual = Double.parseDouble("0x10000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000p-1600");
         expected = Double.longBitsToDouble(0xf0000000000000L);
-        assertEquals("Returned incorrect value", expected, actual);
+        assertEquals("Returned incorrect value", expected, actual, 0.0D);
         
         actual = Double.parseDouble("0x1.p9223372036854775807");
-        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual);
+        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
         
         actual = Double.parseDouble("0x1.p9223372036854775808");
-        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual);
+        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
         
         actual = Double.parseDouble("0x10.p9223372036854775808");
-        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual);
+        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
         
         actual = Double.parseDouble("0xabcd.ffffffffp+2000");
-        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual);
+        assertEquals("Returned incorrect value", Double.POSITIVE_INFINITY, actual, 0.0D);
         
         actual = Double.parseDouble("0x1.p-9223372036854775808");
-        assertEquals("Returned incorrect value", 0.0, actual);
+        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
         
         actual = Double.parseDouble("0x1.p-9223372036854775809");
-        assertEquals("Returned incorrect value", 0.0, actual);
+        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
         
         actual = Double.parseDouble("0x.1p-9223372036854775809");
-        assertEquals("Returned incorrect value", 0.0, actual);
+        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
         
         actual = Double.parseDouble("0xabcd.ffffffffffffffp-2000");
-        assertEquals("Returned incorrect value", 0.0, actual);
+        assertEquals("Returned incorrect value", 0.0, actual, 0.0D);
     }
     
     /**
@@ -763,7 +763,7 @@
                     + ">.The expected result should be:<" + expectedString
                     + ">, but was: <" + actualString + ">. ";
             
-            assertEquals(errorMsg, expected, actual);
+            assertEquals(errorMsg, expected, actual, 0.0D);
         }
     }
     
@@ -824,7 +824,7 @@
                     + ">.The expected result should be:<" + expectedString
                     + ">, but was: <" + actualString + ">. ";
             
-            assertEquals(errorMsg, expected, actual);
+            assertEquals(errorMsg, expected, actual, 0.0D);
         }
     }
     
@@ -888,7 +888,7 @@
                    + ">.The expected result should be:<" + expectedString
                    + ">, but was: <" + actualString + ">. ";
            
-           assertEquals(errorMsg, expected, actual);
+           assertEquals(errorMsg, expected, actual, 0.0D);
        }
     }
     
@@ -952,7 +952,7 @@
                    + ">.The expected result should be:<" + expectedString
                    + ">, but was: <" + actualString + ">. ";
            
-           assertEquals(errorMsg, expected, actual);
+           assertEquals(errorMsg, expected, actual, 0.0D);
        }
     }
     
@@ -1016,7 +1016,7 @@
                    + ">.The expected result should be:<" + expectedString
                    + ">, but was: <" + actualString + ">. ";
            
-           assertEquals(errorMsg, expected, actual);
+           assertEquals(errorMsg, expected, actual, 0.0D);
        }
     }
     
@@ -1080,7 +1080,7 @@
                    + ">.The expected result should be:<" + expectedString
                    + ">, but was: <" + actualString + ">. ";
            
-           assertEquals(errorMsg, expected, actual);
+           assertEquals(errorMsg, expected, actual, 0.0D);
        }
     }
     
@@ -1127,7 +1127,7 @@
                    + ">.The expected result should be:<" + expectedString
                    + ">, but was: <" + actualString + ">. ";
            
-           assertEquals(errorMsg, expected, actual);
+           assertEquals(errorMsg, expected, actual, 0.0D);
        }
     }
 

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=464314&r1=464313&r2=464314
==============================================================================
--- 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
Sun Oct 15 15:38:56 2006
@@ -409,46 +409,45 @@
      */
     public void test_parseFloat_LString_Unusual() {
         float actual;
-        float expected;
         
         actual = Float.parseFloat("0x00000000000000000000000000000000000000000.0000000000000000000000000000000000000p0000000000000000000000000000000000");
-        assertEquals("Returned incorrect value", 0.0f, actual);
+        assertEquals("Returned incorrect value", 0.0f, actual, 0.0F);
                 
         actual = Float.parseFloat("+0Xfffff.fffffffffffffffffffffffffffffffp+99F");
-        assertEquals("Returned incorrect value", 6.64614E35f, actual);
+        assertEquals("Returned incorrect value", 6.64614E35f, actual, 0.0F);
         
         actual = Float.parseFloat("-0X.123456789abcdefp+99f");
-        assertEquals("Returned incorrect value", -4.5072022E28f, actual);
+        assertEquals("Returned incorrect value", -4.5072022E28f, actual, 0.0F);
         
         actual = Float.parseFloat("-0X123456789abcdef.p+1f");
-        assertEquals("Returned incorrect value", -1.63971062E17f, actual);
+        assertEquals("Returned incorrect value", -1.63971062E17f, actual, 0.0F);
         
         actual = Float.parseFloat("-0X000000000000000000000000000001abcdef.0000000000000000000000000001abefp00000000000000000000000000000000000000000004f");
-        assertEquals("Returned incorrect value", -4.48585472E8f, actual);
+        assertEquals("Returned incorrect value", -4.48585472E8f, actual, 0.0F);
         
         actual = Float.parseFloat("0X0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001234p600f");
-        assertEquals("Returned incorrect value", 5.907252E33f, actual);
+        assertEquals("Returned incorrect value", 5.907252E33f, actual, 0.0F);
         
         actual = Float.parseFloat("0x1.p9223372036854775807");
-        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual);
+        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F);
         
         actual = Float.parseFloat("0x1.p9223372036854775808");
-        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual);
+        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F);
         
         actual = Float.parseFloat("0x10.p9223372036854775808");
-        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual);
+        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F);
         
         actual = Float.parseFloat("0xabcd.ffffffffp+2000");
-        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual);
+        assertEquals("Returned incorrect value", Float.POSITIVE_INFINITY, actual, 0.0F);
         
         actual = Float.parseFloat("0x1.p-9223372036854775808");
-        assertEquals("Returned incorrect value", 0.0f, actual);
+        assertEquals("Returned incorrect value", 0.0f, actual, 0.0F);
         
         actual = Float.parseFloat("0x1.p-9223372036854775809");
-        assertEquals("Returned incorrect value", 0.0f, actual);
+        assertEquals("Returned incorrect value", 0.0f, actual, 0.0F);
         
         actual = Float.parseFloat("0x.1p-9223372036854775809");
-        assertEquals("Returned incorrect value", 0.0f, actual);
+        assertEquals("Returned incorrect value", 0.0f, actual, 0.0F);
     }
     
     /**
@@ -480,7 +479,7 @@
             + ">.The expected result should be:<" + expectedString
             + ">, but was: <" + actualString + ">. ";
             
-            assertEquals(errorMsg, expected, actual);
+            assertEquals(errorMsg, expected, actual, 0.0F);
         }
     }
     
@@ -529,7 +528,7 @@
             + ">.The expected result should be:<" + expectedString
             + ">, but was: <" + actualString + ">. ";
             
-            assertEquals(errorMsg, expected, actual);
+            assertEquals(errorMsg, expected, actual, 0.0F);
         }
     }
     
@@ -579,7 +578,7 @@
             + ">.The expected result should be:<" + expectedString
             + ">, but was: <" + actualString + ">. ";
             
-            assertEquals(errorMsg, expected, actual);
+            assertEquals(errorMsg, expected, actual, 0.0F);
         }
     }
     
@@ -629,7 +628,7 @@
             + ">.The expected result should be:<" + expectedString
             + ">, but was: <" + actualString + ">. ";
             
-            assertEquals(errorMsg, expected, actual);
+            assertEquals(errorMsg, expected, actual, 0.0F);
         }
     }
     
@@ -679,7 +678,7 @@
             + ">.The expected result should be:<" + expectedString
             + ">, but was: <" + actualString + ">. ";
             
-            assertEquals(errorMsg, expected, actual);
+            assertEquals(errorMsg, expected, actual, 0.0F);
         }
     }
     
@@ -729,7 +728,7 @@
             + ">.The expected result should be:<" + expectedString
             + ">, but was: <" + actualString + ">. ";
             
-            assertEquals(errorMsg, expected, actual);
+            assertEquals(errorMsg, expected, actual, 0.0F);
         }
     }
 
@@ -779,7 +778,7 @@
             + ">.The expected result should be:<" + expectedString
             + ">, but was: <" + actualString + ">. ";
             
-            assertEquals(errorMsg, expected, actual);
+            assertEquals(errorMsg, expected, actual, 0.0F);
         }
     }
 



Mime
View raw message