package org.junit;
import org.hamcrest.Matcher;
import org.hamcrest.MatcherAssert;
import org.junit.internal.ArrayComparisonFailure;
import org.junit.internal.ExactComparisonCriteria;
import org.junit.internal.InexactComparisonCriteria;
A set of assertion methods useful for writing tests. Only failed assertions
are recorded. These methods can be used directly:
Assert.assertEquals(...)
, however, they read better if they
are referenced through static import:
import static org.junit.Assert.*;
...
assertEquals(...);
See Also: - AssertionError
Since: 4.0
/**
* A set of assertion methods useful for writing tests. Only failed assertions
* are recorded. These methods can be used directly:
* <code>Assert.assertEquals(...)</code>, however, they read better if they
* are referenced through static import:
*
* <pre>
* import static org.junit.Assert.*;
* ...
* assertEquals(...);
* </pre>
*
* @see AssertionError
* @since 4.0
*/
public class Assert {
Protect constructor since it is a static only class
/**
* Protect constructor since it is a static only class
*/
protected Assert() {
}
Asserts that a condition is true. If it isn't it throws an AssertionError
with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - condition – condition to be checked
/**
* Asserts that a condition is true. If it isn't it throws an
* {@link AssertionError} with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param condition condition to be checked
*/
static public void assertTrue(String message, boolean condition) {
if (!condition) {
fail(message);
}
}
Asserts that a condition is true. If it isn't it throws an AssertionError
without a message. Params: - condition – condition to be checked
/**
* Asserts that a condition is true. If it isn't it throws an
* {@link AssertionError} without a message.
*
* @param condition condition to be checked
*/
static public void assertTrue(boolean condition) {
assertTrue(null, condition);
}
Asserts that a condition is false. If it isn't it throws an AssertionError
with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - condition – condition to be checked
/**
* Asserts that a condition is false. If it isn't it throws an
* {@link AssertionError} with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param condition condition to be checked
*/
static public void assertFalse(String message, boolean condition) {
assertTrue(message, !condition);
}
Asserts that a condition is false. If it isn't it throws an AssertionError
without a message. Params: - condition – condition to be checked
/**
* Asserts that a condition is false. If it isn't it throws an
* {@link AssertionError} without a message.
*
* @param condition condition to be checked
*/
static public void assertFalse(boolean condition) {
assertFalse(null, condition);
}
Fails a test with the given message.
Params: - message – the identifying message for the
AssertionError
(null
okay)
See Also:
/**
* Fails a test with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @see AssertionError
*/
static public void fail(String message) {
if (message == null) {
throw new AssertionError();
}
throw new AssertionError(message);
}
Fails a test with no message.
/**
* Fails a test with no message.
*/
static public void fail() {
fail(null);
}
Asserts that two objects are equal. If they are not, an AssertionError
is thrown with the given message. If expected
and actual
are null
,
they are considered equal.
Params: - message – the identifying message for the
AssertionError
(null
okay) - expected – expected value
- actual – actual value
/**
* Asserts that two objects are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* <code>expected</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 expected expected value
* @param actual actual value
*/
static public void assertEquals(String message, Object expected,
Object actual) {
if (equalsRegardingNull(expected, actual)) {
return;
} else if (expected instanceof String && actual instanceof String) {
String cleanMessage = message == null ? "" : message;
throw new ComparisonFailure(cleanMessage, (String) expected,
(String) actual);
} else {
failNotEquals(message, expected, actual);
}
}
private static boolean equalsRegardingNull(Object expected, Object actual) {
if (expected == null) {
return actual == null;
}
return isEquals(expected, actual);
}
private static boolean isEquals(Object expected, Object actual) {
return expected.equals(actual);
}
Asserts that two objects are equal. If they are not, an AssertionError
without a message is thrown. If expected
and actual
are null
,
they are considered equal.
Params: - expected – expected value
- actual – the value to check against
expected
/**
* Asserts that two objects are equal. If they are not, an
* {@link AssertionError} without a message is thrown. If
* <code>expected</code> and <code>actual</code> are <code>null</code>,
* they are considered equal.
*
* @param expected expected value
* @param actual the value to check against <code>expected</code>
*/
static public void assertEquals(Object expected, Object actual) {
assertEquals(null, expected, actual);
}
Asserts that two objects are not equals. If they are, an AssertionError
is thrown with the given message. If unexpected
and actual
are null
,
they are considered equal.
Params: - message – the identifying message for the
AssertionError
(null
okay) - unexpected – unexpected value to check
- actual – the value to check against
unexpected
/**
* 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 not equals. If they are, an AssertionError
without a message is thrown. If unexpected
and actual
are null
,
they are considered equal.
Params: - unexpected – unexpected value to check
- actual – the value to check against
unexpected
/**
* Asserts that two objects are <b>not</b> equals. If they are, an
* {@link AssertionError} without a message is thrown. If
* <code>unexpected</code> and <code>actual</code> are <code>null</code>,
* they are considered equal.
*
* @param unexpected unexpected value to check
* @param actual the value to check against <code>unexpected</code>
*/
static public void assertNotEquals(Object unexpected, Object actual) {
assertNotEquals(null, unexpected, actual);
}
private static void failEquals(String message, Object actual) {
String formatted = "Values should be different. ";
if (message != null) {
formatted = message + ". ";
}
formatted += "Actual: " + actual;
fail(formatted);
}
Asserts that two longs are not equals. If they are, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - unexpected – unexpected value to check
- actual – the value to check against
unexpected
/**
* 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 not equals. If they are, an AssertionError
without a message is thrown. Params: - unexpected – unexpected value to check
- actual – the value to check against
unexpected
/**
* Asserts that two longs are <b>not</b> equals. If they are, an
* {@link AssertionError} without a message is thrown.
*
* @param unexpected unexpected value to check
* @param actual the value to check against <code>unexpected</code>
*/
static public void assertNotEquals(long unexpected, long actual) {
assertNotEquals(null, unexpected, actual);
}
Asserts that two doubles are not equal to within a positive delta. If they are, an AssertionError
is thrown with the given message. If the unexpected value is infinity then the delta value is ignored. NaNs are considered equal: assertNotEquals(Double.NaN, Double.NaN, *)
fails
Params: - message – the identifying message for the
AssertionError
(null
okay) - unexpected – unexpected value
- actual – the value to check against
unexpected
- delta – the maximum delta between
unexpected
and
actual
for which both numbers are still
considered equal.
/**
* 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 not equal to within a positive delta. If they are, an AssertionError
is thrown. If the unexpected value is infinity then the delta value is ignored.NaNs are considered equal: assertNotEquals(Double.NaN, Double.NaN, *)
fails
Params: - unexpected – unexpected value
- actual – the value to check against
unexpected
- delta – the maximum delta between
unexpected
and
actual
for which both numbers are still
considered equal.
/**
* Asserts that two doubles are <b>not</b> equal to within a positive delta.
* If they are, an {@link AssertionError} is thrown. 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 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(double unexpected, double actual, double delta) {
assertNotEquals(null, unexpected, actual, delta);
}
Asserts that two floats are not equal to within a positive delta. If they are, an AssertionError
is thrown. If the unexpected value is infinity then the delta value is ignored.NaNs are considered equal: assertNotEquals(Float.NaN, Float.NaN, *)
fails
Params: - unexpected – unexpected value
- actual – the value to check against
unexpected
- delta – the maximum delta between
unexpected
and
actual
for which both numbers are still
considered equal.
/**
* Asserts that two floats are <b>not</b> equal to within a positive delta.
* If they are, an {@link AssertionError} is thrown. 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 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(float unexpected, float actual, float delta) {
assertNotEquals(null, unexpected, actual, delta);
}
Asserts that two object arrays are equal. If they are not, an AssertionError
is thrown with the given message. If expecteds
and actuals
are null
,
they are considered equal.
Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – Object array or array of arrays (multi-dimensional array) with
expected values.
- actuals – Object array or array of arrays (multi-dimensional array) with
actual values
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values.
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
*/
public static void assertArrayEquals(String message, Object[] expecteds,
Object[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
Asserts that two object arrays are equal. If they are not, an AssertionError
is thrown. If expected
and
actual
are null
, they are considered
equal.
Params: - expecteds – Object array or array of arrays (multi-dimensional array) with
expected values
- actuals – Object array or array of arrays (multi-dimensional array) with
actual values
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown. If <code>expected</code> and
* <code>actual</code> are <code>null</code>, they are considered
* equal.
*
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
*/
public static void assertArrayEquals(Object[] expecteds, Object[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
Asserts that two boolean arrays are equal. If they are not, an AssertionError
is thrown with the given message. If expecteds
and actuals
are null
,
they are considered equal.
Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – boolean array with expected values.
- actuals – boolean array with expected values.
/**
* Asserts that two boolean arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds boolean array with expected values.
* @param actuals boolean array with expected values.
*/
public static void assertArrayEquals(String message, boolean[] expecteds,
boolean[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
Asserts that two boolean arrays are equal. If they are not, an AssertionError
is thrown. If expected
and
actual
are null
, they are considered
equal.
Params: - expecteds – boolean array with expected values.
- actuals – boolean array with expected values.
/**
* Asserts that two boolean arrays are equal. If they are not, an
* {@link AssertionError} is thrown. If <code>expected</code> and
* <code>actual</code> are <code>null</code>, they are considered
* equal.
*
* @param expecteds boolean array with expected values.
* @param actuals boolean array with expected values.
*/
public static void assertArrayEquals(boolean[] expecteds, boolean[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
Asserts that two byte arrays are equal. If they are not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – byte array with expected values.
- actuals – byte array with actual values
/**
* Asserts that two byte arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds byte array with expected values.
* @param actuals byte array with actual values
*/
public static void assertArrayEquals(String message, byte[] expecteds,
byte[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
Asserts that two byte arrays are equal. If they are not, an AssertionError
is thrown. Params: - expecteds – byte array with expected values.
- actuals – byte array with actual values
/**
* Asserts that two byte arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds byte array with expected values.
* @param actuals byte array with actual values
*/
public static void assertArrayEquals(byte[] expecteds, byte[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
Asserts that two char arrays are equal. If they are not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – char array with expected values.
- actuals – char array with actual values
/**
* Asserts that two char arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds char array with expected values.
* @param actuals char array with actual values
*/
public static void assertArrayEquals(String message, char[] expecteds,
char[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
Asserts that two char arrays are equal. If they are not, an AssertionError
is thrown. Params: - expecteds – char array with expected values.
- actuals – char array with actual values
/**
* Asserts that two char arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds char array with expected values.
* @param actuals char array with actual values
*/
public static void assertArrayEquals(char[] expecteds, char[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
Asserts that two short arrays are equal. If they are not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – short array with expected values.
- actuals – short array with actual values
/**
* Asserts that two short arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds short array with expected values.
* @param actuals short array with actual values
*/
public static void assertArrayEquals(String message, short[] expecteds,
short[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
Asserts that two short arrays are equal. If they are not, an AssertionError
is thrown. Params: - expecteds – short array with expected values.
- actuals – short array with actual values
/**
* Asserts that two short arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds short array with expected values.
* @param actuals short array with actual values
*/
public static void assertArrayEquals(short[] expecteds, short[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
Asserts that two int arrays are equal. If they are not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – int array with expected values.
- actuals – int array with actual values
/**
* Asserts that two int arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds int array with expected values.
* @param actuals int array with actual values
*/
public static void assertArrayEquals(String message, int[] expecteds,
int[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
Asserts that two int arrays are equal. If they are not, an AssertionError
is thrown. Params: - expecteds – int array with expected values.
- actuals – int array with actual values
/**
* Asserts that two int arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds int array with expected values.
* @param actuals int array with actual values
*/
public static void assertArrayEquals(int[] expecteds, int[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
Asserts that two long arrays are equal. If they are not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – long array with expected values.
- actuals – long array with actual values
/**
* Asserts that two long arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds long array with expected values.
* @param actuals long array with actual values
*/
public static void assertArrayEquals(String message, long[] expecteds,
long[] actuals) throws ArrayComparisonFailure {
internalArrayEquals(message, expecteds, actuals);
}
Asserts that two long arrays are equal. If they are not, an AssertionError
is thrown. Params: - expecteds – long array with expected values.
- actuals – long array with actual values
/**
* Asserts that two long arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds long array with expected values.
* @param actuals long array with actual values
*/
public static void assertArrayEquals(long[] expecteds, long[] actuals) {
assertArrayEquals(null, expecteds, actuals);
}
Asserts that two double arrays are equal. If they are not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – double array with expected values.
- actuals – double array with actual values
- delta – the maximum delta between
expecteds[i]
and
actuals[i]
for which both numbers are still
considered equal.
/**
* Asserts that two double arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds double array with expected values.
* @param actuals double array with actual values
* @param delta the maximum delta between <code>expecteds[i]</code> and
* <code>actuals[i]</code> for which both numbers are still
* considered equal.
*/
public static void assertArrayEquals(String message, double[] expecteds,
double[] actuals, double delta) throws ArrayComparisonFailure {
new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
}
Asserts that two double arrays are equal. If they are not, an AssertionError
is thrown. Params: - expecteds – double array with expected values.
- actuals – double array with actual values
- delta – the maximum delta between
expecteds[i]
and
actuals[i]
for which both numbers are still
considered equal.
/**
* Asserts that two double arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds double array with expected values.
* @param actuals double array with actual values
* @param delta the maximum delta between <code>expecteds[i]</code> and
* <code>actuals[i]</code> for which both numbers are still
* considered equal.
*/
public static void assertArrayEquals(double[] expecteds, double[] actuals, double delta) {
assertArrayEquals(null, expecteds, actuals, delta);
}
Asserts that two float arrays are equal. If they are not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – float array with expected values.
- actuals – float array with actual values
- delta – the maximum delta between
expecteds[i]
and
actuals[i]
for which both numbers are still
considered equal.
/**
* Asserts that two float arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds float array with expected values.
* @param actuals float array with actual values
* @param delta the maximum delta between <code>expecteds[i]</code> and
* <code>actuals[i]</code> for which both numbers are still
* considered equal.
*/
public static void assertArrayEquals(String message, float[] expecteds,
float[] actuals, float delta) throws ArrayComparisonFailure {
new InexactComparisonCriteria(delta).arrayEquals(message, expecteds, actuals);
}
Asserts that two float arrays are equal. If they are not, an AssertionError
is thrown. Params: - expecteds – float array with expected values.
- actuals – float array with actual values
- delta – the maximum delta between
expecteds[i]
and
actuals[i]
for which both numbers are still
considered equal.
/**
* Asserts that two float arrays are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expecteds float array with expected values.
* @param actuals float array with actual values
* @param delta the maximum delta between <code>expecteds[i]</code> and
* <code>actuals[i]</code> for which both numbers are still
* considered equal.
*/
public static void assertArrayEquals(float[] expecteds, float[] actuals, float delta) {
assertArrayEquals(null, expecteds, actuals, delta);
}
Asserts that two object arrays are equal. If they are not, an AssertionError
is thrown with the given message. If expecteds
and actuals
are null
,
they are considered equal.
Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – Object array or array of arrays (multi-dimensional array) with
expected values.
- actuals – Object array or array of arrays (multi-dimensional array) with
actual values
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values.
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
*/
private static void internalArrayEquals(String message, Object expecteds,
Object actuals) throws ArrayComparisonFailure {
new ExactComparisonCriteria().arrayEquals(message, expecteds, actuals);
}
Asserts that two doubles are equal to within a positive delta. If they are not, an AssertionError
is thrown with the given message. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: assertEquals(Double.NaN, Double.NaN, *)
passes
Params: - message – the identifying message for the
AssertionError
(null
okay) - expected – expected value
- actual – the value to check against
expected
- delta – the maximum delta between
expected
and
actual
for which both numbers are still
considered equal.
/**
* Asserts that two doubles are equal to within a positive delta.
* If they are not, an {@link AssertionError} is thrown with the given
* message. If the expected value is infinity then the delta value is
* ignored. NaNs are considered equal:
* <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expected expected value
* @param actual the value to check against <code>expected</code>
* @param delta the maximum delta between <code>expected</code> and
* <code>actual</code> for which both numbers are still
* considered equal.
*/
static public void assertEquals(String message, double expected,
double actual, double delta) {
if (doubleIsDifferent(expected, actual, delta)) {
failNotEquals(message, Double.valueOf(expected), Double.valueOf(actual));
}
}
Asserts that two floats are equal to within a positive delta. If they are not, an AssertionError
is thrown with the given message. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: assertEquals(Float.NaN, Float.NaN, *)
passes
Params: - message – the identifying message for the
AssertionError
(null
okay) - expected – expected value
- actual – the value to check against
expected
- delta – the maximum delta between
expected
and
actual
for which both numbers are still
considered equal.
/**
* Asserts that two floats are equal to within a positive delta.
* If they are not, an {@link AssertionError} is thrown with the given
* message. If the expected value is infinity then the delta value is
* ignored. NaNs are considered equal:
* <code>assertEquals(Float.NaN, Float.NaN, *)</code> passes
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expected expected value
* @param actual the value to check against <code>expected</code>
* @param delta the maximum delta between <code>expected</code> and
* <code>actual</code> for which both numbers are still
* considered equal.
*/
static public void assertEquals(String message, float expected,
float actual, float delta) {
if (floatIsDifferent(expected, actual, delta)) {
failNotEquals(message, Float.valueOf(expected), Float.valueOf(actual));
}
}
Asserts that two floats are not equal to within a positive delta. If they are, an AssertionError
is thrown with the given message. If the unexpected value is infinity then the delta value is ignored. NaNs are considered equal: assertNotEquals(Float.NaN, Float.NaN, *)
fails
Params: - message – the identifying message for the
AssertionError
(null
okay) - unexpected – unexpected value
- actual – the value to check against
unexpected
- delta – the maximum delta between
unexpected
and
actual
for which both numbers are still
considered equal.
/**
* 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));
}
}
static private boolean doubleIsDifferent(double d1, double d2, double delta) {
if (Double.compare(d1, d2) == 0) {
return false;
}
if ((Math.abs(d1 - d2) <= delta)) {
return false;
}
return true;
}
static private boolean floatIsDifferent(float f1, float f2, float delta) {
if (Float.compare(f1, f2) == 0) {
return false;
}
if ((Math.abs(f1 - f2) <= delta)) {
return false;
}
return true;
}
Asserts that two longs are equal. If they are not, an AssertionError
is thrown. Params: - expected – expected long value.
- actual – actual long value
/**
* Asserts that two longs are equal. If they are not, an
* {@link AssertionError} is thrown.
*
* @param expected expected long value.
* @param actual actual long value
*/
static public void assertEquals(long expected, long actual) {
assertEquals(null, expected, actual);
}
Asserts that two longs are equal. If they are not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - expected – long expected value.
- actual – long actual value
/**
* Asserts that two longs are equal. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expected long expected value.
* @param actual long actual value
*/
static public void assertEquals(String message, long expected, long actual) {
if (expected != actual) {
failNotEquals(message, Long.valueOf(expected), Long.valueOf(actual));
}
}
Deprecated: Use
assertEquals(double expected, double actual, double delta)
instead
/**
* @deprecated Use
* <code>assertEquals(double expected, double actual, double delta)</code>
* instead
*/
@Deprecated
static public void assertEquals(double expected, double actual) {
assertEquals(null, expected, actual);
}
Deprecated: Use
assertEquals(String message, double expected, double actual, double delta)
instead
/**
* @deprecated Use
* <code>assertEquals(String message, double expected, double actual, double delta)</code>
* instead
*/
@Deprecated
static public void assertEquals(String message, double expected,
double actual) {
fail("Use assertEquals(expected, actual, delta) to compare floating-point numbers");
}
Asserts that two doubles are equal to within a positive delta. If they are not, an AssertionError
is thrown. If the expected value is infinity then the delta value is ignored.NaNs are considered equal: assertEquals(Double.NaN, Double.NaN, *)
passes
Params: - expected – expected value
- actual – the value to check against
expected
- delta – the maximum delta between
expected
and
actual
for which both numbers are still
considered equal.
/**
* Asserts that two doubles are equal to within a positive delta.
* If they are not, an {@link AssertionError} is thrown. If the expected
* value is infinity then the delta value is ignored.NaNs are considered
* equal: <code>assertEquals(Double.NaN, Double.NaN, *)</code> passes
*
* @param expected expected value
* @param actual the value to check against <code>expected</code>
* @param delta the maximum delta between <code>expected</code> and
* <code>actual</code> for which both numbers are still
* considered equal.
*/
static public void assertEquals(double expected, double actual, double delta) {
assertEquals(null, expected, actual, delta);
}
Asserts that two floats are equal to within a positive delta. If they are not, an AssertionError
is thrown. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: assertEquals(Float.NaN, Float.NaN, *)
passes
Params: - expected – expected value
- actual – the value to check against
expected
- delta – the maximum delta between
expected
and
actual
for which both numbers are still
considered equal.
/**
* Asserts that two floats are equal to within a positive delta.
* If they are not, an {@link AssertionError} is thrown. If the expected
* value is infinity then the delta value is ignored. NaNs are considered
* equal: <code>assertEquals(Float.NaN, Float.NaN, *)</code> passes
*
* @param expected expected value
* @param actual the value to check against <code>expected</code>
* @param delta the maximum delta between <code>expected</code> and
* <code>actual</code> for which both numbers are still
* considered equal.
*/
static public void assertEquals(float expected, float actual, float delta) {
assertEquals(null, expected, actual, delta);
}
Asserts that an object isn't null. If it is an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - object – Object to check or
null
/**
* Asserts that an object isn't null. If it is an {@link AssertionError} is
* thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param object Object to check or <code>null</code>
*/
static public void assertNotNull(String message, Object object) {
assertTrue(message, object != null);
}
Asserts that an object isn't null. If it is an AssertionError
is thrown. Params: - object – Object to check or
null
/**
* Asserts that an object isn't null. If it is an {@link AssertionError} is
* thrown.
*
* @param object Object to check or <code>null</code>
*/
static public void assertNotNull(Object object) {
assertNotNull(null, object);
}
Asserts that an object is null. If it is not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - object – Object to check or
null
/**
* Asserts that an object is null. If it is not, an {@link AssertionError}
* is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param object Object to check or <code>null</code>
*/
static public void assertNull(String message, Object object) {
if (object == null) {
return;
}
failNotNull(message, object);
}
Asserts that an object is null. If it isn't an AssertionError
is thrown. Params: - object – Object to check or
null
/**
* Asserts that an object is null. If it isn't an {@link AssertionError} is
* thrown.
*
* @param object Object to check or <code>null</code>
*/
static public void assertNull(Object object) {
assertNull(null, object);
}
static private void failNotNull(String message, Object actual) {
String formatted = "";
if (message != null) {
formatted = message + " ";
}
fail(formatted + "expected null, but was:<" + actual + ">");
}
Asserts that two objects refer to the same object. If they are not, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - expected – the expected object
- actual – the object to compare to
expected
/**
* Asserts that two objects refer to the same object. If they are not, an
* {@link AssertionError} is thrown with the given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expected the expected object
* @param actual the object to compare to <code>expected</code>
*/
static public void assertSame(String message, Object expected, Object actual) {
if (expected == actual) {
return;
}
failNotSame(message, expected, actual);
}
Asserts that two objects refer to the same object. If they are not the same, an AssertionError
without a message is thrown. Params: - expected – the expected object
- actual – the object to compare to
expected
/**
* Asserts that two objects refer to the same object. If they are not the
* same, an {@link AssertionError} without a message is thrown.
*
* @param expected the expected object
* @param actual the object to compare to <code>expected</code>
*/
static public void assertSame(Object expected, Object actual) {
assertSame(null, expected, actual);
}
Asserts that two objects do not refer to the same object. If they do refer to the same object, an AssertionError
is thrown with the given message. Params: - message – the identifying message for the
AssertionError
(null
okay) - unexpected – the object you don't expect
- actual – the object to compare to
unexpected
/**
* Asserts that two objects do not refer to the same object. If they do
* refer to the same object, an {@link AssertionError} is thrown with the
* given message.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param unexpected the object you don't expect
* @param actual the object to compare to <code>unexpected</code>
*/
static public void assertNotSame(String message, Object unexpected,
Object actual) {
if (unexpected == actual) {
failSame(message);
}
}
Asserts that two objects do not refer to the same object. If they do refer to the same object, an AssertionError
without a message is thrown. Params: - unexpected – the object you don't expect
- actual – the object to compare to
unexpected
/**
* Asserts that two objects do not refer to the same object. If they do
* refer to the same object, an {@link AssertionError} without a message is
* thrown.
*
* @param unexpected the object you don't expect
* @param actual the object to compare to <code>unexpected</code>
*/
static public void assertNotSame(Object unexpected, Object actual) {
assertNotSame(null, unexpected, actual);
}
static private void failSame(String message) {
String formatted = "";
if (message != null) {
formatted = message + " ";
}
fail(formatted + "expected not same");
}
static private void failNotSame(String message, Object expected,
Object actual) {
String formatted = "";
if (message != null) {
formatted = message + " ";
}
fail(formatted + "expected same:<" + expected + "> was not:<" + actual
+ ">");
}
static private void failNotEquals(String message, Object expected,
Object actual) {
fail(format(message, expected, actual));
}
static String format(String message, Object expected, Object actual) {
String formatted = "";
if (message != null && !message.equals("")) {
formatted = message + " ";
}
String expectedString = String.valueOf(expected);
String actualString = String.valueOf(actual);
if (expectedString.equals(actualString)) {
return formatted + "expected: "
+ formatClassAndValue(expected, expectedString)
+ " but was: " + formatClassAndValue(actual, actualString);
} else {
return formatted + "expected:<" + expectedString + "> but was:<"
+ actualString + ">";
}
}
private static String formatClassAndValue(Object value, String valueString) {
String className = value == null ? "null" : value.getClass().getName();
return className + "<" + valueString + ">";
}
Asserts that two object arrays are equal. If they are not, an AssertionError
is thrown with the given message. If expecteds
and actuals
are null
,
they are considered equal.
Params: - message – the identifying message for the
AssertionError
(null
okay) - expecteds – Object array or array of arrays (multi-dimensional array) with
expected values.
- actuals – Object array or array of arrays (multi-dimensional array) with
actual values
Deprecated: use assertArrayEquals
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown with the given message. If
* <code>expecteds</code> and <code>actuals</code> are <code>null</code>,
* they are considered equal.
*
* @param message the identifying message for the {@link AssertionError} (<code>null</code>
* okay)
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values.
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
* @deprecated use assertArrayEquals
*/
@Deprecated
public static void assertEquals(String message, Object[] expecteds,
Object[] actuals) {
assertArrayEquals(message, expecteds, actuals);
}
Asserts that two object arrays are equal. If they are not, an AssertionError
is thrown. If expected
and
actual
are null
, they are considered
equal.
Params: - expecteds – Object array or array of arrays (multi-dimensional array) with
expected values
- actuals – Object array or array of arrays (multi-dimensional array) with
actual values
Deprecated: use assertArrayEquals
/**
* Asserts that two object arrays are equal. If they are not, an
* {@link AssertionError} is thrown. If <code>expected</code> and
* <code>actual</code> are <code>null</code>, they are considered
* equal.
*
* @param expecteds Object array or array of arrays (multi-dimensional array) with
* expected values
* @param actuals Object array or array of arrays (multi-dimensional array) with
* actual values
* @deprecated use assertArrayEquals
*/
@Deprecated
public static void assertEquals(Object[] expecteds, Object[] actuals) {
assertArrayEquals(expecteds, actuals);
}
Asserts that actual
satisfies the condition specified by
matcher
. If not, an AssertionError
is thrown with information about the matcher and failing value. Example: assertThat(0, is(1)); // fails:
// failure message:
// expected: is <1>
// got value: <0>
assertThat(0, is(not(1))) // passes
org.hamcrest.Matcher
does not currently document the meaning
of its type parameter T
. This method assumes that a matcher
typed as Matcher<T>
can be meaningfully applied only
to values that could be assigned to a variable of type T
.
Params: - actual – the computed value being compared
- matcher – an expression, built of
Matcher
s, specifying allowed values
Type parameters: - <T> – the static type accepted by the matcher (this can flag obvious compile-time problems such as
assertThat(1, is("a"))
See Also:
/**
* Asserts that <code>actual</code> satisfies the condition specified by
* <code>matcher</code>. If not, an {@link AssertionError} is thrown with
* information about the matcher and failing value. Example:
*
* <pre>
* assertThat(0, is(1)); // fails:
* // failure message:
* // expected: is <1>
* // got value: <0>
* assertThat(0, is(not(1))) // passes
* </pre>
*
* <code>org.hamcrest.Matcher</code> does not currently document the meaning
* of its type parameter <code>T</code>. This method assumes that a matcher
* typed as <code>Matcher<T></code> can be meaningfully applied only
* to values that could be assigned to a variable of type <code>T</code>.
*
* @param <T> the static type accepted by the matcher (this can flag obvious
* compile-time problems such as {@code assertThat(1, is("a"))}
* @param actual the computed value being compared
* @param matcher an expression, built of {@link Matcher}s, specifying allowed
* values
* @see org.hamcrest.CoreMatchers
* @see org.hamcrest.MatcherAssert
*/
public static <T> void assertThat(T actual, Matcher<? super T> matcher) {
assertThat("", actual, matcher);
}
Asserts that actual
satisfies the condition specified by
matcher
. If not, an AssertionError
is thrown with the reason and information about the matcher and failing value. Example: assertThat("Help! Integers don't work", 0, is(1)); // fails:
// failure message:
// Help! Integers don't work
// expected: is <1>
// got value: <0>
assertThat("Zero is one", 0, is(not(1))) // passes
org.hamcrest.Matcher
does not currently document the meaning
of its type parameter T
. This method assumes that a matcher
typed as Matcher<T>
can be meaningfully applied only
to values that could be assigned to a variable of type T
.
Params: - reason – additional information about the error
- actual – the computed value being compared
- matcher – an expression, built of
Matcher
s, specifying allowed values
Type parameters: - <T> – the static type accepted by the matcher (this can flag obvious compile-time problems such as
assertThat(1, is("a"))
See Also:
/**
* Asserts that <code>actual</code> satisfies the condition specified by
* <code>matcher</code>. If not, an {@link AssertionError} is thrown with
* the reason and information about the matcher and failing value. Example:
*
* <pre>
* assertThat("Help! Integers don't work", 0, is(1)); // fails:
* // failure message:
* // Help! Integers don't work
* // expected: is <1>
* // got value: <0>
* assertThat("Zero is one", 0, is(not(1))) // passes
* </pre>
*
* <code>org.hamcrest.Matcher</code> does not currently document the meaning
* of its type parameter <code>T</code>. This method assumes that a matcher
* typed as <code>Matcher<T></code> can be meaningfully applied only
* to values that could be assigned to a variable of type <code>T</code>.
*
* @param reason additional information about the error
* @param <T> the static type accepted by the matcher (this can flag obvious
* compile-time problems such as {@code assertThat(1, is("a"))}
* @param actual the computed value being compared
* @param matcher an expression, built of {@link Matcher}s, specifying allowed
* values
* @see org.hamcrest.CoreMatchers
* @see org.hamcrest.MatcherAssert
*/
public static <T> void assertThat(String reason, T actual,
Matcher<? super T> matcher) {
MatcherAssert.assertThat(reason, actual, matcher);
}
}