org.testng.Assert Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of testng Show documentation
Show all versions of testng Show documentation
A testing framework for the JVM
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 static org.testng.internal.EclipseInterface.ASSERT_LEFT_INEQUALITY;
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++) {
assertEquals(actual[i], expected[i],
String.format(
ARRAY_MISMATCH_TEMPLATE,
i,
Float.toString(expected[i]),
Float.toString(actual[i]),
message));
}
}
/**
* Asserts that two arrays contain the equal elements concerning a delta in the same order. If they do not, an
* AssertionError is thrown.
*
* @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, "");
}
/**
* Asserts that two arrays contain the equal elements concerning a delta in the same order. If
* they do not, an
* AssertionError is thrown.
*
* @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) {
if (checkRefEqualityAndLength(actual, expected, message)) {
return;
}
for (int i = 0; i < expected.length; i++) {
assertEquals(actual[i], expected[i], delta,
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++) {
assertEquals(actual[i], expected[i],
String.format(
ARRAY_MISMATCH_TEMPLATE,
i,
Double.toString(expected[i]),
Double.toString(actual[i]),
message));
}
}
/**
* Asserts that two arrays contain the equal elements concerning a delta in the same order. If they do not, an
* AssertionError is thrown.
*
* @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, "");
}
/**
* Asserts that two arrays contain the equal elements concerning a delta 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 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) {
if (checkRefEqualityAndLength(actual, expected, message)) {
return;
}
for (int i = 0; i < expected.length; i++) {
assertEquals(actual[i], expected[i], delta,
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 doubles 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(double actual, double expected, String message) {
if (Double.isNaN(expected)) {
if (!Double.isNaN(actual)) {
failNotEquals(actual, expected, message);
}
} else if (actual != expected) {
failNotEquals(actual, expected, message);
}
}
/**
* Asserts that two doubles are equal. If they are 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, 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 (Float.isNaN(expected)) {
if (!Float.isNaN(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 floats 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(float actual, float expected, String message) {
if (Float.isNaN(expected)) {
if (!Float.isNaN(actual)) {
failNotEquals(actual, expected, message);
}
} else if (actual != expected) {
failNotEquals(actual, expected, message);
}
}
/**
* Asserts that two floats are equal. If they are 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, 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);
}
private static 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);
}
private static 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);
}
private static void failNotEquals(Object actual, Object expected, String message) {
fail(format(actual, expected, message));
}
static String format(Object actual, Object expected, String message) {
return format(actual, expected, message, false);
}
static String format(Object actual, Object expected, String message, boolean equality) {
String formatted = "";
if (null != message) {
formatted = message + " ";
}
if (equality) {
return formatted + ASSERT_LEFT + expected + ASSERT_MIDDLE + actual + ASSERT_RIGHT;
}
return formatted + ASSERT_LEFT_INEQUALITY + 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));
}
}
if (actual.length != expected.length) {
failAssertNoEqual(
"Arrays do not have the same size:" + actual.length + " != " + expected.length, message);
}
for(int i=0; i actual, Set expected) {
assertEquals(actual, expected, null);
}
/** Assert set equals */
public static void assertEquals(Set actual, Set expected, String message) {
if (actual == expected) {
return;
}
if (actual == null || expected == null) {
// Keep the back compatible
if (message == null) {
fail("Sets not equal: expected: " + expected + " and actual: " + actual);
} else {
failNotEquals(actual, expected, message);
}
}
if (!actual.equals(expected)) {
if (message == null) {
fail("Sets differ: expected " + expected + " but got " + actual);
} else {
failNotEquals(actual, expected, message);
}
}
}
public static void assertEqualsDeep(Set actual, Set expected, String message) {
if (actual == expected) {
return;
}
if (actual == null || expected == null) {
// Keep the back compatible
if (message == null) {
fail("Sets not equal: expected: " + expected + " and actual: " + actual);
} else {
failNotEquals(actual, expected, message);
}
}
Iterator actualIterator = actual.iterator();
Iterator expectedIterator = expected.iterator();
while (expectedIterator.hasNext()) {
Object expectedValue = expectedIterator.next();
if (!actualIterator.hasNext()) {
fail("Sets not equal: expected: " + expected + " and actual: " + actual);
}
Object value = actualIterator.next();
if (expectedValue.getClass().isArray()) {
assertArrayEquals(value, expectedValue, message);
} else {
assertEqualsImpl(value, expectedValue, message);
}
}
}
/** Asserts that two maps are equal. */
public static void assertEquals(Map actual, Map expected, String message) {
if (actual == expected) {
return;
}
if (actual == null || expected == null) {
fail("Maps not equal: expected: " + expected + " and actual: " + actual);
}
if (actual.size() != expected.size()) {
fail("Maps do not have the same size:" + actual.size() + " != " + expected.size());
}
Set entrySet = actual.entrySet();
for (Object anEntrySet : entrySet) {
Map.Entry entry = (Map.Entry) anEntrySet;
Object key = entry.getKey();
Object value = entry.getValue();
Object expectedValue = expected.get(key);
String assertMessage =
message != null
? message
: "Maps do not match for key:"
+ key
+ " actual:"
+ value
+ " expected:"
+ expectedValue;
assertEqualsImpl(value, expectedValue, assertMessage);
}
}
public static void assertEqualsDeep(Map actual, Map expected) {
assertEqualsDeep(actual, expected, null);
}
public static void assertEqualsDeep(Map actual, Map expected, String message) {
if (actual == expected) {
return;
}
if (actual == null || expected == null) {
fail("Maps not equal: expected: " + expected + " and actual: " + actual);
}
if (actual.size() != expected.size()) {
fail("Maps do not have the same size:" + actual.size() + " != " + expected.size());
}
Set entrySet = actual.entrySet();
for (Object anEntrySet : entrySet) {
Map.Entry entry = (Map.Entry) anEntrySet;
Object key = entry.getKey();
Object value = entry.getValue();
Object expectedValue = expected.get(key);
String assertMessage =
message != null
? message
: "Maps do not match for key:"
+ key
+ " actual:"
+ value
+ " expected:"
+ expectedValue;
if (expectedValue.getClass().isArray()) {
assertArrayEquals(value, expectedValue, assertMessage);
} else {
assertEqualsImpl(value, expectedValue, assertMessage);
}
}
}
/////
// assertNotEquals
//
public static void assertNotEquals(Object actual1, Object actual2, String message) {
boolean fail;
try {
Assert.assertEquals(actual1, actual2);
fail = true;
} catch (AssertionError e) {
fail = false;
}
if (fail) {
Assert.fail(format(actual1, actual2, message, false));
}
}
public static void assertNotEquals(Object actual1, Object actual2) {
assertNotEquals(actual1, actual2, null);
}
static void assertNotEquals(String actual1, String actual2, String message) {
assertNotEquals((Object) actual1, (Object) actual2, message);
}
static void assertNotEquals(String actual1, String actual2) {
assertNotEquals(actual1, actual2, null);
}
static void assertNotEquals(long actual1, long actual2, String message) {
assertNotEquals(Long.valueOf(actual1), Long.valueOf(actual2), message);
}
static void assertNotEquals(long actual1, long actual2) {
assertNotEquals(actual1, actual2, null);
}
static void assertNotEquals(boolean actual1, boolean actual2, String message) {
assertNotEquals(Boolean.valueOf(actual1), Boolean.valueOf(actual2), message);
}
static void assertNotEquals(boolean actual1, boolean actual2) {
assertNotEquals(actual1, actual2, null);
}
static void assertNotEquals(byte actual1, byte actual2, String message) {
assertNotEquals(Byte.valueOf(actual1), Byte.valueOf(actual2), message);
}
static void assertNotEquals(byte actual1, byte actual2) {
assertNotEquals(actual1, actual2, null);
}
static void assertNotEquals(char actual1, char actual2, String message) {
assertNotEquals(Character.valueOf(actual1), Character.valueOf(actual2), message);
}
static void assertNotEquals(char actual1, char actual2) {
assertNotEquals(actual1, actual2, null);
}
static void assertNotEquals(short actual1, short actual2, String message) {
assertNotEquals(Short.valueOf(actual1), Short.valueOf(actual2), message);
}
static void assertNotEquals(short actual1, short actual2) {
assertNotEquals(actual1, actual2, null);
}
static void assertNotEquals(int actual1, int actual2, String message) {
assertNotEquals(Integer.valueOf(actual1), Integer.valueOf(actual2), message);
}
static void assertNotEquals(int actual1, int actual2) {
assertNotEquals(actual1, actual2, null);
}
public static void assertNotEquals(float actual1, float actual2, float delta, String message) {
boolean fail;
try {
Assert.assertEquals(actual1, actual2, delta, message);
fail = true;
} catch (AssertionError e) {
fail = false;
}
if (fail) {
Assert.fail(message);
}
}
public static void assertNotEquals(float actual1, float actual2, float delta) {
assertNotEquals(actual1, actual2, delta, null);
}
public static void assertNotEquals(double actual1, double actual2, double delta, String message) {
boolean fail;
try {
Assert.assertEquals(actual1, actual2, delta, message);
fail = true;
} catch (AssertionError e) {
fail = false;
}
if (fail) {
Assert.fail(message);
}
}
public static void assertNotEquals(Set actual, Set expected) {
assertNotEquals(actual, expected, null);
}
public static void assertNotEquals(Set actual, Set expected, String message) {
boolean fail;
try {
Assert.assertEquals(actual, expected, message);
fail = true;
} catch (AssertionError e) {
fail = false;
}
if (fail) {
Assert.fail(message);
}
}
public static void assertNotEqualsDeep(Set actual, Set expected) {
assertNotEqualsDeep(actual, expected, null);
}
public static void assertNotEqualsDeep(Set actual, Set expected, String message) {
boolean fail;
try {
Assert.assertEqualsDeep(actual, expected, message);
fail = true;
} catch (AssertionError e) {
fail = false;
}
if (fail) {
Assert.fail(message);
}
}
public static void assertNotEquals(Map actual, Map expected) {
assertNotEquals(actual, expected, null);
}
public static void assertNotEquals(Map actual, Map expected, String message) {
boolean fail;
try {
Assert.assertEquals(actual, expected, message);
fail = true;
} catch (AssertionError e) {
fail = false;
}
if (fail) {
Assert.fail(message);
}
}
public static void assertNotEqualsDeep(Map actual, Map expected) {
assertNotEqualsDeep(actual, expected, null);
}
public static void assertNotEqualsDeep(Map actual, Map expected, String message) {
boolean fail;
try {
Assert.assertEqualsDeep(actual, expected, message);
fail = true;
} catch (AssertionError e) {
fail = false;
}
if (fail) {
Assert.fail(message);
}
}
public static void assertNotEquals(double actual1, double actual2, double delta) {
assertNotEquals(actual1, actual2, delta, null);
}
/**
* This interface facilitates the use of {@link #expectThrows} from Java 8. It allows method
* references to both void and non-void methods to be passed directly into expectThrows without
* wrapping, even if they declare checked exceptions.
*
* This interface is not meant to be implemented directly.
*/
public interface ThrowingRunnable {
void run() throws Throwable;
}
/**
* Asserts that {@code runnable} throws an exception when invoked. If it does not, an {@link
* AssertionError} is thrown.
*
* @param runnable A function that is expected to throw an exception when invoked
* @since 6.9.5
*/
public static void assertThrows(ThrowingRunnable runnable) {
assertThrows(Throwable.class, runnable);
}
/**
* Asserts that {@code runnable} throws an exception of type {@code throwableClass} when executed.
* If it does not throw an exception, an {@link AssertionError} is thrown. If it throws the wrong
* type of exception, an {@code AssertionError} is thrown describing the mismatch; the exception
* that was actually thrown can be obtained by calling {@link AssertionError#getCause}.
*
* @param throwableClass the expected type of the exception
* @param runnable A function that is expected to throw an exception when invoked
* @since 6.9.5
*/
@SuppressWarnings("ThrowableResultOfMethodCallIgnored")
public static void assertThrows(
Class throwableClass, ThrowingRunnable runnable) {
expectThrows(throwableClass, runnable);
}
/**
* Asserts that {@code runnable} throws an exception of type {@code throwableClass} when executed
* and returns the exception. If {@code runnable} does not throw an exception, an {@link
* AssertionError} is thrown. If it throws the wrong type of exception, an {@code AssertionError}
* is thrown describing the mismatch; the exception that was actually thrown can be obtained by
* calling {@link AssertionError#getCause}.
*
* @param throwableClass the expected type of the exception
* @param runnable A function that is expected to throw an exception when invoked
* @return The exception thrown by {@code runnable}
* @since 6.9.5
*/
public static T expectThrows(
Class throwableClass, ThrowingRunnable runnable) {
try {
runnable.run();
} catch (Throwable t) {
if (throwableClass.isInstance(t)) {
return throwableClass.cast(t);
} else {
String mismatchMessage =
String.format(
"Expected %s to be thrown, but %s was thrown",
throwableClass.getSimpleName(), t.getClass().getSimpleName());
throw new AssertionError(mismatchMessage, t);
}
}
String message =
String.format(
"Expected %s to be thrown, but nothing was thrown", throwableClass.getSimpleName());
throw new AssertionError(message);
}
}