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.public abstract class AbstractThrowableAssert<SELF extends AbstractThrowableAssert<SELF,ACTUAL>,ACTUAL extends Throwable> extends AbstractObjectAssert<SELF,ACTUAL>
Throwables.actual, info, myself, objects, throwUnsupportedExceptionOnEquals| Modifier | Constructor and Description |
|---|---|
protected |
AbstractThrowableAssert(ACTUAL actual,
Class<?> selfType) |
| Modifier and Type | Method and Description |
|---|---|
AbstractThrowableAssert<?,?> |
cause()
Returns a new assertion object that uses the cause of the current Throwable as the actual Throwable under test.
|
void |
doesNotThrowAnyException()
Verifies that the
ThrowableAssert.ThrowingCallable didn't raise a throwable. |
AbstractThrowableAssert<?,?> |
getCause()
Deprecated.
use
cause() instead.
Returns a new assertion object that uses the cause of the current Throwable as the actual Throwable under test. Examples: |
AbstractThrowableAssert<?,?> |
getRootCause()
Deprecated.
use
rootCause() instead.
Returns a new assertion object that uses the root cause of the current Throwable as the actual Throwable under test. Examples: |
protected SELF |
hasBeenThrown() |
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). |
SELF |
hasCauseExactlyInstanceOf(Class<? extends Throwable> type)
Verifies that the cause of the actual
Throwable is exactly an instance of the given type. |
SELF |
hasCauseInstanceOf(Class<? extends Throwable> type)
Verifies that the cause of the actual
Throwable is an instance of the given type. |
SELF |
hasCauseReference(Throwable expected)
Verifies that the actual
Throwable has a cause that refers to the given one, i.e. |
SELF |
hasMessage(String message)
Verifies that the message of the actual
Throwable is equal to the given one. |
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. |
SELF |
hasMessageContaining(String description)
Verifies that the message of the actual
Throwable contains the given description. |
SELF |
hasMessageContaining(String description,
Object... parameters)
Verifies that the message of the actual
Throwable contains the given description, after being formatted using
the String.format(java.lang.String, java.lang.Object...) method. |
SELF |
hasMessageContainingAll(CharSequence... values)
Verifies that the message of the actual
Throwable contains all the given values. |
SELF |
hasMessageEndingWith(String description)
Verifies that the message of the actual
Throwable ends with the given description. |
SELF |
hasMessageEndingWith(String description,
Object... parameters)
Verifies that the message of the actual
Throwable ends with the given description, after being formatted using
the String.format(java.lang.String, java.lang.Object...) method. |
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. |
SELF |
hasMessageMatching(String regex)
Verifies that the message of the actual
Throwable matches the given regular expression. |
SELF |
hasMessageNotContaining(String content)
Verifies that the message of the actual
Throwable does not contain the given content or is null. |
SELF |
hasMessageNotContainingAny(CharSequence... values)
Verifies that the message of the actual
Throwable does not contain any of the given values or is null. |
SELF |
hasMessageStartingWith(String description)
Verifies that the message of the actual
Throwable starts with the given description. |
SELF |
hasMessageStartingWith(String description,
Object... parameters)
Verifies that the message of the actual
Throwable starts with the given description, after being formatted using
the String.format(java.lang.String, java.lang.Object...) method. |
SELF |
hasNoCause()
Verifies that the actual
Throwable does not have a cause. |
SELF |
hasNoSuppressedExceptions()
Verifies that the actual
Throwable has no suppressed exceptions. |
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). |
SELF |
hasRootCauseExactlyInstanceOf(Class<? extends Throwable> type)
Verifies that the root cause of the actual
Throwable is exactly an instance of the given type. |
SELF |
hasRootCauseInstanceOf(Class<? extends Throwable> type)
Verifies that the root cause of the actual
Throwable is an instance of the given type. |
SELF |
hasRootCauseMessage(String message)
Verifies that the message of the root cause of the actual
Throwable is equal to the given one. |
SELF |
hasRootCauseMessage(String message,
Object... parameters)
Verifies that the message of the root cause of the actual
Throwable is equal to the given one, after
being formatted using String.format(String, Object...) method. |
SELF |
hasStackTraceContaining(String description)
Verifies that the stack trace of the actual
Throwable contains the given description. |
SELF |
hasStackTraceContaining(String description,
Object... parameters)
Verifies that the stack trace of the actual
Throwable contains the given description, after being formatted using
the String.format(java.lang.String, java.lang.Object...) method. |
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). |
AbstractStringAssert<?> |
message()
A shortcut for
extracting(Throwable::getMessage, as(InstanceOfAssertFactories.STRING)) which allows
to extract a throwable's message and then execute assertions on it. |
AbstractThrowableAssert<?,?> |
rootCause()
Returns a new assertion object that uses the root cause of the current Throwable as the actual Throwable under test.
|
as, as, doesNotReturn, extracting, extracting, extracting, extracting, extracting, extracting, extractingForProxy, getComparatorsByType, hasAllNullFieldsOrProperties, hasAllNullFieldsOrPropertiesExcept, hasFieldOrProperty, hasFieldOrPropertyWithValue, hasNoNullFieldsOrProperties, hasNoNullFieldsOrPropertiesExcept, hasOnlyFields, isEqualToComparingFieldByField, isEqualToComparingFieldByFieldRecursively, isEqualToComparingOnlyGivenFields, isEqualToIgnoringGivenFields, isEqualToIgnoringNullFields, newObjectAssert, returns, usingComparatorForFields, usingComparatorForType, usingRecursiveComparison, usingRecursiveComparisonareEqual, asInstanceOf, asList, assertionError, asString, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, doesNotHaveSameHashCodeAs, doesNotHaveToString, equals, extracting, extracting, failure, failureWithActualExpected, failWithActualExpectedAndMessage, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isElementOfCustomAssert, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, overridingErrorMessage, satisfies, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, satisfiesAnyOfForProxy, satisfiesForProxy, setCustomRepresentation, setDescriptionConsumer, setPrintAssertionsDescription, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, withFailMessage, withFailMessage, withRepresentation, withThreadDumpOnErrorclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitas, describedAsprotected SELF hasBeenThrown()
public SELF hasMessage(String message)
Throwable is equal to the given one.message - the expected message.AssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable is not equal to the given one.public SELF hasMessage(String message, Object... parameters)
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");message - a format string representing the expected messageparameters - argument referenced by the format specifiers in the format stringAssertionError - 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...).public SELF hasCause(Throwable cause)
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()cause - the expected causeAssertionError - if the actual Throwable is null.AssertionError - if the actual Throwable has not the given cause.public SELF hasCauseReference(Throwable expected)
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()expected - the expected causeAssertionError - 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)public SELF hasNoCause()
Throwable does not have a cause.AssertionError - if the actual Throwable is null.AssertionError - if the actual Throwable has a cause.public AbstractThrowableAssert<?,?> cause()
Examples:
Throwable cause = new IllegalArgumentException("wrong amount 123");
Throwable exception = new Exception("boom!", cause);
// typical use:
assertThat(throwableWithMessage).cause()
.hasMessageStartingWith("wrong amount");AssertionError - if the actual Throwable is null.AssertionError - if the actual Throwable does not have a cause.@Deprecated public AbstractThrowableAssert<?,?> getCause()
cause() instead.
Returns a new assertion object that uses the cause of the current Throwable as the actual Throwable under test.
Examples:
Throwable cause = new IllegalArgumentException("wrong amount 123");
Throwable exception = new Exception("boom!", cause);
// typical use:
assertThat(throwableWithMessage).getCause()
.hasMessageStartingWith("wrong amount");AssertionError - if the actual Throwable is null.AssertionError - if the actual Throwable does not have a cause.public AbstractThrowableAssert<?,?> rootCause()
Examples:
Throwable rootCause = new JdbcException("invalid query");
Throwable cause = new RuntimeException(rootCause);
Throwable exception = new Exception("boom!", cause);
// typical use:
assertThat(throwableWithMessage).rootCause()
.hasMessageStartingWith("invalid");AssertionError - if the actual Throwable is null.AssertionError - if the actual Throwable does not have a root cause.@Deprecated public AbstractThrowableAssert<?,?> getRootCause()
rootCause() instead.
Returns a new assertion object that uses the root cause of the current Throwable as the actual Throwable under test.
Examples:
Throwable rootCause = new JdbcException("invalid query");
Throwable cause = new RuntimeException(rootCause);
Throwable exception = new Exception("boom!", cause);
// typical use:
assertThat(throwableWithMessage).getRootCause()
.hasMessageStartingWith("invalid");AssertionError - if the actual Throwable is null.AssertionError - if the actual Throwable does not have a root cause.public SELF hasMessageStartingWith(String description)
Throwable starts with the given description.
Examples:
Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
// assertion will pass:
assertThat(throwableWithMessage).hasMessageStartingWith("wrong amount");
// assertions will fail:
assertThat(throwableWithMessage).hasMessageStartingWith("right amount"); description - the description expected to start the actual Throwable's message.AssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable does not start with the given description.public SELF hasMessageStartingWith(String description, Object... parameters)
Throwable starts with the given description, after being formatted using
the String.format(java.lang.String, java.lang.Object...) method.
Examples:
Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
// assertion will pass:
assertThat(throwableWithMessage).hasMessageStartingWith("%s amount", "wrong");
// assertions will fail:
assertThat(throwableWithMessage).hasMessageStartingWith("%s amount", "right"); description - the description expected to start the actual Throwable's message.parameters - argument referenced by the format specifiers in the format stringAssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable does not start with the given description.IllegalFormatException - if the message contains an illegal syntax according to String.format(String, Object...).public SELF hasMessageContaining(String description)
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"); description - the description expected to be contained in the actual Throwable's message.AssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable does not contain the given description.public SELF hasMessageContaining(String description, Object... parameters)
Throwable contains the given description, after being formatted using
the String.format(java.lang.String, java.lang.Object...) method.
Examples:
Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
Throwable throwableWithoutMessage = new IllegalArgumentException();
// assertion will pass:
assertThat(throwableWithMessage).hasMessageContaining("amount %d", 123);
// assertions will fail:
assertThat(throwableWithoutMessage).hasMessageContaining("amount %d", 123);
assertThat(throwableWithMessage).hasMessageContaining("%s amount", "right"); description - the description expected to be contained in the actual Throwable's message.parameters - argument referenced by the format specifiers in the format stringAssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable does not contain the given description.IllegalFormatException - if the message contains an illegal syntax according to String.format(String, Object...).public SELF hasMessageContainingAll(CharSequence... values)
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"); values - the Strings expected to be contained in the actual Throwable's message.AssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable does not contain all the given values.public SELF hasMessageNotContaining(String content)
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");content - the content expected not to be contained in the actual Throwable's message.AssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable contains the given content.public SELF hasMessageNotContainingAny(CharSequence... values)
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");values - the contents expected to not be contained in the actual Throwable's message.AssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable contains any of the given values.public SELF hasStackTraceContaining(String description)
Throwable contains the given description.
Examples:
Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
// assertion will pass
assertThat(throwableWithMessage).hasStackTraceContaining("amount 123");
// assertion will fail
assertThat(throwableWithMessage).hasStackTraceContaining("456");description - the description expected to be contained in the actual Throwable's stack trace.AssertionError - if the actual Throwable is null.AssertionError - if the stack trace of the actual Throwable does not contain the given description.public SELF hasStackTraceContaining(String description, Object... parameters)
Throwable contains the given description, after being formatted using
the String.format(java.lang.String, java.lang.Object...) method.
Examples:
Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
// assertion will pass
assertThat(throwableWithMessage).hasStackTraceContaining("%s", amount);
// assertion will fail
assertThat(throwableWithMessage).hasStackTraceContaining("%d", 456);description - the description expected to be contained in the actual Throwable's stack trace.parameters - argument referenced by the format specifiers in the format stringAssertionError - if the actual Throwable is null.AssertionError - if the stack trace of the actual Throwable does not contain the given description.IllegalFormatException - if the message contains an illegal syntax according to String.format(String, Object...).public SELF hasMessageMatching(String regex)
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");regex - the regular expression of value expected to be matched the actual Throwable's message.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 nullpublic SELF hasMessageFindingMatch(String regex)
Throwable matches with
the given regular expression (see Matcher.find()).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$");regex - the regular expression expected to be found in the actual Throwable's message.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 expressionNullPointerException - if the regex is nullpublic SELF hasMessageEndingWith(String description)
Throwable ends with the given description.
Examples:
Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
// assertion will pass
assertThat(throwableWithMessage).hasMessageEndingWith("123");
// assertion will fail
assertThat(throwableWithMessage).hasMessageEndingWith("456");description - the description expected to end the actual Throwable's message.AssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable does not end with the given description.public SELF hasMessageEndingWith(String description, Object... parameters)
Throwable ends with the given description, after being formatted using
the String.format(java.lang.String, java.lang.Object...) method.
Examples:
Throwable throwableWithMessage = new IllegalArgumentException("wrong amount 123");
// assertion will pass
assertThat(throwableWithMessage).hasMessageEndingWith("%s 123", "amount");
// assertion will fail
assertThat(throwableWithMessage).hasMessageEndingWith("amount %d", 456);description - the description expected to end the actual Throwable's message.parameters - argument referenced by the format specifiers in the format stringAssertionError - if the actual Throwable is null.AssertionError - if the message of the actual Throwable does not end with the given description.IllegalFormatException - if the message contains an illegal syntax according to String.format(String, Object...).public SELF hasCauseInstanceOf(Class<? extends Throwable> type)
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);type - the expected cause type.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.public SELF hasCauseExactlyInstanceOf(Class<? extends Throwable> type)
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);type - the expected cause type.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.public SELF hasRootCause(Throwable cause)
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()cause - the expected root causeAssertionError - if the actual Throwable is null.AssertionError - if the actual Throwable has not the given cause.public SELF hasRootCauseInstanceOf(Class<? extends Throwable> type)
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);type - the expected cause type.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.public SELF hasRootCauseExactlyInstanceOf(Class<? extends Throwable> type)
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);type - the expected cause type.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.public SELF hasRootCauseMessage(String message)
Throwable is equal to the given one.
Example:
Throwable throwable = new Throwable(new IllegalStateException(new NullPointerException("object")));
// assertion will pass
assertThat(throwable).hasRootCauseMessage("object");
// assertions will fail
assertThat((Throwable) null).hasRootCauseMessage("object");
assertThat(throwable).hasRootCauseMessage("another object");
assertThat(new Throwable()).hasRootCauseMessage("object");
assertThat(new Throwable(new NullPointerException())).hasRootCauseMessage("object");message - the expected root cause message.AssertionError - if the actual Throwable is null.AssertionError - if the root cause of the actual Throwable is null.AssertionError - if the message of the root cause of the actual Throwable is not equal to
the given one.public SELF hasRootCauseMessage(String message, Object... parameters)
Throwable is equal to the given one, after
being formatted using String.format(String, Object...) method.
Example:
Throwable throwable = new Throwable(new IllegalStateException(new NullPointerException("expected message")));
// assertion will pass
assertThat(throwable).hasRootCauseMessage("%s %s", "expected", "message");
// assertions will fail
assertThat((Throwable) null).hasRootCauseMessage("%s %s", "expected", "message");
assertThat(throwable).hasRootCauseMessage("%s", "message");
assertThat(new Throwable()).hasRootCauseMessage("%s %s", "expected", "message");
assertThat(new Throwable(new NullPointerException())).hasRootCauseMessage("%s %s", "expected", "message");message - the expected root cause message.parameters - argument referenced by the format specifiers in the format string.AssertionError - if the actual Throwable is null.AssertionError - if the root cause of the actual Throwable is null.AssertionError - if the message of the root cause 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...).public SELF hasNoSuppressedExceptions()
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();NullPointerException - if given type is null.AssertionError - if the actual Throwable has any suppressed exceptions.public SELF hasSuppressedException(Throwable suppressedException)
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());suppressedException - the expected suppressed exceptionAssertionError - if the actual Throwable is null.AssertionError - if the actual Throwable does not have the given suppressed exception.public void doesNotThrowAnyException()
ThrowableAssert.ThrowingCallable didn't raise a throwable.
Example :
assertThatCode(() -> foo.bar()).doesNotThrowAnyException();AssertionError - if the actual statement raised a Throwable.public AbstractStringAssert<?> message()
extracting(Throwable::getMessage, as(InstanceOfAssertFactories.STRING)) which allows
to extract a throwable's message and then execute assertions on it.
Note that once you have navigated to the throwable's message you can't navigate back to the throwable.
Example :
Throwable throwable = new Throwable("boom!");
// assertions succeed:
assertThat(throwable).message().startsWith("boo")
.endsWith("!");
// assertion fails:
assertThat(throwable).message().isEmpty();StringAssert on the throwable message.Copyright © 2025. All rights reserved.