com.github.mkolisnyk.cucumber.assertions

Class LazyAssert

java.lang.Object

com.github.mkolisnyk.cucumber.assertions.LazyAssert

public final class LazyAssert
extends Object

Constructor Summary

Constructors

Modifier	Constructor and Description
private	LazyAssert()

Method Summary

Modifier and Type	Method and Description
static void	assertArrayEquals(boolean[] expecteds, boolean[] actuals) Asserts that two boolean arrays are equal.
static void	assertArrayEquals(byte[] expecteds, byte[] actuals) Asserts that two byte arrays are equal.
static void	assertArrayEquals(char[] expecteds, char[] actuals) Asserts that two char arrays are equal.
static void	assertArrayEquals(double[] expecteds, double[] actuals, double delta) Asserts that two double arrays are equal.
static void	assertArrayEquals(float[] expecteds, float[] actuals, float delta) Asserts that two float arrays are equal.
static void	assertArrayEquals(int[] expecteds, int[] actuals) Asserts that two int arrays are equal.
static void	assertArrayEquals(long[] expecteds, long[] actuals) Asserts that two long arrays are equal.
static void	assertArrayEquals(Object[] expecteds, Object[] actuals) Asserts that two object arrays are equal.
static void	assertArrayEquals(short[] expecteds, short[] actuals) Asserts that two short arrays are equal.
static void	assertArrayEquals(String message, boolean[] expecteds, boolean[] actuals) Asserts that two boolean arrays are equal.
static void	assertArrayEquals(String message, byte[] expecteds, byte[] actuals) Asserts that two byte arrays are equal.
static void	assertArrayEquals(String message, char[] expecteds, char[] actuals) Asserts that two char arrays are equal.
static void	assertArrayEquals(String message, double[] expecteds, double[] actuals, double delta) Asserts that two double arrays are equal.
static void	assertArrayEquals(String message, float[] expecteds, float[] actuals, float delta) Asserts that two float arrays are equal.
static void	assertArrayEquals(String message, int[] expecteds, int[] actuals) Asserts that two int arrays are equal.
static void	assertArrayEquals(String message, long[] expecteds, long[] actuals) Asserts that two long arrays are equal.
static void	assertArrayEquals(String message, Object[] expecteds, Object[] actuals) Asserts that two object arrays are equal.
static void	assertArrayEquals(String message, short[] expecteds, short[] actuals) Asserts that two short arrays are equal.
static void	assertEquals(double expected, double actual, double delta) Asserts that two doubles are equal to within a positive delta.
static void	assertEquals(float expected, float actual, float delta) Asserts that two floats are equal to within a positive delta.
static void	assertEquals(long expected, long actual) Asserts that two longs are equal.
static void	assertEquals(Object[] expecteds, Object[] actuals) Deprecated. use assertArrayEquals
static void	assertEquals(Object expected, Object actual) Asserts that two objects are equal.
static void	assertEquals(String message, double expected, double actual, double delta) Asserts that two doubles are equal to within a positive delta.
static void	assertEquals(String message, float expected, float actual, float delta) Asserts that two floats are equal to within a positive delta.
static void	assertEquals(String message, long expected, long actual) Asserts that two longs are equal.
static void	assertEquals(String message, Object[] expecteds, Object[] actuals) Deprecated. use assertArrayEquals
static void	assertEquals(String message, Object expected, Object actual) Asserts that two objects are equal.
static void	assertFalse(boolean condition) Asserts that a condition is false.
static void	assertFalse(String message, boolean condition) Asserts that a condition is false.
static void	assertNotEquals(double unexpected, double actual, double delta) Asserts that two doubles are not equal to within a positive delta.
static void	assertNotEquals(float unexpected, float actual, float delta) Asserts that two floats are not equal to within a positive delta.
static void	assertNotEquals(long unexpected, long actual) Asserts that two longs are not equals.
static void	assertNotEquals(Object unexpected, Object actual) Asserts that two objects are not equals.
static void	assertNotEquals(String message, double unexpected, double actual, double delta) Asserts that two doubles are not equal to within a positive delta.
static void	assertNotEquals(String message, float unexpected, float actual, float delta) Asserts that two floats are not equal to within a positive delta.
static void	assertNotEquals(String message, long unexpected, long actual) Asserts that two longs are not equals.
static void	assertNotEquals(String message, Object unexpected, Object actual) Asserts that two objects are not equals.
static void	assertNotNull(Object object) Asserts that an object isn't null.
static void	assertNotNull(String message, Object object) Asserts that an object isn't null.
static void	assertNotSame(Object unexpected, Object actual) Asserts that two objects do not refer to the same object.
static void	assertNotSame(String message, Object unexpected, Object actual) Asserts that two objects do not refer to the same object.
static void	assertNull(Object object) Asserts that an object is null.
static void	assertNull(String message, Object object) Asserts that an object is null.
static void	assertSame(Object expected, Object actual) Asserts that two objects refer to the same object.
static void	assertSame(String message, Object expected, Object actual) Asserts that two objects refer to the same object.
static <T> void	assertThat(String reason, T actual, org.hamcrest.Matcher<? super T> matcher) Asserts that actual satisfies the condition specified by matcher.
static <T> void	assertThat(T actual, org.hamcrest.Matcher<? super T> matcher) Asserts that actual satisfies the condition specified by matcher.
static void	assertTrue(boolean condition) Asserts that a condition is true.
static void	assertTrue(String message, boolean condition) Asserts that a condition is true.
private static boolean	doubleIsDifferent(double d1, double d2, double delta)
private static boolean	equalsRegardingNull(Object expected, Object actual)
static void	fail() Fails a test with no message.
static void	fail(String message) Fails a test with the given message.
private static void	failEquals(String message, Object actual)
private static void	failNotEquals(String message, Object expected, Object actual)
private static void	failNotNull(String message, Object actual)
private static void	failNotSame(String message, Object expected, Object actual)
private static void	failSame(String message)
private static boolean	floatIsDifferent(float f1, float f2, float delta)
(package private) static String	format(String message, Object expected, Object actual)
private static String	formatClassAndValue(Object value, String valueString)
private static void	internalArrayEquals(String message, Object expecteds, Object actuals) Asserts that two object arrays are equal.
private static boolean	isEquals(Object expected, Object actual)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

LazyAssert

private LazyAssert()

Method Detail

assertTrue

public static void assertTrue(String message,
                              boolean condition)

Asserts that a condition is true. If it isn't it throws an LazyAssertionError with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

condition - condition to be checked

assertTrue

public static void assertTrue(boolean condition)

Asserts that a condition is true. If it isn't it throws an LazyAssertionError without a message.

Parameters:

condition - condition to be checked

assertFalse

public static void assertFalse(String message,
                               boolean condition)

Asserts that a condition is false. If it isn't it throws an LazyAssertionError with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

condition - condition to be checked

assertFalse

public static void assertFalse(boolean condition)

Asserts that a condition is false. If it isn't it throws an LazyAssertionError without a message.

Parameters:

condition - condition to be checked

fail

public static void fail(String message)

Fails a test with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

See Also:

LazyAssertionError

fail

public static void fail()

Fails a test with no message.

assertEquals

public static void assertEquals(String message,
                                Object expected,
                                Object actual)

Asserts that two objects are equal. If they are not, an LazyAssertionError is thrown with the given message. If expected and actual are null, they are considered equal.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

expected - expected value

actual - actual value

equalsRegardingNull

private static boolean equalsRegardingNull(Object expected,
                                           Object actual)

isEquals

private static boolean isEquals(Object expected,
                                Object actual)

assertEquals

public static void assertEquals(Object expected,
                                Object actual)

Asserts that two objects are equal. If they are not, an LazyAssertionError without a message is thrown. If expected and actual are null, they are considered equal.

Parameters:

expected - expected value

actual - the value to check against expected

assertNotEquals

public static void assertNotEquals(String message,
                                   Object unexpected,
                                   Object actual)

Asserts that two objects are not equals. If they are, an LazyAssertionError is thrown with the given message. If unexpected and actual are null, they are considered equal.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

unexpected - unexpected value to check

actual - the value to check against unexpected

assertNotEquals

public static void assertNotEquals(Object unexpected,
                                   Object actual)

Asserts that two objects are not equals. If they are, an LazyAssertionError without a message is thrown. If unexpected and actual are null, they are considered equal.

Parameters:

unexpected - unexpected value to check

actual - the value to check against unexpected

failEquals

private static void failEquals(String message,
                               Object actual)

assertNotEquals

public static void assertNotEquals(String message,
                                   long unexpected,
                                   long actual)

Asserts that two longs are not equals. If they are, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

unexpected - unexpected value to check

actual - the value to check against unexpected

assertNotEquals

public static void assertNotEquals(long unexpected,
                                   long actual)

Asserts that two longs are not equals. If they are, an LazyAssertionError without a message is thrown.

Parameters:

unexpected - unexpected value to check

actual - the value to check against unexpected

assertNotEquals

public static void assertNotEquals(String message,
                                   double unexpected,
                                   double actual,
                                   double delta)

Asserts that two doubles are not equal to within a positive delta. If they are, an LazyAssertionError 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

Parameters:

message - the identifying message for the LazyAssertionError (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.

assertNotEquals

public static void assertNotEquals(double unexpected,
                                   double actual,
                                   double delta)

Asserts that two doubles are not equal to within a positive delta. If they are, an LazyAssertionError is thrown. If the unexpected value is infinity then the delta value is ignored.NaNs are considered equal: assertNotEquals(Double.NaN, Double.NaN, *) fails

Parameters:

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.

assertNotEquals

public static void assertNotEquals(float unexpected,
                                   float actual,
                                   float delta)

Asserts that two floats are not equal to within a positive delta. If they are, an LazyAssertionError is thrown. If the unexpected value is infinity then the delta value is ignored.NaNs are considered equal: assertNotEquals(Float.NaN, Float.NaN, *) fails

Parameters:

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.

assertArrayEquals

public static void assertArrayEquals(String message,
                                     Object[] expecteds,
                                     Object[] actuals)
                              throws org.junit.internal.ArrayComparisonFailure

Asserts that two object arrays are equal. If they are not, an LazyAssertionError is thrown with the given message. If expecteds and actuals are null, they are considered equal.

Parameters:

message - the identifying message for the LazyAssertionError (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

Throws:

org.junit.internal.ArrayComparisonFailure

assertArrayEquals

public static void assertArrayEquals(Object[] expecteds,
                                     Object[] actuals)

Asserts that two object arrays are equal. If they are not, an LazyAssertionError is thrown. If expected and actual are null, they are considered equal.

Parameters:

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

assertArrayEquals

public static void assertArrayEquals(String message,
                                     boolean[] expecteds,
                                     boolean[] actuals)
                              throws org.junit.internal.ArrayComparisonFailure

Asserts that two boolean arrays are equal. If they are not, an LazyAssertionError is thrown with the given message. If expecteds and actuals are null, they are considered equal.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

expecteds - boolean array with expected values.

actuals - boolean array with expected values.

Throws:

org.junit.internal.ArrayComparisonFailure

assertArrayEquals

public static void assertArrayEquals(boolean[] expecteds,
                                     boolean[] actuals)

Asserts that two boolean arrays are equal. If they are not, an LazyAssertionError is thrown. If expected and actual are null, they are considered equal.

Parameters:

expecteds - boolean array with expected values.

actuals - boolean array with expected values.

assertArrayEquals

public static void assertArrayEquals(String message,
                                     byte[] expecteds,
                                     byte[] actuals)
                              throws org.junit.internal.ArrayComparisonFailure

Asserts that two byte arrays are equal. If they are not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

expecteds - byte array with expected values.

actuals - byte array with actual values

Throws:

org.junit.internal.ArrayComparisonFailure

assertArrayEquals

public static void assertArrayEquals(byte[] expecteds,
                                     byte[] actuals)

Asserts that two byte arrays are equal. If they are not, an LazyAssertionError is thrown.

Parameters:

expecteds - byte array with expected values.

actuals - byte array with actual values

assertArrayEquals

public static void assertArrayEquals(String message,
                                     char[] expecteds,
                                     char[] actuals)
                              throws org.junit.internal.ArrayComparisonFailure

Asserts that two char arrays are equal. If they are not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

expecteds - char array with expected values.

actuals - char array with actual values

Throws:

org.junit.internal.ArrayComparisonFailure

assertArrayEquals

public static void assertArrayEquals(char[] expecteds,
                                     char[] actuals)

Asserts that two char arrays are equal. If they are not, an LazyAssertionError is thrown.

Parameters:

expecteds - char array with expected values.

actuals - char array with actual values

assertArrayEquals

public static void assertArrayEquals(String message,
                                     short[] expecteds,
                                     short[] actuals)
                              throws org.junit.internal.ArrayComparisonFailure

Asserts that two short arrays are equal. If they are not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

expecteds - short array with expected values.

actuals - short array with actual values

Throws:

org.junit.internal.ArrayComparisonFailure

assertArrayEquals

public static void assertArrayEquals(short[] expecteds,
                                     short[] actuals)

Asserts that two short arrays are equal. If they are not, an LazyAssertionError is thrown.

Parameters:

expecteds - short array with expected values.

actuals - short array with actual values

assertArrayEquals

public static void assertArrayEquals(String message,
                                     int[] expecteds,
                                     int[] actuals)
                              throws org.junit.internal.ArrayComparisonFailure

Asserts that two int arrays are equal. If they are not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

expecteds - int array with expected values.

actuals - int array with actual values

Throws:

org.junit.internal.ArrayComparisonFailure

assertArrayEquals

public static void assertArrayEquals(int[] expecteds,
                                     int[] actuals)

Asserts that two int arrays are equal. If they are not, an LazyAssertionError is thrown.

Parameters:

expecteds - int array with expected values.

actuals - int array with actual values

assertArrayEquals

public static void assertArrayEquals(String message,
                                     long[] expecteds,
                                     long[] actuals)
                              throws org.junit.internal.ArrayComparisonFailure

Asserts that two long arrays are equal. If they are not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

expecteds - long array with expected values.

actuals - long array with actual values

Throws:

org.junit.internal.ArrayComparisonFailure

assertArrayEquals

public static void assertArrayEquals(long[] expecteds,
                                     long[] actuals)

Asserts that two long arrays are equal. If they are not, an LazyAssertionError is thrown.

Parameters:

expecteds - long array with expected values.

actuals - long array with actual values

assertArrayEquals

public static void assertArrayEquals(String message,
                                     double[] expecteds,
                                     double[] actuals,
                                     double delta)
                              throws org.junit.internal.ArrayComparisonFailure

Asserts that two double arrays are equal. If they are not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (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.

Throws:

org.junit.internal.ArrayComparisonFailure

assertArrayEquals

public static void assertArrayEquals(double[] expecteds,
                                     double[] actuals,
                                     double delta)

Asserts that two double arrays are equal. If they are not, an LazyAssertionError is thrown.

Parameters:

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.

assertArrayEquals

public static void assertArrayEquals(String message,
                                     float[] expecteds,
                                     float[] actuals,
                                     float delta)
                              throws org.junit.internal.ArrayComparisonFailure

Asserts that two float arrays are equal. If they are not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (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.

Throws:

org.junit.internal.ArrayComparisonFailure

assertArrayEquals

public static void assertArrayEquals(float[] expecteds,
                                     float[] actuals,
                                     float delta)

Asserts that two float arrays are equal. If they are not, an LazyAssertionError is thrown.

Parameters:

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.

internalArrayEquals

private static void internalArrayEquals(String message,
                                        Object expecteds,
                                        Object actuals)
                                 throws org.junit.internal.ArrayComparisonFailure

Asserts that two object arrays are equal. If they are not, an LazyAssertionError is thrown with the given message. If expecteds and actuals are null, they are considered equal.

Parameters:

message - the identifying message for the LazyAssertionError (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

Throws:

org.junit.internal.ArrayComparisonFailure

assertEquals

public static void assertEquals(String message,
                                double expected,
                                double actual,
                                double delta)

Asserts that two doubles are equal to within a positive delta. If they are not, an LazyAssertionError 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

Parameters:

message - the identifying message for the LazyAssertionError (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.

assertEquals

public static void assertEquals(String message,
                                float expected,
                                float actual,
                                float delta)

Asserts that two floats are equal to within a positive delta. If they are not, an LazyAssertionError 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

Parameters:

message - the identifying message for the LazyAssertionError (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.

assertNotEquals

public static void assertNotEquals(String message,
                                   float unexpected,
                                   float actual,
                                   float delta)

Asserts that two floats are not equal to within a positive delta. If they are, an LazyAssertionError 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

Parameters:

message - the identifying message for the LazyAssertionError (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.

doubleIsDifferent

private static boolean doubleIsDifferent(double d1,
                                         double d2,
                                         double delta)

floatIsDifferent

private static boolean floatIsDifferent(float f1,
                                        float f2,
                                        float delta)

assertEquals

public static void assertEquals(long expected,
                                long actual)

Asserts that two longs are equal. If they are not, an LazyAssertionError is thrown.

Parameters:

expected - expected long value.

actual - actual long value

assertEquals

public static void assertEquals(String message,
                                long expected,
                                long actual)

Asserts that two longs are equal. If they are not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

expected - long expected value.

actual - long actual value

assertEquals

public static void assertEquals(double expected,
                                double actual,
                                double delta)

Asserts that two doubles are equal to within a positive delta. If they are not, an LazyAssertionError is thrown. If the expected value is infinity then the delta value is ignored.NaNs are considered equal: assertEquals(Double.NaN, Double.NaN, *) passes

Parameters:

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.

assertEquals

public static void assertEquals(float expected,
                                float actual,
                                float delta)

Asserts that two floats are equal to within a positive delta. If they are not, an LazyAssertionError is thrown. If the expected value is infinity then the delta value is ignored. NaNs are considered equal: assertEquals(Float.NaN, Float.NaN, *) passes

Parameters:

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.

assertNotNull

public static void assertNotNull(String message,
                                 Object object)

Asserts that an object isn't null. If it is an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

object - Object to check or null

assertNotNull

public static void assertNotNull(Object object)

Asserts that an object isn't null. If it is an LazyAssertionError is thrown.

Parameters:

object - Object to check or null

assertNull

public static void assertNull(String message,
                              Object object)

Asserts that an object is null. If it is not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

object - Object to check or null

assertNull

public static void assertNull(Object object)

Asserts that an object is null. If it isn't an LazyAssertionError is thrown.

Parameters:

object - Object to check or null

failNotNull

private static void failNotNull(String message,
                                Object actual)

assertSame

public static void assertSame(String message,
                              Object expected,
                              Object actual)

Asserts that two objects refer to the same object. If they are not, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

expected - the expected object

actual - the object to compare to expected

assertSame

public static void assertSame(Object expected,
                              Object actual)

Asserts that two objects refer to the same object. If they are not the same, an LazyAssertionError without a message is thrown.

Parameters:

expected - the expected object

actual - the object to compare to expected

assertNotSame

public static void assertNotSame(String message,
                                 Object unexpected,
                                 Object actual)

Asserts that two objects do not refer to the same object. If they do refer to the same object, an LazyAssertionError is thrown with the given message.

Parameters:

message - the identifying message for the LazyAssertionError (null okay)

unexpected - the object you don't expect

actual - the object to compare to unexpected

assertNotSame

public static void assertNotSame(Object unexpected,
                                 Object actual)

Asserts that two objects do not refer to the same object. If they do refer to the same object, an LazyAssertionError without a message is thrown.

Parameters:

unexpected - the object you don't expect

actual - the object to compare to unexpected

failSame

private static void failSame(String message)

failNotSame

private static void failNotSame(String message,
                                Object expected,
                                Object actual)

failNotEquals

private static void failNotEquals(String message,
                                  Object expected,
                                  Object actual)

format

static String format(String message,
                     Object expected,
                     Object actual)

formatClassAndValue

private static String formatClassAndValue(Object value,
                                          String valueString)

assertEquals

@Deprecated
public static void assertEquals(String message,
                                            Object[] expecteds,
                                            Object[] actuals)

Deprecated. use assertArrayEquals

Asserts that two object arrays are equal. If they are not, an LazyAssertionError is thrown with the given message. If expecteds and actuals are null, they are considered equal.

Parameters:

message - the identifying message for the LazyAssertionError (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

assertEquals

@Deprecated
public static void assertEquals(Object[] expecteds,
                                            Object[] actuals)

Deprecated. use assertArrayEquals

Asserts that two object arrays are equal. If they are not, an LazyAssertionError is thrown. If expected and actual are null, they are considered equal.

Parameters:

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

assertThat

public static <T> void assertThat(T actual,
                                  org.hamcrest.Matcher<? super T> matcher)

Asserts that actual satisfies the condition specified by matcher. If not, an LazyAssertionError 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.

Type Parameters:

T - the static type accepted by the matcher (this can flag obvious compile-time problems such as assertThat(1, is("a"))

Parameters:

actual - the computed value being compared

matcher - an expression, built of Matchers, specifying allowed values

See Also:

CoreMatchers, MatcherAssert

assertThat

public static <T> void assertThat(String reason,
                                  T actual,
                                  org.hamcrest.Matcher<? super T> matcher)

Asserts that actual satisfies the condition specified by matcher. If not, an LazyAssertionError 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.

Type Parameters:

T - the static type accepted by the matcher (this can flag obvious compile-time problems such as assertThat(1, is("a"))

Parameters:

reason - additional information about the error

actual - the computed value being compared

matcher - an expression, built of Matchers, specifying allowed values

See Also:

CoreMatchers, MatcherAssert