Class AbstractThrowableAssert<SELF extends AbstractThrowableAssert<SELF,ACTUAL>,ACTUAL extends Throwable>

java.lang.Object
org.assertj.core.api.AbstractAssert<SELF,ACTUAL>
org.assertj.core.api.AbstractObjectAssert<SELF,ACTUAL>
org.assertj.core.api.AbstractThrowableAssert<SELF,ACTUAL>
Type Parameters:
SELF - the "self" type of this assertion class. Please read "Emulating 'self types' using Java Generics to simplify fluent API implementation" for more details.
ACTUAL - the type of the "actual" value.
All Implemented Interfaces:
Assert<SELF,ACTUAL>, Descriptable<SELF>, ExtensionPoints<SELF,ACTUAL>
Direct Known Subclasses:
ThrowableAssert

public abstract class AbstractThrowableAssert<SELF extends AbstractThrowableAssert<SELF,ACTUAL>,ACTUAL extends Throwable> extends AbstractObjectAssert<SELF,ACTUAL>
Base class for all implementations of assertions for Throwables.
  • Field Details

  • Constructor Details

    • AbstractThrowableAssert

      public AbstractThrowableAssert(ACTUAL actual, Class<?> selfType)
  • Method Details

    • hasBeenThrown

      protected SELF hasBeenThrown()
    • hasMessage

      public SELF hasMessage(String message)
      Verifies that the message of the actual Throwable is equal to the given one.
      Parameters:
      message - the expected message.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the message of the actual Throwable is not equal to the given one.
    • hasMessage

      public SELF hasMessage(String message, Object... parameters)
      Verifies that the message of the actual (@code Throwable) is equal to the given one, after being formatted using the String.format(java.lang.String, java.lang.Object...) method.

      Example:

       Throwable invalidArgException = new IllegalArgumentException("foo is not a valid input");
       Throwable throwable = new Throwable(invalidArgException);
      
       // This assertion succeeds:
       assertThat(throwable).hasMessage("%s is not a valid input", "foo");
      
       // These assertions fail:
       assertThat(throwable).hasMessage("%s is not a valid input", "bar");
       assertThat(throwable).hasMessage("%s is not a valid input", 12);
       assertThat(null).hasMessage("%s is not a valid input", "foo");
       

      Parameters:
      message - a format string representing the expected message
      parameters - argument referenced by the format specifiers in the format string
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the message of the actual Throwable is not equal to the given one.
      IllegalFormatException - if the message contains an illegal syntax according to String.format(String, Object...).
    • hasCause

      public SELF hasCause(Throwable cause)
      Verifies that the actual Throwable has a cause similar to the given one, that is with the same type and message (it does not use the equals method for comparison). Example:
       Throwable invalidArgException = new IllegalArgumentException("invalid arg");
       Throwable throwable = new Throwable(invalidArgException);
      
       // This assertion succeeds:
       assertThat(throwable).hasCause(invalidArgException);
      
       // These assertions fail:
       assertThat(throwable).hasCause(new IllegalArgumentException("bad arg"));
       assertThat(throwable).hasCause(new NullPointerException());
       assertThat(throwable).hasCause(null); // prefer hasNoCause()
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the actual Throwable has not the given cause.
    • hasNoCause

      public SELF hasNoCause()
      Verifies that the actual Throwable does not have a cause.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the actual Throwable has a cause.
    • hasMessageStartingWith

      public SELF hasMessageStartingWith(String description)
      Verifies that the message of the actual Throwable starts with the given description.
      Parameters:
      description - the description expected to start the actual Throwable's message.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the message of the actual Throwable does not start with the given description.
    • hasMessageContaining

      public SELF hasMessageContaining(String description)
      Verifies that the message of the actual Throwable contains the given description.
      Parameters:
      description - the description expected to be contained in the actual Throwable's message.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the message of the actual Throwable does not contain the given description.
    • hasStackTraceContaining

      public SELF hasStackTraceContaining(String description)
      Verifies that the stack trace of the actual Throwable contains the given description.
      Parameters:
      description - the description expected to be contained in the actual Throwable's stack trace.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the stack trace of the actual Throwable does not contain the given description.
    • hasMessageMatching

      public SELF hasMessageMatching(String regex)
      Verifies that the message of the actual Throwable matches the given regular expression.

      Examples:

       Throwable throwable = new IllegalArgumentException("wrong amount 123");
      
       // assertion will pass
       assertThat(throwable).hasMessageMatching("wrong amount [0-9]*");
      
       // assertion will fail
       assertThat(throwable).hasMessageMatching("wrong amount [0-9]* euros");
      Parameters:
      regex - the regular expression of value expected to be matched the actual Throwable's message.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the message of the actual Throwable does not match the given regular expression.
      NullPointerException - if the regex is null
    • hasMessageEndingWith

      public SELF hasMessageEndingWith(String description)
      Verifies that the message of the actual Throwable ends with the given description.
      Parameters:
      description - the description expected to end the actual Throwable's message.
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the message of the actual Throwable does not end with the given description.
    • hasCauseInstanceOf

      public SELF hasCauseInstanceOf(Class<? extends Throwable> type)
      Verifies that the cause of the actual Throwable is an instance of the given type.

      Example:

       Throwable throwable = new Throwable(new NullPointerException());
      
       // assertions will pass
       assertThat(throwable).hasCauseInstanceOf(NullPointerException.class);
       assertThat(throwable).hasCauseInstanceOf(RuntimeException.class);
      
       // assertion will fail
       assertThat(throwable).hasCauseInstanceOf(IllegalArgumentException.class);
      Parameters:
      type - the expected cause type.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if given type is null.
      AssertionError - if the actual Throwable is null.
      AssertionError - if the actual Throwable has no cause.
      AssertionError - if the cause of the actual Throwable is not an instance of the given type.
    • hasCauseExactlyInstanceOf

      public SELF hasCauseExactlyInstanceOf(Class<? extends Throwable> type)
      Verifies that the cause of the actual Throwable is exactly an instance of the given type.

      Example:

       Throwable throwable = new Throwable(new NullPointerException());
      
       // assertion will pass
       assertThat(throwable).hasCauseExactlyInstanceOf(NullPointerException.class);
      
       // assertions will fail (even if NullPointerException is a RuntimeException since we want an exact match)
       assertThat(throwable).hasCauseExactlyInstanceOf(RuntimeException.class);
       assertThat(throwable).hasCauseExactlyInstanceOf(IllegalArgumentException.class);

      Parameters:
      type - the expected cause type.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if given type is null.
      AssertionError - if the actual Throwable is null.
      AssertionError - if the actual Throwable has no cause.
      AssertionError - if the cause of the actual Throwable is not exactly an instance of the given type.
    • hasRootCauseInstanceOf

      public SELF hasRootCauseInstanceOf(Class<? extends Throwable> type)
      Verifies that the root cause of the actual Throwable is an instance of the given type.

      Example:

       Throwable throwable = new Throwable(new IllegalStateException(new NullPointerException()));
      
       // assertions will pass
       assertThat(throwable).hasRootCauseInstanceOf(NullPointerException.class);
       assertThat(throwable).hasRootCauseInstanceOf(RuntimeException.class);
      
       // assertion will fail
       assertThat(throwable).hasRootCauseInstanceOf(IllegalStateException.class);

      Parameters:
      type - the expected cause type.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if given type is null.
      AssertionError - if the actual Throwable is null.
      AssertionError - if the actual Throwable has no cause.
      AssertionError - if the cause of the actual Throwable is not an instance of the given type.
    • hasRootCauseExactlyInstanceOf

      public SELF hasRootCauseExactlyInstanceOf(Class<? extends Throwable> type)
      Verifies that the root cause of the actual Throwable is exactly an instance of the given type.

      Example:

       Throwable throwable = new Throwable(new IllegalStateException(new NullPointerException()));
      
       // assertion will pass
       assertThat(throwable).hasRootCauseExactlyInstanceOf(NullPointerException.class);
      
       // assertions will fail (even if NullPointerException is a RuntimeException since we want an exact match)
       assertThat(throwable).hasRootCauseExactlyInstanceOf(RuntimeException.class);
       assertThat(throwable).hasRootCauseExactlyInstanceOf(IllegalStateException.class);

      Parameters:
      type - the expected cause type.
      Returns:
      this assertion object.
      Throws:
      NullPointerException - if given type is null.
      AssertionError - if the actual Throwable is null.
      AssertionError - if the actual Throwable has no cause.
      AssertionError - if the root cause of the actual Throwable is not exactly an instance of the given type.
    • hasNoSuppressedExceptions

      public SELF hasNoSuppressedExceptions()
      Verifies that the actual Throwable has no suppressed exceptions.

      Example:

       // assertion will pass
       assertThat(new Throwable()).hasNoSuppressedExceptions();
       
       // assertion will fail
       Throwable throwableWithSuppressedException = new Throwable();
       throwableWithSuppressedException.addSuppressed(new IllegalArgumentException());
       assertThat(throwableWithSuppressedException).hasNoSuppressedExceptions();

      Returns:
      this assertion object.
      Throws:
      NullPointerException - if given type is null.
      AssertionError - if the actual Throwable has any suppressed exceptions.
      Since:
      2.6.0 / 3.6.0
    • hasSuppressedException

      public SELF hasSuppressedException(Throwable suppressedException)
      Verifies that the actual Throwable has a suppressed exception similar to the given one, that is with the same type and message (it does not use the equals method for comparison). Example:
       Throwable throwable = new Throwable();
       Throwable invalidArgException = new IllegalArgumentException("invalid argument");
       throwable.addSuppressed(invalidArgException);
       
       // These assertions succeed:
       assertThat(throwable).hasSuppressedException(invalidArgException);
       assertThat(throwable).hasSuppressedException(new IllegalArgumentException("invalid argument"));
      
       // These assertions fail:
       assertThat(throwable).hasSuppressedException(new IllegalArgumentException("invalid parameter"));
       assertThat(throwable).hasSuppressedException(new NullPointerException());
      Parameters:
      suppressedException - the expected suppressed exception
      Returns:
      this assertion object.
      Throws:
      AssertionError - if the actual Throwable is null.
      AssertionError - if the actual Throwable does not have the given suppressed exception.
      Since:
      2.6.0 / 3.6.0
    • doesNotThrowAnyException

      public void doesNotThrowAnyException()
      Verifies that the ThrowableAssert.ThrowingCallable didn't raise a throwable.

      Example :

       assertThatCode(() -> foo.bar()).doesNotThrowAnyException();
      Throws:
      AssertionError - if the actual statement raised a Throwable.
      Since:
      3.7.0