Return-Path: Delivered-To: apmail-incubator-harmony-commits-archive@www.apache.org Received: (qmail 23044 invoked from network); 15 Oct 2006 22:39:19 -0000 Received: from hermes.apache.org (HELO mail.apache.org) (209.237.227.199) by minotaur.apache.org with SMTP; 15 Oct 2006 22:39:19 -0000 Received: (qmail 36951 invoked by uid 500); 15 Oct 2006 22:39:19 -0000 Delivered-To: apmail-incubator-harmony-commits-archive@incubator.apache.org Received: (qmail 36914 invoked by uid 500); 15 Oct 2006 22:39:19 -0000 Mailing-List: contact harmony-commits-help@incubator.apache.org; run by ezmlm Precedence: bulk List-Help: List-Unsubscribe: List-Post: List-Id: Reply-To: harmony-dev@incubator.apache.org Delivered-To: mailing list harmony-commits@incubator.apache.org Received: (qmail 36903 invoked by uid 99); 15 Oct 2006 22:39:19 -0000 Received: from asf.osuosl.org (HELO asf.osuosl.org) (140.211.166.49) by apache.org (qpsmtpd/0.29) with ESMTP; Sun, 15 Oct 2006 15:39:19 -0700 X-ASF-Spam-Status: No, hits=-9.4 required=10.0 tests=ALL_TRUSTED,NO_REAL_NAME X-Spam-Check-By: apache.org Received-SPF: pass (asf.osuosl.org: local policy) Received: from [140.211.166.113] (HELO eris.apache.org) (140.211.166.113) by apache.org (qpsmtpd/0.29) with ESMTP; Sun, 15 Oct 2006 15:39:17 -0700 Received: by eris.apache.org (Postfix, from userid 65534) id 6FD8F1A981A; Sun, 15 Oct 2006 15:38:57 -0700 (PDT) Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit 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 -0000 To: harmony-commits@incubator.apache.org From: ndbeyer@apache.org X-Mailer: svnmailer-1.1.0 Message-Id: <20061015223857.6FD8F1A981A@eris.apache.org> X-Virus-Checked: Checked by ClamAV on apache.org X-Spam-Rating: minotaur.apache.org 1.6.2 0/1000/N 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); } }