Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package org.testng;
import static org.testng.internal.EclipseInterface.ASSERT_LEFT;
import static org.testng.internal.EclipseInterface.ASSERT_LEFT2;
import static org.testng.internal.EclipseInterface.ASSERT_MIDDLE;
import static org.testng.internal.EclipseInterface.ASSERT_RIGHT;
import java.lang.reflect.Array;
import java.util.Arrays;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.testng.collections.Lists;
/**
* Assertion tool class. Presents assertion methods with a more natural parameter order.
* The order is always actualValue, expectedValue [, message].
*
* @author Alexandru Popescu
*/
public class Assert {
public static final String ARRAY_MISMATCH_TEMPLATE = "arrays differ firstly at element [%d]; "
+ "expected value is <%s> but was <%s>. %s";
/**
* Protect constructor since it is a static only class
*/
protected Assert() {
// hide constructor
}
/**
* Asserts that a condition is true. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param condition the condition to evaluate
* @param message the assertion error message
*/
public static void assertTrue(boolean condition, String message) {
if(!condition) {
failNotEquals(condition, Boolean.TRUE, message);
}
}
/**
* Asserts that a condition is true. If it isn't,
* an AssertionError is thrown.
* @param condition the condition to evaluate
*/
public static void assertTrue(boolean condition) {
assertTrue(condition, null);
}
/**
* Asserts that a condition is false. If it isn't,
* an AssertionError, with the given message, is thrown.
* @param condition the condition to evaluate
* @param message the assertion error message
*/
public static void assertFalse(boolean condition, String message) {
if(condition) {
failNotEquals(condition, Boolean.FALSE, message); // TESTNG-81
}
}
/**
* Asserts that a condition is false. If it isn't,
* an AssertionError is thrown.
* @param condition the condition to evaluate
*/
public static void assertFalse(boolean condition) {
assertFalse(condition, null);
}
/**
* Fails a test with the given message and wrapping the original exception.
*
* @param message the assertion error message
* @param realCause the original exception
*/
public static void fail(String message, Throwable realCause) {
AssertionError ae = new AssertionError(message);
ae.initCause(realCause);
throw ae;
}
/**
* Fails a test with the given message.
* @param message the assertion error message
*/
public static void fail(String message) {
throw new AssertionError(message);
}
/**
* Fails a test with no message.
*/
public static void fail() {
fail(null);
}
/**
* Asserts that two objects 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(Object actual, Object expected, String message) {
if (expected != null && expected.getClass().isArray()) {
assertArrayEquals(actual, expected, message);
return;
}
assertEqualsImpl(actual, expected, message);
}
/**
* Differs from {@link #assertEquals(Object, Object, String)} by not taking arrays into
* special consideration hence comparing them by reference. Intended to be called directly
* to test equality of collections content.
*/
private static void assertEqualsImpl(Object actual, Object expected,
String message) {
if((expected == null) && (actual == null)) {
return;
}
if(expected == null ^ actual == null) {
failNotEquals(actual, expected, message);
}
if (expected.equals(actual) && actual.equals(expected)) {
return;
}
failNotEquals(actual, expected, message);
}
private static void assertArrayEquals(Object actual, Object expected, String message) {
if (expected == actual) {
return;
}
if (null == expected) {
fail("expected a null array, but not null found. " + message);
}
if (null == actual) {
fail("expected not null array, but null found. " + message);
}
//is called only when expected is an array
if (!actual.getClass().isArray()) {
failNotEquals(actual, expected, message);
}
int expectedLength = Array.getLength(expected);
if (expectedLength != Array.getLength(actual)) {
failNotEquals(Array.getLength(actual), expectedLength, message == null ? "" : message
+ " (Array lengths are not the same)");
}
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) {
failNotEquals(actual, expected, message == null ? "" : message
+ " (values at index " + i + " are not the same)");
}
}
}
/**
* 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(byte[] actual, byte[] expected) {
assertEquals(actual, expected, "");
}
/**
* 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(byte[] actual, byte[] expected, String message) {
if (checkRefEqualityAndLength(actual, expected, message)) return;
for (int i = 0; i < expected.length; i++) {
if (expected[i] != actual[i]) {
fail(String.format(ARRAY_MISMATCH_TEMPLATE, i, Byte.toString(expected[i]), Byte.toString(actual[i]), message));
}
}
}
/**
* 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(short[] actual, short[] expected) {
assertEquals(actual, expected, "");
}
/**
* 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(short[] actual, short[] expected, String message) {
if (checkRefEqualityAndLength(actual, expected, message)) return;
for (int i = 0; i < expected.length; i++) {
if (expected[i] != actual[i]) {
fail(String.format(ARRAY_MISMATCH_TEMPLATE, i, Short.toString(expected[i]), Short.toString(actual[i]),
message));
}
}
}
/**
* 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(int[] actual, int[] expected) {
assertEquals(actual, expected, "");
}
/**
* 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(int[] actual, int[] expected, String message) {
if (checkRefEqualityAndLength(actual, expected, message)) return;
for (int i = 0; i < expected.length; i++) {
if (expected[i] != actual[i]) {
fail(String.format(ARRAY_MISMATCH_TEMPLATE, i, Integer.toString(expected[i]), Integer.toString(actual[i]),
message));
}
}
}
/**
* 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(boolean[] actual, boolean[] expected) {
assertEquals(actual, expected, "");
}
/**
* 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(boolean[] actual, boolean[] expected, String message) {
if (checkRefEqualityAndLength(actual, expected, message)) return;
for (int i = 0; i < expected.length; i++) {
if (expected[i] != actual[i]) {
fail(String.format(ARRAY_MISMATCH_TEMPLATE, i, Boolean.toString(expected[i]), Boolean.toString(actual[i]),
message));
}
}
}
/**
* 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(char[] actual, char[] expected) {
assertEquals(actual, expected, "");
}
/**
* 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(char[] actual, char[] expected, String message) {
if (checkRefEqualityAndLength(actual, expected, message)) return;
for (int i = 0; i < expected.length; i++) {
if (expected[i] != actual[i]) {
fail(String.format(ARRAY_MISMATCH_TEMPLATE, i, Character.toString(expected[i]), Character.toString(actual[i]),
message));
}
}
}
/**
* 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(float[] actual, float[] expected) {
assertEquals(actual, expected, "");
}
/**
* 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(float[] actual, float[] expected, String message) {
if (checkRefEqualityAndLength(actual, expected, message)) return;
for (int i = 0; i < expected.length; i++) {
if (expected[i] != actual[i]) {
fail(String.format(ARRAY_MISMATCH_TEMPLATE, i, Float.toString(expected[i]), Float.toString(actual[i]),
message));
}
}
}
/**
* 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(double[] actual, double[] expected) {
assertEquals(actual, expected, "");
}
/**
* 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(double[] actual, double[] expected, String message) {
if (checkRefEqualityAndLength(actual, expected, message)) return;
for (int i = 0; i < expected.length; i++) {
if (expected[i] != actual[i]) {
fail(String.format(ARRAY_MISMATCH_TEMPLATE, i, Double.toString(expected[i]), Double.toString(actual[i]),
message));
}
}
}
/**
* 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(long[] actual, long[] expected) {
assertEquals(actual, expected, "");
}
/**
* 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(long[] actual, long[] expected, String message) {
if (checkRefEqualityAndLength(actual, expected, message)) return;
for (int i = 0; i < expected.length; i++) {
if (expected[i] != actual[i]) {
fail(String.format(ARRAY_MISMATCH_TEMPLATE, i, Long.toString(expected[i]), Long.toString(actual[i]), message));
}
}
}
/**
* This methods check referential equality of given arguments as well as references length (assuming they are arrays).
* Successful execution of this method guaranties arrays length equality.
*
* @param actualArray array of elements
* @param expectedArray array of elements
* @param message the assertion error message
* @return {@code true} if {@code actualArray} and {@code expectedArray} are the same, {@code false} otherwise. If
* references are different and arrays length are different {@link AssertionError} is thrown.
*/
private static boolean checkRefEqualityAndLength(Object actualArray, Object expectedArray, String message) {
if (expectedArray == actualArray) {
return true;
}
if (null == expectedArray) {
fail("expectedArray a null array, but not null found. " + message);
}
if (null == actualArray) {
fail("expectedArray not null array, but null found. " + message);
}
assertEquals(Array.getLength(actualArray), Array.getLength(expectedArray),
"arrays don't have the same size. " + message);
return false;
}
/**
* Asserts that two objects are equal. If they are not,
* an AssertionError is thrown.
* @param actual the actual value
* @param expected the expected value
*/
public static void assertEquals(Object actual, Object expected) {
assertEquals(actual, expected, null);
}
/**
* Asserts that two Strings 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(String actual, String expected, String message) {
assertEquals((Object) actual, (Object) expected, message);
}
/**
* Asserts that two Strings are equal. If they are not,
* an AssertionError is thrown.
* @param actual the actual value
* @param expected the expected value
*/
public static void assertEquals(String actual, String expected) {
assertEquals(actual, expected, null);
}
/**
* Asserts that two doubles are equal concerning a delta. If they are not,
* an AssertionError, with the given message, 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
* @param message the assertion error message
*/
public static void assertEquals(double actual, double expected, double delta, String message) {
// handle infinity specially since subtracting to infinite values gives NaN and the
// the following test fails
if(Double.isInfinite(expected)) {
if(!(expected == actual)) {
failNotEquals(actual, expected, message);
}
}
else if (Double.isNaN(expected)) {
if (!Double.isNaN(actual)) {
failNotEquals(actual, expected, message);
}
}
else if(!(Math.abs(expected - actual) <= delta)) {
failNotEquals(actual, expected, message);
}
}
/**
* 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 floats are equal concerning a delta. If they are not,
* an AssertionError, with the given message, 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
* @param message the assertion error message
*/
public static void assertEquals(float actual, float expected, float delta, String message) {
// handle infinity specially since subtracting to infinite values gives NaN and the
// the following test fails
if(Float.isInfinite(expected)) {
if(!(expected == actual)) {
failNotEquals(actual, expected, message);
}
}
else if(!(Math.abs(expected - actual) <= delta)) {
failNotEquals(actual, expected, message);
}
}
/**
* 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);
}
/**
* 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 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 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 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 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 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 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 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 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 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 an object isn't null. If it is,
* an AssertionError is thrown.
* @param object the assertion object
*/
public static void assertNotNull(Object object) {
assertNotNull(object, null);
}
/**
* Asserts that an object isn't null. If it is,
* an AssertionFailedError, with the given message, is thrown.
* @param object the assertion object
* @param message the assertion error message
*/
public static void assertNotNull(Object object, String message) {
if (object == null) {
String formatted = "";
if(message != null) {
formatted = message + " ";
}
fail(formatted + "expected object to not be null");
}
assertTrue(object != null, message);
}
/**
* Asserts that an object is null. If it is not,
* an AssertionError, with the given message, is thrown.
* @param object the assertion object
*/
public static void assertNull(Object object) {
assertNull(object, null);
}
/**
* Asserts that an object is null. If it is not,
* an AssertionFailedError, with the given message, is thrown.
* @param object the assertion object
* @param message the assertion error message
*/
public static void assertNull(Object object, String message) {
if (object != null) {
failNotSame(object, null, message);
}
}
/**
* Asserts that two objects refer to the same object. If they do 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 assertSame(Object actual, Object expected, String message) {
if(expected == actual) {
return;
}
failNotSame(actual, expected, message);
}
/**
* Asserts that two objects refer to the same object. If they do not,
* an AssertionError is thrown.
* @param actual the actual value
* @param expected the expected value
*/
public static void assertSame(Object actual, Object expected) {
assertSame(actual, expected, null);
}
/**
* Asserts that two objects do not refer to the same objects. If they do,
* 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 assertNotSame(Object actual, Object expected, String message) {
if(expected == actual) {
failSame(actual, expected, message);
}
}
/**
* Asserts that two objects do not refer to the same object. If they do,
* an AssertionError is thrown.
* @param actual the actual value
* @param expected the expected value
*/
public static void assertNotSame(Object actual, Object expected) {
assertNotSame(actual, expected, null);
}
static private void failSame(Object actual, Object expected, String message) {
String formatted = "";
if(message != null) {
formatted = message + " ";
}
fail(formatted + ASSERT_LEFT2 + expected + ASSERT_MIDDLE + actual + ASSERT_RIGHT);
}
static private void failNotSame(Object actual, Object expected, String message) {
String formatted = "";
if(message != null) {
formatted = message + " ";
}
fail(formatted + ASSERT_LEFT + expected + ASSERT_MIDDLE + actual + ASSERT_RIGHT);
}
static private void failNotEquals(Object actual , Object expected, String message ) {
fail(format(actual, expected, message));
}
static String format(Object actual, Object expected, String message) {
String formatted = "";
if (null != message) {
formatted = message + " ";
}
return formatted + ASSERT_LEFT + expected + ASSERT_MIDDLE + actual + ASSERT_RIGHT;
}
/**
* 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 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) {
if (message != null) {
fail(message);
} else {
fail("Collections not equal: expected: " + expected + " and actual: " + actual);
}
}
assertEquals(actual.size(), expected.size(), (message == null ? "" : message + ": ") + "lists don't have the same size");
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;
assertEqualsImpl(a, e, errorMessage);
}
}
/** Asserts that two iterators return the same elements in the same order. If they do not,
* an AssertionError 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
*/
public static void assertEquals(Iterator actual, Iterator expected) {
assertEquals(actual, expected, null);
}
/** 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) {
String msg = message != null ? message : "Iterators not equal: expected: " + expected + " and actual: " + actual;
fail(msg);
}
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;
assertEqualsImpl(a, e, errorMessage);
}
if(actual.hasNext()) {
String explanation = "Actual iterator returned more elements than the expected iterator.";
String errorMessage = message == null ? explanation : message + ": " + explanation;
fail(errorMessage);
} else if(expected.hasNext()) {
String explanation = "Expected iterator returned more elements than the actual iterator.";
String errorMessage = message == null ? explanation : message + ": " + explanation;
fail(errorMessage);
}
}
/** 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 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) {
if(message != null) {
fail(message);
} else {
fail("Iterables not equal: expected: " + expected + " and actual: " + actual);
}
}
Iterator actIt = actual.iterator();
Iterator expIt = expected.iterator();
assertEquals(actIt, expIt, 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(Object[] actual, Object[] expected, String message) {
if(actual == expected) {
return;
}
if ((actual == null && expected != null) || (actual != null && expected == null)) {
if (message != null) {
fail(message);
} else {
fail("Arrays not equal: " + Arrays.toString(expected) + " and " + Arrays.toString(actual));
}
}
assertEquals(Arrays.asList(actual), Arrays.asList(expected), message);
}
/**
* Asserts that two arrays contain the same elements in no particular 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 assertEqualsNoOrder(Object[] actual, Object[] expected, String message) {
if(actual == expected) {
return;
}
if ((actual == null && expected != null) || (actual != null && expected == null)) {
failAssertNoEqual(
"Arrays not equal: " + Arrays.toString(expected) + " and " + Arrays.toString(actual),
message);
}
if (actual.length != expected.length) {
failAssertNoEqual(
"Arrays do not have the same size:" + actual.length + " != " + expected.length,
message);
}
List