diff --git a/user_guides/jakartaee/src/main/jbake/content/TCKpreface.adoc b/user_guides/jakartaee/src/main/jbake/content/TCKpreface.adoc index 0695560da0..20cab950ad 100644 --- a/user_guides/jakartaee/src/main/jbake/content/TCKpreface.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/TCKpreface.adoc @@ -27,16 +27,17 @@ Enterprise Edition should be considered references to Jakarta EE. Please see the Title page for additional license information. ======================================================================== -This book introduces the Test Compatibility Kit (TCK) for the Jakarta -Platform 9 full profile (Jakarta EE 9) and Jakarta Platform 9 Web Profile (Jakarta EE 9 Web Profile), and explains how to +This book introduces the Compatibility Test Suite (CTS) for the Jakarta +Platform, Enterprise Edition 9 (Jakarta EE 9) and Jakarta Platform, Enterprise +Edition 9 Web Profile (Jakarta EE 9 Web Profile), and explains how to configure and run the test suite. It also provides information for troubleshooting problems you may encounter as you run the test suite. The Jakarta Platform, Enterprise Edition 9 Compatibility Test Suite (Jakarta -EE 9 Platform TCK) is a portable, configurable automated test suite for verifying +EE 9 CTS) is a portable, configurable automated test suite for verifying the compatibility of an implementer's compliance with the Jakarta EE 9 Specification (hereafter referred to as the implementer's implementation, or VI). -The Jakarta EE 9 Platform TCK uses the JavaTest harness version 5.0 to run the +The Jakarta EE 9 CTS uses the JavaTest harness version 5.0 to run the test suite. @@ -72,7 +73,7 @@ programming language, the Jakarta Platform, Enterprise Edition 9 (Jakarta EE The Jakarta Platform, Enterprise Edition 9 (Jakarta EE 9) Specification can be downloaded from `https://projects.eclipse.org/projects/ee4j.jakartaee-platform`. -For documentation on the test harness used for running the Jakarta EE 9 Platform TCK +For documentation on the test harness used for running the Jakarta EE 9 CTS test suite, see `https://wiki.openjdk.java.net/display/CodeTools/Documentation`. diff --git a/user_guides/jakartaee/src/main/jbake/content/building.adoc b/user_guides/jakartaee/src/main/jbake/content/building.adoc index febfdd5601..54771310ba 100644 --- a/user_guides/jakartaee/src/main/jbake/content/building.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/building.adoc @@ -22,7 +22,7 @@ to use Ant with the following targets to rebuild, list, and run tests: * `build` * `ld`, `lld`, `lc`, `llc`, `pd`, `pc` -Implementers can only run the version of the tests provided with the TCK +Implementers can only run the version of the tests provided with the CTS for certification, except in the case of rebuildable tests. This chapter includes the following topics: @@ -39,12 +39,12 @@ This chapter includes the following topics: ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Complete the following steps to set up your environment to build, -deploy, and run the TCK tests using Ant. The following example is for +deploy, and run the CTS tests using Ant. The following example is for the Solaris platform: 1. Set the following environment variables in your shell environment to use the build infrastructure that comes with the TCK: -* `TS_HOME` to the directory in which the Jakarta EE 9 TCK software is +* `TS_HOME` to the directory in which the Jakarta EE 9 CTS software is installed. * `TS_HOME/bin` to your `PATH` in your command shell. * C Shell: + @@ -79,7 +79,7 @@ build infrastructure 10.2 Building the Tests ~~~~~~~~~~~~~~~~~~~~~~~ -To build the Jakarta EE 9 TCK tests using Ant, complete the following +To build the Jakarta EE 9 CTS tests using Ant, complete the following steps: 1. To build a single test directory, type the following: + @@ -118,7 +118,7 @@ ant pc 10.3 Running the Tests ~~~~~~~~~~~~~~~~~~~~~~ -To run the Jakarta EE 9 TCK tests using Ant, use one of the following +To run the Jakarta EE 9 CTS tests using Ant, use one of the following procedures. [[GFAOW]][[to-run-a-single-test-directory]] @@ -222,20 +222,20 @@ HelloHome.class 10.5 Debugging Service Tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -The Jakarta EE 9 TCK service tests test the compatibility of the Jakarta +The Jakarta EE 9 CTS service tests test the compatibility of the Jakarta Platform, Enterprise Edition Service APIs: Jakarta Mail, JDBC, Jakarta Messaging, Jakarta Transactions, Jakarta XML Web Services, Jakarta Web Services Metadata, Jakarta Annotations. The test suite contains sets of -tests that the JavaTest harness, in conjunction with the Jakarta EE 9 TCK +tests that the JavaTest harness, in conjunction with the Jakarta EE 9 CTS harness extensions, runs from different Jakarta Platform, Enterprise Edition containers (Jakarta Enterprise Beans, Jakarta Server Pages, Jakarta Servlet, and application client). The test suite wraps each of these tests inside generic -components, called vehicles. Each Jakarta EE 9 TCK service test has been +components, called vehicles. Each Jakarta EE 9 CTS service test has been set up to run in a default set of vehicles. Each technology's specification determines this set. When run as part of the certification process, all service API tests must pass in their default vehicle set. Refer to the `/src/vehicle.properties` file to for a list the -default vehicle sets for the Jakarta EE 9 TCK service API tests. +default vehicle sets for the Jakarta EE 9 CTS service API tests. To help you debug service API tests, the test suite provides a mechanism that allows for fine-grained control over which tests you can run in @@ -278,7 +278,7 @@ Before you run the test or tests, you should temporarily rename the file `/src/testsuite.jtd`. Note that you must remove these properties before you run the Jakarta EE 9 -TCK test suite for certification. +CTS test suite for certification. [[GFARW]][[obtaining-additional-debugging-information]] diff --git a/user_guides/jakartaee/src/main/jbake/content/config.adoc b/user_guides/jakartaee/src/main/jbake/content/config.adoc index 0a00650d13..bc6d01ad7c 100644 --- a/user_guides/jakartaee/src/main/jbake/content/config.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/config.adoc @@ -12,7 +12,7 @@ Setup and Configuration 5 Setup and Configuration ------------------------- -This chapter describes how to set up the Jakarta EE 9 Platform TCK test suite and +This chapter describes how to set up the Jakarta EE 9 CTS test suite and configure it to work with your test environment. It is recommended that you first set up the testing environment using the Jakarta EE 9 CI and then with your Jakarta EE 9 server. @@ -49,14 +49,14 @@ The instructions in this section and in link:#GEWWA[Section 5.3.3, configuration process for the Solaris, Microsoft Windows, and Linux platforms. -All TCK test configuration procedures are based on running the Ant +All CTS test configuration procedures are based on running the Ant scripts against a set of build targets. The primary location of any configuration settings you are likely to make is the `/bin/ts.jte` environment file. You may also want to modify the `javaee_vi.xml` and `initdb.xml` Ant configuration files and the vendor-specific SQL files. These two files contain predefined Ant targets that are implemented such that they automatically configure the -Jakarta EE 9 CI and its associated database in order to pass the TCK. A +Jakarta EE 9 CI and its associated database in order to pass the CTS. A Implementer may choose to implement these targets to work with their server environment to perform the steps described in link:#GEWWA[Section 5.3.3, "Configuring Your Application Server as the VI."] @@ -65,7 +65,7 @@ environment to perform the steps described in link:#GEWWA[Section 5.3.3, [NOTE] ======================================================================= -Ant targets are available at all levels of the TCK source tree that +Ant targets are available at all levels of the CTS source tree that allow you to execute a wide variety of test scenarios and configurations. @@ -86,7 +86,7 @@ backslashes (`\`) for Windows. platform to be tested for certification. 2. Implement the porting package APIs. + Some functionality in the Jakarta EE 9 platform is not completely specified -by an API. To handle this situation, the Jakarta EE 9 Platform TCK test suite +by an API. To handle this situation, the Jakarta EE 9 CTS test suite defines a set of interfaces in the `com.sun.cts.porting` package, which serve to abstract any implementation-specific code. You must create your own implementations of the porting package interfaces to work with your @@ -98,18 +98,18 @@ directory. 3. Set up the Jakarta Platform, Enterprise Edition Compatible Implementation (CI) server. + See link:#GEWUI[Section 5.3.2, "Configuring the Jakarta EE 9 CI as the -VI,"] for a list of the modifications that must be made to run TCK +VI,"] for a list of the modifications that must be made to run CTS against the Jakarta EE 9 CI. 4. Set up the vendor's Jakarta EE 9 server implementation (VI). + See link:#GEWWA[Section 5.3.3, "Configuring Your Application Server as -the VI,"] for a list of the modifications that must be made to run TCK +the VI,"] for a list of the modifications that must be made to run CTS against the vendor's Jakarta EE 9 server. 5. Validate your configuration. + Run the sample tests provided. If the tests pass, your basic configuration is valid. See link:using.html#GFACS[Section 7.3, "Validating Your Test Configuration,"] for information about using JavaTest to run the sample tests. -6. Run the TCK tests. + +6. Run the CTS tests. + See link:using.html#GBFWO[Chapter 7, "Executing Tests,"] for information about Starting JavaTest and running tests. @@ -119,7 +119,7 @@ about Starting JavaTest and running tests. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ This section describes how to configure the Jakarta EE 9 server under test. -You can run the TCK tests against the Jakarta EE 9 CI or your own Jakarta +You can run the CTS tests against the Jakarta EE 9 CI or your own Jakarta Platform, Enterprise Edition server. When performing interoperability (interop) tests or web service-based tests, you will be running two Jakarta EE 9 CI servers, one of which must be a Jakarta EE 9 CI using, or configured to @@ -131,8 +131,8 @@ they are used here: * Compatible Implementation (CI): Jakarta EE 9 CI, for example, Eclipse GlassFish 6.0 * Vendor Implemention (VI): Jakarta EE 9 implementation from a vendor other -than Eclipse; typically, the goal of running the TCK is to certify a Jakarta -EE 9 VI; in some cases, for purposes of familiarizing yourself with TCK, +than Eclipse; typically, the goal of running the CTS is to certify a Jakarta +EE 9 VI; in some cases, for purposes of familiarizing yourself with CTS, you may choose to run the Jakarta EE 9 CI as the VI * Bundled Derby: Apache Derby database bundled with the Jakarta EE 9 CI, Eclipse GlassFish 6.0 @@ -142,7 +142,7 @@ you may choose to run the Jakarta EE 9 CI as the VI ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ There are three general scenarios for configuring Jakarta EE 9 servers for -Jakarta EE 9 Platform TCK testing (Note: in the following images, Java EE refers to Jakarta EE. +Jakarta EE 9 CTS testing (Note: in the following images, Java EE refers to Jakarta EE. RI should be replaced with CI for Compatible Implementation): * Configure the Jakarta EE 9 CI as the server under test + @@ -150,7 +150,7 @@ image:img/serverpath-ri.png["CI as Server Under Test"] Use the Jakarta EE 9 CI as the Jakarta EE 9 VI; you may want to do this as a sanity check to make sure you are comfortable with using the Jakarta EE 9 -Platform TCK against a known standard CI with certified sample applications +CTS against a known standard CI with certified sample applications before proceeding with tests against your Jakarta EE 9 VI. See link:#GEWUI[Section 5.3.2, "Configuring the Jakarta EE 9 CI as the VI,"] for instructions. @@ -158,7 +158,7 @@ for instructions. * Configure your Jakarta EE 9 VI as Server Under Test + image:img/serverpath-vi.png["VI as Server Under Test"] -This is the primary goal of using the Jakarta EE 9 Platform TCK; you will eventually +This is the primary goal of using the Jakarta EE 9 CTS; you will eventually need to configure the Jakarta EE 9 implementation you want to certify. See link:#GEWWA[Section 5.3.3, "Configuring Your Application Server as the VI,"] for instructions. @@ -172,7 +172,7 @@ VI running a database of your choice with JDBC 4.1-compliant drivers. The second server must be the Jakarta EE 9 CI using the bundled Java DB database. -In terms of the Jakarta EE 9 Platform TCK, all configuration settings are made +In terms of the Jakarta EE 9 CTS, all CTS configuration settings are made in the `/bin/ts.jte` file. When configuring a Jakarta EE 9 server, the important thing is to make sure that the settings you use for your server match those in the `ts.jte` file. @@ -186,10 +186,10 @@ These configuration scenarios are described in the following sections. To configure the Jakarta EE 9 CI as the server under test (that is, to use the Jakarta EE 9 CI as the VI) follow the steps listed below. In this -scenario, the goal is simply to test the Jakarta EE 9 CI against the TCK -for the purposes of familiarizing yourself with TCK test procedures. You +scenario, the goal is simply to test the Jakarta EE 9 CI against the CTS +for the purposes of familiarizing yourself with CTS test procedures. You may also want to refer to the Quick Start guides included with the Jakarta -EE 9 Platform TCK for similar instructions. +EE 9 CTS for similar instructions. . Set server properties in your `/bin/ts.jte` file to suit your test environment. + @@ -214,7 +214,7 @@ The default setting for the CI porting implementation is `com.sun.ts.lib.implementation.sun.common.SunRIURL`. .. Set the database-related properties in the `/bin/ts.jte` file. + -link:database-config.html#GFKMW[Section D.3, "Database Properties in +link:database-config.html#GFKMW[Section C.3, "Database Properties in ts.jte,"] lists the names and descriptions for the database properties you need to set. .. Add the following JVM option to the `command.testExecuteAppClient` @@ -270,7 +270,7 @@ ant -f xml/init.xml init.derby ---- + If you are not using Derby as your backend database, refer to -link:database-config.html#GFAVUb[Appendix D, "Configuring Your Backend +link:database-config.html#GFAVUb[Appendix C, "Configuring Your Backend Database."] + + [NOTE] @@ -368,7 +368,7 @@ implementation class that is used for obtaining URLs. .. Set the database-related properties in the `/bin/ts.jte` file. + -link:database-config.html#GFKMW[Section D.3, "Database Properties in +link:database-config.html#GFKMW[Section C.3, "Database Properties in ts.jte,"] lists the names and descriptions for the database properties you need to set. @@ -413,10 +413,10 @@ The `/bin` directory contains the following `.dat` files: * `jws-url-props.dat` * `webservices12-url-props.dat` + -These files contain the webservice endpoint and WSDL URLs that the TCK +These files contain the webservice endpoint and WSDL URLs that the CTS tests use when running against the CI. In the porting package used by -the TCK, the URLs are returned as is since this is the form that the CI -expects. You may need an alternate form of these URLs to run the TCK +the CTS, the URLs are returned as is since this is the form that the CI +expects. You may need an alternate form of these URLs to run the CTS tests in your environment. However, you MUST NOT modify the existing `.dat` files, but instead make any necessary changes in your own porting implementation class to transform the URLs appropriately for your @@ -426,7 +426,7 @@ environment. . Start your database. -. Initialize your database for TCK tests. +. Initialize your database for CTS tests. .. If you choose to not implement the `javaee_vi.xml` targets, execute the following command to specify the appropriate DML file: + @@ -455,7 +455,7 @@ ant -f /bin/xml/initdb.xml init.javadb ---- + -Refer to link:database-config.html#GFAVUb[Appendix D, "Configuring Your +Refer to link:database-config.html#GFAVUb[Appendix C, "Configuring Your Backend Database,"] for detailed database configuration and initialization instructions and a list of database-specific initialization targets. @@ -466,14 +466,14 @@ initialization targets. .. Set up database users and passwords that are used for JDBC connections. + -The Jakarta EE 9 Platform TCK requires several user names, passwords, and +The Jakarta EE 9 CTS requires several user names, passwords, and user-to-role mappings. These need to match those set in your `ts.jte` file. By default, `user1`, `user2`, `user3, password1`, `password2`, and `password3` are set to `cts1`. .. [[BABBHFAI]] Set up users and passwords for your Jakarta Platform, Enterprise Edition server. + -For the purpose of running the TCK test suite, these should be set as +For the purpose of running the CTS test suite, these should be set as follows: + [width="100%",cols="33%,33%,34%",options="header",] @@ -532,13 +532,13 @@ server. + Certificates are located `/bin/certificates`. Use the certificate that suits your environment. -.. `cts_cert`: For importing the TCK client certificate into a +.. `cts_cert`: For importing the CTS client certificate into a `truststore` -.. `clientcert.jks`: Used by the Java SE 8 runtime to identify the TCK +.. `clientcert.jks`: Used by the Java SE 8 runtime to identify the CTS client's identity -.. `clientcert.p12`: Contains TCK client certificate in `pkcs12` format +.. `clientcert.p12`: Contains CTS client certificate in `pkcs12` format .. Append the file `/bin/server_policy.append` to the Java policy file or files on your Jakarta EE 9 server. + @@ -654,7 +654,7 @@ back to their original values: 5.4 Modifying Environment Settings for Specific Technology Tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Before you can run any of the technology-specific Jakarta EE 9 Platform TCK tests, +Before you can run any of the technology-specific Jakarta EE 9 CTS tests, you must supply certain information that JavaTest needs to run the tests in your particular environment. This information exists in the `/bin/ts.jte` environment file. This file contains sets of @@ -758,15 +758,15 @@ will write temporary files. 5.4.2 Windows-Specific Properties ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -When configuring the Jakarta EE 9 Platform TCK for the Windows environment, set the +When configuring the Jakarta EE 9 CTS for the Windows environment, set the following properties in `/bin/ts.jte`: * `pathsep` to semicolon (pathsep=`;`) -* `s1as.applicationRoot` to the drive on which you have installed Platform TCK +* `s1as.applicationRoot` to the drive on which you have installed CTS (for example, `s1as.applicationRoot=C:`) + When installing in the Windows environment, the Jakarta Platform, -Enterprise Edition CI, JDK, and Platform TCK should all be installed on the same +Enterprise Edition CI, JDK, and CTS should all be installed on the same drive. If you must install these components on different drives, also change the `ri.applicationRoot` property in addition to the `pathsep` and `s1as.applicationRoot` properties; for example: + @@ -779,7 +779,7 @@ ri.applicationRoot=C: [NOTE] ======================================================================= -When configuring the CI and Platform TCK for the Windows environment, never +When configuring the CI and CTS for the Windows environment, never specify drive letters in any path properties in `ts.jte`. ======================================================================= @@ -926,7 +926,7 @@ properties. The SSL related tests under `/ts/javaeetck/src/com/sun/ts/tests/websocket/platform/jakarta/websocket/server/handshakerequest/authenticatedssl/` -use self signed certificate bundled with the Platform TCK bundle. These +use self signed certificate bundled with the CTS bundle. These certificates are generated with localhost as the hostname and would work only when orb.host value is set to localhost in ts.jte. If the server's hostname is used instead of the localhost, the tests in this suite might @@ -1036,7 +1036,7 @@ directory contains packaging instructions. 5.4.8.2 To Package WAR files for Deployment on the Jakarta EE 9 CI ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ -The Jakarta EE 9 Platform TCK test suite does not come with prebuilt test WAR files +The Jakarta EE 9 CTS test suite does not come with prebuilt test WAR files for deployment on Jakarta EE 9 CI. The test suite includes a command to generate the test WAR files that will be deployed on the Jakarta EE 9 CI. The WAR files are Jersey-specific, with Jersey's servlet class and @@ -1102,10 +1102,10 @@ VI-specific Servlet class will be included instead of the Jakarta EE 9 CI-specific Servlet class. All resource and application class files are already compiled. The -Vendor needs to package these files. Jakarta EE 9 Platform TCK makes this task +Vendor needs to package these files. Jakarta EE 9 CTS makes this task easier by including template WAR files that contain all of the necessary files except for the VI-specific servlet adaptor class. The Jakarta EE 9 -Platform TCK also provides a tool to help with the repackaging task. +CTS also provides a tool to help with the repackaging task. Each test that has a Jakarta RESTful Web Services resource class to publish comes with a template deployment descriptor file. For example, the file @@ -1172,7 +1172,7 @@ http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"> ---- -The Jakarta EE 9 Platform TCK test suite provides a tool, +The Jakarta EE 9 CTS test suite provides a tool, `${ts.home}/bin/xml/impl/glassfish/jersey.xml`, for the Jakarta EE 9 CI that you can use as a model to help you create your own VI-specific Web test application. @@ -1275,8 +1275,8 @@ extension library. The `whitebox.jar` file is a Shared Library that must be deployed as a separate entity that all the Jakarta Connector RAR files access. This extension library is needed to address classloading issues. -The RAR files that are used with Jakarta EE 9 Platform TCK test suite differ from -those that were used in earlier test suites. Jakarta EE 9 Platform TCK no longer +The RAR files that are used with Jakarta EE 9 CTS test suite differ from +those that were used in earlier test suites. Jakarta EE 9 CTS no longer bundles the same common classes into every RAR file. Duplicate common classes have been removed and now exist in the `whitebox.jar` file, an Installed Library that is deployed and is made available before any @@ -1299,7 +1299,7 @@ requirements that are listed in section 20.3 in the specification. 5.4.9.2 Connector Resource Adapters and Classloading +++++++++++++++++++++++++++++++++++++++++++++++++++++ -Jakarta EE 9 Platform TCK has scenarios in which multiple standalone RAR files that +Jakarta EE 9 CTS has scenarios in which multiple standalone RAR files that use the same shared library (for example, `whitebox.jar`) are referenced from an application component. @@ -1362,7 +1362,7 @@ copied. 5.4.9.4 Required Porting Package +++++++++++++++++++++++++++++++++ -The Jakarta EE 9 Platform TCK treats the `whitebox.jar` dependency as an +The Jakarta EE 9 CTS test suite treats the `whitebox.jar` dependency as an Installed Library dependency instead of bundling the dependency (or dependencies) with every RAR file. Each RAR file now contains a reference to the `whitebox.jar` file through its Manifest files @@ -1523,7 +1523,7 @@ asadmin create-jdbc-resource --connectionpoolid cts-derby-XA-pool \ ---- + If two or more JDBC resource elements point to the same connection pool -element, they use the same pool connection at runtime. Jakarta EE 9 Platform TCK +element, they use the same pool connection at runtime. Jakarta EE 9 CTS does reuse the same connection pool ID for testing the Jakarta EE 9 CI Eclipse GlassFish 6.0. . Make sure that the following EIS and RAR files have been deployed @@ -1665,7 +1665,7 @@ interval timers. The default setting and recommended minimum value is for results from the `ejbTimeout()` method. The default setting and recommended minimum value is `60000` milliseconds. -Jakarta EE 9 Platform TCK does not have a property that you can set to configure the +Jakarta EE 9 CTS does not have a property that you can set to configure the date for date timers. The timer tests use the specific `jndi-name` jdbc`/DBTimer` for the @@ -1699,7 +1699,7 @@ CI as the VI]. Your Jakarta Platform, Enterprise Edition implementation should map the following instance variables to a backend datastore. These are needed to -run the Platform TCK entity bean container-managed persistence (cmp1.1) tests. +run the CTS entity bean container-managed persistence (cmp1.1) tests. The Jakarta Platform, Enterprise Edition CI creates the table used by container-managed persistence by appending `"Table"` to the bean name. @@ -1780,7 +1780,7 @@ stubbed-out legacy JPA 2.1 implementation, which is located in the `src/com/sun/ts/jpa/common/pluggibility/altprovider` directory. In Java EE 7 CTS, the Persistence API pluggability tests required -special setup to run. This is no longer the case, since Jakarta EE 9 Platform TCK +special setup to run. This is no longer the case, since Jakarta EE 9 CTS now enables the pluggability tests to be executed automatically along with all the other Persistence tests. The Jakarta Persistence tests have a new directory structure. In Java EE 7 CTS, the tests were in the @@ -1794,7 +1794,7 @@ the `src/com/sun/ts/tests/jpa` directory. Jakarta Persistence supports the use of a second-level cache by the persistence provider. The `ts.jte` file provides a property that -controls the Platform TCK test suite's use of the second-level cache. +controls the CTS test suite's use of the second-level cache. The `persistence.second.level.caching.supported` property is used to determine if the persistence provider supports the use of a second-level @@ -1870,7 +1870,7 @@ supports the use of SEQUENCE. If it does not, this property should be set to false so the test is not run. The default value is true. If the database under test is not one of the databases defined and -supported by Platform TCK, the user will need to create an entry similar to the +supported by CTS, the user will need to create an entry similar to the one listed in link:#GEXOO[Example 5-1]. [[GEXOO]] @@ -1888,7 +1888,7 @@ INSERT into SEQUENCE(SEQ_NAME, SEQ_COUNT) values ('SEQ_GEN', 0) ; You should add your own table to your chosen database DDL file provided prior to running these tests. The Data Model used to test the Jakarta Persistence Query Language can be found in -link:ejbql-schema.html#GFAVUc[Appendix E, "EJBQL Schema."] +link:ejbql-schema.html#GFAVUc[Appendix D, "EJBQL Schema."] The `persistence.xml` file, which defines a persistence unit, contains the `unitName` `CTS-EM` for Jakarta Transactions entity managers. This corresponds to @@ -1901,7 +1901,7 @@ entity managers, which correspond to a `non-jta-data-source` 5.4.15 Jakarta Messaging Test Setup ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -This section explains how to set up and configure the Jakarta EE 9 Platform TCK +This section explains how to set up and configure the Jakarta EE 9 CTS test suite before running the Jakarta Messaging tests. @@ -1909,7 +1909,7 @@ suite before running the Jakarta Messaging tests. ======================================================================= The client-specified values for `JMSDeliveryMode`, `JMSExpiration`, and -`JMSPriority` must not be overridden when running the Platform TCK Jakarta Messaging tests. +`JMSPriority` must not be overridden when running the CTS Jakarta Messaging tests. ======================================================================= @@ -2141,7 +2141,7 @@ in the `ts.jte` file. Jakarta Authentication Service for Containers (Authentication) 1.1 tests are security tests. The Jakarta Authentication Servlet (jaspicservlet) profile is the only -required profile for Jakarta EE 9 Platform TCK. There are other optional profile +required profile for Jakarta EE 9 CTS. There are other optional profile tests, such as SOAP, but you are not required to run these for certification. @@ -2896,7 +2896,7 @@ running against the Jakarta Platform, Enterprise Edition CI 5.4.21.2 Additional Signature Test Information ++++++++++++++++++++++++++++++++++++++++++++++ -The Jakarta EE 9 Platform TCK signature tests perform verifications in two different +The Jakarta EE 9 CTS signature tests perform verifications in two different modes: static and reflection. The test results list which SPEC API signature tests pass or fail, and the mode (static or reflection) for that test. @@ -2926,8 +2926,7 @@ Tested version: 2.0_se8 Check mode: src [throws normalized] Constant checking: on -Missing Fields --------------- +Missing Fields : jakarta.servlet.jsp.jstl.core.Config: field public final static java.lang.String jakarta.servlet.jsp.jstl.core.Config.FMT_FALLBACK_LOCALE = "jakarta.servlet.jsp.jstl.fmt.fallbackLocale" jakarta.servlet.jsp.jstl.core.Config: field public final static java.lang.String jakarta.servlet.jsp.jstl.core.Config.FMT_LOCALE = "jakarta.servlet.jsp.jstl.fmt.locale" @@ -2936,8 +2935,7 @@ jakarta.servlet.jsp.jstl.core.Config: field public final static java.lang.Stri jakarta.servlet.jsp.jstl.core.Config: field public final static java.lang.String jakarta.servlet.jsp.jstl.core.Config.SQL_DATA_SOURCE = "jakarta.servlet.jsp.jstl.sql.dataSource" jakarta.servlet.jsp.jstl.core.Config: field public final static java.lang.String jakarta.servlet.jsp.jstl.core.Config.SQL_MAX_ROWS = "jakarta.servlet.jsp.jstl.sql.maxRows" -Added Fields ------------- +Added Fields : jakarta.servlet.jsp.jstl.core.Config: field public final static java.lang.String jakarta.servlet.jsp.jstl.core.Config.FMT_FALLBACK_LOCALE = "javax.servlet.jsp.jstl.fmt.fallbackLocale" jakarta.servlet.jsp.jstl.core.Config: field public final static java.lang.String jakarta.servlet.jsp.jstl.core.Config.FMT_LOCALE = "javax.servlet.jsp.jstl.fmt.locale" @@ -2965,16 +2963,14 @@ Tested version: 4.0_se8 Check mode: src [throws normalized] Constant checking: on -Missing Methods ---------------- +Missing Methods : jakarta.el.ELContext: method public java.lang.Object jakarta.el.ELContext.getContext(java.lang.Class) jakarta.el.ELContext: method public void jakarta.el.ELContext.putContext(java.lang.Class,java.lang.Object) jakarta.el.StandardELContext: method public java.lang.Object jakarta.el.StandardELContext.getContext(java.lang.Class) jakarta.el.StandardELContext: method public void jakarta.el.StandardELContext.putContext(java.lang.Class,java.lang.Object) -Added Methods -------------- +Added Methods : jakarta.el.ELContext: method public java.lang.Object jakarta.el.ELContext.getContext(java.lang.Class) jakarta.el.ELContext: method public void jakarta.el.ELContext.putContext(java.lang.Class,java.lang.Object) @@ -3052,7 +3048,7 @@ Edition server. ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ You can use the JavaTest harness GUI to modify general test settings and -to quickly get started with the default Platform TCK test environment. After +to quickly get started with the default CTS test environment. After familiarizing yourself with these basic configuration settings, you will probably want to continue with the instructions in link:#GEXPP[Modifying Environment Settings for Specific Technology Tests]. @@ -3112,7 +3108,7 @@ proceed with running the test. 5.5.2 The Configuration Interview ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -To configure the JavaTest harness to run the Jakarta EE 9 Platform TCK tests, +To configure the JavaTest harness to run the Jakarta EE 9 CTS tests, complete the following steps. Note that you only need to complete these steps the first time you start the JavaTest harness. After you complete these steps, you can either run all or a subset of the tests, as diff --git a/user_guides/jakartaee/src/main/jbake/content/contextrootmappingrules.adoc b/user_guides/jakartaee/src/main/jbake/content/contextrootmappingrules.adoc index fc505b3a20..00bf595b23 100644 --- a/user_guides/jakartaee/src/main/jbake/content/contextrootmappingrules.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/contextrootmappingrules.adoc @@ -7,9 +7,9 @@ prev=ejbql-schema.html Context Root Mapping Rules for Web Services Tests ================================================= -[[GJJWH]][[f-context-root-mapping-rules-for-web-services-tests]] +[[GJJWH]][[e-context-root-mapping-rules-for-web-services-tests]] -F Context Root Mapping Rules for Web Services Tests +E Context Root Mapping Rules for Web Services Tests --------------------------------------------------- The context root mapping rules that are described in this appendix apply @@ -21,9 +21,9 @@ This appendix covers the following topics: * link:#GJJWR[Servlet-Based Web Service Endpoint Context Root Mapping] * link:#GJJWG[Jakarta Enterprise Bean-Based Web Service Endpoint Context Root Mapping] -[[GJJWR]][[f.1-servlet-based-web-service-endpoint-context-root-mapping]] +[[GJJWR]][[e.1-servlet-based-web-service-endpoint-context-root-mapping]] -F.1 Servlet-Based Web Service Endpoint Context Root Mapping +E.1 Servlet-Based Web Service Endpoint Context Root Mapping ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ This section describes the context root mapping for servlet-based web @@ -35,7 +35,7 @@ example, the context root for the archive `web-client.war` defaults to `web-client`. This covers the mapping for all servlet-based web services endpoints and -clients under the Jakarta EE 9 Platform TCK test trees +clients under the Jakarta EE 9 CTS test trees Jakarta XML Web Services (`jaxws`), Jakarta Web Services Metadata (`jws`), webservices, webservices12, webservices13]. @@ -83,9 +83,9 @@ The directory listing is as follows: For Web archives, the context root mapping becomes the base name of the Web archive file minus the extension. -[[GJJWG]][[f.2-jakarta-enterprise-bean-based-web-service-endpoint-context-root-mapping]] +[[GJJWG]][[e.2-jakarta-enterprise-bean-based-web-service-endpoint-context-root-mapping]] -F.2 Jakarta Enterprise Bean-Based Web Service Endpoint Context Root Mapping +E.2 Jakarta Enterprise Bean-Based Web Service Endpoint Context Root Mapping ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ This section describes the context root mapping for Jakarta Enterprise Bean-based web diff --git a/user_guides/jakartaee/src/main/jbake/content/database-config.adoc b/user_guides/jakartaee/src/main/jbake/content/database-config.adoc index 2949e05b8f..52fc2a7b06 100644 --- a/user_guides/jakartaee/src/main/jbake/content/database-config.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/database-config.adoc @@ -7,14 +7,14 @@ prev=jaspic-files.html Configuring Your Backend Database ================================= -[[GFAVUb]][[d-configuring-your-backend-database]] +[[GFAVUb]][[c-configuring-your-backend-database]] -D Configuring Your Backend Database +C Configuring Your Backend Database ----------------------------------- This appendix explains how to configure a backend database to use with a Jakarta Platform, Enterprise Edition server being tested against the Jakarta -EE 9 Platform TCK. +EE 9 CTS. The topics included in this appendix are as follows: @@ -24,13 +24,13 @@ The topics included in this appendix are as follows: * link:#GFKOC[Database DDL and DML Files] * link:#GFKND[CMP Table Creation] -[[GFKNA]][[d.1-overview]] +[[GFKNA]][[c.1-overview]] -D.1 Overview +C.1 Overview ~~~~~~~~~~~~ All Jakarta Platform, Enterprise Edition servers tested against the Jakarta EE -9 Platform TCK must be configured with a database and JDBC 4.1-compliant drivers. +9 CTS must be configured with a database and JDBC 4.1-compliant drivers. Note that the Jakarta Platform, Enterprise Edition CI, Eclipse GlassFish 6.0 includes the Apache Derby database. @@ -40,46 +40,46 @@ must be the Jakarta Platform, Enterprise Edition RI with the bundled Apache Derb database. See link:config.html#GEWSQ[Jakarta Platform, Enterprise Edition Server Configuration Scenarios] for more information. -For the purposes of Jakarta EE 9 Platform TCK testing, all database configuration -properties required by the TCK are made in the `/bin/ts.jte` -file. The TCK `init.<`database> Ant target uses the properties you set +For the purposes of Jakarta EE 9 CTS testing, all database configuration +properties required by the CTS are made in the `/bin/ts.jte` +file. The CTS `init.<`database> Ant target uses the properties you set in `ts.jte` to generate one or more SQL statement files that are in turn used create and populate database tables and configure procedures -required by the TCK. +required by the CTS. The database configuration process comprises four general steps: 1. Set database-related properties in the `/bin/ts.jte` file. -2. Configure your Jakarta Platform server -implementation for your database and for Platform TCK. +2. Configure your Jakarta Platform, Enterprise Edition server +implementation for your database and for CTS. 3. Start your database. 4. Run the `init.` Ant target to initialize your database for -TCK. +CTS. The procedure for configuring your Jakarta Platform, Enterprise Edition server for your database is described in link:config.html#GEWTQ[Configuring a Jakarta EE 9 Server]. The final step, -initializing your database for TCK by running `init.<`database> target, +initializing your database for CTS by running `init.<`database> target, is explained more in the next section. -[[GFKNR]][[d.2-the-init.database-ant-target]] +[[GFKNR]][[c.2-the-init.database-ant-target]] -D.2 The init. Ant Target +C.2 The init. Ant Target ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Before your Jakarta Platform, Enterprise Edition server database can be -tested against the Jakarta EE 9 Platform TCK, the database must be initialized for -TCK by means of the Ant `init.<`database> target. For example, the +tested against the Jakarta EE 9 CTS, the database must be initialized for +CTS by means of the Ant `init.<`database> target. For example, the `init.javadb` Ant task is used to initialize the Apache Derby database for -TCK. +CTS. This Ant target references database properties in `ts.jte` file and database-specific DDL and DML files to generate SQL statement files that -are read by the Jakarta EE 9 Platform TCK when you start the test suite. The DDL and +are read by the Jakarta EE 9 CTS when you start the test suite. The DDL and DML files are described later in this appendix, in link:#GFKOC[Database DDL and DML Files]. -The Jakarta EE 9 Platform TCK includes the following database-specific Ant targets: +The Jakarta EE 9 CTS includes the following database-specific Ant targets: * `init.cloudscape` * `init.db2` @@ -99,13 +99,13 @@ backend for a specific database; for example, OracleInet/Oracle Inet driver; OracleDD/Oracle DataDirect driver. These targets are configured in the `/xml/initdb.xml` file. -[[GFKMW]][[d.3-database-properties-in-ts.jte]] +[[GFKMW]][[c.3-database-properties-in-ts.jte]] -D.3 Database Properties in ts.jte +C.3 Database Properties in ts.jte ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Listed below are the names and descriptions for the database properties -you need to set for TCK testing. +you need to set for CTS testing. Note that some properties take the form property`.ri`. In all cases, properties with an `.ri` suffix are used for interoperability testing @@ -151,7 +151,7 @@ need to modify this property. |database`.server` |Database Server. -|database`.url` |URL for the TCK database; the `dbName`, `server`, and +|database`.url` |URL for the CTS database; the `dbName`, `server`, and `port` properties are automatically substituted in to build the correct URL. You should never need to modify this property. @@ -174,7 +174,7 @@ RI database; for example, `db.dml.file=${javadb.dml.file}`. point to the location of the JDBC drivers. |`jdbc.poolName` |Configures the connection pool that will be used in -the TCK test run; for example, `jdbc.poolName=${javadb.poolName}`. Set +the CTS test run; for example, `jdbc.poolName=${javadb.poolName}`. Set this property when running against the RI if using a database other than Apache Derby. @@ -198,12 +198,12 @@ Apache Derby. |======================================================================= -[[GFKOC]][[d.4-database-ddl-and-dml-files]] +[[GFKOC]][[c.4-database-ddl-and-dml-files]] -D.4 Database DDL and DML Files +C.4 Database DDL and DML Files ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -For each supported database type, the Jakarta EE 9 Platform TCK includes a set of +For each supported database type, the Jakarta EE 9 CTS includes a set of DDL and DML files in subdirectories off the `/sql` directory. The `config.vi` and `config.ri` targets use two `ts.jte` properties, `db.dml.file` and `db.dml.file.ri` (interop only), to determine the @@ -211,17 +211,17 @@ database type, and hence which database-specific DML files to copy as `/bin/tssql.stmt` and `tssql.stmt.ri` (for interop) files. The `tssql.stmt` and `tssql.stmt.ri` files contain directives for -configuring and populating database tables as required by the TCK tests, +configuring and populating database tables as required by the CTS tests, and for defining any required primary or foreign key constraints and database-specific conmand line terminators. -In addition to the database-specific DML files, the Jakarta EE 9 Platform TCK +In addition to the database-specific DML files, the Jakarta EE 9 CTS includes database-specific DDL files, also in subdirectories off `/sql`. These DDL files are used by the `init.`database target -to create and drop database tables and procedures required by the TCK. +to create and drop database tables and procedures required by the CTS. The SQL statements in the `tssql.stmt` and `tssql.stmt.ri` files are -read as requested by individual TCK tests, which use the statements to +read as requested by individual CTS tests, which use the statements to locate required DML files. The DDL and DML files are as follows: @@ -266,9 +266,9 @@ After updating `initdb.xml`, you invoke the new target with: ant -f /bin/xml/initdb.xml init.databasename ---- -[[GFKND]][[d.5-cmp-table-creation]] +[[GFKND]][[c.5-cmp-table-creation]] -D.5 CMP Table Creation +C.5 CMP Table Creation ~~~~~~~~~~~~~~~~~~~~~~ If the application server under test does not provide an option to diff --git a/user_guides/jakartaee/src/main/jbake/content/ejbql-schema.adoc b/user_guides/jakartaee/src/main/jbake/content/ejbql-schema.adoc index c12e2d74b5..f9c677c811 100644 --- a/user_guides/jakartaee/src/main/jbake/content/ejbql-schema.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/ejbql-schema.adoc @@ -7,9 +7,9 @@ prev=database-config.html EJBQL Schema ============ -[[GFAVUc]][[e-ejbql-schema]] +[[GFAVUc]][[d-ejbql-schema]] -E EJBQL Schema +D EJBQL Schema -------------- The Jakarta Enterprise Beans, EJB-QL tests perform queries against a CMP 2.0 abstract persistence @@ -25,9 +25,9 @@ This appendix includes information about the following topics: * link:#GFKSI[Persistence Schema Relationships] * link:#GFKQT[SQL Statements for CMP 1.1 Finders] -[[GFKSI]][[e.1-persistence-schema-relationships]] +[[GFKSI]][[d.1-persistence-schema-relationships]] -E.1 Persistence Schema Relationships +D.1 Persistence Schema Relationships ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The figure, link:#GFKUU[Figure E-1], below, contains detailed @@ -186,9 +186,9 @@ CustomerLocal customer;(cmr) |================================ -[[GFKQT]][[e.2-sql-statements-for-cmp-1.1-finders]] +[[GFKQT]][[d.2-sql-statements-for-cmp-1.1-finders]] -E.2 SQL Statements for CMP 1.1 Finders +D.2 SQL Statements for CMP 1.1 Finders ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Listed below are the SQL statements used for CMP 1.1 finders in: @@ -198,9 +198,9 @@ Listed below are the SQL statements used for CMP 1.1 finders in: * `ejb/ee/bb/entity/cmp/complexpktest` * `ejb/ee/tx/txECMPbean` -[[GFKSD]][[e.2.1-ejbeebbentitycmpclientviewtest-interopejbentitycmpclientviewtest]] +[[GFKSD]][[d.2.1-ejbeebbentitycmpclientviewtest-interopejbentitycmpclientviewtest]] -E.2.1 ejb/ee/bb/entity/cmp/clientviewtest, interop/ejb/entity/cmp/clientviewtest +D.2.1 ejb/ee/bb/entity/cmp/clientviewtest, interop/ejb/entity/cmp/clientviewtest ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [source,oac_no_warn] @@ -219,9 +219,9 @@ E.2.1 ejb/ee/bb/entity/cmp/clientviewtest, interop/ejb/entity/cmp/clientviewtest SELECT "KEY_ID" FROM "TestBeanEJBTable" WHERE "BRAND_NAME" = ?1 ---- -[[GFKQU]][[e.2.2-ejbeebbentitycmpcomplexpktest]] +[[GFKQU]][[d.2.2-ejbeebbentitycmpcomplexpktest]] -E.2.2 ejb/ee/bb/entity/cmp/complexpktest +D.2.2 ejb/ee/bb/entity/cmp/complexpktest ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [source,oac_no_warn] @@ -234,9 +234,9 @@ E.2.2 ejb/ee/bb/entity/cmp/complexpktest SELECT "BRAND_NAME", "ID" FROM "TestBeanEJBTable" WHERE "BRAND_NAME" = ?1 ---- -[[GFKSB]][[e.2.3-ejbeetxtxecmpbean]] +[[GFKSB]][[d.2.3-ejbeetxtxecmpbean]] -E.2.3 ejb/ee/tx/txECMPbean +D.2.3 ejb/ee/tx/txECMPbean ^^^^^^^^^^^^^^^^^^^^^^^^^^ [source,oac_no_warn] diff --git a/user_guides/jakartaee/src/main/jbake/content/install.adoc b/user_guides/jakartaee/src/main/jbake/content/install.adoc index 4fabd9e0b1..4c42bbdfa6 100644 --- a/user_guides/jakartaee/src/main/jbake/content/install.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/install.adoc @@ -12,9 +12,9 @@ Installation 4 Installation -------------- -This chapter explains how to install the Jakarta EE 9 Platform TCK software and +This chapter explains how to install the Jakarta EE 9 CTS software and perform a sample test run to verify your installation and familiarize -yourself with the Platform TCK. Installation instructions are provided for Eclipse +yourself with the CTS. Installation instructions are provided for Eclipse GlassFish 6.0, a Compatible Implementation (CI) of Jakarta EE. If you are using another compatible implementation, refer to instructions provided with that implementation. @@ -26,7 +26,7 @@ Configuration,"] for instructions on configuring your test environment. This chapter covers the following topics: * link:#GEVGN[Installing the Jakarta EE 9 Compatible Implementation] -* link:#GEVHP[Installing the Jakarta EE 9 Platform TCK] +* link:#GEVHP[Installing the Jakarta EE 9 CTS] * link:#GEVGZ[Verifying Your Installation (Optional)] [[GEVGN]][[installing-the-jakarta-ee-8-compatible-implementation]] @@ -59,12 +59,12 @@ EE 9 CI. /bin/asadmin start-domain ---- -[[GEVHP]][[installing-the-jakarta-ee-9-platform-TCK]] +[[GEVHP]][[installing-the-jakarta-ee-8-cts]] -4.2 Installing the Jakarta EE 9 Platform TCK +4.2 Installing the Jakarta EE 9 CTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Complete the following procedure to install the Jakarta EE 9 Platform TCK on a +Complete the following procedure to install the Jakarta EE 9 CTS on a system running the Solaris, Linux, or Windows operating system. @@ -72,42 +72,42 @@ system running the Solaris, Linux, or Windows operating system. ======================================================================= When installing in the Windows environment, the Jakarta EE 9 CI, Java SE 8 -JDK, and TCK should be installed on the same drive. If you must install +JDK, and CTS should be installed on the same drive. If you must install these components on different drives, be sure to change the `ri.applicationRoot` and `s1as.applicationRoot` properties as needed in -the `/bin/ts.jte` TCK configuration file. See +the `/bin/ts.jte` CTS configuration file. See link:config.html#GEXOS[Section 5.4.2, "Windows-Specific Properties,"] for more information. ======================================================================= -. Copy or download the Platform TCK 9 software. +. Copy or download the CTS 9 software. . Change to the directory in which you want to install the Jakarta EE 9 CTS software and use the `unzip` command to extract the bundle: + [source,oac_no_warn] ---- cd install_directory -unzip jakartaee.zip +unzip jakartaeetck-nnn.zip ---- + This creates the `jakartaeetck` directory. The -install_directory`/javaeetck` directory will be `TS_HOME`. +install_directory`/jakartaeetck` directory will be `TS_HOME`. . Set the `TS_HOME` environment variable to point to the `javaeetck` directory. After you complete the installation, follow the directions in link:config.html#GBFVV[Chapter 5, "Setup and Configuration,"] to set up -and configure the Jakarta EE 9 Platform TCK test suite. +and configure the Jakarta EE 9 CTS test suite. [[GEVGZ]][[verifying-your-installation-optional]] 4.3 Verifying Your Installation (Optional) ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -This procedure is optional. After installing the Jakarta EE 9 CI and Java -EE 9 Platform TCK, you may want to verify your installation by running the TCK +This procedure is optional. After installing the Jakarta EE 9 CI and Jakarta +EE 9 CTS, you may want to verify your installation by running the CTS samples against the Jakarta EE 9 CI. See link:config.html#GBFVV[Chapter 5, "Setup and Configuration,"] for complete configuration instructions. @@ -124,7 +124,7 @@ orb.host=localhost // the name of the machine running the Jakarta EE 9 CI orb.host.ri=localhost // the name of the machine running the Jakarta EE 9 CI ---- + -. Use these commands to run the Jakarta EE 9 Platform TCK sample tests: +. Use these commands to run the Jakarta EE 9 CTS sample tests: + [source,oac_no_warn] ---- diff --git a/user_guides/jakartaee/src/main/jbake/content/intro.adoc b/user_guides/jakartaee/src/main/jbake/content/intro.adoc index 165aead4c3..d34c255162 100644 --- a/user_guides/jakartaee/src/main/jbake/content/intro.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/intro.adoc @@ -14,16 +14,16 @@ Introduction This document provides instructions for installing, configuring, and running the Jakarta Platform, Enterprise Edition 9 Compatibility Test Suite -(Jakarta EE 9 Platform TCK). +(Jakarta EE 9 CTS). This chapter includes the following topics: * link:#GBFTK[Compatibility Testing] -* link:#GEUYK[About Jakarta EE 9 Platform TCK] +* link:#GEUYK[About Jakarta EE 9 CTS] * link:#GEVAD[Hardware Requirements] * link:#GEVBB[Software Requirements] -* link:#GEVCL[Additional Jakarta EE 9 Platform TCK Requirements] -* link:#GBFQW[Getting Started With the Jakarta EE 9 Platform TCK Test Suite] +* link:#GEVCL[Additional Jakarta EE 9 CTS Requirements] +* link:#GBFQW[Getting Started With the Jakarta EE 9 CTS Test Suite] [[GBFTK]][[compatibility-testing]] @@ -74,19 +74,19 @@ level playing field for all Jakarta Platform ports. Compatibility criteria for all technology implementations are embodied in the Compatibility Rules that apply to a specified technology. The -Jakarta EE 9 Platform TCK tests for adherence to these Rules as described in +Jakarta EE 9 CTS tests for adherence to these Rules as described in link:rules.html#GBFSN[Chapter 2, "Procedure for Jakarta Platform, Enterprise Edition 9 Certification,"] for Jakarta EE 9 and link:rules-wp.html#GJJPZ[Chapter 3, "Procedure for Jakarta Platform, Enterprise Edition 9 Web Profile Certification,"] for Jakarta EE 9 Web Profile. -[[GBFPW]][[tck-overview]] +[[GBFPW]][[cts-overview]] -1.1.3 TCK Overview +1.1.3 CTS Overview ^^^^^^^^^^^^^^^^^^ -A Jakarta EE 9 Platform TCK is a set of tools and tests used to verify that a +A Jakarta EE 9 CTS is a set of tools and tests used to verify that a Implementer's implementation of Jakarta EE 9 technology conforms to the applicable specification. All tests in the CTS are based on the written specifications for the Jakarta Platform. The CTS tests compatibility of a @@ -95,7 +95,7 @@ specification of the technology. Compatibility testing is a means of ensuring correctness, completeness, and consistency across all implementations developed by technology Implementers. -The set of tests included with the Jakarta EE 9 Platform TCK is called the test +The set of tests included with the Jakarta EE 9 CTS is called the test suite. All tests in the CTS test suite are self-checking, but some tests may require tester interaction. Most tests return either a Pass or Fail status. For a given platform to be certified, all of the required tests @@ -104,11 +104,11 @@ platform. The definition of required tests will change over time. Before your final certification test pass, be sure to download the latest Exclude -List for the Jakarta EE 9 Platform TCK. The definition of required tests will change +List for the Jakarta EE 9 CTS. The definition of required tests will change over time. See link:#GEUYQ[Section 1.2.5, "Exclude Lists,"] for more information. -[[GBFPB]][[jakarta-specification-community-process-program-and-compatibility-testing]] +[[GBFPB]][[jakarta-community-community-process-program-and-compatibility-testing]] 1.1.4 Jakarta Specification Community Process Program and Compatibility Testing ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ @@ -128,26 +128,26 @@ direction of the responsible specification project committer group: For further information about the JESP program, go to Jakarta EE Specification Process community page (https://jakarta.ee/specifications). -[[GEUYK]][[about-jakarta-ee-9-platform-tck]] +[[GEUYK]][[about-jakarta-ee-8-cts]] -1.2 About Jakarta EE 9 Platform TCK +1.2 About Jakarta EE 9 CTS ~~~~~~~~~~~~~~~~~~~~~~~~~~ -Jakarta EE 9 Platform TCK is a portable, configurable, automated test suite for +Jakarta EE 9 CTS is a portable, configurable, automated test suite for verifying the compliance of a Implementer's implementation of the Jakarta EE 9 -technologies. Jakarta EE 9 Platform TCK includes version 5.0 of the JavaTest +technologies. Jakarta EE 9 CTS includes version 5.0 of the JavaTest harness. -For documentation on the test harness used for running the Jakarta EE 9 Platform TCK +For documentation on the test harness used for running the Jakarta EE 9 CTS test suite, see `https://wiki.openjdk.java.net/display/CodeTools/Documentation`. -[[sthref4]][[jakarta-ee-9-technologies-tested-with-jakarta-ee-9-platform-tck]] +[[sthref4]][[jakarta-ee-8-technologies-tested-with-jakarta-ee-8-cts]] -1.2.1 Jakarta EE 9 Technologies Tested with Jakarta EE 9 Platform TCK +1.2.1 Jakarta EE 9 Technologies Tested with Jakarta EE 9 CTS ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -The Jakarta EE 9 Platform TCK test suite includes compatibility tests for the +The Jakarta EE 9 CTS test suite includes compatibility tests for the following required and optional Jakarta EE 9 technologies: * Jakarta Enterprise Beans 4.0 + @@ -187,12 +187,12 @@ following required and optional Jakarta EE 9 technologies: * Jakarta XML Binding 3.0 (optional) -[[BHCGFHDI]][[jakarta-ee-9-web-profile-technologies-tested-with-jakarta-ee-9-platform-tck]] +[[BHCGFHDI]][[jakarta-ee-8-web-profile-technologies-tested-with-jakarta-ee-8-cts]] -1.2.2 Jakarta EE 9 Web Profile Technologies Tested With Jakarta EE 9 Platform TCK +1.2.2 Jakarta EE 9 Web Profile Technologies Tested With Jakarta EE 9 CTS ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -The Jakarta EE 9 Platform TCK test suite can also be used to test compatibility for +The Jakarta EE 9 CTS test suite can also be used to test compatibility for the following required Jakarta EE 9 Web Profile technologies: * Jakarta Servlet 5.0 @@ -217,12 +217,12 @@ the following required Jakarta EE 9 Web Profile technologies: * Jakarta Authentication 2.0, Servlet Container Profile * Jakarta Debugging Support for Other Languages 2.0 -[[GEUZS]][[tck-tests]] +[[GEUZS]][[cts-tests]] -1.2.3 TCK Tests +1.2.3 CTS Tests ^^^^^^^^^^^^^^^ -The Jakarta EE 9 Platform TCK contains API tests and enterprise edition tests, which +The Jakarta EE 9 CTS contains API tests and enterprise edition tests, which are tests that start in the Jakarta EE 9 platform and use the underlying enterprise service or services as specified. For example, a JDBC enterprise edition test connects to a database, uses SQL commands and @@ -253,11 +253,11 @@ Certification."] These chapters explain the certification process and provides a definitive list of certification rules for Jakarta EE 9 and Jakarta EE 9 Web Profile implementations. * Next, take a look at the test assertions in the Assertion List, which -you can find in the Jakarta EE 9 Platform TCK documentation bundle. The assertions +you can find in the Jakarta EE 9 CTS documentation bundle. The assertions explain what each test is testing. When you run the tests with the JavaTest GUI, the assertion being tested as part of the test description of the currently selected test is displayed. -* Third, install and configure the Jakarta EE 9 Platform TCK software and the Jakarta +* Third, install and configure the Jakarta EE 9 CTS software and the Jakarta EE 9 CI or Jakarta EE 9 Web Profile CI and run the tests as described in this guide. This will familiarize you with the testing process. * Finally, set up and run the test suite with your own Jakarta EE 9 or Jakarta @@ -281,7 +281,7 @@ with backslashes (`\`) for Windows. 1.2.4 JavaTest Harness ^^^^^^^^^^^^^^^^^^^^^^ -The JavaTest harness version 5.0 is a set of tools designed to run and +The JavaTest harness version 4.4.1 is a set of tools designed to run and manage test suites on different Java platforms. The JavaTest harness can be described as both a Java application and a set of compatibility testing tools. It can run tests on different kinds of Java platforms and @@ -316,7 +316,7 @@ filters you are using and queues them up for execution. 1.2.5 Exclude Lists ^^^^^^^^^^^^^^^^^^^ -The Jakarta EE 9 Platform TCK includes an Exclude List contained in a `.jtx` file. +The Jakarta EE 9 CTS includes an Exclude List contained in a `.jtx` file. This is a list of test file URLs that identify tests which do not have to be run for the specific version of the CTS being used. Whenever tests are run, the JavaTest harness automatically excludes any test on the @@ -331,7 +331,7 @@ EE 9 CTS. ======================================================================= Always make sure you are using an up-to-date copy of the Exclude List -before running the Jakarta EE 9 Platform TCK test suite to verify your +before running the Jakarta EE 9 CTS test suite to verify your implementation. ======================================================================= @@ -374,7 +374,7 @@ Edition Version 8 TCK Test Appeals Steps."] 1.2.6 Apache Ant ^^^^^^^^^^^^^^^^ -The Jakarta EE 9 CI, Jakarta EE 9 Web Profile CI, and Jakarta EE 9 Platform TCK require +The Jakarta EE 9 CI, Jakarta EE 9 Web Profile CI, and Jakarta EE 9 CTS require implementations of Apache Ant 1.9.7 from the Apache Ant Project (`http://ant.apache.org/`). Apache Ant is a free, open-source, Java-based build tool, similar in some ways to the make tool, but more @@ -382,18 +382,18 @@ flexible, cross-platform compatible, and centered around XML-based configuration files. Ant is invoked in the Jakarta EE 9 CI, Jakarta EE 9 Web Profile CI, and Jakarta -EE 9 Platform TCK in conjunction with various XML files containing Ant targets. +EE 9 CTS in conjunction with various XML files containing Ant targets. These Ant targets provide a convenient way to automate various -configuration tasks for Jakarta EE 9 Platform TCK. For example, the initial -configuration of the Jakarta EE 9 CI or Jakarta EE 9 Web Profile CI for TCK is +configuration tasks for Jakarta EE 9 CTS. For example, the initial +configuration of the Jakarta EE 9 CI or Jakarta EE 9 Web Profile CI for CTS is done by means of the `config.vi` Ant target. The Ant configuration targets are there for your convenience. When configuring your Jakarta EE 9 or Jakarta EE 9 Web Profile implementation for -the Jakarta EE 9 Platform TCK, you can either set up your environment to use the Ant +the Jakarta EE 9 CTS, you can either set up your environment to use the Ant tools, or you can perform some or all of your configuration procedures -manually. Jakarta EE 9 Platform TCK includes the Ant Contrib package, and the tasks -included with Ant Contrib are used within the TCK build files. See +manually. Jakarta EE 9 CTS includes the Ant Contrib package, and the tasks +included with Ant Contrib are used within the CTS build files. See `http://ant-contrib.sourceforge.net/` for more information about Ant Contrib. @@ -441,7 +441,7 @@ repository, and the database 1.4 Software Requirements ~~~~~~~~~~~~~~~~~~~~~~~~~ -You can run the Jakarta EE 9 Platform TCK software on platforms running the +You can run the Jakarta EE 9 CTS software on platforms running the Linux software that meet the following software requirements: * Operating Systems: @@ -458,9 +458,9 @@ Linux software that meet the following software requirements: ** Apache Derby -[[GEVCL]][[additional-jakarta-ee-9-platform-tck-requirements]] +[[GEVCL]][[additional-java-ee-8-cts-requirements]] -1.5 Additional Jakarta EE 9 Platform TCK Requirements +1.5 Additional Jakarta EE 9 CTS Requirements ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ In addition to the instructions and requirements described in this @@ -480,22 +480,22 @@ see the specification at `https://jakarta.ee/specifications/dependency-injection For more information about the Jakarta Bean Validation technology, see the specification at `https://jakarta.ee/specifications/bean-validation/3.0/` -[[GBFQW]][[getting-started-with-the-jakarta-ee-9-platform-tck-test-suite]] +[[GBFQW]][[getting-started-with-the-java-ee-8-cts-test-suite]] -1.6 Getting Started With the Jakarta EE 9 Platform TCK Test Suite +1.6 Getting Started With the Jakarta EE 9 CTS Test Suite ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -Installing, configuring, and using the Jakarta EE 9 Platform TCK involves the +Installing, configuring, and using the Jakarta EE 9 CTS involves the following general steps: 1. Download, install, and configure a Jakarta EE 9 CI or Jakarta EE 9 Web Profile CI. For example Eclipse GlassFish 6.0. -2. Download and install the Jakarta EE 9 Platform TCK package. +2. Download and install the Jakarta EE 9 CTS package. 3. Configure your database to work with your CI. 4. Configure CTS to work with your database and CI. 5. Run the CTS tests. The remainder of this guide explains these steps in detail. If you just -want to get started quickly with the Jakarta EE 9 Platform TCK using the most basic +want to get started quickly with the Jakarta EE 9 CTS using the most basic test configuration, refer to link:install.html#GBFTP[Chapter 4, "Installation."] diff --git a/user_guides/jakartaee/src/main/jbake/content/jaspic-files.adoc b/user_guides/jakartaee/src/main/jbake/content/jaspic-files.adoc index 4c7b828696..2f71c33f41 100644 --- a/user_guides/jakartaee/src/main/jbake/content/jaspic-files.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/jaspic-files.adoc @@ -7,9 +7,9 @@ prev=commonappdeploy.html Jakarta Authentication Technology Notes and Files ================================================== -[[GLAEQ]][[c-jakarta-authentication-technology-notes-and-files]] +[[GLAEQ]][[b-jakarta-authentication-technology-notes-and-files]] -C Jakarta Authentication Technology Notes and Files +B Jakarta Authentication Technology Notes and Files --------------------------------------------------- The Jakarta Authentication (formerly jaspic) technology tests are used to verify the compatibility of an @@ -32,9 +32,9 @@ could be left in a partially working state. The CTS security compatibility testing, not the functional completeness that one expects from the Jakarta EE 9 CI. -[[GLAFO]][[c.1-jakarta-authentication-1.1-technology-overview]] +[[GLAFO]][[b.1-jakarta-authentication-1.1-technology-overview]] -C.1 Jakarta Authentication 1.1 Technology Overview +B.1 Jakarta Authentication 1.1 Technology Overview ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The Jakarta Authentication 1.1 specification defines a service provider @@ -42,7 +42,7 @@ interface (SPI) by which authentication providers implementing message authentication mechanisms can be integrated in client and server message processing runtimes (or containers). -Jakarta EE 9 Platform TCK uses a Test Suite SPI Verifier (TSSV) to verify whether +Jakarta EE 9 CTS uses a Test Suite SPI Verifier (TSSV) to verify whether the vendor's message processing runtimes invoke the right SPI in the right order. @@ -78,7 +78,7 @@ as follows: [NOTE] ======================================================================= -For the Jakarta EE 9 Platform TCK, we register more than one provider in vendor's +For the Jakarta EE 9 CTS, we register more than one provider in vendor's message processing runtime. ======================================================================= @@ -98,18 +98,18 @@ contains the Jakarta Authentication log file processor, which writes output to t `TSSVLog.txt` file. The `TSSVLog.txt` file is put into the location defined by the `log.file.location` property in the `ts.jte` file. -[[GLAFE]][[c.2-jakarta-authentication-tssv-files]] +[[GLAFE]][[b.2-jakarta-authentication-tssv-files]] -C.2 Jakarta Authentication TSSV Files +B.2 Jakarta Authentication TSSV Files ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The following sections describe the `tssv.jar`, `ProviderConfiguration.xml`, and `provider-configuration.dtd` files that are used by the Jakarta Authentication TCK tests. -[[GLAGR]][[c.2.1-tssv.jar-file]] +[[GLAGR]][[b.2.1-tssv.jar-file]] -C.2.1 tssv.jar file +B.2.1 tssv.jar file ^^^^^^^^^^^^^^^^^^^ The `tssv.jar` file contains classes necessary for populating your @@ -118,9 +118,9 @@ used to register CTS providers. The tssv.jar file contains the class files for the Test Suite SPI Verifier. The `tssv.jar` file classes need to be loaded by your implementation's runtime during startup. -[[GLADE]][[c.2.2-providerconfiguration.xml-file]] +[[GLADE]][[b.2.2-providerconfiguration.xml-file]] -C.2.2 ProviderConfiguration.xml file +B.2.2 ProviderConfiguration.xml file ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The format of the `ProviderConfiguration.xml` file is a test @@ -159,9 +159,9 @@ done by setting the `traceflag` property in the `ts.jte` file and the application context identifier information should appear in the debug output. -[[GLAFZ]][[c.2.3-provider-configuration.dtd-file]] +[[GLAFZ]][[b.2.3-provider-configuration.dtd-file]] -C.2.3 provider-configuration.dtd file +B.2.3 provider-configuration.dtd file ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ The `provider-configuration.dtd` file is a DTD file that resides in the diff --git a/user_guides/jakartaee/src/main/jbake/content/jms-resource-adaptr.adoc b/user_guides/jakartaee/src/main/jbake/content/jms-resource-adaptr.adoc index 44cf623602..9aabdb5ccc 100644 --- a/user_guides/jakartaee/src/main/jbake/content/jms-resource-adaptr.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/jms-resource-adaptr.adoc @@ -6,18 +6,18 @@ prev=contextrootmappingrules.html Testing a Standalone Jakarta Messaging Resource Adapter ======================================================= -[[CJGFHFIF]][[g-testing-a-standalone-jakarta-messaging-resource-adapter]] +[[CJGFHFIF]][[f-testing-a-standalone-jakarta-messaging-resource-adapter]] -G Testing a Standalone Jakarta Messaging Resource Adapter +F Testing a Standalone Jakarta Messaging Resource Adapter --------------------------------------------------------- This appendix explains how to set up and configure a Jakarta EE 9 CI and -Jakarta EE 9 Platform TCK so a standalone Jakarta Messaging resource adapter can be tested. +Jakarta EE 9 CTS so a standalone Jakarta Messaging resource adapter can be tested. This appendix covers the following topics: * link:#CJGGIEEJ[Setting Up Your Environment] -* link:#CJGDJCEC[Configuring Jakarta EE 9 Platform TCK] +* link:#CJGDJCEC[Configuring Jakarta EE 9 CTS] * link:#CJGFCJBA[Configuring a Jakarta EE 9 CI for the Standalone Jakarta Messaging Resource Adapter] * link:#CJGEBECH[Modifying the Runtime Deployment Descriptors for the @@ -25,12 +25,12 @@ Jakarta Messaging MDB and Resource Adapter Tests] * link:#CJGFHCBJ[Running the Jakarta Messaging Tests From the Command Line] * link:#CJGCJGIH[Restoring the Runtime Deployment Descriptors for the Jakarta Messaging MDB and Resource Adapter Tests] -* link:#CJGCDGIG[Reconfiguring Jakarta EE 9 CI for Jakarta EE 9 Platform TCK After +* link:#CJGCDGIG[Reconfiguring Jakarta EE 9 CI for Jakarta EE 9 CTS After Testing the Standalone Jakarta Messaging Resource Adapter] -[[CJGGIEEJ]][[g.1-setting-up-your-environment]] +[[CJGGIEEJ]][[f.1-setting-up-your-environment]] -G.1 Setting Up Your Environment +F.1 Setting Up Your Environment ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Before you can run the Jakarta Messaging CTS tests against a standalone Jakarta Messaging Resource @@ -39,7 +39,7 @@ components: * Java SE 8 software * Jakarta EE 9 CI software such as Eclipse GlassFish 6.0 -* Jakarta EE 9 Platform TCK software +* Jakarta EE 9 CTS software Complete the following steps to set up Eclipse GlassFish 6.0 in your environment: @@ -48,15 +48,15 @@ Complete the following steps to set up Eclipse GlassFish 6.0 in your environment installed * JAVAEE_HOME to the directory where the Jakarta EE 9 CI (Eclipse GlassFish 6.0) software has been installed -* TS_HOME to the directory where the Jakarta EE 9 Platform TCK software has been +* TS_HOME to the directory where the Jakarta EE 9 CTS software has been installed 2. Update your PATH environment variable to include the following directories: JAVA_HOME/bin, JAVAEE_HOME/bin, TS_HOME/bin, and ANT_HOME/bin. -[[CJGDJCEC]][[g.2-configuring-java-ee-8-cts]] +[[CJGDJCEC]][[f.2-configuring-java-ee-8-cts]] -G.2 Configuring Jakarta EE 9 Platform TCK +F.2 Configuring Jakarta EE 9 CTS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The `ts.jte` file includes properties that must be set for testing a @@ -87,9 +87,9 @@ your Jakarta EE 9 environment when the `config.vi` Ant task, which is described in the next section, is invoked. For the Jakarta EE 9 CI Eclipse GlassFish 6.0, the file is copied to the `JAVAEE_HOME/lib` directory. -[[CJGFCJBA]][[g.3-configuring-the-jakarta-ee-8-CI-for-the-standalone-jakarta-messaging-resource-adapter]] +[[CJGFCJBA]][[f.3-configuring-the-jakarta-ee-8-CI-for-the-standalone-jakarta-messaging-resource-adapter]] -G.3 Configuring a Jakarta EE 9 CI for the Standalone Jakarta Messaging Resource Adapter +F.3 Configuring a Jakarta EE 9 CI for the Standalone Jakarta Messaging Resource Adapter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Invoke the config.vi Ant task to configure the Jakarta EE 9 CI, Eclipse GlassFish 6.0 for CTS 9 @@ -117,9 +117,9 @@ for that environment. If you are using a different standalone Jakarta Messaging resource adapter, you will need to rewrite these scripts for that Jakarta Messaging resource adapter. -[[CJGEBECH]][[g.4-modifying-the-runtime-deployment-descriptors-for-the-jakarta-messaging-mdb-and-resource-adapter-tests]] +[[CJGEBECH]][[f.4-modifying-the-runtime-deployment-descriptors-for-the-jakarta-messaging-mdb-and-resource-adapter-tests]] -G.4 Modifying the Runtime Deployment Descriptors for the Jakarta Messaging MDB and Resource Adapter Tests +F.4 Modifying the Runtime Deployment Descriptors for the Jakarta Messaging MDB and Resource Adapter Tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ After the standalone Jakarta Messaging Resource Adapter has been configured and @@ -152,9 +152,9 @@ runtime deployment descriptor XML files will need to be vendor specific. In this case, you will need to modify the Ant script to handle your vendor-specific runtime deployment descriptor XML files. -[[CJGFHCBJ]][[g.5-running-the-jakarta-messaging-tests-from-the-command-line]] +[[CJGFHCBJ]][[f.5-running-the-jakarta-messaging-tests-from-the-command-line]] -G.5 Running the Jakarta Messaging Tests From the Command Line +F.5 Running the Jakarta Messaging Tests From the Command Line ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ Run the Jakarta Messaging tests: @@ -163,14 +163,14 @@ Run the Jakarta Messaging tests: . Invoke the `runclient` Ant target: + `ant runclient` -[[CJGCJGIH]][[g.6-restoring-the-runtime-deployment-descriptors-for-the-jakarta-messaging-mdb-and-resource-adapter-tests]] +[[CJGCJGIH]][[f.6-restoring-the-runtime-deployment-descriptors-for-the-jakarta-messaging-mdb-and-resource-adapter-tests]] -G.6 Restoring the Runtime Deployment Descriptors for the Jakarta Messaging MDB and Resource Adapter Tests +F.6 Restoring the Runtime Deployment Descriptors for the Jakarta Messaging MDB and Resource Adapter Tests ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ After you run the Jakarta Messaging tests against your standalone Jakarta Messaging Resource Adapter, you need to restore the Jakarta Messaging MDB and Resource Adapter tests. -Jakarta EE 9 Platform TCK provides an Ant task that handles the restoration. Invoke +Jakarta EE 9 CTS provides an Ant task that handles the restoration. Invoke the following Ant task to restore the Jakarta Messaging MDB and Resource Adapter `glassfish-ejb-jar` runtime deployment descriptor XML files to their previous state: @@ -184,14 +184,14 @@ descriptor XML files will be vendor specific. In this case, you will need to modify the Ant script to handle the vendor-specific runtime deployment descriptor XML files appropriate for your environment. -[[CJGCDGIG]][[g.7-reconfiguring-jakarta-ee-8-CI-for-jakarta-ee-8-cts-after-testing-the-standalone-jakarta-messaging-resource-adapter]] +[[CJGCDGIG]][[f.7-reconfiguring-jakarta-ee-8-CI-for-jakarta-ee-8-cts-after-testing-the-standalone-jakarta-messaging-resource-adapter]] -G.7 Reconfiguring Jakarta EE 9 CI for Jakarta EE 9 Platform TCK After Testing the Standalone Jakarta Messaging Resource Adapter +F.7 Reconfiguring Jakarta EE 9 CI for Jakarta EE 9 CTS After Testing the Standalone Jakarta Messaging Resource Adapter ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ After you finish testing the standalone Jakarta Messaging Resource Adapter, you need to reconfigure the Jakarta EE 9 CI before you can continue testing with -Jakarta EE 9 Platform TCK: +Jakarta EE 9 CTS: . Change to the `TS_HOME/bin` directory. . Invoke the `clean.vi` Ant target: + @@ -208,7 +208,7 @@ number * Reset the `jmsra.name` property to `jmsra` to refer to the Jakarta Messaging Resource Adapter for the Jakarta EE 9 CI . From the TS_HOME/bin directory, invoke the config.vi Ant task to -reconfigure the Jakarta EE 9 CI for Jakarta EE 9 Platform TCK: + +reconfigure the Jakarta EE 9 CI for Jakarta EE 9 CTS: + `ant config.vi` diff --git a/user_guides/jakartaee/src/main/jbake/content/portingpackage.adoc b/user_guides/jakartaee/src/main/jbake/content/portingpackage.adoc index 3ca6d9fc74..c600edc43f 100644 --- a/user_guides/jakartaee/src/main/jbake/content/portingpackage.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/portingpackage.adoc @@ -110,7 +110,7 @@ permitted to exit the VM (for example, by using the `System.exit` call). 11.2 Porting Package APIs ~~~~~~~~~~~~~~~~~~~~~~~~~ -The following sections describe the API in the Jakarta EE 9 Platform TCK porting +The following sections describe the API in the Jakarta EE 9 CTS porting package. The implementation classes used with the Jakarta Platform, Enterprise Edition CI are located in the `/src/com/sun/ts/lib/implementation/sun/javaee` directory. You diff --git a/user_guides/jakartaee/src/main/jbake/content/rules-wp.adoc b/user_guides/jakartaee/src/main/jbake/content/rules-wp.adoc index 4ed81f2453..5c927caa2d 100644 --- a/user_guides/jakartaee/src/main/jbake/content/rules-wp.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/rules-wp.adoc @@ -429,7 +429,7 @@ programmatic behavior of the Runtime in the absence of that comment. EE-WP20 Compatibility testing for the Jakarta EE 9 Web Profile consists of running the tests for the technologies defined in link:intro.html#BHCGFHDI[Section 1.2.2, "Jakarta EE 9 Web Profile -Technologies Tested With Jakarta EE 9 Platform TCK."] If optional technologies +Technologies Tested With Jakarta EE 9 CTS."] If optional technologies defined in the Jakarta EE 9 Web Profile platform are implemented in addition to the required Jakarta EE 9 Web Profile technologies, corresponding tests within this TCK for those additional technologies diff --git a/user_guides/jakartaee/src/main/jbake/content/title.adoc b/user_guides/jakartaee/src/main/jbake/content/title.adoc index de61d3d849..55badad263 100644 --- a/user_guides/jakartaee/src/main/jbake/content/title.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/title.adoc @@ -1,32 +1,32 @@ type=page status=published -title=Jakarta EE Platform, Enterprise Edition 9 Test Compatibility Kit User's Guide, Release 9 for Jakarta EE +title=Jakarta EE Platform, Enterprise Edition 9 Compatibility Test Suite User's Guide, Release 9 for Jakarta EE next=TCKpreface.html prev=toc.html ~~~~~~ -Jakarta EE Platform, Enterprise Edition 9 Test Compatibility Kit User's Guide, Release 9 for Jakarta EE +Jakarta EE Platform, Enterprise Edition 9 Compatibility Test Suite User's Guide, Release 9 for Jakarta EE ========================================================================================================= [[oracle]] Eclipse Foundation™ ------------------- -Jakarta Platform, Enterprise Edition 9 Test Compatibility Kit User's +Jakarta Platform, Enterprise Edition 9 Compatibility Test Suite User's Guide Release 9 for Jakarta EE -October, 2020 +November, 2020 Provides detailed instructions for obtaining, installing, configuring, -and using the Eclipse Jakarta, Enterprise Edition 9 Test Compatibility Kit - for the Full Profile and the Web Profile. +and using the Eclipse Jakarta, Enterprise Edition 9 Compatibility Test +Suite for the Full Profile and the Web Profile. [[sthref1]] ''''' -Jakarta Platform, Enterprise Edition 9 Test Compatibility Kit User's +Jakarta Platform, Enterprise Edition 9 Compatibility Test Suite User's Guide, Release 9 for Jakarta EE Copyright © 2013, 2020 Oracle and/or its affiliates. All rights reserved. diff --git a/user_guides/jakartaee/src/main/jbake/content/toc.adoc b/user_guides/jakartaee/src/main/jbake/content/toc.adoc index 063b4a364f..440bebef4d 100644 --- a/user_guides/jakartaee/src/main/jbake/content/toc.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/toc.adoc @@ -26,19 +26,19 @@ link:intro.html#GBFOW[1 Introduction] ** link:intro.html#GBFTK[1.1 Compatibility Testing] *** link:intro.html#GBFQN[1.1.1 Why Compatibility Testing is Important] *** link:intro.html#GBFPR[1.1.2 Compatibility Rules] -*** link:intro.html#GBFPW[1.1.3 TCK Overview] +*** link:intro.html#GBFPW[1.1.3 CTS Overview] *** link:intro.html#GBFPB[1.1.4 Jakarta Specification Community Process Program and Compatibility Testing] -** link:intro.html#GEUYK[1.2 About Jakarta EE 9 Platform TCK] -*** link:intro.html#sthref4[1.2.1 Jakarta EE 9 Technologies Tested with Jakarta EE 9 Platform TCK] -*** link:intro.html#BHCGFHDI[1.2.2 Jakarta EE 9 Web Profile Technologies Tested With Jakarta EE 9 Platform TCK] -*** link:intro.html#GEUZS[1.2.3 TCK Tests] +** link:intro.html#GEUYK[1.2 About Jakarta EE 9 CTS] +*** link:intro.html#sthref4[1.2.1 Jakarta EE 9 Technologies Tested with Jakarta EE 9 CTS] +*** link:intro.html#BHCGFHDI[1.2.2 Jakarta EE 9 Web Profile Technologies Tested With Jakarta EE 9 CTS] +*** link:intro.html#GEUZS[1.2.3 CTS Tests] *** link:intro.html#GEUYR[1.2.4 JavaTest Harness] *** link:intro.html#GEUYQ[1.2.5 Exclude Lists] *** link:intro.html#GEUZN[1.2.6 Apache Ant] ** link:intro.html#GEVAD[1.3 Hardware Requirements] ** link:intro.html#GEVBB[1.4 Software Requirements] -** link:intro.html#GEVCL[1.5 Additional Jakarta EE 9 Platform TCK Requirements] -** link:intro.html#GBFQW[1.6 Getting Started With the Jakarta EE 9 Platform TCK Test Suite] +** link:intro.html#GEVCL[1.5 Additional Jakarta EE 9 CTS Requirements] +** link:intro.html#GBFQW[1.6 Getting Started With the Jakarta EE 9 CTS Test Suite] [[procedure-for-jakarta-platform-enterprise-edition-8-certification]] link:rules.html#GBFSN[2 Procedure for Jakarta Platform, Enterprise Edition 9 Certification] @@ -74,7 +74,7 @@ link:install.html#GBFTP[4 Installation] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ** link:install.html#GEVGN[4.1 Installing the Jakarta EE 9 Compatible Implementation] -** link:install.html#GEVHP[4.2 Installing the Jakarta EE 9 Platform TCK] +** link:install.html#GEVHP[4.2 Installing the Jakarta EE 9 CTS] ** link:install.html#GEVGZ[4.3 Verifying Your Installation (Optional)] [[setup-and-configuration]] @@ -127,7 +127,7 @@ link:webprofileconfig.html#GJRHB[6 Setup and Configuration for Testing with the link:using.html#GBFWO[7 Executing Tests] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -** link:using.html#GFADX[7.1 Jakarta EE 9 Platform TCK Operating Assumptions] +** link:using.html#GFADX[7.1 Jakarta EE 9 CTS Operating Assumptions] ** link:using.html#GBFUZ[7.2 Starting JavaTest] *** link:using.html#GBFWH[7.2.1 To Start JavaTest in GUI Mode] *** link:using.html#GFAEF[7.2.2 To Start JavaTest in Command-Line Mode] @@ -160,7 +160,7 @@ link:debug.html#GBFUV[8 Debugging Test Problems] link:troubleshooting.html#GFAHF[9 Troubleshooting] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ -** link:troubleshooting.html#GFAUR[9.1 Common TCK Problems and Resolutions] +** link:troubleshooting.html#GFAUR[9.1 Common CTS Problems and Resolutions] ** link:troubleshooting.html#GFAGN[9.2 Support] [[building-and-debugging-tests]] @@ -214,9 +214,9 @@ link:portingpackage.html#GFATG[11 Implementing the Porting Package] ** link:contextrootmappingrules.html#GJJWG[E.2 Jakarta Enterprise Bean-Based Web Service Endpoint Context Root Mapping] * link:jms-resource-adaptr.html#CJGFHFIF[F Testing a Standalone Jakarta Messaging Resource Adapter] ** link:jms-resource-adaptr.html#CJGGIEEJ[F.1 Setting Up Your Environment] -** link:jms-resource-adaptr.html#CJGDJCEC[F.2 Configuring Jakarta EE 9 Platform TCK] +** link:jms-resource-adaptr.html#CJGDJCEC[F.2 Configuring Jakarta EE 9 CTS] ** link:jms-resource-adaptr.html#CJGFCJBA[F.3 Configuring a Jakarta EE 9 CI for the Standalone Jakarta Messaging Resource Adapter] ** link:jms-resource-adaptr.html#CJGEBECH[F.4 Modifying the Runtime Deployment Descriptors for the Jakarta Messaging MDB and Resource Adapter Tests] ** link:jms-resource-adaptr.html#CJGFHCBJ[F.5 Running the Jakarta Messaging Tests From the Command Line] ** link:jms-resource-adaptr.html#CJGCJGIH[F.6 Restoring the Runtime Deployment Descriptors for the Jakarta Messaging MDB and Resource Adapter Tests] -** link:jms-resource-adaptr.html#CJGCDGIG[F.7 Reconfiguring Jakarta EE 9 CI for Jakarta EE 9 Platform TCK After Testing the Standalone Jakarta Messaging Resource Adapter] +** link:jms-resource-adaptr.html#CJGCDGIG[F.7 Reconfiguring Jakarta EE 9 CI for Jakarta EE 9 CTS After Testing the Standalone Jakarta Messaging Resource Adapter] diff --git a/user_guides/jakartaee/src/main/jbake/content/troubleshooting.adoc b/user_guides/jakartaee/src/main/jbake/content/troubleshooting.adoc index a254c0ad73..f1324229a3 100644 --- a/user_guides/jakartaee/src/main/jbake/content/troubleshooting.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/troubleshooting.adoc @@ -16,9 +16,9 @@ This chapter explains how to debug test failures that you could encounter as you run the Jakarta Platform, Enterprise Edition Compatibility Test Suite. -[[GFAUR]][[common-tck-problems-and-resolutions]] +[[GFAUR]][[common-cts-problems-and-resolutions]] -9.1 Common TCK Problems and Resolutions +9.1 Common CTS Problems and Resolutions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ This section lists common problems that you may encounter as you run the @@ -27,7 +27,7 @@ the Jakarta Platform, Enterprise Edition CI, Eclipse GlassFish 6.0. It also prop for the problems, where applicable. * Problem: + -The following exception may occur when a Jakarta EE 9 Platform TCK test tries to +The following exception may occur when a Jakarta EE 9 CTS test tries to write a very long tracelog: + [source,oac_no_warn] ---- diff --git a/user_guides/jakartaee/src/main/jbake/content/using.adoc b/user_guides/jakartaee/src/main/jbake/content/using.adoc index a91d2872f6..eb2f4b3059 100644 --- a/user_guides/jakartaee/src/main/jbake/content/using.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/using.adoc @@ -12,13 +12,13 @@ Executing Tests 7 Executing Tests ----------------- -The Jakarta EE 9 Platform TCK uses the JavaTest harness to execute the tests in the +The Jakarta EE 9 CTS uses the JavaTest harness to execute the tests in the test suite. For detailed instructions that explain how to run and use JavaTest, see the JavaTest User's Guide and Reference. This chapter includes the following topics: -* link:#GFADX[Jakarta EE 9 Platform TCK Operating Assumptions] +* link:#GFADX[Jakarta EE 9 CTS Operating Assumptions] * link:#GBFUZ[Starting JavaTest] * link:#GFACS[Validating Your Test Configuration] * link:#GBFWM[Running a Subset of the Tests] @@ -39,7 +39,7 @@ respectively. [[GFADX]][[jakarta-ee-8-cts-operating-assumptions]] -7.1 Jakarta EE 9 Platform TCK Operating Assumptions +7.1 Jakarta EE 9 CTS Operating Assumptions ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ The following are assumed in this chapter: @@ -50,7 +50,7 @@ for configuring the Jakarta EE CI, Eclipse GlassFish 6.0. If you are using anoth product's setup and configuration documentation. * Java SE 8 software is correctly installed and configured on the host machine. -* Jakarta EE 9 Platform TCK is installed and configured as described in this guide. +* Jakarta EE 9 CTS is installed and configured as described in this guide. * Implementations of the technologies to be tested are properly installed and configured. @@ -59,7 +59,7 @@ installed and configured. 7.2 Starting JavaTest ~~~~~~~~~~~~~~~~~~~~~ -There are two general ways to run Jakarta EE 9 Platform TCK using the JavaTest +There are two general ways to run Jakarta EE 9 CTS using the JavaTest harness software: * Through the JavaTest GUI @@ -78,7 +78,7 @@ server configurations, and for running tests in batch mode. ======================================================================= The `build.xml` file in `/bin` contains the various Ant -targets for the Jakarta EE 9 Platform TCK test suite +targets for the Jakarta EE 9 CTS test suite ======================================================================= @@ -89,7 +89,7 @@ targets for the Jakarta EE 9 Platform TCK test suite ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 1. Set the `TS_HOME` environment variable to the directory in which the -Jakarta EE 9 Platform TCK is installed. +Jakarta EE 9 CTS is installed. 2. Change to the `/bin` directory. 3. Ensure that the `ts.jte` file contains information relevant to your setup. + @@ -142,7 +142,7 @@ directions must pass. ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 1. Set the `TS_HOME` environment variable to the directory in which -Jakarta EE 9 Platform TCK was installed. +Jakarta EE 9 CTS was installed. 2. Change to any subdirectory under `/src/com/sun/ts/tests`. 3. Ensure that the `ts.jte` file contains information relevant to your setup. + @@ -157,9 +157,9 @@ This runs all tests in the current directory and any subdirectories. [[GCMCU]] -===== Example 7-1 Running the Jakarta EE 9 Platform TCK Signature Tests +===== Example 7-1 Running the Jakarta EE 9 CTS Signature Tests -To run the Jakarta EE 9 Platform TCK signature tests, enter the following commands: +To run the Jakarta EE 9 CTS signature tests, enter the following commands: [source,oac_no_warn] ---- diff --git a/user_guides/jakartaee/src/main/jbake/content/webprofileconfig.adoc b/user_guides/jakartaee/src/main/jbake/content/webprofileconfig.adoc index abed208be6..0e09a1634e 100644 --- a/user_guides/jakartaee/src/main/jbake/content/webprofileconfig.adoc +++ b/user_guides/jakartaee/src/main/jbake/content/webprofileconfig.adoc @@ -12,7 +12,7 @@ Setup and Configuration for Testing with the Jakarta EE 9 Web Profile 6 Setup and Configuration for Testing with the Jakarta EE 9 Web Profile ----------------------------------------------------------------------- -This chapter describes how to configure the Jakarta EE 9 Platform TCK test suite to +This chapter describes how to configure the Jakarta EE 9 CTS test suite to work with your Jakarta EE 9 Web Profile test environment. It is recommended that you first set up the testing environment using the Jakarta EE 9 Web Profile CI and then with your Jakarta EE 9 Web Profile server. @@ -32,10 +32,10 @@ Windows, and Linux platforms. 6.1.1 To Run Tests Against a Jakarta EE 9 Web Profile Implementation ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ -The Jakarta EE 9 Platform TCK is the Technology Compatibility Kit (TCK) for the Jakarta +The Jakarta EE 9 CTS is the Technology Compatibility Kit (TCK) for the Jakarta Platform, Enterprise Edition as well as the Jakarta EE 9 Web Profile. Implementations of the full Jakarta Platform, Enterprise Edition must pass -all of the tests as defined by Jakarta EE 9 Platform TCK Rules in +all of the tests as defined by Jakarta EE 9 CTS Rules in link:rules.html#GBFSN[Chapter 2, "Procedure for Jakarta Platform, Enterprise Edition 9 Certification"]. @@ -44,7 +44,7 @@ verify requirements defined by the Jakarta EE 9 Web Profile Specification. These tests are defined by the Rules in link:rules-wp.html#GJJPZ[Chapter 3, "Procedure for Jakarta Platform, Enterprise Edition 9 Web Profile Certification"]. These requirements are a subset of the tests contained -in the Jakarta EE 9 Platform TCK test suite. The test suite provides a mechanism +in the Jakarta EE 9 CTS test suite. The test suite provides a mechanism whereby only those tests for the Jakarta EE 9 Web Profile will be run. The following steps explain how to use this mechanism.