## org.junit
Class Assert

    java.lang.Object
      org.junit.Assert

    public class Assert

extends Object

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(...);

Since:
  4.0
See Also:
  `AssertionError`

Constructor Summary
`protected` `Assert()` Protect constructor since it is a static only class

Method Summary
`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)` Deprecated. Use `assertEquals(double expected, double actual, double delta)` instead
`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)` Deprecated. Use `assertEquals(String message, double expected, double actual, double delta)` instead
`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, Matcher<? super T> matcher)`
Deprecated. use `org.hamcrest.MatcherAssert.assertThat()`

`static

`<T> void`

`

`assertThat(T actual, Matcher<? super T> matcher)`
Deprecated. use `org.hamcrest.MatcherAssert.assertThat()`

`static

`<T extends Throwable> T`

`

`assertThrows(Class<T> expectedThrowable, ThrowingRunnable runnable)`
Asserts that `runnable` throws an exception of type `expectedThrowable` when executed.

`static

`<T extends Throwable> T`

`

`assertThrows(String message, Class<T> expectedThrowable, ThrowingRunnable runnable)`
Asserts that `runnable` throws an exception of type `expectedThrowable` when executed.

`static void` `assertTrue(boolean condition)` Asserts that a condition is true.
`static void` `assertTrue(String message, boolean condition)` Asserts that a condition is true.
`static void` `fail()` Fails a test with no message.
`static void` `fail(String message)` Fails a test with the given message.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Constructor Detail

### Assert

    protected Assert()

  Protect constructor since it is a static only class

Method Detail

### assertTrue

    public static void assertTrue(String message,
                                  boolean condition)

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

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` (`null` okay)
  See Also:
    `AssertionError`

### 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 `AssertionError` is thrown with the given message. If `expected` and `actual` are `null`, they are considered equal.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`null` okay)
    `expected` - expected value
    `actual` - actual value

### assertEquals

    public static void assertEquals(Object expected,
                                    Object 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.

  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 `AssertionError` is thrown with the given message. If `unexpected` and `actual` are `null`, they are considered equal.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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`

### assertNotEquals

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

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

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `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

  Parameters:
    `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.

### 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 `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

  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 `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

  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 `AssertionError` is thrown with the given message. If `expecteds` and `actuals` are `null`, they are considered equal.

  Parameters:
    `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
  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 `AssertionError` 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 `AssertionError` is thrown with the given message. If `expecteds` and `actuals` are `null`, they are considered equal.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `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.
  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 `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `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.
  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 `AssertionError` 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.

### 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 `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

  Parameters:
    `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.

### 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 `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

  Parameters:
    `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.

### 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 `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

  Parameters:
    `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.

### assertEquals

    public static void assertEquals(long expected,
                                    long actual)

  Asserts that two longs are equal. If they are not, an `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`null` okay)
    `expected` - long expected value.
    `actual` - long actual value

### assertEquals

    @Deprecated
    public static void assertEquals(double expected,
                                               double actual)

  Deprecated. Use `assertEquals(double expected, double actual, double delta)` instead

### assertEquals

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

  Deprecated. Use `assertEquals(String message, double expected, double actual, double delta)` instead

### 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 `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

  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 `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

  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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` is thrown.

  Parameters:
    `object` - Object to check or `null`

### 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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` 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 `AssertionError` is thrown with the given message.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`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 `AssertionError` without a message is thrown.

  Parameters:
    `unexpected` - the object you don't expect
    `actual` - the object to compare to `unexpected`

### 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 `AssertionError` is thrown with the given message. If `expecteds` and `actuals` are `null`, they are considered equal.

  Parameters:
    `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

### 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 `AssertionError` 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

    @Deprecated
    public static <T> void assertThat(T actual,
                                                 Matcher<? super T> matcher)

  Deprecated. use `org.hamcrest.MatcherAssert.assertThat()`

  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`.

  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 `Matcher`s, specifying allowed values
  See Also:
    `CoreMatchers`

### assertThat

    @Deprecated
    public static <T> void assertThat(String reason,
                                                 T actual,
                                                 Matcher<? super T> matcher)

  Deprecated. use `org.hamcrest.MatcherAssert.assertThat()`

  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`.

  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 `Matcher`s, specifying allowed values
  See Also:
    `CoreMatchers`

### assertThrows

    public static <T extends Throwable> T assertThrows(Class<T> expectedThrowable,
                                                       ThrowingRunnable runnable)

  Asserts that `runnable` throws an exception of type `expectedThrowable` when executed. If it does, the exception object is returned. If it does not throw an exception, an `AssertionError` is thrown. If it throws the wrong type of exception, an `AssertionError` is thrown describing the mismatch; the exception that was actually thrown can be obtained by calling `Throwable.getCause()`.

  Parameters:
    `expectedThrowable` - the expected type of the exception
    `runnable` - a function that is expected to throw an exception when executed
  Returns:
    the exception thrown by `runnable`
  Since:
    4.13

### assertThrows

    public static <T extends Throwable> T assertThrows(String message,
                                                       Class<T> expectedThrowable,
                                                       ThrowingRunnable runnable)

  Asserts that `runnable` throws an exception of type `expectedThrowable` when executed. If it does, the exception object is returned. If it does not throw an exception, an `AssertionError` is thrown. If it throws the wrong type of exception, an `AssertionError` is thrown describing the mismatch; the exception that was actually thrown can be obtained by calling `Throwable.getCause()`.

  Parameters:
    `message` - the identifying message for the `AssertionError` (`null` okay)
    `expectedThrowable` - the expected type of the exception
    `runnable` - a function that is expected to throw an exception when executed
  Returns:
    the exception thrown by `runnable`
  Since:
    4.13

Copyright © 2002–2020 JUnit. All rights reserved.