Package org.apache.juneau.assertions

Class FluentThrowableAssertion<T extends Throwable,R>

java.lang.Object
org.apache.juneau.assertions.Assertion
org.apache.juneau.assertions.FluentAssertion<R>
org.apache.juneau.assertions.FluentObjectAssertion<T,R>
org.apache.juneau.assertions.FluentThrowableAssertion<T,R>
Type Parameters:
T - The throwable type.
R - The return type.
Direct Known Subclasses:
ThrowableAssertion
public class FluentThrowableAssertion<T extends Throwable,R> extends FluentObjectAssertion<T,R>
Used for fluent assertion calls against throwables.
Test Methods:

Transform Methods:

Configuration Methods:

See Also:

  • Constructor Details

    • FluentThrowableAssertion

      public FluentThrowableAssertion(T value, R returns)
      Constructor.
      Parameters:
      value - The object being tested.
      Can be null.
      returns - The object to return after a test method is called.
      If null, the test method returns this object allowing multiple test method calls to be used on the same assertion.

    • FluentThrowableAssertion

      public FluentThrowableAssertion(Assertion creator, T value, R returns)
      Chained constructor.

      Used when transforming one assertion into another so that the assertion config can be used by the new assertion.

      Parameters:
      creator - The assertion that created this assertion.
      Should be null if this is the top-level assertion.
      value - The object being tested.
      Can be null.
      returns - The object to return after a test method is called.
      If null, the test method returns this object allowing multiple test method calls to be used on the same assertion.

  • Method Details

    • asTransformed

      public FluentThrowableAssertion<T,R> asTransformed(Function<T,T> function)
      Description copied from class: FluentObjectAssertion
      Applies a transform on the inner object and returns a new inner object.
      Overrides:
      asTransformed in class FluentObjectAssertion<T extends Throwable,R>
      Parameters:
      function - The function to apply.
      Returns:
      This object.

    • asMessage

      public FluentStringAssertion<R> asMessage()
      Returns an assertion against the throwable message.
      Example:

      // Asserts that the specified method throws an exception // with 'foobar' somewhere in the messages. ThrowableAssertion.assertThrown(() -> foo.getBar()) .asMessage() .isPattern(".*foobar.*");

      Returns:
      An assertion against the throwable message. Never null.

    • asMessages

      public FluentListAssertion<String,R> asMessages()
      Returns an assertion against the throwable message and all caused-by messages.
      Example:

      // Asserts that the specified method throws an exception with // 'foobar' somewhere in the messages. ThrowableAssertion.assertThrown(() -> foo.getBar()) .asMessages() .isPattern(".*foobar.*");

      Returns:
      An assertion against the throwable message. Never null.

    • asLocalizedMessage

      public FluentStringAssertion<R> asLocalizedMessage()
      Returns an assertion against the throwable localized message.
      Example:

      // Asserts that the specified method throws an exception with // 'foobar' somewhere in the localized messages. ThrowableAssertion.assertThrown(() -> foo.getBar()) .asLocalizedMessage() .isPattern(".*foobar.*");

      Returns:
      An assertion against the throwable localized message. Never null.

    • asLocalizedMessages

      public FluentListAssertion<String,R> asLocalizedMessages()
      Returns an assertion against the throwable message and all caused-by messages.
      Example:

      // Asserts that the specified method throws an exception with // 'foobar' somewhere in the messages. ThrowableAssertion.assertThrown(() -> foo.getBar()) .asLocalizedMessages() .isPattern(".*foobar.*");

      Returns:
      An assertion against the throwable message. Never null.

    • asStackTrace

      public FluentStringListAssertion<R> asStackTrace()
      Returns an assertion against the throwable localized message.
      Example:

      // Asserts that the specified method throws an exception with // 'foobar' somewhere in the stack trace. ThrowableAssertion.assertThrown(() -> foo.getBar()) .asStackTrace() .isPattern("foobar");

      Returns:
      An assertion against the throwable stacktrace. Never null.

    • asCausedBy

      public FluentThrowableAssertion<Throwable,R> asCausedBy()
      Returns an assertion against the caused-by throwable.
      Example:

      // Asserts that the specified method throws an exception whose // caused-by message contains 'foobar'. ThrowableAssertion.assertThrown(() -> foo.getBar()) .asCausedBy() .asMessage() .isPattern("foobar");

      Returns:
      An assertion against the caused-by. Never null.

    • asCausedBy

      public <X extends Throwable> FluentThrowableAssertion<X,R> asCausedBy(Class<X> type)
      Returns an assertion against the caused-by throwable.
      Example:

      // Asserts that the specified method throws an exception whose // caused-by message contains 'foobar'. ThrowableAssertion.assertThrown(() -> foo.getBar()) .asCausedBy(RuntimeException.class) .asMessage() .isPattern("foobar");

      Type Parameters:
      X - The throwable type.
      Parameters:
      type - The expected exception type.
      Returns:
      An assertion against the caused-by. Never null.

    • asFind

      public <X extends Throwable> FluentThrowableAssertion<X,R> asFind(Class<X> throwableClass)
      Returns an assertion against the throwable localized message.
      Example:

      // Asserts that the specified method throws an exception with a // caused-by RuntimeException containing 'foobar' ThrowableAssertion.assertThrown(() -> foo.getBar()) .findCausedBy(RuntimeException.class) .isExists() .asMessage() .isPattern("foobar");

      Type Parameters:
      X - The throwable type.
      Parameters:
      throwableClass - The class type to search for in the caused-by chain.
      Returns:
      An assertion against the caused-by throwable. Never null.

    • isType

      public R isType(Class<?> parent)
      Asserts that this throwable is of the specified type.
      Example:

      // Asserts that the specified method throws a RuntimeException. ThrowableAssertion.assertThrown(() -> foo.getBar()) .isType(RuntimeException.class);

      Overrides:
      isType in class FluentObjectAssertion<T extends Throwable,R>
      Parameters:
      parent - The type.
      Returns:
      The fluent return object.

    • isExactType

      public R isExactType(Class<?> type)
      Asserts that this throwable is exactly the specified type.
      Example:

      // Asserts that the specified method throws a RuntimeException. ThrowableAssertion.assertThrown(() -> foo.getBar()) .isExactType(RuntimeException.class);

      Overrides:
      isExactType in class FluentObjectAssertion<T extends Throwable,R>
      Parameters:
      type - The type.
      Returns:
      The fluent return object.

    • isExists

      public R isExists()
      Asserts that this throwable exists.
      Example:

      // Asserts that the specified method throws any exception. ThrowableAssertion.assertThrown(() -> foo.getBar()).isExists();

      Overrides:
      isExists in class FluentObjectAssertion<T extends Throwable,R>
      Returns:
      The fluent return object.

    • setMsg

      public FluentThrowableAssertion<T,R> setMsg(String msg, Object... args)
      Description copied from class: Assertion
      Allows you to override the assertion failure message.

      String can contain "{msg}" to represent the original message.

      Example:

      import static org.apache.juneau.assertions.Assertions.*; // Throws an assertion with a custom message instead of the default "Value was null." assertString(myString) .setMsg("My string was bad: {msg}") .isNotNull();

      Overrides:
      setMsg in class FluentObjectAssertion<T extends Throwable,R>
      Parameters:
      msg - The assertion failure message.
      args - Optional message arguments.
      Returns:
      This object.

    • setOut

      public FluentThrowableAssertion<T,R> setOut(PrintStream value)
      Description copied from class: Assertion
      If an error occurs, send the error message to the specified stream instead of STDERR.
      Overrides:
      setOut in class FluentObjectAssertion<T extends Throwable,R>
      Parameters:
      value - The output stream. Can be null to suppress output.
      Returns:
      This object.

    • setSilent

      public FluentThrowableAssertion<T,R> setSilent()
      Description copied from class: Assertion
      Suppresses output to STDERR.

      This is the equivalent to calling out(null).

      Overrides:
      setSilent in class FluentObjectAssertion<T extends Throwable,R>
      Returns:
      This object.

    • setStdOut

      public FluentThrowableAssertion<T,R> setStdOut()
      Description copied from class: Assertion
      If an error occurs, send the error message to STDOUT instead of STDERR.
      Overrides:
      setStdOut in class FluentObjectAssertion<T extends Throwable,R>
      Returns:
      This object.

    • setThrowable

      public FluentThrowableAssertion<T,R> setThrowable(Class<? extends RuntimeException> value)
      Description copied from class: Assertion
      If an error occurs, throw this exception instead of the standard AssertionError.

      The throwable class must have a public constructor that takes in any of the following parameters:

      • Throwable - The caused-by exception (if there is one).
      • String - The assertion failure message.

      If the throwable cannot be instantiated, a RuntimeException is thrown instead.

      Example:

      import static org.apache.juneau.assertions.Assertions.*; // Throws a BadRequest instead of an AssertionError if the string is null. assertString(myString) .setThrowable(BadRequest.class) .isNotNull();

      Overrides:
      setThrowable in class FluentObjectAssertion<T extends Throwable,R>
      Parameters:
      value - The new value for this setting.
      Returns:
      This object.

    • equals

      protected boolean equals(Object o1, Object o2)
      Description copied from class: FluentObjectAssertion
      Checks two objects for equality.
      Overrides:
      equals in class FluentObjectAssertion<T extends Throwable,R>
      Parameters:
      o1 - The first object.
      o2 - The second object.
      Returns:
      true if the objects are equal.