org.assertj.core.api

Class ThrowableAssertAlternative<ACTUAL extends Throwable>

java.lang.Object

org.assertj.core.api.AbstractAssert<SELF,ACTUAL>

org.assertj.core.api.AbstractObjectAssert<ThrowableAssertAlternative<ACTUAL>,ACTUAL>

org.assertj.core.api.ThrowableAssertAlternative<ACTUAL>

All Implemented Interfaces:

Assert<ThrowableAssertAlternative<ACTUAL>,ACTUAL>, Descriptable<ThrowableAssertAlternative<ACTUAL>>, ExtensionPoints<ThrowableAssertAlternative<ACTUAL>,ACTUAL>

Direct Known Subclasses:

SoftThrowableAssertAlternative

public class ThrowableAssertAlternative<ACTUAL extends Throwable>
extends AbstractObjectAssert<ThrowableAssertAlternative<ACTUAL>,ACTUAL>

Assertion methods for Throwable similar to ThrowableAssert but with assertions methods named differently to make testing code fluent (ex : withMessage instead of hasMessage.

 assertThatExceptionOfType(IOException.class)
           .isThrownBy(() -> { throw new IOException("boom! tcha!"); });
           .withMessage("boom! %s", "tcha!"); 

This class is linked with the ThrowableTypeAssert and allow to check that an exception type is thrown by a lambda.

Field Summary

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

actual, info, myself, objects, throwUnsupportedExceptionOnEquals

Constructor Summary

Constructors

Constructor and Description
ThrowableAssertAlternative(ACTUAL actual)

Method Summary

Modifier and Type	Method and Description
ThrowableAssertAlternative<ACTUAL>	as(Description description) Sets the description of the assertion that is going to be called after.
ThrowableAssertAlternative<ACTUAL>	describedAs(Description description) Sets the description of the assertion that is going to be called after.
ThrowableAssertAlternative<ACTUAL>	describedAs(String description, Object... args) Sets the description of the assertion that is going to be called after.
protected ThrowableAssert<ACTUAL>	getDelegate()
ThrowableAssertAlternative<?>	havingCause() Checks if the actual Throwable has a cause and returns a new assertion object where the cause becomes the actual Throwable in order to further assert properties of the cause Throwable
ThrowableAssertAlternative<?>	havingRootCause() Checks if the actual Throwable has a root cause and returns a new assertion object where the root cause becomes the actual Throwable in order to further assert properties of the cause Throwable
ThrowableAssertAlternative<ACTUAL>	withCause(Throwable cause) Verifies that the actual Throwable has a cause similar to the given one, that is with same type and message (it does not use equals method for comparison).
ThrowableAssertAlternative<ACTUAL>	withCauseExactlyInstanceOf(Class<? extends Throwable> type) Verifies that the cause of the actual Throwable is exactly an instance of the given type.
ThrowableAssertAlternative<ACTUAL>	withCauseInstanceOf(Class<? extends Throwable> type) Verifies that the cause of the actual Throwable is an instance of the given type.
ThrowableAssertAlternative<ACTUAL>	withMessage(String message) Verifies that the message of the actual Throwable is equal to the given one.
ThrowableAssertAlternative<ACTUAL>	withMessage(String message, Object... parameters) Verifies that the message of the actual Throwable is equal to the given one built using String.format(String, Object...) syntax.
ThrowableAssertAlternative<ACTUAL>	withMessageContaining(String description) Verifies that the message of the actual Throwable contains the given description.
ThrowableAssertAlternative<ACTUAL>	withMessageContaining(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.
ThrowableAssertAlternative<ACTUAL>	withMessageContainingAll(CharSequence... values) Verifies that the message of the actual Throwable contains all the given values.
ThrowableAssertAlternative<ACTUAL>	withMessageEndingWith(String description) Verifies that the message of the actual Throwable ends with the given description.
ThrowableAssertAlternative<ACTUAL>	withMessageEndingWith(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.
ThrowableAssertAlternative<ACTUAL>	withMessageMatching(String regex) Verifies that the message of the actual Throwable matches with the given regular expression.
ThrowableAssertAlternative<ACTUAL>	withMessageNotContaining(String content) Verifies that the message of the actual Throwable does not contain the given content or is null.
ThrowableAssertAlternative<ACTUAL>	withMessageNotContainingAny(CharSequence... values) Verifies that the message of the actual Throwable does not contain any of the given values or is null.
ThrowableAssertAlternative<ACTUAL>	withMessageStartingWith(String description) Verifies that the message of the actual Throwable starts with the given description.
ThrowableAssertAlternative<ACTUAL>	withMessageStartingWith(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.
ThrowableAssertAlternative<ACTUAL>	withNoCause() Verifies that the actual Throwable does not have a cause.
ThrowableAssertAlternative<ACTUAL>	withRootCauseExactlyInstanceOf(Class<? extends Throwable> type) Verifies that the root cause of the actual Throwable is exactly an instance of the given type.
ThrowableAssertAlternative<ACTUAL>	withRootCauseInstanceOf(Class<? extends Throwable> type) Verifies that the root cause of the actual Throwable is an instance of the given type.
ThrowableAssertAlternative<ACTUAL>	withStackTraceContaining(String description) Verifies that the stack trace of the actual Throwable contains with the given description.
ThrowableAssertAlternative<ACTUAL>	withStackTraceContaining(String description, Object... parameters) Verifies that the stack trace of the actual Throwable contains with the given description, after being formatted using the String.format(java.lang.String, java.lang.Object...) method.

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

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, usingRecursiveComparison

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

areEqual, asInstanceOf, asList, assertionError, asString, 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, withThreadDumpOnError

Methods inherited from class java.lang.Object

clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface org.assertj.core.api.Descriptable

as

Constructor Detail

ThrowableAssertAlternative

public ThrowableAssertAlternative(ACTUAL actual)

Method Detail

getDelegate

protected ThrowableAssert<ACTUAL> getDelegate()

as

public ThrowableAssertAlternative<ACTUAL> as(Description description)

Description copied from interface: Descriptable

Sets the description of the assertion that is going to be called after.

You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.

This overloaded version of "describedAs" offers more flexibility than the one taking a String by allowing users to pass their own implementation of a description. For example, a description that creates its value lazily, only when an assertion failure occurs.

Specified by:

as in interface Descriptable<ThrowableAssertAlternative<ACTUAL extends Throwable>>

Overrides:

as in class AbstractObjectAssert<ThrowableAssertAlternative<ACTUAL extends Throwable>,ACTUAL extends Throwable>

Parameters:

description - the new description to set.

Returns:

this object.

See Also:

Descriptable.describedAs(Description)

withMessage

public ThrowableAssertAlternative<ACTUAL> withMessage(String message)

Verifies that the message of the actual Throwable is equal to the given one.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessage("wrong amount 123");

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessage("wrong amount 123 euros");

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.

See Also:

AbstractThrowableAssert.hasMessage(String)

withMessage

public ThrowableAssertAlternative<ACTUAL> withMessage(String message,
                                                      Object... parameters)

Verifies that the message of the actual Throwable is equal to the given one built using String.format(String, Object...) syntax.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessage("wrong amount %s, "123");

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessage("wrong amount 123 euros");

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.

See Also:

AbstractThrowableAssert.hasMessage(String)

withCause

public ThrowableAssertAlternative<ACTUAL> withCause(Throwable cause)

Verifies that the actual Throwable has a cause similar to the given one, that is with same type and message (it does not use equals method for comparison).

Example:

 Throwable illegalArgumentException = new IllegalArgumentException("invalid arg");
 Throwable wrappingException = new Throwable(illegalArgumentException);

 // This assertion succeeds:

 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw wrappingException;})
           .withCause(illegalArgumentException);

 // These assertions fail:

 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw wrappingException;})
           .withCause(new IllegalArgumentException("bad arg"));

 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw wrappingException;})
           .withCause(new NullPointerException());

 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw wrappingException;})
           .withCause(null);

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.

See Also:

AbstractThrowableAssert.hasCause(Throwable)

withNoCause

public ThrowableAssertAlternative<ACTUAL> withNoCause()

Verifies that the actual Throwable does not have a cause.

Example:

 IllegalArgumentException exception = new IllegalArgumentException();

 // This assertion succeeds:
 assertThatExceptionOfType(IllegalArgumentException.class)
           .isThrownBy(() -> {throw exception;})
           .withNoCause();

 // These assertion fails:
 Throwable illegalArgumentException = new Throwable(exception);
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withNoCause();

Returns:

this assertion object.

Throws:

AssertionError - if the actual Throwable is null.

AssertionError - if the actual Throwable has a cause.

See Also:

AbstractThrowableAssert.hasNoCause()

withMessageStartingWith

public ThrowableAssertAlternative<ACTUAL> withMessageStartingWith(String description)

Verifies that the message of the actual Throwable starts with the given description.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageStartingWith("wrong amount");

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageStartingWith("right amount");

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.

See Also:

AbstractThrowableAssert.hasMessageStartingWith(String)

withMessageStartingWith

public ThrowableAssertAlternative<ACTUAL> withMessageStartingWith(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.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageStartingWith("%s amount", "wrong");

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageStartingWith("%s amount", "right");

Parameters:

description - the description expected to start the actual Throwable's 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 does not start with the given description.

IllegalFormatException - if the message contains an illegal syntax according to String.format(String, Object...).

See Also:

AbstractThrowableAssert.hasMessageStartingWith(String, Object...)

withMessageContaining

public ThrowableAssertAlternative<ACTUAL> withMessageContaining(String description)

Verifies that the message of the actual Throwable contains the given description.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageContaining("amount");

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageContaining("456");

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.

See Also:

AbstractThrowableAssert.hasMessageContaining(String)

withMessageContaining

public ThrowableAssertAlternative<ACTUAL> withMessageContaining(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.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageContaining("%s", amount);

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageContaining("%d", 456);

Parameters:

description - the description expected to be contained in the actual Throwable's 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 does not contain the given description.

IllegalFormatException - if the message contains an illegal syntax according to String.format(String, Object...).

See Also:

AbstractThrowableAssert.hasMessageContaining(String, Object...)

withMessageContainingAll

public ThrowableAssertAlternative<ACTUAL> withMessageContainingAll(CharSequence... values)

Verifies that the message of the actual Throwable contains all the given values.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageContainingAll("amount", "123");

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageContainingAll("456");

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.

See Also:

AbstractThrowableAssert.hasMessageContainingAll(CharSequence...)

withMessageNotContaining

public ThrowableAssertAlternative<ACTUAL> withMessageNotContaining(String content)

Verifies that the message of the actual Throwable does not contain the given content or is null.

Examples:

 //assertions will pass
 assertThatExceptionOfType(Exception.class)
           .isThrownBy(codeThrowing(new Exception("boom")))
           .withMessageNotContaining("bam");

 assertThatExceptionOfType(Exception.class)
           .isThrownBy(codeThrowing(new Exception()))
           .withMessageNotContaining("bam");

 //assertion fails:
 assertThatExceptionOfType(Exception.class)
           .isThrownBy(codeThrowing(new Exception("boom")))
           .withMessageNotContaining("boom");

Parameters:

content - the content expected to not 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.

See Also:

AbstractThrowableAssert.hasMessageNotContaining(String)

withMessageNotContainingAny

public ThrowableAssertAlternative<ACTUAL> withMessageNotContainingAny(CharSequence... values)

Verifies that the message of the actual Throwable does not contain any of the given values or is null.

Examples:

 //assertions will pass
 assertThatExceptionOfType(Exception.class)
           .isThrownBy(codeThrowing(new Exception("boom")))
           .withMessageNotContainingAny("bam");

 assertThatExceptionOfType(Exception.class)
           .isThrownBy(codeThrowing(new Exception()))
           .withMessageNotContainingAny("bam");

 // assertion fails:
 assertThatExceptionOfType(Exception.class)
           .isThrownBy(codeThrowing(new Exception("boom")))
           .withMessageNotContainingAny("bam", "boom");

Parameters:

values - the contents expected to not 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 any of the given values.

See Also:

AbstractThrowableAssert.hasMessageNotContainingAny(CharSequence...)

withStackTraceContaining

public ThrowableAssertAlternative<ACTUAL> withStackTraceContaining(String description)

Verifies that the stack trace of the actual Throwable contains with the given description.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withStackTraceContaining("amount");

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withStackTraceContaining("456");

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.

See Also:

AbstractThrowableAssert.hasStackTraceContaining(String)

withStackTraceContaining

public ThrowableAssertAlternative<ACTUAL> withStackTraceContaining(String description,
                                                                   Object... parameters)

Verifies that the stack trace of the actual Throwable contains with the given description, after being formatted using the String.format(java.lang.String, java.lang.Object...) method.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withStackTraceContaining("%s", amount);

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withStackTraceContaining("%d", 456);

Parameters:

description - the description expected to be contained in the actual Throwable's stack trace.

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

See Also:

AbstractThrowableAssert.hasStackTraceContaining(String, Object...)

withMessageMatching

public ThrowableAssertAlternative<ACTUAL> withMessageMatching(String regex)

Verifies that the message of the actual Throwable matches with the given regular expression.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageMatching("wrong amount [0-9]*");

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageMatching("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

See Also:

AbstractThrowableAssert.hasMessageMatching(String)

withMessageEndingWith

public ThrowableAssertAlternative<ACTUAL> withMessageEndingWith(String description)

Verifies that the message of the actual Throwable ends with the given description.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageEndingWith("123");

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageEndingWith("456");

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.

See Also:

AbstractThrowableAssert.hasMessageEndingWith(String)

withMessageEndingWith

public ThrowableAssertAlternative<ACTUAL> withMessageEndingWith(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.

Examples:

 Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageEndingWith("%d", 123);

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw illegalArgumentException;})
           .withMessageEndingWith("%d", 456);

Parameters:

description - the description expected to end the actual Throwable's 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 does not end with the given description.

IllegalFormatException - if the message contains an illegal syntax according to String.format(String, Object...).

See Also:

AbstractThrowableAssert.hasMessageEndingWith(String, Object...)

withCauseInstanceOf

public ThrowableAssertAlternative<ACTUAL> withCauseInstanceOf(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());

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withCauseInstanceOf(NullPointerException.class);
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withCauseInstanceOf(RuntimeException.class);

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withCauseInstanceOf(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.

See Also:

AbstractThrowableAssert.hasCauseInstanceOf(Class)

withCauseExactlyInstanceOf

public ThrowableAssertAlternative<ACTUAL> withCauseExactlyInstanceOf(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 succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withCauseExactlyInstanceOf(NullPointerException.class);

 // assertions will fail (even if NullPointerException is a RuntimeException since we want an exact match)
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withCauseExactlyInstanceOf(RuntimeException.class);
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withCauseExactlyInstanceOf(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.

See Also:

AbstractThrowableAssert.hasCauseExactlyInstanceOf(Class)

withRootCauseInstanceOf

public ThrowableAssertAlternative<ACTUAL> withRootCauseInstanceOf(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()));

 // assertion succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withRootCauseInstanceOf(NullPointerException.class);
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withRootCauseInstanceOf(RuntimeException.class);

 // assertion fails:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withRootCauseInstanceOf(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.

See Also:

AbstractThrowableAssert.hasRootCauseInstanceOf(Class)

withRootCauseExactlyInstanceOf

public ThrowableAssertAlternative<ACTUAL> withRootCauseExactlyInstanceOf(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 succeeds:
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withRootCauseExactlyInstanceOf(NullPointerException.class);

 // assertion fails (even if NullPointerException is a RuntimeException since we want an exact match)
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withRootCauseExactlyInstanceOf(RuntimeException.class);
 assertThatExceptionOfType(Throwable.class)
           .isThrownBy(() -> {throw throwable;})
           .withRootCauseExactlyInstanceOf(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.

See Also:

AbstractThrowableAssert.hasRootCauseExactlyInstanceOf(Class)

describedAs

public ThrowableAssertAlternative<ACTUAL> describedAs(String description,
                                                      Object... args)

Sets the description of the assertion that is going to be called after.

You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.

Alias for Descriptable.as(String, Object...) since "as" is a keyword in Groovy.

Parameters:

description - the new description to set.

args - optional parameter if description is a format String.

Returns:

this object.

describedAs

public ThrowableAssertAlternative<ACTUAL> describedAs(Description description)

Sets the description of the assertion that is going to be called after.

You must set it before calling the assertion otherwise it is ignored as the failing assertion breaks the chained call by throwing an AssertionError.

This overloaded version of "describedAs" offers more flexibility than the one taking a String by allowing users to pass their own implementation of a description. For example, a description that creates its value lazily, only when an assertion failure occurs.

Specified by:

describedAs in interface Descriptable<ThrowableAssertAlternative<ACTUAL extends Throwable>>

Overrides:

describedAs in class AbstractAssert<ThrowableAssertAlternative<ACTUAL extends Throwable>,ACTUAL extends Throwable>

Parameters:

description - the new description to set.

Returns:

this object.

havingCause

public ThrowableAssertAlternative<?> havingCause()

Checks if the actual Throwable has a cause and returns a new assertion object where the cause becomes the actual Throwable in order to further assert properties of the cause Throwable

Returns:

a new assertion object with the cause of the current actual becoming the new actual

Throws:

AssertionError - if the actual Throwable is null.

AssertionError - if the actual Throwable has no cause.

Since:

3.16.0

havingRootCause

public ThrowableAssertAlternative<?> havingRootCause()

Checks if the actual Throwable has a root cause and returns a new assertion object where the root cause becomes the actual Throwable in order to further assert properties of the cause Throwable

Returns:

a new assertion object with the root cause of the current actual becoming the new actual

Throws:

AssertionError - if the actual Throwable is null.

AssertionError - if the actual Throwable has no root cause.

Since:

3.16.0