Implement assertNotEquals() for float parameters.

Fix inconsistencies between assertEquals() and assertNotEquals() for
double parameters.

Author: motlin

src/main/java/org/junit/Assert.java

@@ -210,41 +210,57 @@ static public void assertNotEquals(long first, long second) {
     }
 
     /**
-     * Asserts that two doubles or floats are <b>not</b> equal to within a positive delta.
+     * Asserts that two doubles are <b>not</b> equal to within a positive delta.
      * If they are, an {@link AssertionError} is thrown with the given
      * message. If the expected value is infinity then the delta value is
      * ignored. NaNs are considered equal:
      * <code>assertNotEquals(Double.NaN, Double.NaN, *)</code> fails
      *
      * @param message the identifying message for the {@link AssertionError} (<code>null</code>
      * okay)
-     * @param first first value to check
-     * @param second the value to check against <code>first</code>
+     * @param expected expected value
+     * @param actual the value to check against <code>expected</code>
      * @param delta the maximum delta between <code>expected</code> and
      * <code>actual</code> for which both numbers are still
      * considered equal.
      */
-    static public void assertNotEquals(String message, double first,
-            double second, double delta) {
-        if (!doubleIsDifferent(first, second, delta)) {
-            failEquals(message, new Double(first));
+    static public void assertNotEquals(String message, double expected,
+            double actual, double delta) {
+        if (!doubleIsDifferent(expected, actual, delta)) {
+            failEquals(message, new Double(expected));
         }
     }
 
     /**
-     * Asserts that two doubles or floats are <b>not</b> equal to within a positive delta.
+     * Asserts that two doubles are <b>not</b> equal to within a positive delta.
      * If they are, an {@link AssertionError} is thrown. If the expected
      * value is infinity then the delta value is ignored.NaNs are considered
      * equal: <code>assertNotEquals(Double.NaN, Double.NaN, *)</code> fails
      *
-     * @param first first value to check
-     * @param second the value to check against <code>first</code>
+     * @param expected expected value
+     * @param actual the value to check against <code>expected</code>
+     * @param delta the maximum delta between <code>expected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    static public void assertNotEquals(double expected, double actual, double delta) {
+        assertNotEquals(null, expected, actual, delta);
+    }
+
+    /**
+     * Asserts that two floats are <b>not</b> equal to within a positive delta.
+     * If they are, an {@link AssertionError} is thrown. If the expected
+     * value is infinity then the delta value is ignored.NaNs are considered
+     * equal: <code>assertNotEquals(Float.NaN, Float.NaN, *)</code> fails
+     *
+     * @param expected expected value
+     * @param actual the value to check against <code>expected</code>
      * @param delta the maximum delta between <code>expected</code> and
      * <code>actual</code> for which both numbers are still
      * considered equal.
      */
-    static public void assertNotEquals(double first, double second, double delta) {
-        assertNotEquals(null, first, second, delta);
+    static public void assertNotEquals(float expected, float actual, float delta) {
+        assertNotEquals(null, expected, actual, delta);
     }
 
     /**
@@ -512,14 +528,33 @@ static public void assertEquals(String message, double expected,
      */
     static public void assertEquals(String message, float expected,
             float actual, float delta) {
-        if (Float.compare(expected, actual) == 0) {
-            return;
-        }
-        if (!(Math.abs(expected - actual) <= delta)) {
+        if (floatIsDifferent(expected, actual, delta)) {
             failNotEquals(message, new Float(expected), new Float(actual));
         }
     }
 
+    /**
+     * Asserts that two floats are <b>not</b> equal to within a positive delta.
+     * If they are, an {@link AssertionError} is thrown with the given
+     * message. If the expected value is infinity then the delta value is
+     * ignored. NaNs are considered equal:
+     * <code>assertNotEquals(Float.NaN, Float.NaN, *)</code> fails
+     *
+     * @param message the identifying message for the {@link AssertionError} (<code>null</code>
+     * okay)
+     * @param expected expected value
+     * @param actual the value to check against <code>expected</code>
+     * @param delta the maximum delta between <code>expected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    static public void assertNotEquals(String message, float expected,
+            float actual, float delta) {
+        if (!floatIsDifferent(expected, actual, delta)) {
+            failEquals(message, new Float(expected));
+        }
+    }
+
     static private boolean doubleIsDifferent(double d1, double d2, double delta) {
         if (Double.compare(d1, d2) == 0) {
             return false;
@@ -531,6 +566,17 @@ static private boolean doubleIsDifferent(double d1, double d2, double delta) {
         return true;
     }
 
+    static private boolean floatIsDifferent(float f1, float f2, float delta) {
+        if (Float.compare(f1, f2) == 0) {
+            return false;
+        }
+        if ((Math.abs(f1 - f2) <= delta)) {
+            return false;
+        }
+
+        return true;
+    }
+
     /**
      * Asserts that two longs are equal. If they are not, an
      * {@link AssertionError} is thrown.

src/test/java/org/junit/tests/assertion/AssertionTest.java

@@ -619,15 +619,27 @@ public void assertNotEqualsWorksWithPrimitiveTypes() {
         assertNotEquals("The values should be different", 1L, 2L);
         assertNotEquals(1.0, 2.0, 0);
         assertNotEquals("The values should be different", 1.0, 2.0, 0);
+        assertNotEquals(1.0f, 2.0f, 0f);
+        assertNotEquals("The values should be different", 1.0f, 2.0f, 0f);
     }
 
     @Test(expected = AssertionError.class)
     public void assertNotEqualsConsidersDeltaCorrectly() {
         assertNotEquals(1.0, 0.9, 0.1);
     }
 
+    @Test(expected = AssertionError.class)
+    public void assertNotEqualsConsidersFloatDeltaCorrectly() {
+        assertNotEquals(1.0f, 0.75f, 0.25f);
+    }
+
     @Test(expected = AssertionError.class)
     public void assertNotEqualsIgnoresDeltaOnNaN() {
         assertNotEquals(Double.NaN, Double.NaN, 1);
     }
+
+    @Test(expected = AssertionError.class)
+    public void assertNotEqualsIgnoresFloatDeltaOnNaN() {
+        assertNotEquals(Float.NaN, Float.NaN, 1f);
+    }
 }