org.eclipse.microprofile.context.tck

## Class ThreadContextTest

- java.lang.Object
- - org.jboss.arquillian.testng.Arquillian
  - - org.eclipse.microprofile.context.tck.ThreadContextTest

All Implemented Interfaces:
  org.testng.IHookable, org.testng.ITestNGListener

    public class ThreadContextTest
    extends org.jboss.arquillian.testng.Arquillian

### Nested Class Summary

### Nested classes/interfaces inherited from class org.jboss.arquillian.testng.Arquillian

`org.jboss.arquillian.testng.Arquillian.UpdateResultListener`

### Field Summary

### Fields inherited from class org.jboss.arquillian.testng.Arquillian

`ARQUILLIAN_DATA_PROVIDER`

### Constructor Summary

Constructors
Constructor and Description
`ThreadContextTest()`

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`void` `after()`
`void` `afterMethod(Method m, org.testng.ITestResult result)`
`void` `before()`
`void` `beforeMethod(Method m)`
`void` `builderForThreadContextIsProvided()`
`void` `clearTransactionContextJTA()` Verify that if JTA transactions are supported, then configuring cleared=TRANSACTION results in the active transaction being suspended before running a task and resumed afterward, such that a task can use its own transactions if so desired.
`void` `clearUnspecifiedContexts()` Verify that the ThreadContext implementation clears context types that are not configured under propagated, unchanged, or cleared.
`void` `contextControlsForThreadContextBuilder()` Verify the MicroProfile Context Propagation implementation of propagate(), cleared(), and unchanged() for ThreadContext.Builder.
`void` `contextualBiConsumerRunsWithContext()` Verify that the ThreadContext's contextualConsumer method can be used to wrap a BiConsumer instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the BiConsumer accept method runs.
`void` `contextualBiFunctionRunsWithContext()` Verify that the ThreadContext's contextualFunction method can be used to wrap a BiFunction instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the BiFunction apply method runs.
`void` `contextualCallableRunsWithContext()` Verify that the ThreadContext's contextualCallable method can be used to wrap a Callable instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Callable call method runs.
`void` `contextualConsumerRunsWithContext()` Verify that the ThreadContext's contextualConsumer method can be used to wrap a Consumer instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Consumer accept method runs.
`void` `contextualFunctionRunsWithContext()` Verify that the ThreadContext's contextualFunction method can be used to wrap a Function instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Function apply method runs.
`void` `contextualRunnableRunsWithContext()` Verify that the ThreadContext's contextualRunnable method can be used to wrap a Runnable instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Runnable run method runs.
`void` `contextualSupplierRunsWithContext()` Verify that the ThreadContext's contextualSupplier method can be used to wrap a Supplier instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Supplier get method runs.
`static org.jboss.shrinkwrap.api.spec.WebArchive` `createDeployment()`
`void` `currentContextExecutorRunsWithContext()` Verify that the ThreadContext's currentContextExecutor method can be used to create an Executor instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied to the thread where the Executor's execute method runs.
`void` `reuseThreadContextBuilder()` Verify that the ThreadContext.Builder can be used to create multiple ThreadContexts with different configured contexts.
`void` `thirdPartyContextProvidersAreIncludedInThreadContext()` Verify that the MicroProfile Context Propagation implementation finds third-party thread context providers that are made available to the ServiceLoader, allows their configuration via the ThreadContext builder, and correctly captures and propagates or clears these thread context types per the builder configuration.
`void` `unchangedContextListDefaultsToEmpty()` It is optional to specify the set of unchanged context.
`void` `withContextCaptureDependentCompletableFuturesRunWithContext()` Verify that the ThreadContext's withContextCapture method can be used to create a dependent CompletableFuture instance that completes when the original stage completes and runs dependent stage actions with context that is captured from the thread that creates the dependent stage.
`void` `withContextCaptureDependentCompletionStagesRunWithContext()` Verify that the ThreadContext's withContextCapture method can be used to create a dependent CompletionStage instance that completes when the original stage completes and runs dependent stage actions with context that is captured from the thread that creates the dependent stage.
`void` `withContextCaptureDependentStageForcedCompletion()` Verify that dependent stages created via withContextCapture can be completed independently of the original stage.
`void` `withContextCaptureMultipleThreadContexts()` The withContextCapture method should be able to create multiple dependent stages having a single parent stage, where each of the dependent stages propagates a different set of thread context.
`void` `withContextCaptureSwitchThreadContext()` The withContextCapture method should be able to create a dependent stage that is associated with a thread context even if its parent stage is already associated with a different thread context.
`void` `withDefaultExecutorServiceContextCanInvokeAsyncActions()` Verify that the presence of a default executor service allows contextualised CompletableFuture/CompletionStage to run async actions on them, and that they are running on that executor service.
`void` `withoutDefaultExecutorServiceContextCannotInvokeAsyncActions()` Verify that the lack of a default executor service bans contextualised CompletableFuture/CompletionStage from running async actions on them.

### Methods inherited from class org.jboss.arquillian.testng.Arquillian

`arquillianAfterClass, arquillianAfterSuite, arquillianAfterTest, arquillianArgumentProvider, arquillianBeforeClass, arquillianBeforeSuite, arquillianBeforeTest, run`

### Methods inherited from class java.lang.Object

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

### Constructor Detail

#### ThreadContextTest

    public ThreadContextTest()

### Method Detail

#### after

    @AfterClass
    public void after()

#### afterMethod

    @AfterMethod
    public void afterMethod(Method m,
                                         org.testng.ITestResult result)

#### before

    @BeforeClass
    public void before()

#### beforeMethod

    @BeforeMethod
    public void beforeMethod(Method m)

#### createDeployment

    @Deployment
    public static org.jboss.shrinkwrap.api.spec.WebArchive createDeployment()

#### builderForThreadContextIsProvided

    public void builderForThreadContextIsProvided()

#### clearTransactionContextJTA

    public void clearTransactionContextJTA()
                                    throws Exception

Verify that if JTA transactions are supported, then configuring cleared=TRANSACTION results in the active transaction being suspended before running a task and resumed afterward, such that a task can use its own transactions if so desired. The test tries to get hold of `UserTransaction` via JNDI and via CDI. Should neither work, it still doesn't throw exception but instead returns.

Throws:
  `Exception` - indicates test failure

#### clearUnspecifiedContexts

    public void clearUnspecifiedContexts()
                                  throws Exception

Verify that the ThreadContext implementation clears context types that are not configured under propagated, unchanged, or cleared.

Throws:
  `Exception` - indicates test failure

#### contextualBiConsumerRunsWithContext

    public void contextualBiConsumerRunsWithContext()
                                             throws InterruptedException

Verify that the ThreadContext's contextualConsumer method can be used to wrap a BiConsumer instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the BiConsumer accept method runs. This test case aligns with use case of supplying a contextual BiConsumer to a completion stage that is otherwise not context-aware.

Throws:
  `InterruptedException` - indicates test failure

#### contextualBiFunctionRunsWithContext

    public void contextualBiFunctionRunsWithContext()
                                             throws ExecutionException,
                                                    InterruptedException,
                                                    TimeoutException

Verify that the ThreadContext's contextualFunction method can be used to wrap a BiFunction instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the BiFunction apply method runs. This test case aligns with use case of supplying a contextual BiFunction to a completion stage that is otherwise not context-aware.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### contextualCallableRunsWithContext

    public void contextualCallableRunsWithContext()
                                           throws ExecutionException,
                                                  InterruptedException,
                                                  TimeoutException

Verify that the ThreadContext's contextualCallable method can be used to wrap a Callable instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Callable call method runs. This test case aligns with use case of supplying a contextual Callable to an unmanaged executor that is otherwise not context-aware.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### contextualConsumerRunsWithContext

    public void contextualConsumerRunsWithContext()
                                           throws InterruptedException

Verify that the ThreadContext's contextualConsumer method can be used to wrap a Consumer instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Consumer accept method runs. This test case aligns with use case of supplying a contextual Consumer to a completion stage that is otherwise not context-aware.

Throws:
  `InterruptedException` - indicates test failure

#### contextualFunctionRunsWithContext

    public void contextualFunctionRunsWithContext()
                                           throws ExecutionException,
                                                  InterruptedException,
                                                  TimeoutException

Verify that the ThreadContext's contextualFunction method can be used to wrap a Function instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Function apply method runs. This test case aligns with use case of supplying a contextual Function to a completion stage that is otherwise not context-aware.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### contextualRunnableRunsWithContext

    public void contextualRunnableRunsWithContext()
                                           throws ExecutionException,
                                                  InterruptedException,
                                                  TimeoutException

Verify that the ThreadContext's contextualRunnable method can be used to wrap a Runnable instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Runnable run method runs. This test case aligns with use case of supplying a contextual Runnable to a completion stage that is otherwise not context-aware.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### contextualSupplierRunsWithContext

    public void contextualSupplierRunsWithContext()
                                           throws InterruptedException

Verify that the ThreadContext's contextualSupplier method can be used to wrap a Supplier instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied when the Supplier get method runs. This test case aligns with use case of supplying a contextual Supplier to a completion stage that is otherwise not context-aware.

Throws:
  `InterruptedException` - indicates test failure

#### reuseThreadContextBuilder

    public void reuseThreadContextBuilder()
                                   throws Exception

Verify that the ThreadContext.Builder can be used to create multiple ThreadContexts with different configured contexts.

Throws:
  `Exception` - indicates test failure

#### unchangedContextListDefaultsToEmpty

    public void unchangedContextListDefaultsToEmpty()

It is optional to specify the set of unchanged context. In absence of any specified value and if MicroProfile Config is not used to override the default, the unchanged context list defaults to empty.

#### thirdPartyContextProvidersAreIncludedInThreadContext

    public void thirdPartyContextProvidersAreIncludedInThreadContext()

Verify that the MicroProfile Context Propagation implementation finds third-party thread context providers that are made available to the ServiceLoader, allows their configuration via the ThreadContext builder, and correctly captures and propagates or clears these thread context types per the builder configuration. Subsequently verify that the MicroProfile Context Propagation implementation properly restores thread context after the contextual action completes.

#### withContextCaptureDependentCompletableFuturesRunWithContext

    public void withContextCaptureDependentCompletableFuturesRunWithContext()
                                                                     throws ExecutionException,
                                                                            InterruptedException,
                                                                            TimeoutException

Verify that the ThreadContext's withContextCapture method can be used to create a dependent CompletableFuture instance that completes when the original stage completes and runs dependent stage actions with context that is captured from the thread that creates the dependent stage.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### withContextCaptureDependentCompletionStagesRunWithContext

    public void withContextCaptureDependentCompletionStagesRunWithContext()
                                                                   throws ExecutionException,
                                                                          InterruptedException,
                                                                          TimeoutException

Verify that the ThreadContext's withContextCapture method can be used to create a dependent CompletionStage instance that completes when the original stage completes and runs dependent stage actions with context that is captured from the thread that creates the dependent stage.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### withContextCaptureDependentStageForcedCompletion

    public void withContextCaptureDependentStageForcedCompletion()
                                                          throws ExecutionException,
                                                                 InterruptedException

Verify that dependent stages created via withContextCapture can be completed independently of the original stage.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure

#### withContextCaptureMultipleThreadContexts

    public void withContextCaptureMultipleThreadContexts()
                                                  throws ExecutionException,
                                                         InterruptedException,
                                                         TimeoutException

The withContextCapture method should be able to create multiple dependent stages having a single parent stage, where each of the dependent stages propagates a different set of thread context.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### withContextCaptureSwitchThreadContext

    public void withContextCaptureSwitchThreadContext()
                                               throws ExecutionException,
                                                      InterruptedException,
                                                      TimeoutException

The withContextCapture method should be able to create a dependent stage that is associated with a thread context even if its parent stage is already associated with a different thread context. Both stages must honor their respective thread context.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### contextControlsForThreadContextBuilder

    public void contextControlsForThreadContextBuilder()
                                                throws InterruptedException,
                                                       ExecutionException,
                                                       TimeoutException

Verify the MicroProfile Context Propagation implementation of propagate(), cleared(), and unchanged() for ThreadContext.Builder.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### currentContextExecutorRunsWithContext

    public void currentContextExecutorRunsWithContext()
                                               throws InterruptedException,
                                                      ExecutionException,
                                                      TimeoutException

Verify that the ThreadContext's currentContextExecutor method can be used to create an Executor instance with the context that is captured from the current thread per the configuration of the ThreadContext builder, and that the context is applied to the thread where the Executor's execute method runs. This test case aligns with use case of supplying a contextual Executor to a thread that is otherwise not context-aware.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### withDefaultExecutorServiceContextCanInvokeAsyncActions

    public void withDefaultExecutorServiceContextCanInvokeAsyncActions()
                                                                throws ExecutionException,
                                                                       InterruptedException,
                                                                       TimeoutException

Verify that the presence of a default executor service allows contextualised CompletableFuture/CompletionStage to run async actions on them, and that they are running on that executor service.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure

#### withoutDefaultExecutorServiceContextCannotInvokeAsyncActions

    public void withoutDefaultExecutorServiceContextCannotInvokeAsyncActions()
                                                                      throws ExecutionException,
                                                                             InterruptedException,
                                                                             TimeoutException

Verify that the lack of a default executor service bans contextualised CompletableFuture/CompletionStage from running async actions on them.

Throws:
  `ExecutionException` - indicates test failure
  `InterruptedException` - indicates test failure
  `TimeoutException` - indicates test failure