Jakarta Concurrency TCK Reference Guide

1. Preface

This guide describes how to download, install, configure, and run the Technology Compatibility Kit (TCK) used to verify the compatibility of an implementation of the Jakarta Concurrency specification.

The specification describes the job specification language, Java programming model, and runtime environment for Jakarta Concurrency applications.

1.1. Licensing

The Jakarta Concurrency TCK is provided under the Eclipse Foundation Technology Compatibility Kit License - v 1.0 [https://www.eclipse.org/legal/tck.php].

1.2. Who Should Use This Guide

This guide will assist in running the test suite, which verifies implementation compatibility for:

implementers of Jakarta Concurrency.

1.3. Terminology - "SE mode" vs. "EE mode"

Building on the previous point, it is convenient to use, as shorthand, the term "EE mode" when talking about the TCK constructs and requirements specifically for users running the TCK to certify against the entire EE platform. It is a convenient shorthand term too, then, to use the term "SE mode" for users that are only trying to certify against the Jakarta Concurrency specification, though this term in some ways might be misleading.

Some specifications have a subset of tests that can run in "SE mode" without the requirement of running against an entire EE Platform. The Concurrency TCK, however, runs all tests in "EE mode" and will require a Jakarta EE platform to test against.

1.4. Terminology - "Standalone TCK"

The community will sometimes refer to this TCK as the "standalone" Concurrency TCK. This usage comes from the fact that Jakarta Concurrency is part of the Jakarta EE Platform, which has a platform-level TCK, which we’re distinguishing this "standalone" TCK from.

This terminology is confusing, since readers might interpret "standalone" to mean that this TCK can be run in SE Mode, when in-fact, it must be run in EE Mode. A better term would be Specification TCK, but that terminology is not yet being used.

1.5. Terminology - "Test Client" vs "Test Server"

The Concurrency TCK acts as a Test Client that will install test applications onto a Jakarta EE Platform Server. The Platform Server will act as a Test Server and run tests based on incoming requests from the Test Client. Assertions will occur both on the client and server sides.

1.6. Before You Read This Guide

Before reading this guide, you should familiarize yourself with the Jakarta Concurrency Version 3.1.0 specification, which can be found at https://jakarta.ee/specifications/concurrency/3.1/.

Other useful information and links can be found on the eclipse.org project home page for the Jakarta Concurrency project [https://projects.eclipse.org/projects/ee4j.cu] and also at the GitHub repository home for the specification project [https://github.com/jakartaee/concurrency].

2. Major TCK Changes

This version of the Jakarta Concurrency TCK introduces two major changes to the TCK:

We change the official execution of the standalone TCK from Ant to Maven. Though the TCK has long been built with Maven and we even have included execution or "runner" Maven modules, our official documentation described an Ant-based execution. This updated version of the TCK Reference Guide details the requirements and procedures for performing an official Maven-based execution of this TCK.
We changed from using a proprietary "Test Harness" framework to deploy and test applications on Jakarta EE Platforms, to using the open source Arquillian test framework.

3. What Tests Must I Pass To Certify Compatibility?

3.1. Runtime Tests and Signature Tests Required

To certify compatibility with the entire Jakarta EE Platform (including Jakarta Concurrency), you will need to run the TCK against your implementation and pass 100% of both the:

Junit5 runtime tests
Signature tests

The two types of tests are encapsulated in a single execution or configuration. This means that the Signature Tests will run alongside all other tests and no additional execution or configuration is required.

By "runtime" tests we simply mean tests simulating Jakarta Concurrency applications running against the Concurrency implementation attempting to certify compatibility. These tests verify that the Concurrency applications behave according to the details defined in the specification, as validated by the TCK test logic.

3.2. Java SE level - Java 11 or Java 17

The JDK used during test execution must be noted and listed as an important component of the certification request. In particular, the Java SE version is important to note, and this version must be used consistently throughout both the Junit5 runtime and Signature tests for a given certification request.

For the current TCK version, this can be done with either Java SE Version 11 or Version 17.

4. Prerequisites

4.1. Software To Install

Java/JDK - Install the JDK you intend to use for this certification request (Java SE Version 11 or Version 17).
Maven - Install Apache Maven 3.6.0 or higher.
Jakarta EE Platform - Jakarta EE Application Server or Container [Glassfish, Open Liberty, JBoss, WebLogic, etc.]

4.2. Testing Framework

To better understand how this TCK works, knowing what testing frameworks are being utilized is helpful. Knowledge of how these frameworks operate and interact will help during the project setup.

Arquillian - Since the EE Platform TCK uses Arquillian to execute tests within an Arquillian "container" for certifying against the EE Platform, you must configure an Arquillian adapter for your target runtime. Version 1.6.0 or later
Signature Test Tool - No action is needed here, but we note that the signature files were built and should be validated with the Maven plugin with group:artifact:version coordinates: org.netbeans.tools:sigtest-maven-plugin:1.6, as used by the sample sigtest runner included in the TCK zip. This is a more specific direction than in earlier releases, in which it was left more open for the user to use a compatible tool. Since there are small differences in the various signature test tools, we standardize on this version.

5. A Guide to the TCK Distribution

This section explains how to obtain the TCK and extract it on your system.

5.1. Obtaining the Software

The Jakarta Concurrency TCK is distributed as a zip file, which contains the TCK artifacts (the test suite binary and source, porting package SPI binary and source, the test suite XML definitions, and signature files) in /artifacts, the documentation in /doc, and a starter project in /starter. You can access the current source code from the Git repository: https://github.com/jakartaee/concurrency.

5.2. The TCK Environment

The software can simply be extracted from the ZIP file. Once the TCK is extracted, you’ll see the following structure:

concurrency-tck-<version>-dist/
  artifacts/
  doc/
  starter/
  LICENSE
  README.md

In more detail:

artifacts contains all the test artifacts pertaining to the TCK: The TCK test classes and source, the Junit5 configuration file, a copy of the SignatureTest file for reference, and a script to copy the TCK into local maven repository.
doc contains the documentation for the TCK: this reference guide.
starter a very basic starter maven project to get you started.

5.3. A Quick Tour of the TCK Artifacts

5.3.1. What is included

The Concurrency TCK is a test library that includes four types of packages:

ee.jakarta.tck.concurrent.api.* these are basic API tests that ensure methods throw the correct exceptions and return the valid values.
ee.jakarta.tck.concurrent.spec.* these are more complex SPEC tests that ensure that implementations behave as expected based on the specification.
ee.jakarta.tck.concurrent.common.* these are common packages shared between test packages.
ee.jakarta.tck.concurrent.framework this package is an abstraction layer to make writing tests using Junit5, Arquillian, SigTest, and java.util.logging easier.

Junit5 "suite" definition XML files

Here we use the term "suite" informally to describe groups of tests required to pass the TCK (and NOT specifically to refer to any particular "suite" construct defined by the Junit5 API).

There are two "suites" included in the TCK. There is a "suite" for the Concurrency API portion of the "Jakarta EE Platform" TCK and there is a second suite for the Concurrency SPI portion of the "Jakarta EE Platform".

These "suites" are both represented within the single artifacts/suite.xml file for the full profile and artifacts/suite-web.xml for the web profile, and are identified by their package names:

ee.jakarta.tck.concurrent.api.*
ee.jakarta.tck.concurrent.spec.*

Note: An implementation MUST run against all tests provided in the suite XML file for the given profile unmodified for an implementation of such profile to pass the TCK.

API Signature Files

The one signature file exists for both Java 11 and 17:

artifacts/jakarta.enterprise.concurrent.sig

Note: This signature file is for reference only. A copy of the signature file is included in the Concurrency TCK test jar.

5.3.2. What is not included

The Concurrency TCK uses but does not provide the necessary application servers, test frameworks, APIs, SPIs, or implementations required to run. It is up to the tester to include those dependencies and set up a test project to run the TCK.

Here is an essential checklist of what you will need, and links to the section that describe how to satisfy these requirements:

An Application Server to test against | Software To Install
The Concurrency API, Concurrency TCK, Arquillian, and Junit5 libraries available to the Test Client | Test Client Dependencies
The Arquillian, Junit5, Derby JDBC, and Signature Test libraries available to the Test Server | Test Server Dependencies
An Arquillian SPI implementation for your Application Server | Configure Arquillian
An Application Server configuration with specific security roles | Configure Application Server
A logging configuration for TCK logging on Test Client and Test Server | Configure Logging

6. TCK Test Requirements

Because there is flexibility regarding how a user could use Maven to configure a TCK execution, we make a separate, clear note here of the required number of tests needed to be passed in order to claim compliance via this TCK.

6.1. Runtime tests

For the Junit5 runtime tests of the TCK, the following table shows the number of tests that should pass based on platform:

standalone	core	web	full	skipped
0	0	183	268	27

standalone

core

web

full

skipped

183

268

Note: Counts include signature test, but do not include disabled tests.

7. Example runner

This section is dedicated to listing example runners for other implementations to use as a reference on how to configure and use the Concurrency TCK.

Below are links to projects where the Concurrency TCK is being used and run successfully:

Open Liberty: https://github.com/OpenLiberty/open-liberty/tree/release/dev/io.openliberty.jakarta.concurrency.3.0_fat_tck

8. Set up a TCK runner project

A simple maven project is required to control the lifecycle of the Concurrency TCK.

8.1. Test Client Dependencies

The entry point to running the TCK will be on the client-side using Junit5. The Test Client will need to be configured with the dependencies necessary to run the TCK. Some of these dependencies will depend on the application server you are using, and comments have been added to this sample describing the customizations necessary.

Example starter/pom.xml:

    <!-- The Arquillian test framework -->
    <dependencyManagement>
        <dependencies>
            <dependency>
                <groupId>org.jboss.arquillian</groupId>
                <artifactId>arquillian-bom</artifactId>
                <version>${arquillian.version}</version>
                <type>pom</type>
                <scope>import</scope>
            </dependency>
        </dependencies>
    </dependencyManagement>

    <!-- Client Dependencies -->
    <dependencies>
        <!-- The TCK -->
        <dependency>
            <groupId>jakarta.enterprise.concurrent</groupId>
            <artifactId>jakarta.enterprise.concurrent-tck</artifactId>
            <version>${jakarta.concurrent.version}</version>
        </dependency>
        <!-- The API -->
        <dependency>
            <groupId>jakarta.enterprise.concurrent</groupId>
            <artifactId>jakarta.enterprise.concurrent-api</artifactId>
            <version>${jakarta.concurrent.version}</version>
        </dependency>
        <!-- Arquillian Implementation for JUnit5 -->
        <dependency>
            <groupId>org.jboss.arquillian.junit5</groupId>
            <artifactId>arquillian-junit5-container</artifactId>
            <version>${arquillian.version}</version>
        </dependency>
        <!-- TODO add Arquillian SPI impl for your Jakarta EE Platform -->
        <!-- Arquillian transitive dependency on Servlet -->
        <dependency>
            <groupId>jakarta.servlet</groupId>
            <artifactId>jakarta.servlet-api</artifactId>
            <version>${jakarta.servlet.version}</version>
        </dependency>
        <!-- JUnit5 -->
        <dependency>
		    <groupId>org.junit.jupiter</groupId>
		    <artifactId>junit-jupiter</artifactId>
            <version>${junit5.version}</version>
        </dependency>
        <!-- Signature Test Plugin -->
        <dependency>
            <groupId>org.netbeans.tools</groupId>
            <artifactId>sigtest-maven-plugin</artifactId>
            <version>${sigtest.version}</version>
        </dependency>
    </dependencies>

Each of these Arquillian tests run within the runtime’s Servlet container, with the help of an Arquillian adapter for that runtime implementation (mentioned as a prerequisite).

8.2. Test Server Dependencies

If the Test Server is running on a separate JVM (recommended), then the Test Server will also need access to the Junit5, Signature Test, and the Derby JDBC libraries. The Test Server dependencies can be copied over during the build phase.

Example starter/pom.xml:

            <!-- Test Server Dependencies -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-dependency-plugin</artifactId>
                <version>${maven.dep.plugin.version}</version>
                <configuration>
                    <artifactItems>
                        <artifactItem>
                            <groupId>org.junit.jupiter</groupId>
                            <artifactId>junit-jupiter</artifactId>
                            <version>${junit5.version}</version>
                        </artifactItem>
                        <artifactItem>
                            <groupId>org.apache.derby</groupId>
                            <artifactId>derby</artifactId>
                            <version>${derby.version}</version>
                        </artifactItem>
                        <artifactItem>
                            <groupId>org.netbeans.tools</groupId>
                            <artifactId>sigtest-maven-plugin</artifactId>
                            <version>${sigtest.version}</version>
                        </artifactItem>
                    </artifactItems>
                    <outputDirectory>${application.server.lib}</outputDirectory>
                </configuration>
            </plugin>

Using the maven command:

$ mvn dependency:copy

8.3. Configure Junit5

Junit5 needs to be configured to know which Jakarta EE profile to test against.

In order for your maven project to execute these tests the surefire plugin needs to be configured.

Example starter/pom.xml:

            <!-- Surefire plugin - Entrypoint for Junit -->
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-surefire-plugin</artifactId>
                <version>${maven.surefire.plugin.version}</version>
                <configuration>
                    <systemPropertyVariables>
                    </systemPropertyVariables>
                    <groups>${test.included}</groups>                        <!-- Groups to include i.e. web/full -->
                    <excludedGroups>${test.excluded.groups}</excludedGroups> <!-- Groups to ignore i.e. signature -->
                    <!-- Ensure surfire plugin looks under src/main/java instead of src/test/java -->
                    <testSourceDirectory>${basedir}${file.separarator}src${file.separarator}main${file.separarator}java${file.separarator}</testSourceDirectory>
                </configuration>
            </plugin>

8.4. Configure Arquillian

Application Servers that implement the Arquillian SPI use a configuration file to define properties, such as hostname, port, username, password, etc. These properties will allow Arquillian to connect to the application server, install applications, and get test responses. An Arquillian configuration file has been provided in the starter/ directory.

8.5. Configure Application Server

The Concurrency TCK uses default objects (java:comp/DefaultManagedExecutorService) and annotation-based configurations (@ManagedExecutorDefinition) to ensure that application servers require minimal customization to run the TCK.

However, the Concurrency TCK does require that Application Servers define a security context for security-based tests.

Username: javajoe
Password: javajoe
Group: Manager

The TCK uses external libraries that also need to be available on the Application Server’s class path.

org.apache.derby:derby - For database testing
org.junit.jupiter:junit-jupiter - For test assertions
org.netbeans.tools:sigtest-maven-plugin - For signature testing

See Test Server Dependencies

8.6. Configure Logging

The Concurrency TCK uses java.util.logging for logging debug messages, and to output test results in some cases. Registered loggers exist both on the Test Client and Test Server meaning you will need to configure both sides to enable logging. This is done by pointing the JVM to the logging configuration file using the property. An example logging configuration file has been provided under the /starter directory.

To enable logging for the Client side of tests, add a system property to the surefire plugin:

Example starter/pom.xml:

                        <java.util.logging.config.file>${logging.config}</java.util.logging.config.file>

To enable logging for the Server side of tests, set the same system property on the JVM running your application server.

8.7. Advanced Configuration

Some application servers may have custom deployment descriptors that they would like to include as part of the applications that are being deployed to their server. The custom deployment descriptors can be included in a programmatic way using ShrinkWrap and the Arquillian SPI.

Example ApplicationArchiveProcessor:

public class MyApplicationArchiveProcessor implements ApplicationArchiveProcessor {
    List<String> appNames;

    @Override
    public void process(Archive<?> archive, TestClass testClass) {
        if(appNames.contains(archive.getName())){
            ((WebArchive) archive).addAsWebInfResource("my-custom-sun-web.xml", "sun-web.xml");
        }
    }

Example LoadableExtension:

public class MyLoadableExtension implements LoadableExtension {
    @Override
    public void register(ExtensionBuilder extensionBuilder) {
        extensionBuilder.service(ApplicationArchiveProcessor.class, MyApplicationArchiveProcessor.class);
    }
}

Example META-INF/services/org.jboss.arquillian.core.spi.LoadableExtension:

my.custom.test.package.MyLoadableExtension

9. Running the TCK

Once the TCK Runner project is created and configured the Concurrency TCK is run as part of the maven test lifecycle.

$ cd starter
$ mvn clean test

9.1. Expected Output

Here is example output when the starter runner runs successfully in full mode:

$ mvn clean test
...
[INFO] --- maven-surefire-plugin:3.0.0-M7:test (default-test) @ tck.runner ---
[INFO] Using auto detected provider org.apache.maven.surefire.junitplatform.JUnitPlatformProvider
[INFO]
[INFO] -------------------------------------------------------
[INFO]  T E S T S
[INFO] -------------------------------------------------------
[INFO] Running ee.jakarta.tck.concurrent.api.AbortedException.AbortedExceptionTests
[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.AbortedException.AbortedExceptionTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.api.ContextService.ContextServiceTests
[INFO] Tests run: 14, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.ContextService.ContextServiceTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.api.LastExecution.LastExecutionTests
[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.LastExecution.LastExecutionTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.api.ManagedExecutors.ManagedExecutorsTests
[INFO] Tests run: 10, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.ManagedExecutors.ManagedExecutorsTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.api.ManagedScheduledExecutorService.ManagedScheduledExecutorServiceTests
[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.ManagedScheduledExecutorService.ManagedScheduledExecutorServiceTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.api.ManagedTask.ManagedTaskTests
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.ManagedTask.ManagedTaskTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.api.ManagedTaskListener.ManagedTaskListenerTests
[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.ManagedTaskListener.ManagedTaskListenerTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.api.ManagedThreadFactory.ManagedThreadFactoryTests
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.ManagedThreadFactory.ManagedThreadFactoryTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.api.SkippedException.SkippedExceptionTests
[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.SkippedException.SkippedExceptionTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.api.Trigger.TriggerTests
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.api.Trigger.TriggerTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ContextService.contextPropagate.ContextPropagationFullTests
[WARNING] Tests run: 15, Failures: 0, Errors: 0, Skipped: 3,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ContextService.contextPropagate.ContextPropagationFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ContextService.contextPropagate.ContextPropagationWebTests
[WARNING] Tests run: 14, Failures: 0, Errors: 0, Skipped: 4,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ContextService.contextPropagate.ContextPropagationWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ContextService.contextPropagate.servlet.ContextPropagationServletTests
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ContextService.contextPropagate.servlet.ContextPropagationServletTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ContextService.tx.TransactionTests
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ContextService.tx.TransactionTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedExecutorService.inheritedapi.InheritedAPITests
[INFO] Tests run: 4, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedExecutorService.inheritedapi.InheritedAPITests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedExecutorService.managed.forbiddenapi.ForbiddenAPIEJBTests
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedExecutorService.managed.forbiddenapi.ForbiddenAPIEJBTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedExecutorService.managed.forbiddenapi.ForbiddenAPIServletTests
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedExecutorService.managed.forbiddenapi.ForbiddenAPIServletTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedExecutorService.resourcedef.ManagedExecutorDefinitionFullTests
[WARNING] Tests run: 18, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedExecutorService.resourcedef.ManagedExecutorDefinitionFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedExecutorService.resourcedef.ManagedExecutorDefinitionWebTests
[WARNING] Tests run: 18, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedExecutorService.resourcedef.ManagedExecutorDefinitionWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedExecutorService.security.SecurityFullTests
[WARNING] Tests run: 0, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedExecutorService.security.SecurityFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedExecutorService.security.SecurityWebTests
[WARNING] Tests run: 0, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedExecutorService.security.SecurityWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedExecutorService.tx.TransactionTests
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedExecutorService.tx.TransactionTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.inheritedapi.InheritedAPIFullTests
[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.inheritedapi.InheritedAPIFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.inheritedapi.InheritedAPIServletTests
[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.inheritedapi.InheritedAPIServletTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.inheritedapi.InheritedAPIWebTests
[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.inheritedapi.InheritedAPIWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.managed.forbiddenapi.ForbiddenAPIEJBTests
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.managed.forbiddenapi.ForbiddenAPIEJBTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.managed.forbiddenapi.ForbiddenAPIServletTests
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.managed.forbiddenapi.ForbiddenAPIServletTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.resourcedef.ManagedScheduledExecutorDefinitionFullTests
[WARNING] Tests run: 20, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.resourcedef.ManagedScheduledExecutorDefinitionFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.resourcedef.ManagedScheduledExecutorDefinitionWebTests
[WARNING] Tests run: 20, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.resourcedef.ManagedScheduledExecutorDefinitionWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.security.SecurityFullTests
[WARNING] Tests run: 0, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.security.SecurityFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.security.SecurityWebTests
[WARNING] Tests run: 0, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.security.SecurityWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.tx.TransactionTests
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedScheduledExecutorService.tx.TransactionTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.context.ContextFullTests
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.context.ContextFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.context.ContextWebTests
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.context.ContextWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.resourcedef.ManagedThreadFactoryDefinitionFullTests
[WARNING] Tests run: 2, Failures: 0, Errors: 0, Skipped: 4,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.resourcedef.ManagedThreadFactoryDefinitionFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.resourcedef.ManagedThreadFactoryDefinitionWebTests
[WARNING] Tests run: 2, Failures: 0, Errors: 0, Skipped: 4,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.resourcedef.ManagedThreadFactoryDefinitionWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.tx.TransactionTests
[INFO] Tests run: 3, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.ManagedThreadFactory.tx.TransactionTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.Platform.anno.AnnotationFullTests
[WARNING] Tests run: 7, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.Platform.anno.AnnotationFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.Platform.anno.AnnotationWebTests
[WARNING] Tests run: 7, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.Platform.anno.AnnotationWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.Platform.dd.DeploymentDescriptorFullTests
[WARNING] Tests run: 7, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.Platform.dd.DeploymentDescriptorFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.Platform.dd.DeploymentDescriptorWebTests
[WARNING] Tests run: 7, Failures: 0, Errors: 0, Skipped: 1,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.Platform.dd.DeploymentDescriptorWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.Platform.virtual.VirtualFullTests
[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.Platform.virtual.VirtualFullTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.Platform.virtual.VirtualWebTests
[INFO] Tests run: 7, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.Platform.virtual.VirtualWebTests
[INFO]
[INFO] Running ee.jakarta.tck.concurrent.spec.signature.SignatureTests
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0,Time elapsed: y.yy s - in ee.jakarta.tck.concurrent.spec.signature.SignatureTests
[INFO]
[INFO] Results:
[INFO]
[WARNING] Tests run: 295, Failures: 0, Errors: 0, Skipped: 27
[INFO]
[INFO] -------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] -------------------------------------------------------
[INFO] Total time:  xx.xxx s
[INFO] Finished at: yyyy-mm-ddThh:mm:ss.mmmm
[INFO] -------------------------------------------------------

10. Signature Tests

The signature tests validate the integrity of the jakarta.enterprise.concurrent Java "namespace" (or "package prefix") of the Concurrency implementation. This would be especially important for an implementation packaging its own API JAR in which the API must be validated in its entirety. For implementations expecting their users to rely on the API released by the Jakarta Concurrency specification project (e.g. to Maven Central) the signature tests are also important to validate that improper (non-spec-defined) extensions have not been added to jakarta.enterprise.concurrent.* packages/classes/etc.

10.1. Running signature tests

The Concurrency TCK will run signature tests on the application server itself, and not as part of a separate plugin / execution. This means that the signature tests will run during the maven test phase.

You need to configure your application server with a JVM property -Djimage.dir=<path-your-server-has-access-to>. This is because, when running the signature tests on JDK 9+ we need to convert the JDK modules back into class files for signature testing.

The signature test plugin we use will also attempt to perform reflective access of classes, methods, and fields. Due to the new module system in JDK 9+ special permissions need to be added in order for these tests to run:

If you are using a Security Manager add the following permissions to the sigtest-maven-plugin on your application server:

permission java.lang.RuntimePermission "accessClassInPackage.jdk.internal";
permission java.lang.RuntimePermission "accessClassInPackage.jdk.internal.reflect";
permission java.lang.RuntimePermission "accessClassInPackage.jdk.internal.vm.annotation";

By default the java.base module only exposes certain classes for reflective access. Therefore, the Concurrency TCK test will need access to the jdk.internal.vm.annotation class. To give the sigtest-maven-plugin access to this class set the following JVM properties:

--add-exports java.base/jdk.internal.vm.annotation=ALL-UNNAMED
--add-opens java.base/jdk.internal.vm.annotation=ALL-UNNAMED

Some JDKs will mistake the space in the prior JVM properties as delimiters between properties In this case use:

--add-exports=java.base/jdk.internal.vm.annotation=ALL-UNNAMED
--add-opens=java.base/jdk.internal.vm.annotation=ALL-UNNAMED

For more information about generating the signature test file, and how the test run read: [ee.jakarta.tck.concurrent.framework.signaturetest/README.md](https://github.com/jakartaee/concurrency/blob/master/tck/src/main/java/ee/jakarta/tck/concurrent/framework/signaturetest/README.md)

As mentioned in the prerequisite section the signature file formats across the various signature test tools have diverged and this test suite uses the Maven plugin with group:artifact:version coordinates: org.netbeans.tools:sigtest-maven-plugin:1.6.

10.2. Expected output

The the Signature Test plugin will log output to System.out. Whereas, the Signature Test framework we use to set up the test will log using java.util.logging so you may see these logs output to two separate locations depending on your application server.

******************************************************
All package signatures passed.
    Passed packages listed below:
        jakarta.enterprise.concurrent(static mode)
        jakarta.enterprise.concurrent(reflection mode)
        jakarta.enterprise.concurrent.spi(static mode)
        jakarta.enterprise.concurrent.spi(reflection mode)

******************************************************

11. TCK Challenges/Appeals Process

The Jakarta EE TCK Process 1.1 will govern all process details used for challenges to the Jakarta Concurrency TCK.

Except from the Jakarta EE TCK Process 1.1:

Specifications are the sole source of truth and considered overruling to the TCK in all senses. In the course of implementing a specification and attempting to pass the TCK, implementations may come to the conclusion that one or more tests or assertions do not conform to the specification, and therefore MUST be excluded from the certification requirements.

Requests for tests to be excluded are referred to as Challenges. This section identifies who can make challenges to the TCK, what challenges to the TCK may be submitted, how these challenges are submitted, how and to whom challenges are addressed.

11.1. Filing a Challenge

The challenge process is defined within the Challenges section within the Jakarta EE TCK Process 1.1.

Challenges will be tracked via the issues of the Jakarta Concurrency Specification repository.

The challenge process mentioned in the Jakarta EE TCK Process 1.1 can be started by clicking here, it is recommended that you read through the challenge process to understand it in detail.

11.2. Successful Challenges

The following tests are exempt from TCK testing due to challenges:

Class	Method	Link	Version
ContextPropagationFullTests	testSecurityUnchangedContext	https://github.com/jakartaee/concurrency/pull/206	3.0.0
ContextPropagationFullTests	testSecurityClearedContext	https://github.com/jakartaee/concurrency/pull/206	3.0.0
ContextPropagationFullTests	testContextualFunction	https://github.com/jakartaee/concurrency/issues/253	3.0.1
ContextPropagationWebTests	testSecurityUnchangedContext	https://github.com/jakartaee/concurrency/pull/206	3.0.0
ContextPropagationWebTests	testJNDIContextAndCreateProxyInEJB	https://github.com/jakartaee/concurrency/pull/260	3.0.0
ContextPropagationWebTests	testSecurityClearedContext	https://github.com/jakartaee/concurrency/pull/206	3.0.0
ContextPropagationWebTests	testContextualFunction	https://github.com/jakartaee/concurrency/issues/253	3.0.1
ManagedExecutorDefinitionFullTests	testCompletedFuture	https://github.com/jakartaee/concurrency/issues/224	3.0.0
ManagedExecutorDefinitionWebTests	testCompletedFuture	https://github.com/jakartaee/concurrency/issues/224	3.0.0
SecurityFullTests	managedExecutorServiceAPISecurityTest	https://github.com/jakartaee/concurrency/issues/227	3.0.0
SecurityWebTests	managedExecutorServiceAPISecurityTest	https://github.com/jakartaee/concurrency/issues/227	3.0.0
ManagedScheduledExecutorDefinitionFullTests	testCompletedFutureMSE	https://github.com/jakartaee/concurrency/issues/224	3.0.0
ManagedScheduledExecutorDefinitionWebTests	testCompletedFutureMSE	https://github.com/jakartaee/concurrency/issues/224	3.0.0
SecurityFullTests	managedScheduledExecutorServiceAPISecurityTest	https://github.com/jakartaee/concurrency/issues/227	3.0.0
SecurityWebTests	managedScheduledExecutorServiceAPISecurityTest	https://github.com/jakartaee/concurrency/issues/227	3.0.0
ManagedThreadFactoryDefinitionFullTests	testManagedThreadFactoryDefinitionAllAttributesEJB	https://github.com/jakartaee/concurrency/issues/226	3.0.0
ManagedThreadFactoryDefinitionFullTests	testManagedThreadFactoryDefinitionAllAttributes	https://github.com/jakartaee/concurrency/issues/226	3.0.0
ManagedThreadFactoryDefinitionFullTests	testParallelStreamBackedByManagedThreadFactoryEJB	https://github.com/jakartaee/concurrency/issues/226	3.0.0
ManagedThreadFactoryDefinitionFullTests	testParallelStreamBackedByManagedThreadFactory	https://github.com/jakartaee/concurrency/issues/226	3.0.0
ManagedThreadFactoryDefinitionWebTests	testManagedThreadFactoryDefinitionAllAttributesEJB	https://github.com/jakartaee/concurrency/issues/226	3.0.0
ManagedThreadFactoryDefinitionWebTests	testManagedThreadFactoryDefinitionAllAttributes	https://github.com/jakartaee/concurrency/issues/226	3.0.0
ManagedThreadFactoryDefinitionWebTests	testParallelStreamBackedByManagedThreadFactoryEJB	https://github.com/jakartaee/concurrency/issues/226	3.0.0
ManagedThreadFactoryDefinitionWebTests	testParallelStreamBackedByManagedThreadFactory	https://github.com/jakartaee/concurrency/issues/226	3.0.0
AnnotationFullTests	testAnnotationDefinesManagedThreadFactory	https://github.com/jakartaee/concurrency/issues/226	3.0.0
AnnotationWebTests	testAnnotationDefinesManagedThreadFactory	https://github.com/jakartaee/concurrency/issues/226	3.0.0
DeploymentDescriptorFullTests	testDeploymentDescriptorDefinesManagedThreadFactory	https://github.com/jakartaee/concurrency/issues/226	3.0.0
DeploymentDescriptorWebTests	testDeploymentDescriptorDefinesManagedThreadFactory	https://github.com/jakartaee/concurrency/issues/226	3.0.0

Class

Method

Link

Version

ContextPropagationFullTests

testSecurityUnchangedContext

https://github.com/jakartaee/concurrency/pull/206

3.0.0

ContextPropagationFullTests

testSecurityClearedContext

https://github.com/jakartaee/concurrency/pull/206

3.0.0

ContextPropagationFullTests

testContextualFunction

https://github.com/jakartaee/concurrency/issues/253

3.0.1

ContextPropagationWebTests

testSecurityUnchangedContext

https://github.com/jakartaee/concurrency/pull/206

3.0.0

ContextPropagationWebTests

testJNDIContextAndCreateProxyInEJB

https://github.com/jakartaee/concurrency/pull/260

3.0.0

ContextPropagationWebTests

testSecurityClearedContext

https://github.com/jakartaee/concurrency/pull/206

3.0.0

ContextPropagationWebTests

testContextualFunction

https://github.com/jakartaee/concurrency/issues/253

3.0.1

ManagedExecutorDefinitionFullTests

testCompletedFuture

https://github.com/jakartaee/concurrency/issues/224

3.0.0

ManagedExecutorDefinitionWebTests

testCompletedFuture

https://github.com/jakartaee/concurrency/issues/224

3.0.0

SecurityFullTests

managedExecutorServiceAPISecurityTest

https://github.com/jakartaee/concurrency/issues/227

3.0.0

SecurityWebTests

managedExecutorServiceAPISecurityTest

https://github.com/jakartaee/concurrency/issues/227

3.0.0

ManagedScheduledExecutorDefinitionFullTests

testCompletedFutureMSE

https://github.com/jakartaee/concurrency/issues/224

3.0.0

ManagedScheduledExecutorDefinitionWebTests

testCompletedFutureMSE

https://github.com/jakartaee/concurrency/issues/224

3.0.0

SecurityFullTests

managedScheduledExecutorServiceAPISecurityTest

https://github.com/jakartaee/concurrency/issues/227

3.0.0

SecurityWebTests

managedScheduledExecutorServiceAPISecurityTest

https://github.com/jakartaee/concurrency/issues/227

3.0.0

ManagedThreadFactoryDefinitionFullTests

testManagedThreadFactoryDefinitionAllAttributesEJB

https://github.com/jakartaee/concurrency/issues/226

3.0.0

ManagedThreadFactoryDefinitionFullTests

testManagedThreadFactoryDefinitionAllAttributes

https://github.com/jakartaee/concurrency/issues/226

3.0.0

ManagedThreadFactoryDefinitionFullTests

testParallelStreamBackedByManagedThreadFactoryEJB

https://github.com/jakartaee/concurrency/issues/226

3.0.0

ManagedThreadFactoryDefinitionFullTests

testParallelStreamBackedByManagedThreadFactory

https://github.com/jakartaee/concurrency/issues/226

3.0.0

ManagedThreadFactoryDefinitionWebTests

testManagedThreadFactoryDefinitionAllAttributesEJB

https://github.com/jakartaee/concurrency/issues/226

3.0.0

ManagedThreadFactoryDefinitionWebTests

testManagedThreadFactoryDefinitionAllAttributes

https://github.com/jakartaee/concurrency/issues/226

3.0.0

ManagedThreadFactoryDefinitionWebTests

testParallelStreamBackedByManagedThreadFactoryEJB

https://github.com/jakartaee/concurrency/issues/226

3.0.0

ManagedThreadFactoryDefinitionWebTests

testParallelStreamBackedByManagedThreadFactory

https://github.com/jakartaee/concurrency/issues/226

3.0.0

AnnotationFullTests

testAnnotationDefinesManagedThreadFactory

https://github.com/jakartaee/concurrency/issues/226

3.0.0

AnnotationWebTests

testAnnotationDefinesManagedThreadFactory

https://github.com/jakartaee/concurrency/issues/226

3.0.0

DeploymentDescriptorFullTests

testDeploymentDescriptorDefinesManagedThreadFactory

https://github.com/jakartaee/concurrency/issues/226

3.0.0

DeploymentDescriptorWebTests

testDeploymentDescriptorDefinesManagedThreadFactory

https://github.com/jakartaee/concurrency/issues/226

3.0.0

12. Certification of Compatibility

The Jakarta EE TCK Process 1.1 will define the core process details used to certify compatibility with the Jakarta Concurrency specification, through execution of the Jakarta Concurrency TCK.

Except from the Jakarta EE TCK Process 1.1:

Jakarta EE is a self-certification ecosystem. If you wish to have your implementation listed on the official https://jakarta.ee implementations page for the given specification, a certification request as defined in this section is required.

12.1. Filing a Certification Request

The certification of compatibility process is defined within the Certification of Compatibility section within the Jakarta EE TCK Process 1.1.

Certifications will be tracked via the issues of the Jakarta Concurrency Specification repository.

The certification of compatibility process mentioned in the Jakarta EE TCK Process 1.1 can be started by clicking here, it is recommended that you read through the certification process to understand it in detail.

13. Rules for Jakarta Concurrency Products

The following rules apply for each version of an operating system, software component, and hardware platform Documented as supporting the Product:

Concurrency1 The Product must be able to satisfy all applicable compatibility requirements, including passing all Conformance Tests, in every Product Configuration and in every combination of Product Configurations, except only as specifically exempted by these Rules. For example, if a Product provides distinct Operating Modes to optimize performance, then that Product must satisfy all applicable compatibility requirements for a Product in each Product Configuration, and combination of Product Configurations, of those Operating Modes.
Concurrency1.1 If an Operating Mode controls a Resource necessary for the basic execution of the Test Suite, testing may always use a Product Configuration of that Operating Mode providing that Resource, even if other Product Configurations do not provide that Resource. Notwithstanding such exceptions, each Product must have at least one set of Product Configurations of such Operating Modes that is able to pass all the Conformance Tests. For example, a Product with an Operating Mode that controls a security policy (i.e., Security Resource) which has one or more Product Configurations that cause Conformance Tests to fail may be tested using a Product Configuration that allows all Conformance Tests to pass.
Concurrency1.2 A Product Configuration of an Operating Mode that causes the Product to report only version, usage, or diagnostic information is exempted from these compatibility rules.
Concurrency1.3 An API Definition Product is exempt from all functional testing requirements defined here, except the signature tests.
Concurrency2 Some Conformance Tests may have properties that may be changed. Properties that can be changed are identified in the configuration interview. Properties that can be changed are identified in the JavaTest Environment (.jte) files in the Test Suite installation. Apart from changing such properties and other allowed modifications described in this User’s Guide (if any), no source or binary code for a Conformance Test may be altered in any way without prior written permission. Any such allowed alterations to the Conformance Tests will be provided via the Jakarta EE Specification Project website and apply to all vendor compatible implementations.
Concurrency3 The testing tools supplied as part of the Test Suite or as updated by the Maintenance Lead must be used to certify compliance.
Concurrency4 The Exclude List associated with the Test Suite cannot be modified.
Concurrency5 The Maintenance Lead can define exceptions to these Rules. Such exceptions would be made available as above, and will apply to all vendor implementations.
Concurrency6 All hardware and software component additions, deletions, and modifications to a Documented supporting hardware/software platform, that are not part of the Product but required for the Product to satisfy the compatibility requirements, must be Documented and available to users of the Product. For example, if a patch to a particular version of a supporting operating system is required for the Product to pass the Conformance Tests, that patch must be Documented and available to users of the Product.
Concurrency7 The Product must contain the full set of public and protected classes and interfaces for all the Libraries. Those classes and interfaces must contain exactly the set of public and protected methods, constructors, and fields defined by the Specifications for those Libraries. No subsetting, supersetting, or modifications of the public and protected API of the Libraries are allowed except only as specifically exempted by these Rules.
Concurrency7.1 If a Product includes Technologies in addition to the Technology Under Test, then it must contain the full set of combined public and protected classes and interfaces. The API of the Product must contain the union of the included Technologies. No further modifications to the APIs of the included Technologies are allowed.
Concurrency8 Except for tests specifically required by this TCK to be rebuilt (if any), the binary Conformance Tests supplied as part of the Test Suite or as updated by the Maintenance Lead must be used to certify compliance.
Concurrency9 The functional programmatic behavior of any binary class or interface must be that defined by the Specifications.

14. Links

Jakarta Concurrency TCK repository - https://github.com/jakartaee/concurrency
Jakarta Concurrency specification/API repository - https://github.com/jakartaee/concurrency
Jakarta Concurrency project home page - https://projects.eclipse.org/projects/ee4j.cu
Arquillian and ShrinkWrap doc: https://arquillian.org/guides/shrinkwrap_introduction/