Merge pull request #611 from motlin/master

Implement assertNotEquals() for float parameters.

Author: David Saff

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

@@ -147,32 +147,32 @@ static public void assertEquals(Object expected, Object actual) {
     /**
      * Asserts that two objects are <b>not</b> equals. If they are, an
      * {@link AssertionError} is thrown with the given message. If
-     * <code>first</code> and <code>second</code> are <code>null</code>,
+     * <code>unexpected</code> and <code>actual</code> are <code>null</code>,
      * they are considered equal.
      *
      * @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 unexpected unexpected value to check
+     * @param actual the value to check against <code>unexpected</code>
      */
-    static public void assertNotEquals(String message, Object first,
-            Object second) {
-        if (equalsRegardingNull(first, second)) {
-            failEquals(message, first);
+    static public void assertNotEquals(String message, Object unexpected,
+            Object actual) {
+        if (equalsRegardingNull(unexpected, actual)) {
+            failEquals(message, actual);
         }
     }
 
     /**
      * Asserts that two objects are <b>not</b> equals. If they are, an
      * {@link AssertionError} without a message is thrown. If
-     * <code>first</code> and <code>second</code> are <code>null</code>,
+     * <code>unexpected</code> and <code>actual</code> are <code>null</code>,
      * they are considered equal.
      *
-     * @param first first value to check
-     * @param second the value to check against <code>first</code>
+     * @param unexpected unexpected value to check
+     * @param actual the value to check against <code>unexpected</code>
      */
-    static public void assertNotEquals(Object first, Object second) {
-        assertNotEquals(null, first, second);
+    static public void assertNotEquals(Object unexpected, Object actual) {
+        assertNotEquals(null, unexpected, actual);
     }
 
     private static void failEquals(String message, Object actual) {
@@ -191,60 +191,76 @@ private static void failEquals(String message, Object actual) {
      *
      * @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 unexpected unexpected value to check
+     * @param actual the value to check against <code>unexpected</code>
      */
-    static public void assertNotEquals(String message, long first, long second) {
-        assertNotEquals(message, (Long) first, (Long) second);
+    static public void assertNotEquals(String message, long unexpected, long actual) {
+        assertNotEquals(message, (Long) unexpected, (Long) actual);
     }
 
     /**
      * Asserts that two longs are <b>not</b> equals. If they are, an
      * {@link AssertionError} without a message is thrown.
      *
-     * @param first first value to check
-     * @param second the value to check against <code>first</code>
+     * @param unexpected unexpected value to check
+     * @param actual the value to check against <code>unexpected</code>
      */
-    static public void assertNotEquals(long first, long second) {
-        assertNotEquals(null, first, second);
+    static public void assertNotEquals(long unexpected, long actual) {
+        assertNotEquals(null, unexpected, actual);
     }
 
     /**
-     * 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
+     * message. If the unexpected 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 delta the maximum delta between <code>expected</code> and
+     * @param unexpected unexpected value
+     * @param actual the value to check against <code>unexpected</code>
+     * @param delta the maximum delta between <code>unexpected</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 unexpected,
+            double actual, double delta) {
+        if (!doubleIsDifferent(unexpected, actual, delta)) {
+            failEquals(message, new Double(actual));
         }
     }
 
     /**
-     * Asserts that two doubles or floats are <b>not</b> equal to within a positive delta.
-     * If they are, an {@link AssertionError} is thrown. If the expected
+     * Asserts that two doubles are <b>not</b> equal to within a positive delta.
+     * If they are, an {@link AssertionError} is thrown. If the unexpected
      * 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 delta the maximum delta between <code>expected</code> and
+     * @param unexpected unexpected value
+     * @param actual the value to check against <code>unexpected</code>
+     * @param delta the maximum delta between <code>unexpected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    static public void assertNotEquals(double unexpected, double actual, double delta) {
+        assertNotEquals(null, unexpected, 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 unexpected
+     * value is infinity then the delta value is ignored.NaNs are considered
+     * equal: <code>assertNotEquals(Float.NaN, Float.NaN, *)</code> fails
+     *
+     * @param unexpected unexpected value
+     * @param actual the value to check against <code>unexpected</code>
+     * @param delta the maximum delta between <code>unexpected</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 unexpected, float actual, float delta) {
+        assertNotEquals(null, unexpected, 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 unexpected 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 unexpected unexpected value
+     * @param actual the value to check against <code>unexpected</code>
+     * @param delta the maximum delta between <code>unexpected</code> and
+     * <code>actual</code> for which both numbers are still
+     * considered equal.
+     */
+    static public void assertNotEquals(String message, float unexpected,
+            float actual, float delta) {
+        if (!floatIsDifferent(unexpected, actual, delta)) {
+            failEquals(message, new Float(actual));
+        }
+    }
+
     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);
+    }
 }