public abstract class AbstractFutureAssert<SELF extends AbstractFutureAssert<SELF,ACTUAL,RESULT>,ACTUAL extends Future<RESULT>,RESULT> extends AbstractAssert<SELF,ACTUAL>
actual, info, myself, objects, throwUnsupportedExceptionOnEquals| Modifier | Constructor and Description |
|---|---|
protected |
AbstractFutureAssert(ACTUAL actual,
Class<?> selfType) |
| Modifier and Type | Method and Description |
|---|---|
WithThrowable |
failsWithin(Duration timeout)
Checks that the future does not complete within the given time and returns the exception that caused the failure for
further (exception) assertions, the exception can be any of
InterruptedException, ExecutionException,
TimeoutException or CancellationException as per Future.get(long, TimeUnit). |
WithThrowable |
failsWithin(long timeout,
TimeUnit unit)
Checks that the future does not complete within the given time and returns the exception that caused the failure for
further (exception) assertions, the exception can be any of
InterruptedException, ExecutionException,
TimeoutException or CancellationException as per Future.get(long, TimeUnit). |
SELF |
isCancelled()
Verifies that the
Future is cancelled. |
SELF |
isDone()
Verifies that the
Future is done. |
SELF |
isNotCancelled()
Verifies that the
Future is not cancelled. |
SELF |
isNotDone()
Verifies that the
Future is not done. |
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<?,?>> |
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<?,?>> |
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. |
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, withThreadDumpOnErrorclone, finalize, getClass, notify, notifyAll, toString, wait, wait, waitas, as, as, describedAspublic SELF isCancelled()
Future is cancelled.
Example:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
return "done";
}
});
// assertion will fail:
assertThat(future).isCancelled();
// assertion will pass:
future.cancel(true);
assertThat(future).isCancelled();Future.isCancelled()public SELF isNotCancelled()
Future is not cancelled.
Example:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
return "done";
}
});
// assertion will pass:
assertThat(future).isNotCancelled();
// assertion will fail:
future.cancel(true);
assertThat(future).isNotCancelled();Future.isCancelled()public SELF isDone()
Future is done.
Example:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
return "done";
}
});
// assertion will pass:
assertThat(future).isDone();
future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(1000);
return "done";
}
});
// assertion will fail:
assertThat(future).isDone();Future.isDone()public SELF isNotDone()
Future is not done.
Example:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
Thread.sleep(1000);
return "done";
}
});
// assertion will pass:
assertThat(future).isNotDone();
future = executorService.submit(new Callable<String>() {
@Override
public String call() throws Exception {
return "done";
}
});
// assertion will fail:
assertThat(future).isNotDone();Future.isDone()public ObjectAssert<RESULT> succeedsWithin(Duration timeout)
If the future's result is not available for any reason an assertion error is thrown.
WARNING
succeedsWithin does not fully integrate with soft assertions, if it fails the test will fail immediately (the error
is not collected as a soft assertion error), if it succeeds the chained assertions are executed and any error will be
collected as a soft assertion error.
The rationale is that if we collected succeedsWithin error as a soft assertion error, the chained assertions would be
executed against a future value that is actually not available.
To get assertions for the future result's type use succeedsWithin(Duration, InstanceOfAssertFactory) instead.
Examples:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(() -> {
Thread.sleep(100);
return "ook!";
});
Duration timeout = Duration.ofMillis(200);
// assertion succeeds
assertThat(future).succeedsWithin(timeout)
.isEqualTo("ook!");
// fails as the future is not done after the given timeout
assertThat(future).succeedsWithin(Duration.ofMillis(50));
// fails as the future is cancelled
Future<String> future = ... ;
future.cancel(false);
assertThat(future).succeedsWithin(timeout);timeout - the maximum time to waitAssertionError - if the actual CompletableFuture is null.AssertionError - if the actual CompletableFuture does not succeed within the given timeout.public ObjectAssert<RESULT> succeedsWithin(long timeout, TimeUnit unit)
If the future's result is not available for any reason an assertion error is thrown.
WARNING
succeedsWithin does not fully integrate with soft assertions, if it fails the test will fail immediately (the error
is not collected as a soft assertion error), if it succeeds the chained assertions are executed and any error will be
collected as a soft assertion error.
The rationale is that if we collected succeedsWithin error as a soft assertion error, the chained assertions would be
executed against a future value that is actually not available.
To get assertions for the future result's type use succeedsWithin(long, TimeUnit, InstanceOfAssertFactory) instead.
Examples:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(() -> {
Thread.sleep(100);
return "ook!";
});
// assertion succeeds
assertThat(future).succeedsWithin(200, TimeUnit.MILLISECONDS)
.isEqualTo("ook!");
// fails as the future is not done after the given timeout
assertThat(future).succeedsWithin(50, TimeUnit.MILLISECONDS);
// fails as the future is cancelled
Future<String> future = ... ;
future.cancel(false);
assertThat(future).succeedsWithin(200, TimeUnit.MILLISECONDS);timeout - the maximum time to waitunit - the time unit of the timeout argumentAssertionError - if the actual Future is null.AssertionError - if the actual Future does not succeed within the given timeout.public <ASSERT extends AbstractAssert<?,?>> ASSERT succeedsWithin(Duration timeout, InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)
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.
WARNING
succeedsWithin does not fully integrate with soft assertions, if it fails the test will fail immediately (the error
is not collected as a soft assertion error), if it succeeds the chained assertions are executed and any error will be
collected as a soft assertion error.
The rationale is that if we collected succeedsWithin error as a soft assertion error, the chained assertions would be
executed against a future value that is actually not available.
Examples:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(() -> {
Thread.sleep(100);
return "ook!";
});
Duration timeout = Duration.ofMillis(200);
// assertion succeeds, contains(String...) assertion can be called because InstanceOfAssertFactories.STRING
// indicates AssertJ to allow String assertions after succeedsWithin.
assertThat(future).succeedsWithin(timeout, InstanceOfAssertFactories.STRING)
.contains("ok");
// fails as the future is not done after the given timeout
// as() is syntactic sugar for better readability.
assertThat(future).succeedsWithin(Duration.ofMillis(50), as(STRING));
// assertion fails if the narrowed type for assertions is incompatible with the future's result type.
assertThat(future).succeedsWithin(timeout, InstanceOfAssertFactories.DATE)
.isToday();ASSERT - the type of the resulting Asserttimeout - the maximum time to waitassertFactory - the factory which verifies the type and creates the new AssertAssert instance for assertions chaining on the value of the FutureAssertionError - if the actual Future is null.IllegalStateException - if the actual Future does not succeed within the given timeout.public <ASSERT extends AbstractAssert<?,?>> ASSERT succeedsWithin(long timeout, TimeUnit unit, InstanceOfAssertFactory<RESULT,ASSERT> assertFactory)
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.
WARNING
succeedsWithin does not fully integrate with soft assertions, if it fails the test will fail immediately (the error
is not collected as a soft assertion error), if it succeeds the chained assertions are executed and any error will be
collected as a soft assertion error.
The rationale is that if we collected succeedsWithin error as a soft assertion error, the chained assertions would be
executed against a future value that is actually not available.
Examples:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(() -> {
Thread.sleep(100);
return "ook!";
});
// assertion succeeds, contains(String...) assertion can be called because InstanceOfAssertFactories.STRING
// indicates AssertJ to allow String assertions after succeedsWithin.
assertThat(future).succeedsWithin(200, TimeUnit.MILLISECONDS, InstanceOfAssertFactories.STRING)
.contains("ok");
// fails as the future is not done after the given timeout
// as() is syntactic sugar for better readability.
assertThat(future).succeedsWithin(50, TimeUnit.MILLISECONDS, as(STRING));
// assertion fails if the narrowed type for assertions is incompatible with the future's result type.
assertThat(future).succeedsWithin(200, TimeUnit.MILLISECONDS, InstanceOfAssertFactories.DATE)
.isToday();ASSERT - the type of the resulting Asserttimeout - the maximum time to waitunit - the time unit of the timeout argumentassertFactory - the factory which verifies the type and creates the new AssertAssert instance for assertions chaining on the value of the FutureAssertionError - if the actual Future is null.AssertionError - if the actual Future does not succeed within the given timeout.public WithThrowable failsWithin(Duration timeout)
InterruptedException, ExecutionException,
TimeoutException or CancellationException as per Future.get(long, TimeUnit).
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:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(() -> {
Thread.sleep(100);
return "ook!";
});
// 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));timeout - the maximum time to waitAssertionError - if the actual CompletableFuture is null.AssertionError - if the actual CompletableFuture succeeds within the given timeout.public WithThrowable failsWithin(long timeout, TimeUnit unit)
InterruptedException, ExecutionException,
TimeoutException or CancellationException as per Future.get(long, TimeUnit).
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:
ExecutorService executorService = Executors.newSingleThreadExecutor();
Future<String> future = executorService.submit(() -> {
Thread.sleep(100);
return "ook!";
});
// 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 the given timeout duration
assertThat(future).failsWithin(200, TimeUnit.MILLISECONDS);timeout - the maximum time to waitunit - the time unitAssertionError - if the actual CompletableFuture is null.AssertionError - if the actual CompletableFuture succeeds within the given timeout.Copyright © 2025. All rights reserved.