Package org.assertj.core.api

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

    • Constructor Detail

      • AbstractThrowableAssert

        public AbstractThrowableAssert​(ACTUAL actual,
                               Class<?> selfType)

    • Method Detail

      • 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