com.oracle.bedrock.deferred

Class Concurrently

java.lang.Object

com.oracle.bedrock.deferred.Concurrently

public class Concurrently
extends Object

Commonly used "assertThat" methods for the purposes of concurrently asserting the state of Deferred values using the style Concurrently.assertThat(...)

try (Concurrent.Assertion assertion = Concurrently.assertThat(invoking(someObject).get(), is(someValue))) { // ...perform some operations... assertion.check(); // ensure the assertion still holds // ...perform some other operations... assertion.check(); // ensure the assertion still holds }

Concurrently.assertThat(...) methods are intended be used within try-with-resources blocks. When not, they should always be closed to ensure correct clean-up of background resources used for concurrent assertion.

To control "fail-fast" semantics, where by the Concurrent.Assertion may interrupt the Thread that created the Concurrent.Assertion, the FailFast option should be specified. try (Concurrent.Assertion assertion = Concurrently.assertThat(invoking(someObject).get(), is(someValue), FailFast.enabled())) { // ...perform some long running operations... (will be interrupted if the assertion fails) } catch (InterruptedException e) { // determine if the InterruptedException was due to AssertionError Concurrent.Assertion.check(e); }

To customize assertion behavior, this class allows extensive use of Options. For example, the following Options may be used to customize timeout constraints when asserting Deferred values; Timeout, MaximumRetryDelay, Initial InitialDelay and RetryFrequency.

Copyright (c) 2016. All Rights Reserved. Oracle Corporation.
Oracle is a registered trademark of Oracle Corporation and/or its affiliates.

Author:

Brian Oliver

See Also:

Eventually, Repetitively

Constructor Summary

Constructors

Constructor and Description
Concurrently()

Method Summary

Modifier and Type	Method and Description
static <T> void	assertThat(JavaApplication application, RemoteCallable<T> callable, org.hamcrest.Matcher<? super T> matcher) Creates a background thread to repetitively assert that the specified RemoteCallable submitted to the JavaApplication matches the specified Matcher.
static <T> void	assertThat(JavaApplication application, RemoteCallable<T> callable, org.hamcrest.Matcher<? super T> matcher, com.oracle.bedrock.Option... options) Creates a background thread to repetitively assert that the specified RemoteCallable submitted to the JavaApplication matches the specified Matcher using the specified Options.
static <T> com.oracle.bedrock.deferred.Concurrent.Assertion	assertThat(String message, com.oracle.bedrock.deferred.Deferred<T> deferred, org.hamcrest.Matcher<? super T> matcher, com.oracle.bedrock.Option... options) Creates a background thread to repetitively assert that a Deferred value, when available, satisfies the specified Matcher using constraints defined by the provided Options.
static <T> com.oracle.bedrock.deferred.Concurrent.Assertion	assertThat(String message, T value, org.hamcrest.Matcher<? super T> matcher) Creates a background thread to repetitively assert that a value will satisfy the specified Matcher.
static <T> com.oracle.bedrock.deferred.Concurrent.Assertion	assertThat(String message, T value, org.hamcrest.Matcher<? super T> matcher, com.oracle.bedrock.Option... options) Creates a background thread to repetitively assert that a value satisfies the specified Matcher using the provided Options.
static <T> com.oracle.bedrock.deferred.Concurrent.Assertion	assertThat(T value, org.hamcrest.Matcher<? super T> matcher, com.oracle.bedrock.Option... options) Creates a background thread to repetitively assert that a value satisfies the specified Matcher using the specified Options.

Methods inherited from class java.lang.Object

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

Constructor Detail

Concurrently

public Concurrently()

Method Detail

assertThat

public static <T> com.oracle.bedrock.deferred.Concurrent.Assertion assertThat(T value,
                                                                              org.hamcrest.Matcher<? super T> matcher,
                                                                              com.oracle.bedrock.Option... options)
                                                                       throws AssertionError

Creates a background thread to repetitively assert that a value satisfies the specified Matcher using the specified Options.

Should the value be the result of a call to DeferredHelper.invoking(Deferred) the result is unwrapped into a Deferred that is then used for the assert.

Type Parameters:

T - the type of the value

Parameters:

value - the value

matcher - the Matcher for the value

options - the Options for the assertion

Returns:

an Concurrent.Assertion to be used to determine the current success of the concurrent assertion

Throws:

AssertionError - if the assertion fails

assertThat

public static <T> com.oracle.bedrock.deferred.Concurrent.Assertion assertThat(String message,
                                                                              T value,
                                                                              org.hamcrest.Matcher<? super T> matcher)
                                                                       throws AssertionError

Creates a background thread to repetitively assert that a value will satisfy the specified Matcher.

Should the value be the result of a call to DeferredHelper.invoking(Deferred) the result is unwrapped into a Deferred that is then used for the assert.

Type Parameters:

T - the type of the value

Parameters:

message - the message for the AssertionError (null ok)

value - the value

matcher - the Matcher for the value

Returns:

an Concurrent.Assertion to be used to determine the current success of the concurrent assertion

Throws:

AssertionError - if the assertion fails

assertThat

public static <T> com.oracle.bedrock.deferred.Concurrent.Assertion assertThat(String message,
                                                                              T value,
                                                                              org.hamcrest.Matcher<? super T> matcher,
                                                                              com.oracle.bedrock.Option... options)
                                                                       throws AssertionError

Creates a background thread to repetitively assert that a value satisfies the specified Matcher using the provided Options.

Should the value be the result of a call to DeferredHelper.invoking(Deferred) the result is unwrapped into a Deferred that is then used for the assert.

Type Parameters:

T - the type of the value

Parameters:

message - the message for the AssertionError (null ok)

value - the value

matcher - the Matcher for the value

options - the Options

Returns:

an Concurrent.Assertion to be used to determine the current success of the concurrent assertion

Throws:

AssertionError - if the assertion fails

assertThat

public static <T> com.oracle.bedrock.deferred.Concurrent.Assertion assertThat(String message,
                                                                              com.oracle.bedrock.deferred.Deferred<T> deferred,
                                                                              org.hamcrest.Matcher<? super T> matcher,
                                                                              com.oracle.bedrock.Option... options)

Creates a background thread to repetitively assert that a Deferred value, when available, satisfies the specified Matcher using constraints defined by the provided Options.

Type Parameters:

T - the type of the value

Parameters:

message - the message for the AssertionError (null ok)

deferred - the Deferred value

matcher - the Matcher for the value

options - the Options

Returns:

an Concurrent.Assertion providing the ability to check the status and control the evaluation of the concurrent Concurrent.Assertion

assertThat

public static <T> void assertThat(JavaApplication application,
                                  RemoteCallable<T> callable,
                                  org.hamcrest.Matcher<? super T> matcher)
                           throws AssertionError

Creates a background thread to repetitively assert that the specified RemoteCallable submitted to the JavaApplication matches the specified Matcher.

Type Parameters:

T - the type of the value

Parameters:

application - the JavaApplication to which the RemoteCallable will be submitted

callable - the RemoteCallable

matcher - the Matcher representing the desire condition to match

Throws:

AssertionError - if the assertion fails

assertThat

public static <T> void assertThat(JavaApplication application,
                                  RemoteCallable<T> callable,
                                  org.hamcrest.Matcher<? super T> matcher,
                                  com.oracle.bedrock.Option... options)
                           throws AssertionError

Creates a background thread to repetitively assert that the specified RemoteCallable submitted to the JavaApplication matches the specified Matcher using the specified Options.

Type Parameters:

T - the type of the value

Parameters:

application - the JavaApplication to which the RemoteCallable will be submitted

callable - the RemoteCallable

matcher - the Matcher representing the desire condition to match

options - the Options

Throws:

AssertionError - if the assertion fails