AbstractCompletableFutureAssert (AssertJ fluent assertions 3.23.1 API)

java.lang.Object
- org.assertj.core.api.AbstractAssert<SELF,CompletableFuture<RESULT>>
- - org.assertj.core.api.AbstractCompletableFutureAssert<SELF,RESULT>

Type Parameters:

RESULT - type of the value contained in the CompletableFuture.

All Implemented Interfaces:

Assert<SELF,CompletableFuture<RESULT>>, Descriptable<SELF>, ExtensionPoints<SELF,CompletableFuture<RESULT>>

Direct Known Subclasses:

CompletableFutureAssert
```
public abstract class AbstractCompletableFutureAssert<SELF extends AbstractCompletableFutureAssert<SELF,RESULT>,RESULT>
extends AbstractAssert<SELF,CompletableFuture<RESULT>>
```
Assertions for CompletableFuture.

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

Constructor Summary

Constructors
Modifier Constructor and Description

protected AbstractCompletableFutureAssert(CompletableFuture<RESULT> actual, Class<?> selfType)

Constructors
Modifier	Constructor and Description
`protected`	`AbstractCompletableFutureAssert(CompletableFuture<RESULT> actual, Class<?> selfType)`

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`WithThrowable`	`failsWithin(Duration timeout)` Checks that the future does not complete within the given time (by calling `Future.get(long, TimeUnit)`) and returns the exception that caused the failure for further (exception) assertions, the exception can be any of `InterruptedException`, `ExecutionException`, `TimeoutException` or `CancellationException`.
`WithThrowable`	`failsWithin(long timeout, TimeUnit unit)` Checks that the future does not complete within the given time (by calling `Future.get(long, TimeUnit)`) and returns the exception that caused the failure for further (exception) assertions, the exception can be any of `InterruptedException`, `ExecutionException`, `TimeoutException` or `CancellationException`.
`SELF`	`hasFailed()` Deprecated. Combine isCompletedExceptionally with isNotCancelled instead: `assertThat(future).isCompletedExceptionally() .isNotCancelled();` This assertion is deprecated to change the semantics of failed to correspond to `CompletableFuture.get()` failing. Original javadoc Verifies that the `CompletableFuture` has completed exceptionally but has not been cancelled, this assertion is equivalent to: `assertThat(future).isCompletedExceptionally() .isNotCancelled();` Assertion will pass : `CompletableFuture future = new CompletableFuture(); future.completeExceptionally(new RuntimeException()); assertThat(future).hasFailed();` Assertion will fail : `CompletableFuture future = new CompletableFuture(); future.cancel(true); assertThat(future).hasFailed();`
`AbstractThrowableAssert<?,? extends Throwable>`	`hasFailedWithThrowableThat()` Deprecated. Although not 100% the same, consider using `failsWithin(Duration)` or `failsWithin(long, TimeUnit)` instead: `CompletableFuture future = new CompletableFuture(); future.completeExceptionally(new RuntimeException("boom!")); assertThat(future).failsWithin(1, TimeUnit.SECONDS) .withThrowableOfType(RuntimeException.class) .withMessage("boom!");` This assertion is deprecated because it relies on `hasFailed()` semantics which we want to move away from (they are not clear!) and to use failure semantics corresponding to `CompletableFuture.get()` failing. Original javadoc Verifies that the `CompletableFuture` has completed exceptionally and returns a Throwable assertion object allowing to check the Throwable that has caused the future to fail. Assertion will pass : `CompletableFuture future = new CompletableFuture(); future.completeExceptionally(new RuntimeException("boom!")); assertThat(future).hasFailedWithThrowableThat().isInstanceOf(RuntimeException.class); .hasMessage("boom!");` Assertion will fail : `CompletableFuture future = new CompletableFuture(); future.completeExceptionally(new RuntimeException()); assertThat(future).hasFailedWithThrowableThat().isInstanceOf(IllegalArgumentException.class);`
`SELF`	`hasNotFailed()` Deprecated. Use matches with the following combination instead: `assertThat(future).matches (f -> f.isNotCompletedExceptionally() \|\| f.isCancelled());` This assertion is deprecated because its semantic is not obvious. Original javadoc Verifies that the `CompletableFuture` has not failed i.e: incomplete, completed or cancelled. This is different from `isNotCompletedExceptionally()` as a cancelled future has not failed but is completed exceptionally. Assertion will pass : `CompletableFuture future = new CompletableFuture(); future.cancel(true); assertThat(future).hasNotFailed();` Assertion will fail : `CompletableFuture future = new CompletableFuture(); future.completeExceptionally(new RuntimeException()); assertThat(future).hasNotFailed();`
`SELF`	`isCancelled()` Verifies that the `CompletableFuture` is `cancelled`.
`SELF`	`isCompleted()` Verifies that the `CompletableFuture` is completed normally (i.e.`done` but not `completed exceptionally`) or `cancelled`.
`SELF`	`isCompletedExceptionally()` Verifies that the `CompletableFuture` is `completed exceptionally`.
`SELF`	`isCompletedWithValue(RESULT expected)` Verifies that the `CompletableFuture` is completed normally with the `expected` result.
`SELF`	`isCompletedWithValueMatching(Predicate<? super RESULT> predicate)` Verifies that the `CompletableFuture` is completed normally with a result matching the `predicate`.
`SELF`	`isCompletedWithValueMatching(Predicate<? super RESULT> predicate, String description)` Verifies that the `CompletableFuture` is completed normally with a result matching the `predicate`, the String parameter is used in the error message.
`SELF`	`isDone()` Verifies that the `CompletableFuture` is `done` i.e.
`SELF`	`isNotCancelled()` Verifies that the `CompletableFuture` is not cancelled.
`SELF`	`isNotCompleted()` Verifies that the `CompletableFuture` is not completed normally (i.e.
`SELF`	`isNotCompletedExceptionally()` Verifies that the `CompletableFuture` is not completed exceptionally.
`SELF`	`isNotDone()` Verifies that the `CompletableFuture` is not done.
`protected ObjectAssert<RESULT>`	`newObjectAssert(RESULT objectUnderTest)`
`ObjectAssert<RESULT>`	`succeedsWithin(Duration timeout)` Waits if necessary for at most the given time for this future to complete, and then returns its result for further assertions.
`<ASSERT extends AbstractAssert<?,?>> ASSERT`	`succeedsWithin(Duration timeout, InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)` Waits if necessary for at most the given time for this future to complete, the `InstanceOfAssertFactory` parameter is used to return assertions specific to the the future's result type.
`ObjectAssert<RESULT>`	`succeedsWithin(long timeout, TimeUnit unit)` Waits if necessary for at most the given time for this future to complete, and then returns its result for further assertions.
`<ASSERT extends AbstractAssert<?,?>> ASSERT`	`succeedsWithin(long timeout, TimeUnit unit, InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)` Waits if necessary for at most the given time for this future to complete, the `InstanceOfAssertFactory` parameter is used to return assertions specific to the the future's result type.

Methods inherited from class org.assertj.core.api.AbstractAssert
areEqual, 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, usingRecursiveComparison, usingRecursiveComparison, 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, as, as, describedAs

Constructor Detail

AbstractCompletableFutureAssert

protected AbstractCompletableFutureAssert(CompletableFuture<RESULT> actual,
                                          Class<?> selfType)

Method Detail
- isDone
```
public SELF isDone()
```
  Verifies that the CompletableFuture is done i.e. completed normally, exceptionally, or via cancellation.
  Assertion will pass :
```
 assertThat(CompletableFuture.completedFuture("something")).isDone();
```
  Assertion will fail :
```
 assertThat(new CompletableFuture()).isDone();
```
  Returns:
  
  this assertion object.
  
  See Also:
  
  CompletableFuture.isDone()
- isNotDone
```
public SELF isNotDone()
```
  Verifies that the CompletableFuture is not done.
  Assertion will pass :
```
 assertThat(new CompletableFuture()).isNotDone();
```
  Assertion will fail :
```
 assertThat(CompletableFuture.completedFuture("something")).isNotDone();
```
  Returns:
  
  this assertion object.
  
  See Also:
  
  CompletableFuture.isDone()
- isCompletedExceptionally
```
public SELF isCompletedExceptionally()
```
  Verifies that the CompletableFuture is completed exceptionally.
  Possible causes include cancellation, explicit invocation of completeExceptionally, and abrupt termination of a CompletionStage action.
  Assertion will pass :
```
 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());
 assertThat(future).isCompletedExceptionally();
```
  Assertion will fail :
```
 assertThat(CompletableFuture.completedFuture("something")).isCompletedExceptionally();
```
  Returns:
  
  this assertion object.
  
  See Also:
  
  CompletableFuture.isCompletedExceptionally()
- isNotCompletedExceptionally
```
public SELF isNotCompletedExceptionally()
```
  Verifies that the CompletableFuture is not completed exceptionally.
  Assertion will pass :
```
 assertThat(CompletableFuture.completedFuture("something")).isNotCompletedExceptionally();
```
  Assertion will fail :
```
 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());
 assertThat(future).isNotCompletedExceptionally();
```
  Returns:
  
  this assertion object.
  
  See Also:
  
  CompletableFuture.isCompletedExceptionally()
- isCancelled
```
public SELF isCancelled()
```
  Verifies that the CompletableFuture is cancelled.
  Assertion will pass :
```
 CompletableFuture future = new CompletableFuture();
 future.cancel(true);
 assertThat(future).isCancelled();
```
  Assertion will fail :
```
 assertThat(new CompletableFuture()).isCancelled();
```
  Returns:
  
  this assertion object.
  
  See Also:
  
  CompletableFuture.isCancelled()
- isNotCancelled
```
public SELF isNotCancelled()
```
  Verifies that the CompletableFuture is not cancelled.
  Assertion will pass :
```
 assertThat(new CompletableFuture()).isNotCancelled();
```
  Assertion will fail :
```
 CompletableFuture future = new CompletableFuture();
 future.cancel(true);
 assertThat(future).isNotCancelled();
```
  Returns:
  
  this assertion object.
  
  See Also:
  
  CompletableFuture.isCancelled()
- isCompleted
```
public SELF isCompleted()
```
  Verifies that the CompletableFuture is completed normally (i.e.done but not completed exceptionally) or cancelled.
  Assertion will pass :
```
 assertThat(CompletableFuture.completedFuture("something")).isCompleted();
```
  Assertion will fail :
```
 assertThat(new CompletableFuture()).isCompleted();
```
  Returns:
  
  this assertion object.
- isNotCompleted
```
public SELF isNotCompleted()
```
  Verifies that the CompletableFuture is not completed normally (i.e. incomplete, failed or cancelled).
  Assertion will pass :
```
 assertThat(new CompletableFuture()).isNotCompleted();
```
  Assertion will fail :
```
 assertThat(CompletableFuture.completedFuture("something")).isNotCompleted();
```
  Returns:
  
  this assertion object.
- isCompletedWithValue
```
public SELF isCompletedWithValue(RESULT expected)
```
  Verifies that the CompletableFuture is completed normally with the expected result.
  Assertion will pass :
```
 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValue("something");
```
  Assertion will fail :
```
 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValue("something else");
```
  Parameters:
  
  expected - the expected result value of the CompletableFuture.
  
  Returns:
  
  this assertion object.
- isCompletedWithValueMatching
```
public SELF isCompletedWithValueMatching(Predicate<? super RESULT> predicate)
```
  Verifies that the CompletableFuture is completed normally with a result matching the predicate.
  Assertion will pass :
```
 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValueMatching(result -> result.equals("something"));
```
  Assertion will fail :
```
 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValueMatching(result -> result.equals("something else"));
```
  Parameters:
  
  predicate - the Predicate to apply.
  
  Returns:
  
  this assertion object.
- isCompletedWithValueMatching
```
public SELF isCompletedWithValueMatching(Predicate<? super RESULT> predicate,
                                         String description)
```
  Verifies that the CompletableFuture is completed normally with a result matching the predicate, the String parameter is used in the error message.
  Assertion will pass :
```
 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValueMatching(result -> result != null, "expected not null");
```
  Assertion will fail :
```
 assertThat(CompletableFuture.completedFuture("something"))
           .isCompletedWithValueMatching(result -> result == null, "expected null");
```
  Error message is:
```
 Expecting:
   <"something">
 to match 'expected null' predicate.
```
  Parameters:
  
  predicate - the Predicate to apply on the resulting value.
  
  description - the Predicate description.
  
  Returns:
  
  this assertion object.
- hasFailed
```
@Deprecated
public SELF hasFailed()
```
  Deprecated.
  Combine isCompletedExceptionally with isNotCancelled instead:
```
 assertThat(future).isCompletedExceptionally()
                   .isNotCancelled();
```
  This assertion is deprecated to change the semantics of failed to correspond to CompletableFuture.get() failing.
  Original javadoc
  Verifies that the CompletableFuture has completed exceptionally but has not been cancelled, this assertion is equivalent to:
```
 assertThat(future).isCompletedExceptionally()
                   .isNotCancelled();
```
  Assertion will pass :
```
 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());
 assertThat(future).hasFailed();
```
  Assertion will fail :
```
 CompletableFuture future = new CompletableFuture();
 future.cancel(true);
 assertThat(future).hasFailed();
```
  Returns:
  
  this assertion object.
- hasNotFailed
```
@Deprecated
public SELF hasNotFailed()
```
  Deprecated.
  Use matches with the following combination instead:
```
 assertThat(future).matches (f -> f.isNotCompletedExceptionally()  || f.isCancelled());
```
  This assertion is deprecated because its semantic is not obvious.
  Original javadoc
  Verifies that the CompletableFuture has not failed i.e: incomplete, completed or cancelled.
  This is different from isNotCompletedExceptionally() as a cancelled future has not failed but is completed exceptionally.
  Assertion will pass :
```
 CompletableFuture future = new CompletableFuture();
 future.cancel(true);
 assertThat(future).hasNotFailed();
```
  Assertion will fail :
```
 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());
 assertThat(future).hasNotFailed();
```
  Returns:
  
  this assertion object.
- succeedsWithin
```
public ObjectAssert<RESULT> succeedsWithin(Duration timeout)
```
  Waits if necessary for at most the given time for this future to complete, and then returns its result for further assertions.
  If the future's result is not available for any reason an assertion error is thrown.
  To get assertions for the future result's type use succeedsWithin(Duration, InstanceOfAssertFactory) instead.
  Examples:
```
 CompletableFuture<String> future = CompletableFuture.completedFuture("ook!");
 Duration timeout = Duration.ofMillis(100);

 // assertion succeeds
 assertThat(future).succeedsWithin(timeout)
                   .isEqualTo("ook!");

 // fails assuming the future is not done after the given timeout
 CompletableFuture<String> future = ... ; // future too long to complete
 assertThat(future).succeedsWithin(timeout);

 // fails as the future is cancelled
 CompletableFuture future = new CompletableFuture();
 future.cancel(false);
 assertThat(future).succeedsWithin(timeout);
```
  Parameters:
  
  timeout - the maximum time to wait
  
  Returns:
  
  a new assertion object on the the future's result.
  
  Throws:
  
  AssertionError - if the actual CompletableFuture is null.
  
  AssertionError - if the actual CompletableFuture does not succeed within the given timeout.
- newObjectAssert
```
protected ObjectAssert<RESULT> newObjectAssert(RESULT objectUnderTest)
```
- succeedsWithin
```
public ObjectAssert<RESULT> succeedsWithin(long timeout,
                                           TimeUnit unit)
```
  Waits if necessary for at most the given time for this future to complete, and then returns its result for further assertions.
  If the future's result is not available for any reason an assertion error is thrown.
  To get assertions for the future result's type use succeedsWithin(long, TimeUnit, InstanceOfAssertFactory) instead.
  Examples:
```
 CompletableFuture<String> future = CompletableFuture.completedFuture("ook!");

 // assertion succeeds
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS)
                   .isEqualTo("ook!");

 // fails assuming the future is not done after the given timeout
 CompletableFuture<String> future = ... ; // future too long to complete
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS);

 // fails as the future is cancelled
 CompletableFuture future = new CompletableFuture();
 future.cancel(false);
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS);
```
  Parameters:
  
  timeout - the maximum time to wait
  
  unit - the time unit of the timeout argument
  
  Returns:
  
  a new assertion object on the the future's result.
  
  Throws:
  
  AssertionError - if the actual CompletableFuture is null.
  
  AssertionError - if the actual CompletableFuture does not succeed within the given timeout.
- succeedsWithin
```
public <ASSERT extends AbstractAssert<?,?>> ASSERT succeedsWithin(Duration timeout,
                                                                  InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)
```
  Waits if necessary for at most the given time for this future to complete, the InstanceOfAssertFactory parameter is used to return assertions specific to the the future's result type.
  If the future's result is not available for any reason an assertion error is thrown.
  Examples:
```
 CompletableFuture<String> future = CompletableFuture.completedFuture("ook!");
 Duration timeout = Duration.ofMillis(100);

 // assertion succeeds
 // using asInstanceOf is recommended to get assertions for the future result's type
 assertThat(future).succeedsWithin(timeout, InstanceOfAssertFactories.STRING)
                   .contains("ok");

 // assertion fails if the narrowed type for assertions is incompatible with the future's result type.
 assertThat(future).succeedsWithin(timeout, InstanceOfAssertFactories.DATE)
                   .isToday();
```
  Type Parameters:
  
  ASSERT - the type of the resulting Assert
  
  Parameters:
  
  timeout - the maximum time to wait
  
  assertFactory - the factory which verifies the type and creates the new Assert
  
  Returns:
  
  a new narrowed Assert instance for assertions chaining on the value of the CompletableFuture
  
  Throws:
  
  AssertionError - if the actual CompletableFuture is null.
  
  IllegalStateException - if the actual CompletableFuture does not succeed within the given timeout.
- succeedsWithin
```
public <ASSERT extends AbstractAssert<?,?>> ASSERT succeedsWithin(long timeout,
                                                                  TimeUnit unit,
                                                                  InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)
```
  Waits if necessary for at most the given time for this future to complete, the InstanceOfAssertFactory parameter is used to return assertions specific to the the future's result type.
  If the future's result is not available for any reason an assertion error is thrown.
  Examples:
```
 CompletableFuture<String> future = CompletableFuture.completedFuture("ook!");

 // assertion succeeds
 // using asInstanceOf is recommended to get assertions for the future result's type
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS, InstanceOfAssertFactories.STRING)
                   .contains("ok");

 // assertion  fails if the narrowed type for assertions is incompatible with the future's result type.
 assertThat(future).succeedsWithin(100, TimeUnit.MILLISECONDS, InstanceOfAssertFactories.DATE)
                   .isToday();
```
  Type Parameters:
  
  ASSERT - the type of the resulting Assert
  
  Parameters:
  
  timeout - the maximum time to wait
  
  unit - the time unit of the timeout argument
  
  assertFactory - the factory which verifies the type and creates the new Assert
  
  Returns:
  
  a new narrowed Assert instance for assertions chaining on the value of the CompletableFuture
  
  Throws:
  
  AssertionError - if the actual CompletableFuture is null.
  
  AssertionError - if the actual CompletableFuture does not succeed within the given timeout.
- hasFailedWithThrowableThat
```
@Deprecated
public AbstractThrowableAssert<?,? extends Throwable> hasFailedWithThrowableThat()
```
  Deprecated.
  Although not 100% the same, consider using failsWithin(Duration) or failsWithin(long, TimeUnit) instead:
```
 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException("boom!"));

 assertThat(future).failsWithin(1, TimeUnit.SECONDS)
                   .withThrowableOfType(RuntimeException.class)
                   .withMessage("boom!"); 
```
  This assertion is deprecated because it relies on hasFailed() semantics which we want to move away from (they are not clear!) and to use failure semantics corresponding to CompletableFuture.get() failing.
  Original javadoc
  Verifies that the CompletableFuture has completed exceptionally and returns a Throwable assertion object allowing to check the Throwable that has caused the future to fail.
  Assertion will pass :
```
 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException("boom!"));

 assertThat(future).hasFailedWithThrowableThat().isInstanceOf(RuntimeException.class);
                                                .hasMessage("boom!"); 
```
  Assertion will fail :
```
 CompletableFuture future = new CompletableFuture();
 future.completeExceptionally(new RuntimeException());

 assertThat(future).hasFailedWithThrowableThat().isInstanceOf(IllegalArgumentException.class);
 
```
  Returns:
  
  an exception assertion object.
- failsWithin
```
public WithThrowable failsWithin(Duration timeout)
```
  Checks that the future does not complete within the given time (by calling Future.get(long, TimeUnit)) and returns the exception that caused the failure for further (exception) assertions, the exception can be any of InterruptedException, ExecutionException, TimeoutException or CancellationException.
  WARNING
  failsWithin does not fully integrate with soft assertions, if the future completes the test will fail immediately (the error is not collected as a soft assertion error), if the assertion succeeds the chained assertions are executed and any errors will be collected as a soft assertion errors.
  The rationale is that if we collect failsWithin error as a soft assertion error, the chained assertions would be executed but that does not make sense since there is no exception to check as the future has completed.
  Examples:
```
 CompletableFuture<?> future = futureCompletingAfterMs(100);

 // assertion succeeds as the future is not completed after 50ms
 assertThat(future).failsWithin(Duration.ofMillis(50))
                   .withThrowableOfType(TimeoutException.class)
                   .withMessage(null);

 // fails as the future is completed after within 200ms
 assertThat(future).failsWithin(Duration.ofMillis(200));
```
  Parameters:
  
  timeout - the maximum time to wait
  
  Returns:
  
  a new assertion instance on the the future's exception.
  
  Throws:
  
  AssertionError - if the actual CompletableFuture is null.
  
  AssertionError - if the actual CompletableFuture succeeds within the given timeout.
  
  Since:
  
  3.18.0
- failsWithin
```
public WithThrowable failsWithin(long timeout,
                                 TimeUnit unit)
```
  Checks that the future does not complete within the given time (by calling Future.get(long, TimeUnit)) and returns the exception that caused the failure for further (exception) assertions, the exception can be any of InterruptedException, ExecutionException, TimeoutException or CancellationException.
  WARNING
  failsWithin does not fully integrate with soft assertions, if the future completes the test will fail immediately (the error is not collected as a soft assertion error), if the assertion succeeds the chained assertions are executed and any errors will be collected as a soft assertion errors.
  The rationale is that if we collect failsWithin error as a soft assertion error, the chained assertions would be executed but that does not make sense since there is no exception to check as the future has completed.
  Examples:
```
 CompletableFuture<?> future = futureCompletingAfterMs(100);

 // assertion succeeds as the future is not completed after 50ms
 assertThat(future).failsWithin(50, TimeUnit.MILLISECONDS)
                   .withThrowableOfType(TimeoutException.class)
                   .withMessage(null);

 // fails as the future is completed after within 200ms
 assertThat(future).failsWithin(200, TimeUnit.MILLISECONDS);
```
  Parameters:
  
  timeout - the maximum time to wait
  
  unit - the time unit
  
  Returns:
  
  a new assertion instance on the the future's exception.
  
  Throws:
  
  AssertionError - if the actual CompletableFuture is null.
  
  AssertionError - if the actual CompletableFuture succeeds within the given timeout.
  
  Since:
  
  3.18.0

Class AbstractCompletableFutureAssert<SELF extends AbstractCompletableFutureAssert<SELF,RESULT>,RESULT>

Field Summary

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

Constructor Summary

Method Summary

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

Methods inherited from class java.lang.Object

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

Constructor Detail

AbstractCompletableFutureAssert

Method Detail

isDone

isNotDone

isCompletedExceptionally

isNotCompletedExceptionally

isCancelled

isNotCancelled

isCompleted

isNotCompleted

isCompletedWithValue

isCompletedWithValueMatching

isCompletedWithValueMatching

hasFailed

hasNotFailed

succeedsWithin

newObjectAssert

succeedsWithin

succeedsWithin

succeedsWithin

hasFailedWithThrowableThat

failsWithin

failsWithin