AbstractThrowableAssert (AssertJ fluent assertions 3.12.2 API)

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.

Author:

David DIDIER, Alex Ruiz, Joel Costigliola, Mikhail Mazursky, Jack Gough

Field Summary
- Fields inherited from class org.assertj.core.api.AbstractAssert
  actual, info, myself, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors
Constructor and Description

AbstractThrowableAssert(ACTUAL actual, Class<?> selfType)

Constructors
Constructor and Description
`AbstractThrowableAssert(ACTUAL actual, Class<?> selfType)`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`doesNotThrowAnyException()` Verifies that the `ThrowableAssert.ThrowingCallable` didn't raise a throwable.
`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`	`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`	`hasMessageEndingWith(String description)` Verifies that the message of the actual `Throwable` ends with the given description.
`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`	`hasMessageStartingWith(String description)` Verifies that the message of the actual `Throwable` starts with the given description.
`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`	`hasStackTraceContaining(String description)` Verifies that the stack trace of the actual `Throwable` contains the given description.
`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).

Methods inherited from class org.assertj.core.api.AbstractAssert
asList, asString, describedAs, describedAs, descriptionText, doesNotHave, doesNotHaveSameClassAs, equals, failWithMessage, getWritableAssertionInfo, has, hashCode, hasSameClassAs, hasSameHashCodeAs, hasToString, inBinary, inHexadecimal, is, isEqualTo, isExactlyInstanceOf, isIn, isIn, isInstanceOf, isInstanceOfAny, isInstanceOfSatisfying, isNot, isNotEqualTo, isNotExactlyInstanceOf, isNotIn, isNotIn, isNotInstanceOf, isNotInstanceOfAny, isNotNull, isNotOfAnyClassIn, isNotSameAs, isNull, isOfAnyClassIn, isSameAs, matches, matches, newListAssertInstance, overridingErrorMessage, satisfies, satisfies, satisfiesAnyOf, satisfiesAnyOf, setCustomRepresentation, throwAssertionError, usingComparator, usingComparator, usingDefaultComparator, withFailMessage, withRepresentation, withThreadDumpOnError

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

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

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

Field Summary

Fields inherited from class org.assertj.core.api.AbstractAssert

Constructor Summary

Method Summary

Methods inherited from class org.assertj.core.api.AbstractObjectAssert

Methods inherited from class org.assertj.core.api.AbstractAssert

Methods inherited from class java.lang.Object

Constructor Detail

AbstractThrowableAssert

Method Detail

hasBeenThrown

hasMessage

hasMessage

hasCause

hasNoCause

hasMessageStartingWith

hasMessageContaining

hasMessageNotContaining

hasStackTraceContaining

hasMessageMatching

hasMessageFindingMatch

hasMessageEndingWith

hasCauseInstanceOf

hasCauseExactlyInstanceOf

hasRootCause

hasRootCauseInstanceOf

hasRootCauseExactlyInstanceOf

hasNoSuppressedExceptions

hasSuppressedException

doesNotThrowAnyException