Class ThrowableAssertAlternative<T extends java.lang.Throwable>

    • Constructor Detail

      • ThrowableAssertAlternative

        ThrowableAssertAlternative​(T actual)
    • Method Detail

      • withMessage

        public ThrowableAssertAlternative<T> withMessage​(java.lang.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 will pass
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw illegalArgumentException;})
                   .withMessage("wrong amount 123");
        
         // assertion will fail
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw illegalArgumentException;})
                   .withMessage("wrong amount 123 euros");
        Parameters:
        message - the expected message.
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the message of the actual Throwable is not equal to the given one.
        See Also:
        AbstractThrowableAssert.hasMessage(String)
      • withMessage

        public ThrowableAssertAlternative<T> withMessage​(java.lang.String message,
                                                         java.lang.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 will pass
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw illegalArgumentException;})
                   .withMessage("wrong amount %s, "123");
        
         // assertion will fail
         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:
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the message of the actual Throwable is not equal to the given one.
        See Also:
        AbstractThrowableAssert.hasMessage(String)
      • withCause

        public ThrowableAssertAlternative<T> withCause​(java.lang.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);
        Returns:
        this assertion object.
        Throws:
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the actual Throwable has not the given cause.
        See Also:
        AbstractThrowableAssert.hasCause(Throwable)
      • withNoCause

        public ThrowableAssertAlternative<T> 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:
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the actual Throwable has a cause.
        See Also:
        AbstractThrowableAssert.hasNoCause()
      • withMessageStartingWith

        public ThrowableAssertAlternative<T> withMessageStartingWith​(java.lang.String description)
        Verifies that the message of the actual Throwable starts with the given description.

        Examples:

         Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");
        
         // assertion will pass
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw illegalArgumentException;})
                   .withMessageStartingWith("wrong amount");
        
         // assertion will fail
         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:
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the message of the actual Throwable does not start with the given description.
        See Also:
        AbstractThrowableAssert.hasMessageStartingWith(String)
      • withMessageContaining

        public ThrowableAssertAlternative<T> withMessageContaining​(java.lang.String description)
        Verifies that the message of the actual Throwable contains with the given description.

        Examples:

         Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");
        
         // assertion will pass
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw illegalArgumentException;})
                   .withMessageContaining("amount");
        
         // assertion will fail
         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:
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the message of the actual Throwable does not contain the given description.
        See Also:
        AbstractThrowableAssert.hasMessageContaining(String)
      • withStackTraceContaining

        public ThrowableAssertAlternative<T> withStackTraceContaining​(java.lang.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 will pass
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw illegalArgumentException;})
                   .withStackTraceContaining("amount");
        
         // assertion will fail
         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:
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the stack trace of the actual Throwable does not contain the given description.
        See Also:
        AbstractThrowableAssert.hasStackTraceContaining(String)
      • withMessageMatching

        public ThrowableAssertAlternative<T> withMessageMatching​(java.lang.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 will pass
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw illegalArgumentException;})
                   .withMessageMatching("wrong amount [0-9]*");
        
         // assertion will fail
         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:
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the message of the actual Throwable does not match the given regular expression.
        java.lang.NullPointerException - if the regex is null
        See Also:
        AbstractThrowableAssert.hasMessageMatching(String)
      • withMessageEndingWith

        public ThrowableAssertAlternative<T> withMessageEndingWith​(java.lang.String description)
        Verifies that the message of the actual Throwable ends with the given description.

        Examples:

         Throwable illegalArgumentException = new IllegalArgumentException("wrong amount 123");
        
         // assertion will pass
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw illegalArgumentException;})
                   .withMessageEndingWith("123");
        
         // assertion will fail
         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:
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the message of the actual Throwable does not end with the given description.
        See Also:
        AbstractThrowableAssert.hasMessageEndingWith(String)
      • withCauseInstanceOf

        public ThrowableAssertAlternative<T> withCauseInstanceOf​(java.lang.Class<? extends java.lang.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 will pass
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw throwable;})
                   .withCauseInstanceOf(NullPointerException.class);
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw throwable;})
                   .withCauseInstanceOf(RuntimeException.class);
        
         // assertion will fail
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw throwable;})
                   .withCauseInstanceOf(IllegalArgumentException.class);
        Parameters:
        type - the expected cause type.
        Returns:
        this assertion object.
        Throws:
        java.lang.NullPointerException - if given type is null.
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the actual Throwable has no cause.
        java.lang.AssertionError - if the cause of the actual Throwable is not an instance of the given type.
        See Also:
        AbstractThrowableAssert.hasCauseInstanceOf(Class)
      • withCauseExactlyInstanceOf

        public ThrowableAssertAlternative<T> withCauseExactlyInstanceOf​(java.lang.Class<? extends java.lang.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
         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:
        java.lang.NullPointerException - if given type is null.
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the actual Throwable has no cause.
        java.lang.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<T> withRootCauseInstanceOf​(java.lang.Class<? extends java.lang.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 will pass
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw throwable;})
                   .withRootCauseInstanceOf(NullPointerException.class);
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw throwable;})
                   .withRootCauseInstanceOf(RuntimeException.class);
        
         // assertion will fail
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw throwable;})
                   .withRootCauseInstanceOf(IllegalStateException.class);
        Parameters:
        type - the expected cause type.
        Returns:
        this assertion object.
        Throws:
        java.lang.NullPointerException - if given type is null.
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the actual Throwable has no cause.
        java.lang.AssertionError - if the cause of the actual Throwable is not an instance of the given type.
        See Also:
        AbstractThrowableAssert.hasRootCauseInstanceOf(Class)
      • withRootCauseExactlyInstanceOf

        public ThrowableAssertAlternative<T> withRootCauseExactlyInstanceOf​(java.lang.Class<? extends java.lang.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
         assertThatExceptionOfType(Throwable.class)
                   .isThrownBy(() -> {throw throwable;})
                   .withRootCauseExactlyInstanceOf(NullPointerException.class);
        
         // assertion will fail (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:
        java.lang.NullPointerException - if given type is null.
        java.lang.AssertionError - if the actual Throwable is null.
        java.lang.AssertionError - if the actual Throwable has no cause.
        java.lang.AssertionError - if the root cause of the actual Throwable is not exactly an instance of the given type.
        See Also:
        AbstractThrowableAssert.hasRootCauseExactlyInstanceOf(Class)