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()
        Parameters:
        cause - the expected cause
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual Throwable is null.
        AssertionError - if the actual Throwable has not the given cause.

      • hasCauseReference

        public SELF hasCauseReference​(Throwable expected)
        Verifies that the actual Throwable has a cause that refers to the given one, i.e. using == comparison

        Example: 

         Throwable invalidArgException = new IllegalArgumentException("invalid arg");
 Throwable throwable = new Throwable(invalidArgException);

 // This assertion succeeds:
 assertThat(throwable).hasCauseReference(invalidArgException);

 // These assertions fail:
 assertThat(throwable).hasCauseReference(new IllegalArgumentException("invalid arg"));
 assertThat(throwable).hasCauseReference(new NullPointerException());
 assertThat(throwable).hasCauseReference(null); // prefer hasNoCause()
        Parameters:
        expected - the expected cause
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual Throwable is null.
        AssertionError - if the actual Throwable has a cause that does not refer to the given (i.e. actual.getCause() != 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.

        Examples: 

         Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
 Throwable throwableWithoutMessage = new IllegalArgumentException();

 // assertion will pass:
 assertThat(throwableWithMessage).hasMessageContaining("123");

 // assertions will fail:
 assertThat(throwableWithoutMessage).hasMessageContaining("123");
 assertThat(throwableWithMessage).hasMessageContaining("234");
        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.

      • hasMessageContainingAll

        public SELF hasMessageContainingAll​(CharSequence... values)
        Verifies that the message of the actual Throwable contains all the given values.

        Examples: 

         Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
 Throwable throwableWithoutMessage = new IllegalArgumentException();

 // assertion will pass:
 assertThat(throwableWithMessage).hasMessageContainingAll("amount", "123");

 // assertions will fail:
 assertThat(throwableWithoutMessage).hasMessageContainingAll("123");
 assertThat(throwableWithMessage).hasMessageContainingAll("234");
        Parameters:
        values - the Strings 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 all the given values.

      • hasMessageNotContaining

        public SELF hasMessageNotContaining​(String content)
        Verifies that the message of the actual Throwable does not contain the given content or is null.

        Examples: 

         Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
 Throwable throwableWithoutMessage = new IllegalArgumentException();

 // assertions will pass:
 assertThat(throwableWithMessage).hasMessageNotContaining("234");
 assertThat(throwableWithoutMessage).hasMessageNotContaining("foo");

 // assertion will fail:
 assertThat(throwableWithMessage).hasMessageNotContaining("amount");
        Parameters:
        content - the content expected not 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 contains the given content.
        Since:
        3.12.0

      • hasMessageNotContainingAny

        public SELF hasMessageNotContainingAny​(CharSequence... values)
        Verifies that the message of the actual Throwable does not contain any of the given values or is null.

        Examples: 

         Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
 Throwable throwableWithoutMessage = new IllegalArgumentException();

 // assertions will pass:
 assertThat(throwableWithMessage).hasMessageNotContainingAny("234");
 assertThat(throwableWithoutMessage).hasMessageNotContainingAny("foo");

 // assertion will fail:
 assertThat(throwableWithMessage).hasMessageNotContainingAny("foo", "amount");
        Parameters:
        values - the contents expected to not be contained in the actual Throwables's message.
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual Throwable is null.
        AssertionError - if the message of the actual Throwable contains any of the given values.
        Since:
        3.12.0

      • 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

      • hasMessageFindingMatch

        public SELF hasMessageFindingMatch​(String regex)
        Verifies that a sequence of the message of the actual Throwable matches with the given regular expression (see Matcher.find()).
        The Pattern used under the hood enables the Pattern.DOTALL mode.

        Examples: 

         Throwable throwable = new IllegalArgumentException("Dear John,\n" +
                                                    "it' s a wrong amount");
 // assertion will pass
 assertThat(throwable).hasMessageFindingMatch("wrong amount");
 assertThat(throwable).hasMessageFindingMatch("Dear John");
 assertThat(throwable).hasMessageFindingMatch("wrong amount$");

 // assertion will fail
 assertThat(throwable).hasMessageFindingMatch("Dear John$");
        Parameters:
        regex - the regular expression expected to be found 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 doesn't contain any sequence matching with the given regular expression
        NullPointerException - if the regex is null
        Since:
        3.12.0

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

      • hasRootCause

        public SELF hasRootCause​(Throwable cause)
        Verifies that the actual Throwable has a root 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(new RuntimeException(invalidArgException));

 // This assertion succeeds:
 assertThat(throwable).hasRootCause(invalidArgException);

 // These assertions fail:
 assertThat(throwable).hasRootCause(new IllegalArgumentException("bad arg"));
 assertThat(throwable).hasRootCause(new RuntimeException());
 assertThat(throwable).hasRootCause(null); // prefer hasNoCause()
        Parameters:
        cause - the expected root cause
        Returns:
        this assertion object.
        Throws:
        AssertionError - if the actual Throwable is null.
        AssertionError - if the actual Throwable has not the given cause.
        Since:
        3.12.0

      • 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