Package 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:
  • Constructor Summary

    Constructors
    Modifier
    Constructor
    Description
    protected
    Protect constructor since it is a static only class
  • Method Summary

    Modifier and Type
    Method
    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(short[] expecteds, short[] actuals)
    Asserts that two short arrays are equal.
    static void
    assertArrayEquals(Object[] expecteds, Object[] actuals)
    Asserts that two object 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, short[] expecteds, short[] actuals)
    Asserts that two short arrays are equal.
    static void
    assertArrayEquals(String message, Object[] expecteds, Object[] actuals)
    Asserts that two object 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
    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
    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)
    Deprecated.
    use org.hamcrest.MatcherAssert.assertThat()
    static <T> void
    assertThat(T actual, org.hamcrest.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.
    private static String
     
    private static boolean
    doubleIsDifferent(double d1, double d2, double delta)
     
    private static boolean
    equalsRegardingNull(Object expected, Object actual)
     
    static void
    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
    formatClass(Class<?> value)
     
    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 Details

    • Assert

      protected Assert()
      Protect constructor since it is a static only class
  • Method Details

    • 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:
    • 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
    • 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 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
    • 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 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 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:
      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 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:
      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 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:
      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 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:
      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 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:
      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 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:
      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 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:
      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 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:
      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 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:
      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.
    • internalArrayEquals

      private static void internalArrayEquals(String message, Object expecteds, Object actuals) throws 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:
      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 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.
    • 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 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
    • 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 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
    • 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)
    • formatClass

      private static String formatClass(Class<?> value)
    • 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 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, org.hamcrest.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 Matchers, specifying allowed values
      See Also:
      • CoreMatchers
    • assertThat

      @Deprecated public static <T> void assertThat(String reason, T actual, org.hamcrest.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 Matchers, 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
    • buildPrefix

      private static String buildPrefix(String message)