/** * Asserts that two longs are <b>not</b> equals. If they are, an * {@link AssertionError} is thrown with the given message. * * @param message the identifying message for the {@link AssertionError} (<code>null</code> * okay) * @param unexpected unexpected value to check * @param actual the value to check against <code>unexpected</code> */ public static void assertNotEquals(String message, long unexpected, long actual) { if (unexpected == actual) { failEquals(message, Long.valueOf(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. */ public static void assertNotEquals(String message, float unexpected, float actual, float delta) { if (!floatIsDifferent(unexpected, actual, delta)) { failEquals(message, actual); } }
/** * Asserts that two objects are <b>not</b> equals. If they are, an * {@link AssertionError} is thrown with the given message. If * <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 unexpected unexpected value to check * @param actual the value to check against <code>unexpected</code> */ public static void assertNotEquals(String message, Object unexpected, Object actual) { if (equalsRegardingNull(unexpected, actual)) { failEquals(message, 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 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>, * 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> */ static public void assertNotEquals(String message, Object first, Object second) { if (equalsRegardingNull(first, second)) { failEquals(message, first); } }
/** * 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 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>, * 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> */ static public void assertNotEquals(String message, Object first, Object second) { if (equalsRegardingNull(first, second)) { failEquals(message, first); } }
/** * 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 longs are <b>not</b> equals. If they are, an * {@link AssertionError} is thrown with the given message. * * @param message the identifying message for the {@link AssertionError} (<code>null</code> * okay) * @param unexpected unexpected value to check * @param actual the value to check against <code>unexpected</code> */ static public void assertNotEquals(String message, long unexpected, long actual) { if (unexpected == actual) { failEquals(message, Long.valueOf(actual)); } }
/** * Asserts that two longs are <b>not</b> equals. If they are, an * {@link AssertionError} is thrown with the given message. * * @param message the identifying message for the {@link AssertionError} (<code>null</code> * okay) * @param unexpected unexpected value to check * @param actual the value to check against <code>unexpected</code> */ static public void assertNotEquals(String message, long unexpected, long actual) { if (unexpected == actual) { failEquals(message, Long.valueOf(actual)); } }
/** * Asserts that two objects are <b>not</b> equals. If they are, an * {@link AssertionError} is thrown with the given message. If * <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 unexpected unexpected value to check * @param actual the value to check against <code>unexpected</code> */ 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} is thrown with the given message. If * <code>first</code> and <code>second</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> */ static public void assertNotEquals(String message, Object first, Object second) { if (equalsRegardingNull(first, second)) { failEquals(message, first); } }
/** * Asserts that two objects are <b>not</b> equals. If they are, an * {@link AssertionError} is thrown with the given message. If * <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 unexpected unexpected value to check * @param actual the value to check against <code>unexpected</code> */ 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} is thrown with the given message. If * <code>first</code> and <code>second</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> */ static public void assertNotEquals(String message, Object first, Object second) { if (equalsRegardingNull(first, second)) { failEquals(message, first); } }
/** * 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 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, Float.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 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 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, Float.valueOf(actual)); } }