/** * 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 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 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. */ public static void assertNotEquals(String message, double unexpected, double actual, double delta) { if (!doubleIsDifferent(unexpected, actual, delta)) { failEquals(message, Double.valueOf(actual)); } }
/** * Asserts that two doubles are equal to within a positive delta. * If they are not, 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>assertEquals(Double.NaN, Double.NaN, *)</code> passes * * @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. */ public static void assertEquals(String message, double expected, double actual, double delta) { if (doubleIsDifferent(expected, actual, delta)) { failNotEquals(message, Double.valueOf(expected), Double.valueOf(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 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 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)); } }
/** * Asserts that two doubles are equal to within a positive delta. * If they are not, 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>assertEquals(Double.NaN, Double.NaN, *)</code> passes * * @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 assertEquals(String message, double expected, double actual, double delta) { if (doubleIsDifferent(expected, actual, delta)) { failNotEquals(message, new Double(expected), 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 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 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)); } }
/** * Asserts that two doubles are equal to within a positive delta. * If they are not, 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>assertEquals(Double.NaN, Double.NaN, *)</code> passes * * @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 assertEquals(String message, double expected, double actual, double delta) { if (doubleIsDifferent(expected, actual, delta)) { failNotEquals(message, new Double(expected), 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 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 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)); } }
/** * Asserts that two doubles are equal to within a positive delta. * If they are not, 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>assertEquals(Double.NaN, Double.NaN, *)</code> passes * * @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 assertEquals(String message, double expected, double actual, double delta) { if (doubleIsDifferent(expected, actual, delta)) { failNotEquals(message, Double.valueOf(expected), Double.valueOf(actual)); } }
/** * Asserts that two doubles are equal to within a positive delta. * If they are not, 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>assertEquals(Double.NaN, Double.NaN, *)</code> passes * * @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 assertEquals(String message, double expected, double actual, double delta) { if (doubleIsDifferent(expected, actual, delta)) { failNotEquals(message, new Double(expected), new Double(actual)); } }
/** * Asserts that two doubles are equal to within a positive delta. * If they are not, 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>assertEquals(Double.NaN, Double.NaN, *)</code> passes * * @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 assertEquals(String message, double expected, double actual, double delta) { if (doubleIsDifferent(expected, actual, delta)) { failNotEquals(message, new Double(expected), new Double(actual)); } }
/** * Asserts that two doubles are equal to within a positive delta. * If they are not, 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>assertEquals(Double.NaN, Double.NaN, *)</code> passes * * @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 assertEquals(String message, double expected, double actual, double delta) { if (doubleIsDifferent(expected, actual, delta)) { failNotEquals(message, Double.valueOf(expected), Double.valueOf(actual)); } }
/** * 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 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 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 unexpected, double actual, double delta) { if (!doubleIsDifferent(unexpected, actual, delta)) { failEquals(message, Double.valueOf(actual)); } }
/** * 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 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 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 unexpected, double actual, double delta) { if (!doubleIsDifferent(unexpected, actual, delta)) { failEquals(message, Double.valueOf(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 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 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)); } }