/** * Asserts that two iterables return iterators with the same elements in the same order. If they * do not, an AssertionError, with the given message, is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(Iterable<?> actual, Iterable<?> expected, String message) { if (actual == expected) { return; } if (actual == null || expected == null) { log.error(message(message, expected, actual)); if (message == null) { message = "Iterables not equal:"; } if (haultonfailure) fail(message); else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } Iterator<?> actIt = actual.iterator(); Iterator<?> expIt = expected.iterator(); assertEquals(actIt, expIt, message); }
/** * Asserts that two collections contain the same elements in the same order. If they do not, an * AssertionError, with the given message, is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(Collection<?> actual, Collection<?> expected, String message) { if (actual == expected) { return; } if (actual == null || expected == null) { log.error(message(message, actual, expected)); if (message == null) { message = "Collections not equal:"; } if (haultonfailure) fail(message); else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } assertEquals(actual.size(), expected.size(), message + ": lists don't have the same size"); // if(actual.size() != expected.size())return; Iterator<?> actIt = actual.iterator(); Iterator<?> expIt = expected.iterator(); int i = -1; while (actIt.hasNext() && expIt.hasNext()) { i++; Object e = expIt.next(); Object a = actIt.next(); String explanation = "Lists differ at element [" + i + "]: " + e + " != " + a; String errorMessage = message == null ? explanation : message + ": " + explanation; assertEquals(a, e, errorMessage); } }
public static void assertNotEquals(double actual1, double actual2, double delta, String message) { boolean fail = false; try { Assert.assertEquals(actual1, actual2, delta, message); fail = true; } catch (AssertionError e) { } if (fail) { Assert.fail(message); } }
/** Asserts that two maps are equal. */ public static void assertEquals(Map<?, ?> actual, Map<?, ?> expected) { if (actual == expected) { return; } if (actual == null || expected == null) { log.error(message(null, expected.toString(), actual.toString())); if (haultonfailure) fail("Maps not equal: expected: " + expected + " and actual: " + actual); else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( "Maps not equal: " + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } if (actual.size() != expected.size()) { if (haultonfailure) fail("Maps do not have the same size:" + actual.size() + " != " + expected.size()); else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( "Maps do not have the same size: " + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } Set<?> entrySet = actual.entrySet(); for (Iterator<?> iterator = entrySet.iterator(); iterator.hasNext(); ) { Map.Entry<?, ?> entry = (Map.Entry<?, ?>) iterator.next(); Object key = entry.getKey(); Object value = entry.getValue(); Object expectedValue = expected.get(key); assertEquals( value, expectedValue, "Maps do not match for key:" + key + " actual:" + value + " expected:" + expectedValue); } }
/** * Asserts that two arrays contain the same elements in the same order. If they do not, an * AssertionError, with the given message, is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(Object[] actual, Object[] expected, String message) { if (actual == expected) { return; } if ((actual == null && expected != null) || (actual != null && expected == null)) { log.error(message(message, expected, actual)); if (message == null) { message = "Iterables not equal:"; } if (haultonfailure) fail(message); else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } assertEquals(Arrays.asList(actual), Arrays.asList(expected), message); }
/** * Asserts that two iterators return the same elements in the same order. If they do not, an * AssertionError, with the given message, is thrown. Please note that this assert iterates over * the elements and modifies the state of the iterators. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(Iterator<?> actual, Iterator<?> expected, String message) { if (actual == expected) { return; } if (actual == null || expected == null) { log.error(message(message, actual, expected)); if (message == null) { message = "Iterators not equal:"; } if (haultonfailure) fail(message + "\n"); else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } int i = -1; while (actual.hasNext() && expected.hasNext()) { i++; Object e = expected.next(); Object a = actual.next(); String explanation = "Iterators differ at element [" + i + "]: " + e + " != " + a; String errorMessage = message == null ? explanation : message + ": " + explanation; assertEquals(a, e, errorMessage); } if (actual.hasNext()) { String explanation = "Actual iterator returned more elements than the expected iterator."; String errorMessage = message == null ? explanation : message + ": " + explanation; if (haultonfailure) fail(message + "\n"); else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } else if (expected.hasNext()) { String explanation = "Expected iterator returned more elements than the actual iterator."; String errorMessage = message == null ? explanation : message + ": " + explanation; if (haultonfailure) fail(message + "\n"); else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } }
/** * Asserts that two doubles are equal concerning a delta. If they are not, an AssertionError is * thrown. If the expected value is infinity then the delta value is ignored. * * @param actual the actual value * @param expected the expected value * @param delta the absolute tolerable difference between the actual and expected values */ public static void assertEquals(double actual, double expected, double delta) { assertEquals(actual, expected, delta, null); }
/** * Asserts that two collections contain the same elements in the same order. If they do not, an * AssertionError is thrown. * * @param actual the actual value * @param expected the expected value */ public static void assertEquals( Collection<?> actual, Collection<?> expected) { // /////////////////////////////// assertEquals(actual, expected, null); }
/** * Asserts that two longs are equal. If they are not, an AssertionError, with the given message, * is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(long actual, long expected, String message) { assertEquals(Long.valueOf(actual), Long.valueOf(expected), message); }
/** Asserts that two sets are equal. */ public static void assertEquals(Set<?> actual, Set<?> expected) { assertEquals(actual, expected, null); }
/** * Asserts that two arrays contain the same elements in the same order. If they do not, an * AssertionError is thrown. * * @param actual the actual value * @param expected the expected value */ public static void assertEquals(final byte[] actual, final byte[] expected) { assertEquals(actual, expected, ""); }
/** * Asserts that two chars are equal. If they are not, an AssertionFailedError, with the given * message, is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(char actual, char expected, String message) { assertEquals(Character.valueOf(actual), Character.valueOf(expected), message); }
/** * Asserts that two chars are equal. If they are not, an AssertionError is thrown. * * @param actual the actual value * @param expected the expected value */ public static void assertEquals(char actual, char expected) { assertEquals(actual, expected, null); }
/** * Asserts that two bytes are equal. If they are not, an AssertionError, with the given message, * is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(byte actual, byte expected, String message) { assertEquals(Byte.valueOf(actual), Byte.valueOf(expected), message); }
/** * Asserts that two bytes are equal. If they are not, an AssertionError is thrown. * * @param actual the actual value * @param expected the expected value */ public static void assertEquals(byte actual, byte expected) { assertEquals(actual, expected, null); }
/** * Asserts that two booleans are equal. If they are not, an AssertionError is thrown. * * @param actual the actual value * @param expected the expected value */ public static void assertEquals(boolean actual, boolean expected) { assertEquals(actual, expected, null); }
/** * Asserts that two booleans are equal. If they are not, an AssertionError, with the given * message, is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(boolean actual, boolean expected, String message) { assertEquals(Boolean.valueOf(actual), Boolean.valueOf(expected), message); }
/** * Asserts that two longs are equal. If they are not, an AssertionError is thrown. * * @param actual the actual value * @param expected the expected value */ public static void assertEquals(long actual, long expected) { assertEquals(actual, expected, null); }
/** * Asserts that two iterables return iterators with the same elements in the same order. If they * do not, an AssertionError is thrown. * * @param actual the actual value * @param expected the expected value */ public static void assertEquals(Iterable<?> actual, Iterable<?> expected) { assertEquals(actual, expected, null); }
/** * Asserts that two shorts are equal. If they are not, an AssertionFailedError, with the given * message, is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(short actual, short expected, String message) { assertEquals(Short.valueOf(actual), Short.valueOf(expected), message); }
/** * Asserts that two Strings are equal. If they are not, an AssertionError, with the given message, * is thrown if haultonfailure. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(String actual, String expected, String message) { assertEquals((Object) actual, (Object) expected, message); }
/** * Asserts that two objects are equal. It they are not, an AssertionError, with given message, is * thrown if haultonfailure. * * @param actual the actual value * @param expected the expected value (should be an non-null array value) * @param message the assertion error message */ private static void assertArrayEquals(Object actual, Object expected, String message) { // is called only when expected is an array if (actual.getClass().isArray()) { int expectedLength = Array.getLength(expected); if (expectedLength == Array.getLength(actual)) { for (int i = 0; i < expectedLength; i++) { Object _actual = Array.get(actual, i); Object _expected = Array.get(expected, i); try { assertEquals(_actual, _expected); } catch (AssertionError ae) { log.error(message(message, expected.toString(), actual.toString())); if (haultonfailure) { failNotEquals(actual, expected, message); } else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message == null ? "" : message + " (values at index " + i + " are not the same)" + SEPARATOR + System.currentTimeMillis(), expected + SEPARATOR + actual); return; } } } // array values matched return; } else { log.error(message(message, expected.toString(), actual.toString())); if (haultonfailure) { failNotEquals(actual, expected, message); } else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message == null ? "" : message + " (Array lengths are not the same)" + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), expectedLength + SEPARATOR + Array.getLength(actual)); } } } log.error(message(message, expected.toString(), actual.toString())); if (haultonfailure) { failNotEquals(actual, expected, message); } else { if (map == null) { map = new LinkedHashMap<String, String>(); } map.put( message + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), expected + SEPARATOR + actual); } }
public static void assertEquals(Object[] actual, Object[] expected) { assertEquals(actual, expected, null); }
/** * Asserts that two ints are equal. If they are not, an AssertionFailedError, with the given * message, is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals(int actual, int expected, String message) { assertEquals(Integer.valueOf(actual), Integer.valueOf(expected), message); }
/** * Asserts that two arrays contain the same elements in the same order. If they do not, an * AssertionError, with the given message, is thrown. * * @param actual the actual value * @param expected the expected value * @param message the assertion error message */ public static void assertEquals( final byte[] actual, final byte[] expected, final String message) { if (expected == actual) { return; } if (null == expected) { if (haultonfailure) fail("expected a null array, but not null found. " + message); else { if (map == null) map = new LinkedHashMap<String, String>(); map.put( "expected a null array, but not null found. " + SEPARATOR + message + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } if (null == actual) { if (haultonfailure) fail("expected not null array, but null found. " + message); else { if (map == null) map = new LinkedHashMap<String, String>(); map.put( "expected not null array, but null found. " + SEPARATOR + message + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } assertEquals(actual.length, expected.length, "arrays don't have the same size. " + message); for (int i = 0; i < expected.length; i++) { if (expected[i] != actual[i]) { if (haultonfailure) fail( "arrays differ firstly at element [" + i + "]; " + "expected value is <" + expected[i] + "> but was <" + actual[i] + ">. " + message); else { if (map == null) map = new LinkedHashMap<String, String>(); map.put( "arrays differ firstly at element [" + i + "]; " + "expected value is <" + expected[i] + "> but was <" + actual[i] + ">. " + message + SEPARATOR + UtilityMethods.getRandomNumber() + System.currentTimeMillis(), actual + SEPARATOR + expected); } } } }
/** * Asserts that two ints are equal. If they are not, an AssertionError is thrown. * * @param actual the actual value * @param expected the expected value */ public static void assertEquals(int actual, int expected) { assertEquals(actual, expected, null); }
/** * Asserts that two shorts are equal. If they are not, an AssertionError is thrown. * * @param actual the actual value * @param expected the expected value */ public static void assertEquals(short actual, short expected) { assertEquals(actual, expected, null); }
/** * Asserts that two floats are equal concerning a delta. If they are not, an AssertionError is * thrown. If the expected value is infinity then the delta value is ignored. * * @param actual the actual value * @param expected the expected value * @param delta the absolute tolerable difference between the actual and expected values */ public static void assertEquals(float actual, float expected, float delta) { assertEquals(actual, expected, delta, null); }