signature test migration from jakartaee-tck repo.
Signed-off-by: gurunandan.rao@oracle.com <gurunandan.rao@oracle.com>
diff --git a/impl-tck/pom.xml b/impl-tck/pom.xml
index 8591ede..9bf1177 100644
--- a/impl-tck/pom.xml
+++ b/impl-tck/pom.xml
@@ -24,7 +24,7 @@
<groupId>org.eclipse.jsonp</groupId>
<artifactId>jakarta.json-tck</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
@@ -33,9 +33,9 @@
</modules>
<properties>
- <jsonp-api.version>2.0.1-SNAPSHOT</jsonp-api.version>
+ <jsonp-api.version>2.1.0-SNAPSHOT</jsonp-api.version>
<jsonp-impl.version>1.0.1-SNAPSHOT</jsonp-impl.version>
- <jsonp-tck.version>2.0.0-SNAPSHOT</jsonp-tck.version>
+ <jsonp-tck.version>2.1.0-SNAPSHOT</jsonp-tck.version>
</properties>
<dependencies>
diff --git a/impl-tck/tck-tests-plugability/pom.xml b/impl-tck/tck-tests-plugability/pom.xml
index 698078f..cc48ed7 100644
--- a/impl-tck/tck-tests-plugability/pom.xml
+++ b/impl-tck/tck-tests-plugability/pom.xml
@@ -25,7 +25,7 @@
<parent>
<groupId>org.eclipse.jsonp</groupId>
<artifactId>jakarta.json-tck</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
</parent>
<artifactId>jakarta.json-tck-tests-plugability</artifactId>
diff --git a/impl-tck/tck-tests/pom.xml b/impl-tck/tck-tests/pom.xml
index cc77e86..b485005 100644
--- a/impl-tck/tck-tests/pom.xml
+++ b/impl-tck/tck-tests/pom.xml
@@ -25,11 +25,15 @@
<parent>
<groupId>org.eclipse.jsonp</groupId>
<artifactId>jakarta.json-tck</artifactId>
- <version>1.0.0-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
</parent>
<artifactId>jakarta.json-tck-tests</artifactId>
+ <properties>
+ <jakarta.json.version>2.1.0-SNAPSHOT</jakarta.json.version>
+ </properties>
+
<dependencies>
<dependency>
<groupId>jakarta.json</groupId>
@@ -43,11 +47,87 @@
<version>${jsonp-tck.version}</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.netbeans.tools</groupId>
+ <artifactId>sigtest-maven-plugin</artifactId>
+ <version>1.4</version>
+ </dependency>
</dependencies>
<build>
<plugins>
<plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-dependency-plugin</artifactId>
+ <version>3.2.0</version>
+ <executions>
+ <execution>
+ <id>copy-jsonp-tck-signature-files</id>
+ <phase>generate-test-sources</phase>
+ <goals>
+ <goal>unpack</goal>
+ </goals>
+ <configuration>
+ <artifactItems>
+ <artifactItem>
+ <groupId>jakarta.json</groupId>
+ <artifactId>jakarta.json-tck-tests</artifactId>
+ <version>${jsonp-tck.version}</version>
+ <type>jar</type>
+ <overWrite>true</overWrite>
+ </artifactItem>
+ </artifactItems>
+ <!-- We need the signature file, mapping file and package list file -->
+ <includes>**/*sig-test*,**/*jakarta.json.sig_*,**/*sig-test-pkg-list.txt</includes>
+ <outputDirectory>${project.build.directory}/signaturedirectory</outputDirectory>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-dependency-plugin</artifactId>
+ <version>3.2.0</version>
+ <executions>
+ <execution>
+ <id>copy</id>
+ <phase>generate-test-sources</phase>
+ <goals>
+ <goal>copy</goal>
+ </goals>
+ <configuration>
+ <artifactItems>
+ <artifactItem>
+ <groupId>jakarta.json</groupId>
+ <artifactId>jakarta.json-api</artifactId>
+ <version>${jakarta.json.version}</version>
+ <type>jar</type>
+ <overWrite>true</overWrite>
+ <outputDirectory>${project.build.directory}/signaturedirectory</outputDirectory>
+ <destFileName>jakarta.json-api.jar</destFileName>
+ </artifactItem>
+ </artifactItems>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ <plugin>
+ <artifactId>maven-surefire-plugin</artifactId>
+ <version>3.0.0-M4</version>
+ <configuration>
+ <trimStackTrace>false</trimStackTrace>
+ <failIfNoTests>true</failIfNoTests>
+ <dependenciesToScan>jakarta.json:jakarta.json-tck-tests</dependenciesToScan>
+ <systemPropertyVariables>
+ <jimage.dir>${project.build.directory}/jdk11-bundle</jimage.dir>
+ <signature.mapfile>${project.build.directory}/signaturedirectory/jakarta/jsonp/tck/signaturetest/sig-test.map</signature.mapfile>
+ <signature.repositoryDir>${project.build.directory}/signaturedirectory/jakarta/jsonp/tck/signaturetest</signature.repositoryDir>
+ <signature.packagelist>${project.build.directory}/signaturedirectory/jakarta/jsonp/tck/signaturetest/sig-test-pkg-list.txt</signature.packagelist>
+ <signature.sigTestClasspath>${project.build.directory}/signaturedirectory/jakarta.json-api.jar:${project.build.directory}/jdk11-bundle/java.base:${project.build.directory}/jdk11-bundle/java.rmi:${project.build.directory}/jdk11-bundle/java.sql:${project.build.directory}/jdk11-bundle/java.naming</signature.sigTestClasspath>
+ </systemPropertyVariables>
+ </configuration>
+ </plugin>
+ <plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>3.0.0-M4</version>
<configuration>
diff --git a/tck/pom.xml b/tck/pom.xml
index 87753b8..ad5e6f7 100644
--- a/tck/pom.xml
+++ b/tck/pom.xml
@@ -27,7 +27,7 @@
<groupId>jakarta.json</groupId>
<artifactId>jakarta.json-tck</artifactId>
- <version>2.0.0-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
<packaging>pom</packaging>
<modules>
@@ -54,8 +54,8 @@
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
- <maven.compiler.target>1.8</maven.compiler.target>
- <maven.compiler.source>1.8</maven.compiler.source>
+ <maven.compiler.target>11</maven.compiler.target>
+ <maven.compiler.source>11</maven.compiler.source>
<junit.jupiter.version>5.7.2</junit.jupiter.version>
<arquillian.junit5.version>1.7.0.Alpha5</arquillian.junit5.version>
</properties>
@@ -64,7 +64,7 @@
<dependency>
<groupId>jakarta.json</groupId>
<artifactId>jakarta.json-api</artifactId>
- <version>2.0.1-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
<dependency>
diff --git a/tck/tck-common/pom.xml b/tck/tck-common/pom.xml
index 50d6c67..084b7fa 100644
--- a/tck/tck-common/pom.xml
+++ b/tck/tck-common/pom.xml
@@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
- Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
This program and the accompanying materials are made available under the
terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,7 +22,7 @@
<parent>
<groupId>jakarta.json</groupId>
<artifactId>jakarta.json-tck</artifactId>
- <version>2.0.0-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
</parent>
<artifactId>jakarta.json-tck-common</artifactId>
diff --git a/tck/tck-tests-plugability/pom.xml b/tck/tck-tests-plugability/pom.xml
index 9ffbf88..e57e80b 100644
--- a/tck/tck-tests-plugability/pom.xml
+++ b/tck/tck-tests-plugability/pom.xml
@@ -1,7 +1,7 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
- Copyright (c) 2020 Oracle and/or its affiliates. All rights reserved.
+ Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
This program and the accompanying materials are made available under the
terms of the Eclipse Public License v. 2.0, which is available at
@@ -22,7 +22,7 @@
<parent>
<groupId>jakarta.json</groupId>
<artifactId>jakarta.json-tck</artifactId>
- <version>2.0.0-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
</parent>
<artifactId>jakarta.json-tck-tests-plugability</artifactId>
@@ -32,7 +32,7 @@
<dependency>
<groupId>jakarta.json</groupId>
<artifactId>jakarta.json-tck-common</artifactId>
- <version>2.0.0-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
</dependencies>
diff --git a/tck/tck-tests/pom.xml b/tck/tck-tests/pom.xml
index af1c6d0..494b6c6 100644
--- a/tck/tck-tests/pom.xml
+++ b/tck/tck-tests/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>jakarta.json</groupId>
<artifactId>jakarta.json-tck</artifactId>
- <version>2.0.0-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
</parent>
<artifactId>jakarta.json-tck-tests</artifactId>
@@ -32,7 +32,7 @@
<dependency>
<groupId>jakarta.json</groupId>
<artifactId>jakarta.json-tck-common</artifactId>
- <version>2.0.0-SNAPSHOT</version>
+ <version>2.1.0-SNAPSHOT</version>
<scope>provided</scope>
</dependency>
</dependencies>
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/api/provider/JsonProviderTest.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/api/provider/JsonProviderTest.java
index 09cc300..573458b 100644
--- a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/api/provider/JsonProviderTest.java
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/api/provider/JsonProviderTest.java
@@ -43,13 +43,16 @@
*
*/
public class JsonProviderTest {
+
+ private static final String JSONP_PROVIDER_FACTORY = "jakarta.json.provider";
+
/**
* Verifies it is possible to obtain the JsonProvider implementation from a System property.
*/
@Test
public void systemProperty() {
- System.setProperty(JsonProvider.JSONP_PROVIDER_FACTORY, DummyJsonProvider.class.getName());
+ System.setProperty(JSONP_PROVIDER_FACTORY, DummyJsonProvider.class.getName());
JsonProvider provider = JsonProvider.provider();
assertEquals(DummyJsonProvider.class, provider.getClass());
}
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/ApiCheckDriver.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/ApiCheckDriver.java
new file mode 100644
index 0000000..612e5f3
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/ApiCheckDriver.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+package jakarta.jsonp.tck.signaturetest;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.PrintWriter;
+import java.io.Serializable;
+import java.lang.reflect.Constructor;
+import java.lang.reflect.Method;
+import java.util.LinkedList;
+import java.util.List;
+
+
+public final class ApiCheckDriver extends SignatureTestDriver
+ implements Serializable {
+
+ /* flags for the Diff utility argument list */
+ private static final String BASE_FLAG = "-base";
+
+ private static final String TEST_FLAG = "-test";
+
+ private static final String PACKAGE_NO_SUBS_FLAG = "-PackageWithoutSubpackages";
+
+ private static final String PACKAGE_FLAG = "-package";
+
+ private static final String EXPACKAGE_FLAG = "-expackage";
+
+ private static final String REFLECT_FLAG = "-reflect";
+
+ private static final String CONST_FLAG = "-constvalues";
+
+ // ---------------------------------------- Methods from SignatureTestDriver
+
+ @Override
+ protected String normalizeFileName(File f) {
+ return f.getPath();
+ }
+
+ @Override
+ protected String[] createTestArguments(String packageListFile, String mapFile,
+ String signatureRepositoryDir, String packageOrClassUnderTest,
+ String classpath, boolean bStaticMode) throws Exception {
+
+ Class pkgListClass = Class.forName("javasoft.sqe.apiCheck.PackageList");
+ Constructor pkgCtor = pkgListClass
+ .getDeclaredConstructor(new Class[] { String.class });
+ Object pkgInstance = pkgCtor.newInstance(new Object[] { packageListFile });
+
+ Method pkgMethod = pkgListClass.getDeclaredMethod("getSubPackagesFormatted",
+ new Class[] { String.class });
+
+ String excludePkgs = (String) pkgMethod.invoke(pkgInstance,
+ new Object[] { packageOrClassUnderTest });
+
+ List sigArgsList = new LinkedList();
+
+ sigArgsList.add(BASE_FLAG);
+ sigArgsList.add(
+ getSigFileInfo(packageOrClassUnderTest, mapFile, signatureRepositoryDir)
+ .getFile());
+
+ if (classpath != null && classpath.length() > 0) {
+ sigArgsList.add(TEST_FLAG);
+ sigArgsList.add(classpath);
+ }
+
+ sigArgsList.add(REFLECT_FLAG);
+ sigArgsList.add(CONST_FLAG);
+ sigArgsList.add(PACKAGE_FLAG);
+ sigArgsList.add(packageOrClassUnderTest);
+
+ if (excludePkgs != null && excludePkgs.length() > 0) {
+ sigArgsList.add(EXPACKAGE_FLAG);
+ sigArgsList.add(excludePkgs);
+ }
+
+ return (String[]) (sigArgsList.toArray(new String[sigArgsList.size()]));
+
+ } // END createTestArguments
+
+ @Override
+ protected boolean runSignatureTest(String packageOrClassName,
+ String[] testArguments) throws Exception {
+
+ Class diffClass = Class.forName("javasoft.sqe.apiCheck.Diff");
+ Method mainMethod = diffClass.getDeclaredMethod("main",
+ new Class[] { String[].class });
+ mainMethod.invoke(null, new Object[] { testArguments });
+
+ Method diffMethod = diffClass.getDeclaredMethod("diffsFound",
+ new Class[] {});
+ return (!((Boolean) diffMethod.invoke(null, new Object[] {}))
+ .booleanValue());
+
+ } // END runSignatureTest
+
+ @Override
+ protected boolean runPackageSearch(String packageOrClassName,
+ String[] testArguments) throws Exception {
+ Class sigTestClass = Class
+ .forName("com.sun.tdk.signaturetest.SignatureTest");
+ Object sigTestInstance = sigTestClass.newInstance();
+
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+
+ // we want to replace the PACKAGE_FLAG with PACKAGE_NO_SUBS_FLAG
+ for (int ii = 0; ii < testArguments.length; ii++) {
+ if (testArguments[ii].equals(PACKAGE_FLAG)) {
+ testArguments[ii] = PACKAGE_NO_SUBS_FLAG;
+ }
+ }
+
+ // dump args for debugging aid
+ System.out.println(
+ "\nCalling: com.sun.tdk.signaturetest.SignatureTest() with following args:");
+ for (int ii = 0; ii < testArguments.length; ii++) {
+ System.out.println(" testArguments[" + ii + "] = " + testArguments[ii]);
+ }
+
+ @SuppressWarnings("unchecked")
+ Method runMethod = sigTestClass.getDeclaredMethod("run",
+ new Class[] { String[].class, PrintWriter.class, PrintWriter.class });
+ runMethod.invoke(sigTestInstance,
+ new Object[] { testArguments, new PrintWriter(output, true), null });
+
+ String rawMessages = output.toString();
+
+ // currently, there is no way to determine if there are error msgs in
+ // the rawmessages, so we will always dump this and call it a status.
+ System.out.println(
+ "********** Status Report '" + packageOrClassName + "' **********\n");
+ System.out.println(rawMessages);
+ return sigTestInstance.toString().substring(7).startsWith("Passed.");
+ }
+
+ @Override
+ protected boolean verifyJTAJarForNoXA(String classpath, String repositoryDir)
+ throws Exception {
+ // Need to find out whether implementing this method is really required now.
+ // By default, signature test framework will use sigtest
+ return true;
+ }
+
+} // END ApiCheckDriver
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/ApiCheckRecorder.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/ApiCheckRecorder.java
new file mode 100644
index 0000000..0ebcc91
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/ApiCheckRecorder.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * @(#)SigTestRecorder.java 1.1 03/03/05
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <p>
+ * This implementation of {@link Recorder} will record signatures using the
+ * <code>ApiCheck</code> framework.
+ * </p>
+ */
+public class ApiCheckRecorder extends Recorder {
+
+ // ------------------------------------------------------------ Constructors
+
+ public ApiCheckRecorder(String[] args) {
+
+ super(args);
+ System.setProperty("pkg.list.file.path", packageListFile);
+ System.setProperty("map.file.path", signatureMapFile);
+ System.setProperty("signature.repository.dir", signatureRepositoryDir);
+
+ } // END ApiCheckRecorder
+
+ // ------------------------------------------------------- Protected Methods
+
+ protected String[] createCommandLine(String version, String classpath,
+ String outputFileName, String packageName) {
+
+ List command = new ArrayList();
+
+ command.add("-constvalues");
+ command.add("-xpriv");
+
+ command.add("-in");
+ command.add(classpath);
+
+ return ((String[]) command.toArray(new String[command.size()]));
+
+ } // END getCommandLine
+
+ protected void writePackageListFile(String basePackageName,
+ String signatureFile, String packageListFile) throws Exception {
+
+ // no-op as this is done internally by our version of ApiCheck
+
+ } // END writePackageListFile
+
+ protected void doRecord(String[] commandLine) throws Exception {
+
+ Class batchSetup = Class.forName("javasoft.sqe.apiCheck.BatchSetup");
+ Method mainMethod = batchSetup.getDeclaredMethod("main",
+ new Class[] { String[].class });
+ mainMethod.invoke(null, new Object[] { commandLine });
+
+ } // END doRecord
+
+} // END SigTestRecorder
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/PackageList.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/PackageList.java
new file mode 100644
index 0000000..ab3240a
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/PackageList.java
@@ -0,0 +1,430 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Set;
+import java.util.TreeSet;
+
+/**
+ * This class represents a package list file. A package list file is used in
+ * conjunction with a set of signature files to execute API signature tests.
+ * Users specify which set of package APIs are verified. Each package's
+ * signature is verified independently. As such all valid sub-packages must be
+ * excluded while a package's signature is being verified. This allows API check
+ * to determine incompatible additional packages included in a distribution.
+ * <p/>
+ * This class builds a package list file when signatures are recorded and
+ * provides an API to provide valid sub-package lists when signatures are played
+ * back (verified).
+ * <p/>
+ * In record mode, this class reads the existing package list file, if one
+ * exists, and removes the package (as well as sub-packages) that are currently
+ * being recorded. All package names read from the existing package list file
+ * are held in a tree set which sorts the package names and keeps duplicate
+ * package names from ocurring. The user can then instruct this class to write
+ * out the package list file. At this point this class reads the currently
+ * recorded signature file and extracts each package names and adds it to the
+ * tree set. After this step the previous package list file is saved as a backup
+ * and the new package list file is written to disk.
+ * <p/>
+ * In playback mode, this class reads the contents of the package list file and
+ * stores each package name in a tree set. Users can then invoke the
+ * getSubPackages method to retrieve the valid sub-packages for any given
+ * package. This is done by simply examining the package names in the tree set
+ * and returning any package name that starts with the parent package name and a
+ * trailing period character.
+ */
+class PackageList {
+
+ // Any line in the packageFile starting with this character is a comment
+ private static final char COMMENT_CHAR = '#';
+
+ private static final String BACKUP_EXT = ".bak";
+
+ // File containing the list of packages and sub-packages
+ private File packageFile;
+
+ // Signature file where the package signatures were recorded
+ private File sigFile;
+
+ // Name of the package being recorded
+ private String additionalPackageName;
+
+ // Name of packages and sub-packages in the
+ private Set packageNames = new TreeSet();
+
+ /**
+ * Creates an instance of the PackageList class. The PackageList instance
+ * reads the specified package file and populates it's internal state with the
+ * package names found in this file. Users should use this c'tor when playing
+ * back signature files. Users can init the PackageList instance then use the
+ * "String[] getSubPackages(String packageName)" method to get the list of
+ * valid sub-packages for every package who's signature is being verified.
+ *
+ * @param packageFileName
+ * The name of the file that contains the package list. This file
+ * contains the names of all the packages that exist across all the
+ * signature files that makeup this deliverable. This file is used to
+ * generate a list of valid sub-packages that must be exclued when
+ * testing theor parent package's signature.
+ *
+ * @throws Exception
+ * when the packageFileName does not exist.
+ */
+ public PackageList(String packageFileName) throws Exception {
+ packageFile = new File(packageFileName);
+ if (packageFile.exists() && packageFile.isFile()) {
+ extractExistingPackageNames();
+ } else {
+ throw new FileNotFoundException(packageFileName);
+ }
+ }
+
+ /**
+ * Creates an instance of the PackageList class. The PackageList instance
+ * reads the contents of the packageFileName and stores it in it's internal
+ * state. Next, any packages whos name starts with the specified packageName
+ * are removed from the internal package list. This is done because this is
+ * the package being recorded and we need to remove any previously recorded
+ * package names in case any sub-packages have been removed since the last
+ * time the signatures were recorded. Users should use this c'tor when they
+ * are recording signature files never during playback.
+ *
+ * @param packageName
+ * The name of the package whos signatures are being recorded (along
+ * with sub-packages).
+ * @param sigFileName
+ * The name of the file that contains the recored signatures.
+ * @param packageFileName
+ * The name of the file that contains the package list. This file
+ * contains the names of all the packages that exist across all the
+ * signature files that makeup this deliverable. This file is used to
+ * generate a list of valid sub-packages that must be exclued when
+ * testing their parent package's signature.
+ *
+ * @throws Exception
+ * when an error occurs reading the packageFileName or the
+ * sigFileName does not exist.
+ */
+ public PackageList(String packageName, String sigFileName,
+ String packageFileName) throws Exception {
+ this.additionalPackageName = packageName;
+ sigFile = new File(sigFileName);
+ if (!sigFile.exists() || !sigFile.isFile()) {
+ throw new FileNotFoundException(sigFileName);
+ }
+ packageFile = new File(packageFileName);
+ if (packageFile.exists() && packageFile.isFile()) {
+ extractExistingPackageNames();
+ removeExistingPackage();
+ }
+ }
+
+ /**
+ * Read the package names stored in the package list file. Each package name
+ * found in the package list file is added to the internal tree set.
+ *
+ * @throws Exception
+ * if there is an error opening or reading the package list file.
+ */
+ private void extractExistingPackageNames() throws Exception {
+ BufferedReader in = new BufferedReader(new FileReader(packageFile));
+ String line;
+ String trimLine;
+ try {
+ while ((line = in.readLine()) != null) {
+ trimLine = line.trim();
+ if (isComment(trimLine) || "".equals(trimLine)) {
+ continue;
+ }
+ packageNames.add(trimLine);
+ }
+ } finally {
+ try {
+ in.close();
+ } catch (Exception e) {
+ }
+ }
+ }
+
+ /**
+ * Returns true if the specified string starts with a comment character as
+ * denoted by the COMMENT_CHAR constant.
+ *
+ * @param line
+ * Determins of this line is a comment line
+ *
+ * @return boolean True if the specified line is a comment line else false.
+ */
+ private boolean isComment(String line) {
+ if (line == null) {
+ return false;
+ }
+ String theLine = line.trim();
+ if (theLine.length() > 0) {
+ return (theLine.charAt(0) == COMMENT_CHAR);
+ }
+
+ return false;
+ }
+
+ /**
+ * Removes package names from the package list file. The packages that are
+ * removed are the ones currently being recorded. The packages being recorded
+ * is denoted by this.additionalPackageName. This includes any sub-packages of
+ * the additionalPackageName. This step is necessary in the cases where a
+ * sub-package has been removed from a parent package in between signature
+ * recordings.
+ */
+ private void removeExistingPackage() {
+ String delPackage = this.additionalPackageName;
+ String packageName;
+ List delPkgs = new ArrayList();
+ // iterate over package set and find package names to remove
+ for (Iterator i = packageNames.iterator(); i.hasNext();) {
+ packageName = (String) i.next();
+ if (packageName.startsWith(delPackage)) {
+ delPkgs.add(packageName);
+ }
+ }
+ // actually remove the package names from the set
+ for (int i = 0; i < delPkgs.size(); i++) {
+ packageName = (String) (delPkgs.get(i));
+ packageNames.remove(packageName);
+ System.out.println(
+ "PackageList.removeExistingPackage() \"" + packageName + "\"");
+ }
+ }
+
+ /**
+ * Write the package list out to the package list file. This is done by
+ * reading all the package names in the specified signature file and adding
+ * them to the internal tree set. Then the old package list file is removed
+ * and the new package list file is written out.
+ *
+ * @throws Exception
+ * if there is a problem removing the existing package file or
+ * writting the new package list file.
+ */
+ public void writePkgListFile() throws Exception {
+ readPkgsFromSigFile();
+ removePkgFile();
+ writePkgFile();
+ }
+
+ /**
+ * Extract the package name from the specified string. The specified string
+ * should have the form: "package jakarta.ejb;"
+ *
+ * @param packageLine
+ * The string containing the package name.
+ *
+ * @return String The extracted package name.
+ *
+ * @throws Exception
+ * if the specified string does not conform to the expected format.
+ */
+ private String parsePackageName(String packageLine) throws Exception {
+
+ // sig test framework doesn't have the concept of package entries
+ // as the ApiCheck signature format does.
+ // Instead, we need to parse an entry similar to this:
+ // CLSS public jakarta.some.package.SomeClass
+
+ return packageLine.substring(packageLine.lastIndexOf(' ') + 1,
+ packageLine.lastIndexOf('.'));
+ }
+
+ /**
+ * Reads the package names from the signature file. Each package name that is
+ * read is added to this classes internal tree set.
+ *
+ * @throws Exception
+ * if there is an error opening or reading the signature file.
+ */
+ private void readPkgsFromSigFile() throws Exception {
+ BufferedReader in = new BufferedReader(new FileReader(sigFile));
+ String line;
+ String trimLine;
+ try {
+ while ((line = in.readLine()) != null) {
+ trimLine = line.trim();
+ if (trimLine.startsWith("CLSS")) {
+ packageNames.add(parsePackageName(trimLine));
+ }
+ }
+ } finally {
+ try {
+ in.close();
+ } catch (Exception e) {
+ }
+ }
+ }
+
+ /**
+ * Removes the existing package list file. The package list file is actually
+ * moved to a backup file if it exists. The old backup is lost.
+ *
+ * @throws Exception
+ * if there is an error moving the current package list file to a
+ * backup file.
+ */
+ private void removePkgFile() throws Exception {
+ File backupPkgFile = new File(packageFile.getPath() + BACKUP_EXT);
+ if (backupPkgFile.exists() && backupPkgFile.isFile()) {
+ backupPkgFile.delete();
+ }
+ if (packageFile.isFile() && packageFile.exists()) {
+ File copyPackageFile = new File(packageFile.getPath());
+ copyPackageFile.renameTo(backupPkgFile);
+ }
+ }
+
+ /**
+ * Write a simple header to the package list file to explain what the file is.
+ *
+ * @param out
+ * The BufferedWriter to dump the header to.
+ *
+ * @throws Exception
+ * if there is any errors writing the header to the specified
+ * BufferedWriter.
+ */
+ private void writeHeader(BufferedWriter out) throws Exception {
+ out.write(COMMENT_CHAR);
+ out.write(COMMENT_CHAR);
+ out.newLine();
+ out.write(COMMENT_CHAR + " This file contains a list of all the packages");
+ out.newLine();
+ out.write(COMMENT_CHAR + " contained in the signature files for this");
+ out.newLine();
+ out.write(
+ COMMENT_CHAR + " deliverable. This file is used to exclude valid");
+ out.newLine();
+ out.write(COMMENT_CHAR + " sub-packages from being verified when their");
+ out.newLine();
+ out.write(COMMENT_CHAR + " parent package's signature is checked.");
+ out.newLine();
+ out.write(COMMENT_CHAR);
+ out.write(COMMENT_CHAR);
+ out.newLine();
+ out.newLine();
+ }
+
+ /**
+ * Write the list of package names out to a package list file.
+ *
+ * @throws Exception
+ * if there is an error creating and writting the package list file.
+ */
+ private void writePkgFile() throws Exception {
+ BufferedWriter out = null;
+ try {
+ out = new BufferedWriter(new FileWriter(packageFile));
+ writeHeader(out);
+ for (Iterator i = packageNames.iterator(); i.hasNext();) {
+ String packageName = (String) i.next();
+ out.write(packageName);
+ out.newLine();
+ System.out
+ .println("PackageList.writePkgFile() \"" + packageName + "\"");
+ }
+ } finally {
+ if (out != null) {
+ out.close();
+ }
+ }
+ }
+
+ /**
+ * Returns the list of sub-packages that exist in the specified package name.
+ *
+ * @param pkgName
+ * The name of the package we want the sub-package list for.
+ *
+ * @return String[] The sub-packages that live under the specified parent
+ * package.
+ */
+ public String[] getSubPackages(String pkgName) {
+ List result = new ArrayList();
+ String subPackageName = pkgName + ".";
+ for (Iterator i = packageNames.iterator(); i.hasNext();) {
+ String packageName = (String) i.next();
+ if (packageName.startsWith(subPackageName)) {
+ result.add(packageName);
+ }
+ }
+ return (String[]) (result.toArray(new String[result.size()]));
+ }
+
+ /**
+ * Returns the list of sub-packages that exist in the specified package name.
+ * The returned string matches the API check format of specifying multiple
+ * packages with a single string. Each package name is separated with the "+"
+ * character.
+ *
+ * @param pkgName
+ * The name of the package we want the sub-package list for.
+ *
+ * @return String The sub-packages that live under the specified parent
+ * package.
+ */
+ public String getSubPackagesFormatted(String pkgName) {
+ StringBuffer formattedResult = new StringBuffer();
+ String[] result = getSubPackages(pkgName);
+ for (int i = 0; i < result.length; i++) {
+ formattedResult.append(result[i]);
+ if (i < (result.length - 1)) {
+ formattedResult.append("+");
+ }
+ }
+ return formattedResult.toString();
+ }
+
+ /*
+ * Test Driver
+ */
+ public static void main(String[] args) throws Exception {
+ System.out.println("\n\n*** Creating package list file ***\n\n");
+ PackageList list = new PackageList("jakarta.ejb",
+ "/home/ryano/cts-tools-master/tools/api-check/test/jakarta.ejb.sig_2.1",
+ "/home/ryano/cts-tools-master/tools/api-check/test/pkg-list.txt");
+ list.writePkgListFile();
+
+ System.out
+ .println("\n\n*** Reading sub-packages from package list file ***\n\n");
+ PackageList readList = new PackageList(
+ "/home/ryano/cts-tools-master/tools/api-check/test/pkg-list.txt");
+ System.out.println(Arrays.asList(readList.getSubPackages("jakarta.ejb")));
+ System.out.println(readList.getSubPackagesFormatted("jakarta.ejb"));
+ }
+
+} // end class PackageList
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/README b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/README
new file mode 100644
index 0000000..1cc412c
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/README
@@ -0,0 +1,96 @@
+The latest signature files are updated in the jsonp-api repoitory
+(tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest)
+generated using sigtest-maven-plugin.jar(version 1.4).
+
+The signature tests are run using the sigtest-maven-plugin.jar and the framework avaliable in this folder.
+
+
+
+For TCK developers :-
+
+ 1. Generate Signature Files : The signature file will be generated by the TCK team using jsonp/tck/pom.xml
+ where the below commented code can be used. The classpath should contain the api jar for which we are generating the signature file.
+
+ <!--plugin>
+ <groupId>org.netbeans.tools</groupId>
+ <artifactId>sigtest-maven-plugin</artifactId>
+ <version>1.4</version>
+ <executions>
+ <execution>
+ <goals>
+ <goal>generate</goal>
+ </goals>
+ </execution>
+ </executions>
+ <configuration>
+ <FileName>${project.build.directory}/jakarta.json.sig_${version}</FileName>
+ <packages>jakarta.json, jakarta.json.spi, jakarta.json.stream</packages>
+ </configuration>
+ </plugin-->
+
+ The signature file name expected is jakarta.json.sig_${version} , where version is the api version for which the signature is generated.
+
+ 2. Place the required files in the TCK folder :
+
+ All the below files has to be placed in the folder tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest, so they are included as part of the TCK jar during the build.
+
+ -The signature file generated from above of the name jakarta.json.sig_${version}
+ -The mapping file will be named sig-test.map, it contains the api to version mapping. This file will be used to pick the right signature file when running the signature test.
+ -The package list file will be named sig-test-pkg-list.txt, contains the list of packages tested.
+
+
+
+For TCK users (to run the signature test as a Junit test) :-
+
+ 1. The signature test related files will need to be extracted from the jar to a known location to be used for running the test.
+For eg: in maven we can use the below code to extract the signature file, mapping file and package list file to ${project.build.directory}/signaturedirectory.
+
+ <plugin>
+ <groupId>org.apache.maven.plugins</groupId>
+ <artifactId>maven-dependency-plugin</artifactId>
+ <version>3.2.0</version>
+ <executions>
+ <execution>
+ <id>copy-jsonp-tck-signature-files</id>
+ <phase>generate-test-sources</phase>
+ <goals>
+ <goal>unpack</goal>
+ </goals>
+ <configuration>
+ <artifactItems>
+ <artifactItem>
+ <groupId>jakarta.json</groupId>
+ <artifactId>jakarta.json-tck-tests</artifactId>
+ <version>${jsonp-tck.version}</version>
+ <type>jar</type>
+ <overWrite>true</overWrite>
+ </artifactItem>
+ </artifactItems>
+ <!-- We need the signature file, mapping file and package list file -->
+ <includes>**/*sig-test*,**/*jakarta.json.sig_*,**/*sig-test-pkg-list.txt</includes>
+ <outputDirectory>${project.build.directory}/signaturedirectory</outputDirectory>
+ </configuration>
+ </execution>
+ </executions>
+ </plugin>
+ 2. Set the below system properties correctly :
+
+ jimage.dir //The jdk9+(jdk11 for this release) will be extracted to this location as to use the Java modules in the path.
+ optional.tech.packages.to.ignore // The optional package that should be ignored while running the signature test
+ signature.mapfile //The full path of the signature mapping file
+ signature.repositoryDir // The directory where the signature file is placed.
+ signature.packagelist //The full path of the list of packages that will be tested.
+ signature.sigTestClasspath // the sigTestClasspath that will contain the implementation jar that needs to be tested along with dependent jars.
+
+ For eg:
+
+ <jimage.dir>${project.build.directory}/jdk11-bundle</jimage.dir>
+ <optional.tech.packages.to.ignore>jakarta.xml.bind</optional.tech.packages.to.ignore>
+ <signature.mapfile>${project.build.directory}/signaturedirectory/jakarta/jsonp/tck/signaturetest/sig-test.map</signature.mapfile>
+ <signature.repositoryDir>${project.build.directory}/signaturedirectory/jakarta/jsonp/tck/signaturetest</signature.repositoryDir>
+ <signature.packagelist>${project.build.directory}/signaturedirectory/jakarta/jsonp/tck/signaturetest/sig-test-pkg-list.txt</signature.packagelist>
+ <signature.sigTestClasspath>${project.build.directory}/signaturedirectory/jakarta.json-api.jar:${project.build.directory}/jdk11-bundle/java.base:${project.build.directory}/jdk11-bundle/java.rmi:${project.build.directory}/jdk11-bundle/java.sql:${project.build.directory}/jdk11-bundle/java.naming</signature.sigTestClasspath>
+
+ 3. The signature test alone can be run using below command within jersey-tck/ directory.
+
+ mvn clean verify -Dit.test=jakarta.jsonp.tck.signaturetest.**
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/Recorder.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/Recorder.java
new file mode 100644
index 0000000..cce2559
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/Recorder.java
@@ -0,0 +1,282 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.Properties;
+
+public abstract class Recorder {
+
+ protected Properties signatureMap;
+
+ protected String packageListFile;
+
+ protected String classpath;
+
+ protected String signatureRepositoryDir;
+
+ protected String signatureMapFile;
+
+ // ------------------------------------------------------------ Constructors
+
+ public Recorder(String[] args) {
+
+ System.out.println("\nCalling: Recorder with following args:");
+ for (int ii = 0; ii < args.length; ii++) {
+ System.out.println(" args[" + ii + "] = " + args[ii]);
+ }
+
+ Arguments arguments = new Arguments(args);
+ packageListFile = arguments.getPackageList();
+ classpath = arguments.getClasspath();
+ signatureRepositoryDir = arguments.getRepository();
+ signatureMapFile = arguments.getSignatureMap();
+ loadSignatureMap(signatureMapFile);
+ }
+
+ // ---------------------------------------------------------- Public Methods
+
+ /**
+ * <p>
+ * Record the signatures for each package listed in the
+ * <code>TS_HOME/bin/sig-test.map</code> file.
+ * </p>
+ */
+ public void batchRecord() {
+
+ for (Iterator i = signatureMap.keySet().iterator(); i.hasNext();) {
+ String basePackageName = (String) i.next();
+ String version = (String) signatureMap.get(basePackageName);
+ String outputFileName = getOutputFileName(basePackageName, version);
+ String[] commandLine = createCommandLine(version, classpath,
+ outputFileName, basePackageName);
+
+ try {
+
+ // dump command line args passed to Setup()...
+ System.out.println("\n\nDUMPING SIGTEST COMMAND LINE: \n");
+ for (int ii = 0; ii < commandLine.length; ii++) {
+ System.out.println("commandLine[" + ii + "] = " + commandLine[ii]);
+ }
+ System.out.println("\nDONE DUMPING SIGTEST COMMAND LINE. \n\n");
+
+ doRecord(commandLine);
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ try {
+ writePackageListFile(basePackageName, outputFileName, packageListFile);
+ } catch (Exception e) {
+ System.out.println("Unexpected exception: " + e);
+ e.printStackTrace();
+ System.exit(1);
+ }
+ }
+
+ } // END batchRecord
+
+ // ------------------------------------------------------- Protected Methods
+
+ /**
+ * Write, to a separate file, all of the packages that were recorded. How this
+ * is accomplised will be dependent on the framework.
+ *
+ * @param basePackageName
+ * the base package
+ * @param signatureFile
+ * the file in which the signatures were recorded to
+ * @param packageListFile
+ * the name of the package list file (which may or may not exist)
+ * @throws Exception
+ * if an error occurs writing the file
+ */
+ protected abstract void writePackageListFile(String basePackageName,
+ String signatureFile, String packageListFile) throws Exception;
+
+ /**
+ * Create a array of arguments appropriate for use with different signature
+ * recording frameworks.
+ *
+ * @param version
+ * The version of the API
+ * @param classpath
+ * the classpath containing classes that will be recorded
+ * @param outputFileName
+ * the file in which to write the recorded signatures to
+ * @param packageName
+ * the base package name of the signatures that will be recorded
+ */
+ protected abstract String[] createCommandLine(String version,
+ String classpath, String outputFileName, String packageName);
+
+ /**
+ * Perform whatever action in necessary to do the actual recording of the
+ * signatures.
+ *
+ * @param commandLine
+ * the options to invoke the recording facility
+ * @throws Exception
+ * if an error occurs during the record process
+ */
+ protected abstract void doRecord(String[] commandLine) throws Exception;
+
+ // --------------------------------------------------------- Private Methods
+
+ private void loadSignatureMap(String signatureTestMapFile) {
+
+ signatureMap = new Properties();
+ try {
+ signatureMap.load(
+ new BufferedInputStream(new FileInputStream(signatureTestMapFile)));
+ } catch (FileNotFoundException fnfe) {
+ throw new RuntimeException(
+ "Unable to find or read file '" + signatureTestMapFile + '\'');
+ } catch (IOException ioe) {
+ throw new RuntimeException(
+ "Error processing file '" + signatureTestMapFile + '\'', ioe);
+ }
+
+ } // END loadSignatureMap
+
+ private String getOutputFileName(String name, String version) {
+
+ StringBuffer fileName = new StringBuffer();
+ fileName.append(signatureRepositoryDir).append(File.separatorChar);
+ fileName.append(name).append(".sig_").append(version);
+ return fileName.toString();
+
+ } // END getOutputFileName
+
+ // --------------------------------------------------- Static Nested Classes
+
+ private static class Arguments {
+
+ private static final String CLASSPATH_ARG = "-classpath";
+
+ private static final String PKG_LIST_ARG = "-packagelist";
+
+ private static final String SIG_MAP_ARG = "-sigmap";
+
+ private static final String REPOSITORY_ARG = "-repository";
+
+ private String classpath;
+
+ private String packageList;
+
+ private String signatureMap;
+
+ private String repository;
+
+ // -------------------------------------------------------- Constructors
+
+ Arguments(String[] args) {
+
+ // all 4 arguments must be defined, thus there should be 8 elements
+ if (args.length != 8) {
+ System.out
+ .println("Error - incorrect number of args should be 8 but was: "
+ + args.length);
+ System.out.println("Args passed in were: ");
+ for (int ii = 0; ii < args.length; ii++) {
+ System.out.println("args[" + ii + "] = " + args[ii]);
+ }
+
+ throw new IllegalArgumentException();
+ }
+
+ String[] clonedArgs = (String[]) args.clone();
+ Arrays.sort(clonedArgs);
+ // ensure the proper arguments are specified
+ if (Arrays.binarySearch(clonedArgs, CLASSPATH_ARG) < 0
+ || Arrays.binarySearch(clonedArgs, PKG_LIST_ARG) < 0
+ || Arrays.binarySearch(clonedArgs, SIG_MAP_ARG) < 0
+ || Arrays.binarySearch(clonedArgs, REPOSITORY_ARG) < 0) {
+ usage();
+ System.exit(1);
+ }
+
+ for (int i = 0; i < args.length; i += 2) {
+ if (CLASSPATH_ARG.equals(args[i])) {
+ classpath = args[i + 1];
+ } else if (PKG_LIST_ARG.equals(args[i])) {
+ packageList = args[i + 1];
+ } else if (SIG_MAP_ARG.equals(args[i])) {
+ signatureMap = args[i + 1];
+ } else if (REPOSITORY_ARG.equals(args[i])) {
+ repository = args[i + 1];
+ } else {
+ // shouldn't get here
+ usage();
+ System.exit(1);
+ }
+ }
+
+ } // END Arguments
+
+ // ---------------------------------------------------------- Properties
+
+ public String getClasspath() {
+
+ return classpath;
+
+ } // END getClasspath
+
+ public String getPackageList() {
+
+ return packageList;
+
+ } // END getPackageList
+
+ public String getSignatureMap() {
+
+ return signatureMap;
+
+ } // END getSignatureMap
+
+ public String getRepository() {
+
+ return repository;
+
+ } // END getRepository
+
+ private static void usage() {
+
+ String usage = "Usage:"
+ + "\t-classpath (classpath to JARs and/or classes under test)\n"
+ + "\t-packageList (Reference to the sig-test-pkg-list.txt file)\n"
+ + "\t-sigmap (Reference to the sig-test.map file)\n"
+ + "\t-repository (Directory in which to write the recorded"
+ + "\tsignatures to)\n\n";
+
+ System.err.println(usage);
+
+ } // END usage
+
+ } // END Arguments
+
+}
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/RecorderFactory.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/RecorderFactory.java
new file mode 100644
index 0000000..68470b2
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/RecorderFactory.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+/**
+ * <p>
+ * This class is a bit overloaded in that it serves as both a factory and entry
+ * point from Ant to handle signature recording.
+ * </p>
+ *
+ * <p>
+ * The desired <code>type</code> is provided using a system property with a key
+ * of <code>recorder.type</code>. Valid values for the
+ * <code>recorder.type</code> property are:
+ * <ul>
+ * <li>apicheck</li>
+ * <li>sigtest</li>
+ * </ul>
+ * </p>
+ *
+ * <p>
+ * If the <code>recorder.type</code> property is not set, this factory will
+ * return a <code>SignatureTestRecorder</code> using the SigTest framework.
+ * </p>
+ */
+public class RecorderFactory {
+
+ public static final String API_CHECK_RECORDER = "apicheck";
+
+ public static final String SIG_TEST_RECORDER = "sigtest";
+
+ // ---------------------------------------------------------- Public Methods
+
+ /**
+ * Returns a {@link Recorder} instance to handle recording signatures based on
+ * the value specified via the <code>type</code> argument.
+ *
+ * @param type
+ * the type of {@link Recorder} to use
+ * @param args
+ * the args to pass to the {@link Recorder}
+ * @return a {@link Recorder} instanced based on the <code>type</code>
+ * provided
+ */
+ public static Recorder getRecorder(String type, String[] args) {
+
+ if (type == null) {
+ throw new IllegalArgumentException("'type' cannot be null");
+ }
+
+ if (type.equals(API_CHECK_RECORDER)) {
+ return new ApiCheckRecorder(args);
+ } else if (type.equals(SIG_TEST_RECORDER)) {
+ return new SigTestRecorder(args);
+ } else {
+ throw new IllegalArgumentException("Unknown type: " + type);
+ }
+
+ } // END getRecorder
+
+ public static void main(String[] args) {
+
+ String type = System.getProperty("recorder.type", SIG_TEST_RECORDER);
+ Recorder recorder = getRecorder(type, args);
+ recorder.batchRecord();
+
+ } // END main
+
+}
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTest.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTest.java
new file mode 100644
index 0000000..e263aa0
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTest.java
@@ -0,0 +1,392 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates and others.
+ * All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStreamReader;
+import java.io.PrintWriter;
+import java.io.PrintStream;
+
+import java.util.ArrayList;
+import java.util.Properties;
+
+
+/**
+ * This class should be extended by TCK developers that wish to create a set of
+ * signature tests that run outside of any Java EE container. Developers must
+ * implement the getPackages method to specify which packages are to be tested
+ * by the signature test framework.
+ */
+public abstract class SigTest {
+
+ protected SignatureTestDriver driver;
+
+ /**
+ * <p>
+ * Returns a {@link SignatureTestDriver} appropriate for the particular TCK
+ * (using API check or the Signature Test Framework).
+ * </p>
+ *
+ * <p>
+ * The default implementation of this method will return a
+ * {@link SignatureTestDriver} that will use API Check. TCK developers can
+ * override this to return the desired {@link SignatureTestDriver} for their
+ * TCK.
+ */
+ protected SignatureTestDriver getSigTestDriver() {
+
+ if (driver == null) {
+ driver = SignatureTestDriverFactory.getInstance(SignatureTestDriverFactory.SIG_TEST);
+ }
+
+ return driver;
+
+ } // END getSigTestDriver
+
+ /**
+ * Returns the location of the package list file. This file denotes the valid
+ * sub-packages of any package being verified in the signature tests.
+ *
+ * Sub-classes are free to override this method if they use a different path
+ * or filename for their package list file. Most users should be able to use
+ * this default implementation.
+ *
+ * @return String The path and name of the package list file.
+ */
+ protected String getPackageFile() {
+ return getSigTestDriver().getPackageFileImpl(testInfo.getBinDir());
+ }
+
+ /**
+ * Returns the path and name of the signature map file that this TCK uses when
+ * conducting signature tests. The signature map file tells the signature test
+ * framework which API versions of tested packages to use. To keep this code
+ * platform independent, be sure to use the File.separator string (or the
+ * File.separatorChar) to denote path separators.
+ *
+ * Sub-classes are free to override this method if they use a different path
+ * or filename for their signature map file. Most users should be able to use
+ * this default implementation.
+ *
+ * @return String The path and name of the signature map file.
+ */
+ protected String getMapFile() {
+ return getSigTestDriver().getMapFileImpl(testInfo.getBinDir());
+ }
+
+ /**
+ * Returns the directory that contains the signature files.
+ *
+ * Sub-classes are free to override this method if they use a different
+ * signature repository directory. Most users should be able to use this
+ * default implementation.
+ *
+ * @return String The signature repository directory.
+ */
+ protected String getRepositoryDir() {
+ return getSigTestDriver().getRepositoryDirImpl(testInfo.getTSHome());
+ }
+
+ /**
+ * Returns the list of Optional Packages which are not accounted for. By
+ * 'unlisted optional' we mean the packages which are Optional to the
+ * technology under test that the user did NOT specifically list for testing.
+ * For example, with Java EE 7 implementation, a user could additionally opt
+ * to test a JSR-88 technology along with the Java EE technology. But if the
+ * user chooses NOT to list this optional technology for testing (via ts.jte
+ * javaee.level prop) then this method will return the packages for JSR-88
+ * technology with this method call.
+ * <p/>
+ * This is useful for checking for a scenarios when a user may have forgotten
+ * to identify a whole or partial technology implementation and in such cases,
+ * Java EE platform still requires testing it.
+ * <p/>
+ * Any partial or complete impl of an unlistedOptionalPackage sends up a red
+ * flag indicating that the user must also pass tests for this optional
+ * technology area.
+ * <p/>
+ * Sub-classes are free to override this method if they use a different
+ * signature repository directory. Most users should be able to use this
+ * default implementation - which means that there was NO optional technology
+ * packages that need to be tested.
+ *
+ * @return ArrayList<String>
+ */
+ protected ArrayList<String> getUnlistedOptionalPackages() {
+ return null;
+ }
+
+ /**
+ * Returns the list of packages that must be tested by the siganture test
+ * framework. TCK developers must implement this method in their signature
+ * test sub-class.
+ *
+ * @return String A list of packages that the developer wishes to test using
+ * the signature test framework.
+ */
+ protected abstract String[] getPackages();
+
+ /**
+ * Returns an array of individual classes that must be tested by the signature
+ * test framwork. TCK developers may override this method when this
+ * functionality is needed. Most will only need package level granularity.
+ *
+ * @return an Array of Strings containing the individual classes the framework
+ * should test. The default implementation of this method returns a
+ * zero-length array.
+ */
+ protected String[] getClasses() {
+
+ return new String[] {};
+
+ } // END getClasses
+
+ protected SigTestData testInfo; // holds the bin.dir property
+
+ /**
+ * Called by the test framework to initialize this test. The method simply
+ * retrieves some state information that is necessary to run the test when
+ * when the test framework invokes the run method (actually the test1 method).
+ *
+ * @param args
+ * List of arguments passed to this test.
+ * @param p
+ * Properties specified by the test user and passed to this test via
+ * the test framework.
+ * @throws Fault
+ * When an error occurs reading or saving the state information
+ * processed by this method.
+ */
+ public void setup() {
+ try {
+ System.out.println("$$$ SigTest.setup() called");
+ this.testInfo = new SigTestData();
+ System.out.println("$$$ SigTest.setup() complete");
+ } catch (Exception e) {
+ System.out.println("Unexpected exception " + e.getMessage());
+ //throw new Fault("setup failed!", e);
+ }
+ }
+
+
+ /**
+ * Called by the test framework to cleanup any outstanding state. This method
+ * simply passes the message through to the utility class so the
+ * implementation can be used by both framework base classes.
+ *
+ * @throws Fault
+ * When an error occurs cleaning up the state of this test.
+ */
+ public void cleanup() throws Fault {
+ System.out.println("$$$ SigTest.cleanup() called");
+ try {
+ getSigTestDriver().cleanupImpl();
+ System.out.println("$$$ SigTest.cleanup() returning");
+ } catch (Exception e) {
+ throw new Fault("Cleanup failed!", e);
+ }
+ }
+
+ public static class Fault extends Exception {
+ private static final long serialVersionUID = -1574745208867827913L;
+
+ public Throwable t;
+
+ /**
+ * creates a Fault with a message
+ */
+ public Fault(String msg) {
+ super(msg);
+ System.out.println(msg);
+ }
+
+ /**
+ * creates a Fault with a message.
+ *
+ * @param msg
+ * the message
+ * @param t
+ * prints this exception's stacktrace
+ */
+ public Fault(String msg, Throwable t) {
+ super(msg);
+ this.t = t;
+ // System.out.println(msg, t);
+ }
+
+ /**
+ * creates a Fault with a Throwable.
+ *
+ * @param t
+ * the Throwable
+ */
+ public Fault(Throwable t) {
+ super(t);
+ this.t = t;
+ }
+
+ /**
+ * Prints this Throwable and its backtrace to the standard error stream.
+ *
+ */
+ public void printStackTrace() {
+ if (this.t != null) {
+ this.t.printStackTrace();
+ } else {
+ super.printStackTrace();
+ }
+ }
+
+ /**
+ * Prints this throwable and its backtrace to the specified print stream.
+ *
+ * @param s
+ * <code>PrintStream</code> to use for output
+ */
+ public void printStackTrace(PrintStream s) {
+ if (this.t != null) {
+ this.t.printStackTrace(s);
+ } else {
+ super.printStackTrace(s);
+ }
+ }
+
+ /**
+ * Prints this throwable and its backtrace to the specified print writer.
+ *
+ * @param s
+ * <code>PrintWriter</code> to use for output
+ */
+ public void printStackTrace(PrintWriter s) {
+ if (this.t != null) {
+ this.t.printStackTrace(s);
+ } else {
+ super.printStackTrace(s);
+ }
+ }
+
+ @Override
+ public Throwable getCause() {
+ return t;
+ }
+
+ @Override
+ public synchronized Throwable initCause(Throwable cause) {
+ if (t != null)
+ throw new IllegalStateException("Can't overwrite cause");
+ if (!Exception.class.isInstance(cause))
+ throw new IllegalArgumentException("Cause not permitted");
+ this.t = (Exception) cause;
+ return this;
+ }
+ }
+
+ /**
+ * This exception is used only by EETest. Overrides 3 printStackTrace methods
+ * to preserver the original stack trace. Using setStackTraceElement() would
+ * be more elegant but it is not available prior to j2se 1.4.
+ *
+ * @author Kyle Grucci
+ */
+ public static class SetupException extends Exception {
+ private static final long serialVersionUID = -7616313680616499158L;
+
+ public Exception e;
+
+ /**
+ * creates a Fault with a message
+ */
+ public SetupException(String msg) {
+ super(msg);
+ }
+
+ /**
+ * creates a SetupException with a message
+ *
+ * @param msg
+ * the message
+ * @param e
+ * prints this exception's stacktrace
+ */
+ public SetupException(String msg, Exception e) {
+ super(msg);
+ this.e = e;
+ }
+
+ /**
+ * Prints this Throwable and its backtrace to the standard error stream.
+ *
+ */
+ public void printStackTrace() {
+ if (this.e != null) {
+ this.e.printStackTrace();
+ } else {
+ super.printStackTrace();
+ }
+ }
+
+ /**
+ * Prints this throwable and its backtrace to the specified print stream.
+ *
+ * @param s
+ * <code>PrintStream</code> to use for output
+ */
+ public void printStackTrace(PrintStream s) {
+ if (this.e != null) {
+ this.e.printStackTrace(s);
+ } else {
+ super.printStackTrace(s);
+ }
+ }
+
+ /**
+ * Prints this throwable and its backtrace to the specified print writer.
+ *
+ * @param s
+ * <code>PrintWriter</code> to use for output
+ */
+ public void printStackTrace(PrintWriter s) {
+ if (this.e != null) {
+ this.e.printStackTrace(s);
+ } else {
+ super.printStackTrace(s);
+ }
+ }
+
+ @Override
+ public Throwable getCause() {
+ return e;
+ }
+
+ @Override
+ public synchronized Throwable initCause(Throwable cause) {
+ if (e != null)
+ throw new IllegalStateException("Can't overwrite cause");
+ if (!Exception.class.isInstance(cause))
+ throw new IllegalArgumentException("Cause not permitted");
+ this.e = (Exception) cause;
+ return this;
+ }
+ }
+
+} // end class SigTest
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestData.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestData.java
new file mode 100644
index 0000000..8c2d157
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestData.java
@@ -0,0 +1,77 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+import java.util.Properties;
+
+/**
+ * This class holds the data passed to a signature test invocation during the
+ * setup phase. This allows us to keep the passed data separate and reuse the
+ * data between the signature test framework base classes.
+ */
+public class SigTestData {
+
+ private Properties props;
+
+ public SigTestData() {
+ this.props = System.getProperties();;
+ }
+
+ public String getVehicle() {
+ return props.getProperty("vehicle", "");
+ }
+
+ public String getBinDir() {
+ return props.getProperty("bin.dir", "");
+ }
+
+ public String getTSHome() {
+ return props.getProperty("ts_home", "");
+ }
+
+ public String getTestClasspath() {
+ return props.getProperty("sigTestClasspath", "");
+ }
+
+ public String getJavaeeLevel() {
+ return props.getProperty("javaee.level", "");
+ }
+
+ public String getCurrentKeywords() {
+ return props.getProperty("current.keywords", "");
+ }
+
+ public String getProperty(String prop) {
+ return props.getProperty(prop);
+ }
+
+ public String getOptionalTechPackagesToIgnore() {
+ return props.getProperty("optional.tech.packages.to.ignore", "jakarta.xml.bind");
+ }
+
+ public String getJtaJarClasspath() {
+ return props.getProperty("jtaJarClasspath", "");
+ }
+
+ public String getJImageDir() {
+ return props.getProperty("jimage.dir", "");
+ }
+} // end class SigTestData
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestDriver.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestDriver.java
new file mode 100644
index 0000000..db58ff0
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestDriver.java
@@ -0,0 +1,281 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+import java.io.ByteArrayOutputStream;
+import java.io.File;
+import java.io.PrintWriter;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+
+/**
+ * <p>
+ * Wrapper for the <code>Sig Test</code> framework.
+ * </p>
+ */
+public class SigTestDriver extends SignatureTestDriver {
+
+ private static final String CLASSPATH_FLAG = "-Classpath";
+
+ private static final String FILENAME_FLAG = "-FileName";
+
+ private static final String PACKAGE_FLAG = "-Package";
+
+ private static final String PACKAGE_NO_SUBS_FLAG = "-PackageWithoutSubpackages";
+
+ private static final String API_VERSION_FLAG = "-ApiVersion";
+
+ private static final String EXCLUDE_FLAG = "-Exclude";
+
+ private static final String STATIC_FLAG = "-Static";
+
+ private static final String CHECKVALUE_FLAG = "-CheckValue"; // only valid w/
+ // -static
+
+ private static final String NO_CHECKVALUE_FLAG = "-NoCheckValue";
+
+ private static final String SMODE_FLAG = "-mode"; // requires arg of bin or
+ // src
+
+ private static final String DEBUG_FLAG = "-Debug";
+
+ private static final String FORMATPLAIN_FLAG = "-FormatPlain";
+
+ private static final String EXCLUDE_JDK_CLASS_FLAG = "-IgnoreJDKClass";
+
+ private static String[] excludeJdkClasses = {
+ "java.util.Map",
+ "java.lang.Object",
+ "java.io.ByteArrayInputStream",
+ "java.io.InputStream",
+ "java.lang.Deprecated",
+ "java.io.Writer",
+ "java.io.OutputStream",
+ "java.util.List",
+ "java.util.Collection",
+ "java.lang.instrument.IllegalClassFormatException",
+ "javax.transaction.xa.XAException",
+ "java.lang.annotation.Repeatable",
+ "java.lang.InterruptedException",
+ "java.lang.CloneNotSupportedException",
+ "java.lang.Throwable",
+ "java.lang.Thread",
+ "java.lang.Enum"
+ };
+
+ // ---------------------------------------- Methods from SignatureTestDriver
+
+ @Override
+ protected String normalizeFileName(File f) {
+ String sURL = null;
+ try {
+ sURL = f.toURI().toURL().toExternalForm();
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+ return sURL;
+ }
+
+ @Override
+ protected String[] createTestArguments(String packageListFile, String mapFile,
+ String signatureRepositoryDir, String packageOrClassUnderTest,
+ String classpath, boolean bStaticMode) throws Exception {
+
+ SignatureFileInfo info = getSigFileInfo(packageOrClassUnderTest, mapFile,
+ signatureRepositoryDir);
+
+ PackageList packageList = new PackageList(packageListFile);
+ String[] subPackages = packageList.getSubPackages(packageOrClassUnderTest);
+
+ List command = new ArrayList();
+
+ if (bStaticMode) {
+ // static mode allows finer level of constants checking
+ // -CheckValue says to check the actual const values
+ System.out.println("Setting static mode flag to allow constant checking.");
+ command.add(STATIC_FLAG);
+ command.add(CHECKVALUE_FLAG);
+
+ // specifying "-mode src" allows stricter 2 way verification of constant
+ // vals
+ // (note that using "-mode bin" mode is less strict)
+ command.add(SMODE_FLAG);
+ // command.add("bin");
+ command.add("src");
+ } else {
+ System.out.println("Not Setting static mode flag to allow constant checking.");
+ }
+
+ command.add("-Verbose");
+
+ command.add(FILENAME_FLAG);
+ command.add(info.getFile());
+
+ command.add(CLASSPATH_FLAG);
+ command.add(classpath);
+
+ command.add(PACKAGE_FLAG);
+ command.add(packageOrClassUnderTest);
+
+ for (int i = 0; i < subPackages.length; i++) {
+ command.add(EXCLUDE_FLAG);
+ command.add(subPackages[i]);
+ }
+
+ for(String jdkClassName:excludeJdkClasses) {
+ command.add(EXCLUDE_JDK_CLASS_FLAG);
+ command.add(jdkClassName);
+ }
+
+
+ command.add(API_VERSION_FLAG);
+ command.add(info.getVersion());
+
+ return ((String[]) command.toArray(new String[command.size()]));
+
+ } // END createTestArguments
+
+ @Override
+ protected boolean runSignatureTest(String packageOrClassName,
+ String[] testArguments) throws Exception {
+
+ Class sigTestClass = Class
+ .forName("com.sun.tdk.signaturetest.SignatureTest");
+ Object sigTestInstance = sigTestClass.newInstance();
+
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+
+ // do some logging to help with troubleshooting
+ System.out.println(
+ "\nCalling: com.sun.tdk.signaturetest.SignatureTest() with following args:");
+ for (int ii = 0; ii < testArguments.length; ii++) {
+ System.out.println(" testArguments[" + ii + "] = " + testArguments[ii]);
+ }
+
+ @SuppressWarnings("unchecked")
+ Method runMethod = sigTestClass.getDeclaredMethod("run",
+ new Class[] { String[].class, PrintWriter.class, PrintWriter.class });
+ runMethod.invoke(sigTestInstance,
+ new Object[] { testArguments, new PrintWriter(output, true), null });
+
+ String rawMessages = output.toString();
+
+ // currently, there is no way to determine if there are error msgs in
+ // the rawmessages, so we will always dump this and call it a status.
+ System.out.println(
+ "********** Status Report '" + packageOrClassName + "' **********\n");
+ System.out.println(rawMessages);
+
+ return sigTestInstance.toString().substring(7).startsWith("Passed.");
+ } // END runSignatureTest
+
+ /*
+ *
+ * @return This returns true if the packageOrClassName is found in the impl.
+ */
+ @Override
+ protected boolean runPackageSearch(String packageOrClassName,
+ String[] testArguments) throws Exception {
+
+ Class sigTestClass = Class
+ .forName("com.sun.tdk.signaturetest.SignatureTest");
+ Object sigTestInstance = sigTestClass.newInstance();
+
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+
+ // we want to replace the PACKAGE_FLAG with PACKAGE_NO_SUBS_FLAG
+ for (int ii = 0; ii < testArguments.length; ii++) {
+ if (testArguments[ii].equals(PACKAGE_FLAG)) {
+ testArguments[ii] = PACKAGE_NO_SUBS_FLAG;
+ }
+ }
+
+ // dump args for debugging aid
+ System.out.println(
+ "\nCalling: com.sun.tdk.signaturetest.SignatureTest() with following args:");
+ for (int ii = 0; ii < testArguments.length; ii++) {
+ System.out.println(" testArguments[" + ii + "] = " + testArguments[ii]);
+ }
+
+ @SuppressWarnings("unchecked")
+ Method runMethod = sigTestClass.getDeclaredMethod("run",
+ new Class[] { String[].class, PrintWriter.class, PrintWriter.class });
+ runMethod.invoke(sigTestInstance,
+ new Object[] { testArguments, new PrintWriter(output, true), null });
+
+ String rawMessages = output.toString();
+
+ // currently, there is no way to determine if there are error msgs in
+ // the rawmessages, so we will always dump this and call it a status.
+ System.out.println(
+ "********** Status Report '" + packageOrClassName + "' **********\n");
+ System.out.println(rawMessages);
+
+ return sigTestInstance.toString().substring(7).startsWith("Passed.");
+ }
+
+ /*
+ * @return This returns true if javax.transaction.xa is not found in the
+ * JTA API jar
+ */
+ protected boolean verifyJTAJarForNoXA(String classpath, String repositoryDir) throws Exception {
+
+ System.out.println("SigTestDriver#verifyJTAJarForNoXA - Starting:");
+ boolean result = false;
+ List command = new ArrayList();
+
+ // Build Commandline for com.sun.tdk.signaturetest.SignatureTest
+ command.add(STATIC_FLAG);
+ command.add(FILENAME_FLAG);
+ command.add(repositoryDir + "empty.sig");
+ command.add(PACKAGE_FLAG);
+ command.add("javax.transaction.xa");
+ command.add(CLASSPATH_FLAG);
+ command.add(classpath);
+
+ String testArguments [] = (String[]) command.toArray(new String[command.size()]);
+
+ // do some logging to help with troubleshooting
+ System.out.println("\nCalling: com.sun.tdk.signaturetest.SignatureTest() with following args:");
+ for (int ii=0; ii < testArguments.length; ii++) {
+ System.out.println(" testArguments[" +ii+ "] = " + testArguments[ii]);
+ }
+
+ Class sigTestClass = Class.forName("com.sun.tdk.signaturetest.SignatureTest");
+ Object sigTestInstance = sigTestClass.newInstance();
+ ByteArrayOutputStream output = new ByteArrayOutputStream();
+
+ @SuppressWarnings("unchecked")
+ Method runMethod = sigTestClass.getDeclaredMethod("run",
+ new Class[] { String[].class,
+ PrintWriter.class,
+ PrintWriter.class });
+ runMethod.invoke(sigTestInstance,
+ new Object[] { testArguments,
+ new PrintWriter(output, true),
+ null });
+ String rawMessages = output.toString();
+
+ // currently, there is no way to determine if there are error msgs in
+ // the rawmessages, so we will always dump this and call it a status.
+ System.out.println("********** Status Report JTA JAR validation **********\n");
+ System.out.println(rawMessages);
+ return sigTestInstance.toString().substring(7).startsWith("Passed.");
+ }
+}
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestEE.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestEE.java
new file mode 100644
index 0000000..aafa354
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestEE.java
@@ -0,0 +1,486 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.PrintStream;
+
+import java.util.ArrayList;
+import java.util.Properties;
+
+
+/**
+ * This class should be extended by TCK developers that wish to create a set of
+ * signature tests that run inside all the Java EE containers. Developers must
+ * implement the getPackages method to specify which packages are to be tested
+ * by the signature test framework within which container.
+ */
+public abstract class SigTestEE {
+
+ String[] sVehicles;
+
+ private Object theSharedObject;
+
+ private Object theSharedObjectArray[];
+
+
+ protected SignatureTestDriver driver;
+
+ /**
+ * <p>
+ * Returns a {@link SignatureTestDriver} appropriate for the particular TCK
+ * (using API check or the Signature Test Framework).
+ * </p>
+ *
+ * <p>
+ * The default implementation of this method will return a
+ * {@link SignatureTestDriver} that will use API Check. TCK developers can
+ * override this to return the desired {@link SignatureTestDriver} for their
+ * TCK.
+ */
+ protected SignatureTestDriver getSigTestDriver() {
+
+ if (driver == null) {
+ driver = SignatureTestDriverFactory.getInstance(SignatureTestDriverFactory.SIG_TEST);
+ }
+
+ return driver;
+
+ } // END getSigTestDriver
+
+ /**
+ * Returns the location of the package list file. This file denotes the valid
+ * sub-packages of any package being verified in the signature tests.
+ * <p/>
+ * Sub-classes are free to override this method if they use a different path
+ * or filename for their package list file. Most users should be able to use
+ * this default implementation.
+ *
+ * @return String The path and name of the package list file.
+ */
+ protected String getPackageFile() {
+ return getSigTestDriver().getPackageFileImpl(testInfo.getBinDir());
+ }
+
+ /**
+ * Returns the path and name of the signature map file that this TCK uses when
+ * conducting signature tests. The signature map file tells the signature test
+ * framework which API versions of tested packages to use. To keep this code
+ * platform independent, be sure to use the File.separator string (or the
+ * File.separatorChar) to denote path separators.
+ * <p/>
+ * Sub-classes are free to override this method if they use a different path
+ * or filename for their signature map file. Most users should be able to use
+ * this default implementation.
+ *
+ * @return String The path and name of the signature map file.
+ */
+ protected String getMapFile() {
+ return getSigTestDriver().getMapFileImpl(testInfo.getBinDir());
+ }
+
+ /**
+ * Returns the directory that contains the signature files.
+ * <p/>
+ * Sub-classes are free to override this method if they use a different
+ * signature repository directory. Most users should be able to use this
+ * default implementation.
+ *
+ * @return String The signature repository directory.
+ */
+ protected String getRepositoryDir() {
+ return getSigTestDriver().getRepositoryDirImpl(testInfo.getTSHome());
+ }
+
+ /**
+ * Returns the list of Optional Packages which are not accounted for. By
+ * 'unlisted optional' we mean the packages which are Optional to the
+ * technology under test that the user did NOT specifically list for testing.
+ * For example, with Java EE 7 implementation, a user could additionally opt
+ * to test a JSR-88 technology along with the Java EE technology. But if the
+ * user chooses NOT to list this optional technology for testing (via ts.jte
+ * javaee.level prop) then this method will return the packages for JSR-88
+ * technology with this method call.
+ * <p/>
+ * This is useful for checking for a scenarios when a user may have forgotten
+ * to identify a whole or partial technology implementation and in such cases,
+ * Java EE platform still requires testing it.
+ * <p/>
+ * Any partial or complete impl of an unlistedOptionalPackage sends up a red
+ * flag indicating that the user must also pass tests for this optional
+ * technology area.
+ * <p/>
+ * Sub-classes are free to override this method if they use a different
+ * signature repository directory. Most users should be able to use this
+ * default implementation - which means that there was NO optional technology
+ * packages that need to be tested.
+ *
+ * @return ArrayList<String>
+ */
+ protected ArrayList<String> getUnlistedOptionalPackages() {
+ return null;
+ }
+
+ /**
+ * Returns the list of packages that must be tested by the signature test
+ * framework. TCK developers must implement this method in their signature
+ * test sub-class.
+ *
+ * @param vehicleName
+ * The name of the vehicle the signature tests should be conducted
+ * in. Valid values for this property are ejb, servlet, ejb and
+ * appclient.
+ *
+ * @return String[] A list of packages that the developer wishes to test using
+ * the signature test framework. If the developer does not wish to
+ * test any package signatures in the specified vehicle this method
+ * should return null.
+ * <p>
+ * Note, The proper way to insure that this method is not called with
+ * a vehicle name that has no package signatures to verify is to
+ * modify the vehicle.properties in the $TS_HOME/src directory. This
+ * file provides a mapping that maps test directories to a list of
+ * vehicles where the tests in those directory should be run. As an
+ * extra precaution users are encouraged to return null from this
+ * method if the specified vehicle has no package signatures to be
+ * verified within it.
+ */
+ protected abstract String[] getPackages(String vehicleName);
+
+ /**
+ * <p>
+ * Returns an array of individual classes that must be tested by the signature
+ * test framwork within the specified vehicle. TCK developers may override
+ * this method when this functionality is needed. Most will only need package
+ * level granularity.
+ * </p>
+ *
+ * <p>
+ * If the developer doesn't wish to test certain classes within a particular
+ * vehicle, the implementation of this method must return a zero-length array.
+ * </p>
+ *
+ * @param vehicleName
+ * The name of the vehicle the signature tests should be conducted
+ * in. Valid values for this property are ejb, servlet, ejb and
+ * appclient.
+ *
+ * @return an Array of Strings containing the individual classes the framework
+ * should test based on the specifed vehicle. The default
+ * implementation of this method returns a zero-length array no matter
+ * the vehicle specified.
+ */
+ protected String[] getClasses(String vehicleName) {
+
+ return new String[] {};
+
+ } // END getClasses
+
+ protected SigTestData testInfo; // holds the bin.dir and vehicle properties
+
+ /**
+ * Called by the test framework to initialize this test. The method simply
+ * retrieves some state information that is necessary to run the test when
+ * when the test framework invokes the run method (actually the test1 method).
+ *
+ * @param args
+ * List of arguments passed to this test.
+ * @param p
+ * Properties specified by the test user and passed to this test via
+ * the test framework.
+ *
+ * @throws Fault
+ * When an error occurs reading or saving the state information
+ * processed by this method.
+ */
+ public void setup() {
+ try {
+ System.out.println("$$$ SigTestEE.setup() called");
+ this.testInfo = new SigTestData();
+ System.out.println("$$$ SigTestEE.setup() complete");
+ } catch (Exception e) {
+ System.out.println("Unexpected exception " + e.getMessage());
+ }
+ }
+
+ /**
+ * Called by the test framework to run this test. This method utilizes the
+ * state information set in the setup method to run the signature tests. All
+ * signature test code resides in the utility class so it can be reused by the
+ * signature test framework base classes.
+ *
+ * @throws Fault
+ * When an error occurs executing the signature tests.
+ */
+ public void signatureTest() throws Fault {
+ System.out.println("$$$ SigTestEE.signatureTest() called");
+ SigTestResult results = null;
+ String mapFile = getMapFile();
+ String repositoryDir = getRepositoryDir();
+ String[] packages = getPackages(testInfo.getVehicle());
+ String[] classes = getClasses(testInfo.getVehicle());
+ String packageFile = getPackageFile();
+ String testClasspath = testInfo.getTestClasspath();
+ String optionalPkgToIgnore = testInfo.getOptionalTechPackagesToIgnore();
+
+ // unlisted optional packages are technology packages for those optional
+ // technologies (e.g. jsr-88) that might not have been specified by the
+ // user.
+ // We want to ensure there are no full or partial implementations of an
+ // optional technology which were not declared
+ ArrayList<String> unlistedTechnologyPkgs = getUnlistedOptionalPackages();
+
+ // If testing with Java 9+, extract the JDK's modules so they can be used
+ // on the testcase's classpath.
+ Properties sysProps = System.getProperties();
+ String version = (String) sysProps.get("java.version");
+ if (!version.startsWith("1.")) {
+ String jimageDir = testInfo.getJImageDir();
+ File f = new File(jimageDir);
+ f.mkdirs();
+
+ String javaHome = (String) sysProps.get("java.home");
+ System.out.println("Executing JImage");
+
+ try {
+ ProcessBuilder pb = new ProcessBuilder(javaHome + "/bin/jimage", "extract", "--dir=" + jimageDir, javaHome + "/lib/modules");
+ System.out.println(javaHome + "/bin/jimage extract --dir=" + jimageDir + " " + javaHome + "/lib/modules");
+ pb.redirectErrorStream(true);
+ Process proc = pb.start();
+ BufferedReader out = new BufferedReader(new InputStreamReader(proc.getInputStream()));
+ String line = null;
+ while ((line = out.readLine()) != null) {
+ System.out.println(line);
+ }
+
+ int rc = proc.waitFor();
+ System.out.println("JImage RC = " + rc);
+ out.close();
+ } catch (Exception e) {
+ System.out.println("Exception while executing JImage! Some tests may fail.");
+ e.printStackTrace();
+ }
+ }
+
+ try {
+ results = getSigTestDriver().executeSigTest(packageFile, mapFile,
+ repositoryDir, packages, classes, testClasspath,
+ unlistedTechnologyPkgs, optionalPkgToIgnore);
+ System.out.println(results.toString());
+ if (!results.passed()) {
+ System.out.println("results.passed() returned false");
+ throw new Exception();
+ }
+
+ // Call verifyJtaJarTest based on some conditions, please check the
+ // comment for verifyJtaJarTest.
+ if ("standalone".equalsIgnoreCase(testInfo.getVehicle())) {
+ Properties mapFileAsProps = getSigTestDriver().loadMapFile(mapFile);
+ if (mapFileAsProps == null || mapFileAsProps.size() == 0) {
+ // empty signature file, something unusual
+ System.out.println("SigTestEE.signatureTest() returning, " +
+ "as signature map file is empty.");
+ return;
+ }
+
+ boolean isJTASigTest = false;
+
+ // Determine whether the signature map file contains package
+ // jakarta.transaction
+ String jtaVersion = mapFileAsProps.getProperty("jakarta.transaction");
+ if (jtaVersion == null || "".equals(jtaVersion.trim())) {
+ System.out.println("SigTestEE.signatureTest() returning, " +
+ "as this is neither JTA TCK run, not Java EE CTS run.");
+ return;
+ }
+
+ System.out.println("jtaVersion " + jtaVersion);
+ // Signature map packaged in JTA TCK will contain a single package
+ // jakarta.transaction
+ if (mapFileAsProps.size() == 1) {
+ isJTASigTest = true;
+ }
+
+ if (isJTASigTest || !jtaVersion.startsWith("1.2")) {
+ verifyJtaJarTest();
+ }
+ }
+ System.out.println("$$$ SigTestEE.signatureTest() returning");
+ } catch (Exception e) {
+ if (results != null && !results.passed()) {
+ throw new Fault("SigTestEE.signatureTest() failed!, diffs found");
+ } else {
+ System.out.println("Unexpected exception " + e.getMessage());
+ throw new Fault("signatureTest failed with an unexpected exception", e);
+ }
+ }
+ }
+
+ /**
+ * Called by the test framework to run this test. This method utilizes the
+ * state information set in the setup method to run. This test validates
+ * that the javax.transaction.xa type is not in the JTA API jar
+ *
+ * This method is called only for standaone vehicle, as calling the same
+ * for all the vehicles in the CTS run is not necessary.
+ *
+ * This method is called always from JTA 1.3 TCK. The test will be run as
+ * part of Java EE Signature Test only when the signature map in the CTS
+ * bundle is using JTA 1.3 (or higher) signature file.
+ *
+ * If property ts.jte jtaJarClasspath is removed in ts.jte of the JTA 1.3 TCK,
+ * this test will display the available options to call SignatureTest and
+ * fail. Similar failure will be seen in CTS run, if the signature map points
+ * to JTA 1.3 signature file and the property jtaJarClasspath is removed from
+ * ts.jte of CTS bundle.
+ *
+ * @throws Fault When an error occurs executing the signature tests.
+ */
+ public void verifyJtaJarTest() throws Exception {
+ System.out.println("SigTestEE#verifyJtaJarTest - Starting:");
+ String repositoryDir = getRepositoryDir();
+ String jtaJarClasspath = testInfo.getJtaJarClasspath();
+ boolean result = getSigTestDriver().verifyJTAJarForNoXA(
+ testInfo.getJtaJarClasspath(), repositoryDir);
+ if(result) {
+ System.out.println("PASS: javax.transaction.xa not found in API jar");
+ } else {
+ System.out.println("FAIL: javax.transaction.xa found in API jar");
+ throw new Fault("javax.transaction.xa validation failed");
+ }
+ System.out.println("SigTestEE#verifyJtaJarTest returning");
+ }
+
+ /**
+ * Called by the test framework to cleanup any outstanding state. This method
+ * simply passes the message through to the utility class so the
+ * implementation can be used by both framework base classes.
+ *
+ * @throws Fault
+ * When an error occurs cleaning up the state of this test.
+ */
+ public void cleanup() throws Fault {
+ System.out.println("$$$ SigTestEE.cleanup() called");
+ try {
+ getSigTestDriver().cleanupImpl();
+ System.out.println("$$$ SigTestEE.cleanup() returning");
+ } catch (Exception e) {
+ throw new Fault("Cleanup failed!", e);
+ }
+ }
+
+
+ public static class Fault extends Exception {
+ private static final long serialVersionUID = -1574745208867827913L;
+
+ public Throwable t;
+
+ /**
+ * creates a Fault with a message
+ */
+ public Fault(String msg) {
+ super(msg);
+ System.out.println(msg);
+ }
+
+ /**
+ * creates a Fault with a message.
+ *
+ * @param msg
+ * the message
+ * @param t
+ * prints this exception's stacktrace
+ */
+ public Fault(String msg, Throwable t) {
+ super(msg);
+ this.t = t;
+ System.out.println(msg);
+ t.printStackTrace();
+ }
+
+ /**
+ * creates a Fault with a Throwable.
+ *
+ * @param t
+ * the Throwable
+ */
+ public Fault(Throwable t) {
+ super(t);
+ this.t = t;
+ }
+
+ /**
+ * Prints this Throwable and its backtrace to the standard error stream.
+ *
+ */
+ public void printStackTrace() {
+ if (this.t != null) {
+ this.t.printStackTrace();
+ } else {
+ super.printStackTrace();
+ }
+ }
+
+ /**
+ * Prints this throwable and its backtrace to the specified print stream.
+ *
+ * @param s
+ * <code>PrintStream</code> to use for output
+ */
+ public void printStackTrace(PrintStream s) {
+ if (this.t != null) {
+ this.t.printStackTrace(s);
+ } else {
+ super.printStackTrace(s);
+ }
+ }
+
+ /**
+ * Prints this throwable and its backtrace to the specified print writer.
+ *
+ * @param s
+ * <code>PrintWriter</code> to use for output
+ */
+ public void printStackTrace(PrintWriter s) {
+ if (this.t != null) {
+ this.t.printStackTrace(s);
+ } else {
+ super.printStackTrace(s);
+ }
+ }
+
+ @Override
+ public Throwable getCause() {
+ return t;
+ }
+
+ @Override
+ public synchronized Throwable initCause(Throwable cause) {
+ if (t != null)
+ throw new IllegalStateException("Can't overwrite cause");
+ if (!Exception.class.isInstance(cause))
+ throw new IllegalArgumentException("Cause not permitted");
+ this.t = (Exception) cause;
+ return this;
+ }
+ }
+
+} // end class SigTestEE
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestRecorder.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestRecorder.java
new file mode 100644
index 0000000..81513e4
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestRecorder.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * @(#)SigTestRecorder.java 1.1 03/03/05
+ */
+package jakarta.jsonp.tck.signaturetest;
+
+import java.io.File;
+import java.io.PrintWriter;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * <p>
+ * This implementation of {@link Recorder} will record signatures using the
+ * <code>Signature Test</code> framework.
+ * </p>
+ */
+public class SigTestRecorder extends Recorder {
+
+ // ------------------------------------------------------------ Constructors
+
+ public SigTestRecorder(String[] args) {
+
+ super(args);
+
+ } // END SigTestRecorder
+
+ // ------------------------------------------------------- Protected Methods
+
+ protected String[] createCommandLine(String version, String classpath,
+ String outputFileName, String packageName) {
+
+ List command = new ArrayList();
+
+ // command.add("-xReflection");
+ command.add("-static");
+ command.add("-debug");
+ command.add("-verbose");
+ command.add("-classpath");
+ command.add(classpath);
+
+ command.add("-FileName");
+ try {
+ command.add(new File(outputFileName).toURI().toURL().toExternalForm());
+ } catch (Exception e) {
+ throw new RuntimeException(e);
+ }
+
+ command.add("-package");
+ command.add(packageName);
+
+ command.add("-apiVersion");
+ command.add(version);
+
+ return ((String[]) command.toArray(new String[command.size()]));
+
+ } // END getCommandLine
+
+ protected void writePackageListFile(String basePackageName,
+ String signatureFile, String packageListFile) throws Exception {
+
+ PackageList packageList = new PackageList(basePackageName, signatureFile,
+ packageListFile);
+ packageList.writePkgListFile();
+
+ } // END writePackageListFile
+
+ protected void doRecord(String[] commandLine) throws Exception {
+
+ Class batchSetup = Class.forName("com.sun.tdk.signaturetest.Setup");
+ Object batchSetupInstance = batchSetup.newInstance();
+ Method runMethod = batchSetup.getDeclaredMethod("run",
+ new Class[] { String[].class, PrintWriter.class, PrintWriter.class });
+
+ runMethod.invoke(batchSetupInstance, new Object[] { commandLine,
+ new PrintWriter(System.out, true), new PrintWriter(System.err, true) });
+
+ } // END doRecord
+
+} // END SigTestRecorder
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestResult.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestResult.java
new file mode 100644
index 0000000..b97819f
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SigTestResult.java
@@ -0,0 +1,134 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+package jakarta.jsonp.tck.signaturetest;
+
+import java.io.Serializable;
+import java.util.ArrayList;
+import java.util.List;
+
+public class SigTestResult implements Serializable {
+
+ private static final String NL = System.getProperty("line.separator", "\n");
+
+ private List failedPkgs = new ArrayList();
+
+ private List passedPkgs = new ArrayList();
+
+ private List failedClasses = new ArrayList();
+
+ private List passedClasses = new ArrayList();
+
+ // ---------------------------------------------------------- Public Methods
+
+ public synchronized boolean passed() {
+
+ return (failedPkgs.size() == 0 && failedClasses.size() == 0);
+
+ } // end passed
+
+ public synchronized void addFailedPkg(String pkg) {
+
+ failedPkgs.add(pkg);
+
+ } // END addFailedPkg
+
+ public synchronized void addPassedPkg(String pkg) {
+
+ passedPkgs.add(pkg);
+
+ } // END addPassedPkg
+
+ public synchronized void addFailedClass(String className) {
+
+ failedClasses.add(className);
+
+ } // END addFailedClass
+
+ public synchronized void addPassedClass(String className) {
+
+ passedClasses.add(className);
+
+ } // END addPassedClass
+
+ public String toString() {
+
+ String delim = "******************************************************"
+ + NL;
+ if (!pkgsTested() && !classesTested()) {
+ return (delim + "******** No packages or classes were tested **********"
+ + NL + delim);
+ }
+ StringBuffer buf = new StringBuffer();
+ buf.append(delim);
+ buf.append(delim);
+ if (passed()) {
+ buf.append("All package signatures passed.").append(NL);
+ } else {
+ buf.append("Some signatures failed.").append(NL);
+ if (failedPkgs.size() > 0) {
+ buf.append("\tFailed packages listed below: ").append(NL);
+ formatList(failedPkgs, buf);
+ }
+ if (failedClasses.size() > 0) {
+ buf.append("\tFailed classes listed below: ").append(NL);
+ formatList(failedClasses, buf);
+ }
+ }
+ if (passedPkgs.size() > 0) {
+ buf.append("\tPassed packages listed below: ").append(NL);
+ formatList(passedPkgs, buf);
+ }
+ if (passedClasses.size() > 0) {
+ buf.append("\tPassed classes listed below: ").append(NL);
+ formatList(passedClasses, buf);
+ }
+ buf.append("\t");
+ buf.append(delim);
+ buf.append(delim);
+ return buf.toString();
+
+ } // END toString
+
+ // --------------------------------------------------------- Private Methods
+
+ private synchronized void formatList(List list, StringBuffer buf) {
+
+ synchronized (this) {
+ for (int i = 0; i < list.size(); i++) {
+ String pkg = (String) (list.get(i));
+ buf.append("\t\t").append(pkg).append(NL);
+ }
+ }
+
+ } // END formatList
+
+ private synchronized boolean pkgsTested() {
+
+ return (failedPkgs.size() != 0 || passedPkgs.size() != 0);
+
+ } // END pkgsTested
+
+ private synchronized boolean classesTested() {
+
+ return (failedClasses.size() != 0 || passedClasses.size() != 0);
+
+ } // END classesTested
+
+} // end class SigTestResult
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SignatureTestDriver.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SignatureTestDriver.java
new file mode 100644
index 0000000..1f2a8a3
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SignatureTestDriver.java
@@ -0,0 +1,690 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates and others.
+ * All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Enumeration;
+import java.util.Properties;
+
+
+/**
+ * Allows the sigtest framework to be extended using different signature test
+ * implementations (e.g. ApiCheck, or SigTest)
+ */
+public abstract class SignatureTestDriver {
+
+ private static final String SIG_FILE_EXT = ".sig";
+
+ private static final String SIG_FILE_VER_SEP = "_";
+
+ // ---------------------------------------------------------- Public Methods
+
+ /**
+ * Implementation of the getPackageFile method defined in both the SigTest and
+ * SigTestEE class.
+ */
+ public String getPackageFileImpl(String binDir) {
+
+ String thePkgListFile = "sig-test-pkg-list.txt";
+
+ System.out.println(
+ "Using the following as the SigTest Package file: " + thePkgListFile);
+
+ String theFile = binDir + File.separator + thePkgListFile;
+ File ff = new File(theFile);
+ if (!ff.exists()) {
+ // we could not find the map file that coresponded to our SE version so
+ // lets
+ // try to default to use the sig-test-pkg-list.txt
+ System.out.println("The SigTest Package file does not exist: " + thePkgListFile);
+ theFile = binDir + File.separator + "sig-test-pkg-list.txt";
+ File ff2 = new File(theFile);
+ if (!ff2.exists()) {
+ System.out.println("The Default SigTest Package file does not exist either: "
+ + theFile);
+ } else {
+ System.out.println("Defaulting to using SigTest Package file: " + theFile);
+ }
+ }
+
+ return (theFile);
+
+ } // END getPackageFileImpl
+
+ /**
+ * Implementation of the getMapFile method defined in both the SigTest and
+ * SigTestEE class.
+ */
+ public String getMapFileImpl(String binDir) {
+
+ String theMapFile = "sig-test.map";
+
+ System.out.println("Using the following as the sig-Test map file: " + theMapFile);
+
+ String theFile = binDir + File.separator + theMapFile;
+ File ff = new File(theFile);
+ if (!ff.exists()) {
+ // we could not find the map file that coresponded to our SE version so
+ // lets
+ // try to default to use the sig-test.map
+ System.out.println("The SigTest Map file does not exist: " + theMapFile);
+ theFile = binDir + File.separator + "sig-test.map";
+ File ff2 = new File(theFile);
+ if (!ff2.exists()) {
+ System.out.println("The SigTest Map file does not exist either: " + theFile);
+ } else {
+ System.out.println("Defaulting to using SigTest Map file: " + theFile);
+ }
+ }
+
+ return (theFile);
+
+ } // END getMapFileImpl
+
+ /**
+ * Returns true if the passed in version matches the current Java version
+ * being used.
+ *
+ */
+ public Boolean isJavaSEVersion(String ver) {
+
+ String strOSVersion = System.getProperty("java.version");
+ if (strOSVersion.startsWith(ver)) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+
+ /**
+ * Implementation of the getRepositoryDir method defined in both the SigTest
+ * and SigTestEE class.
+ */
+ public String getRepositoryDirImpl(String tsHome) {
+
+ return (tsHome + File.separator + "src" + File.separator + "com"
+ + File.separator + "sun" + File.separator + "ts" + File.separator
+ + "tests" + File.separator + "signaturetest" + File.separator
+ + "signature-repository" + File.separator);
+
+ } // END getRepositoryDirImpl
+
+ /**
+ * Implementation of the cleanup method defined in both the SigTest and
+ * SigTestEE class.
+ */
+ public void cleanupImpl() throws Exception {
+
+ try {
+ System.out.println("cleanup");
+ } catch (Exception e) {
+ System.out.println("Exception in cleanup method" + e);
+ throw e;
+ }
+
+ } // END cleanupImpl
+
+ /**
+ * <p>
+ * Execute the signature test. By default, this method passes the result of
+ * {@link #createTestArguments(String, String, String, String, String)} and
+ * passes the result to {@link #runSignatureTest(String, String[])}.
+ *
+ * @param packageListFile
+ * - file containing the packages/classes that are to be verified
+ * @param mapFile
+ * sig-test.map file
+ * @param signatureRepositoryDir
+ * directory containing the recorded signatures
+ * @param packagesUnderTest
+ * packages, defined by the test client, that should be tested
+ * @param classesUnderTest
+ * classes, defined by the test client, that should be tested
+ * @param classpath
+ * The location of the API being verified. Normally the checked API
+ * will be available in the test environment and testClasspath will
+ * be null. In some rare cases the tested API may not be part of the
+ * test environment and will have to specified using this parameter.
+ * @param unaccountedTechPkgs
+ * packages that should not exist within the technology under test.
+ * These will be searched for and if found, will be flagged as error
+ * since they were not explicitly declared as being under test. Their
+ * existence requires explicit testing.
+ *
+ * @return a {@link SigTestResult} containing the result of the test execution
+ */
+ public SigTestResult executeSigTest(String packageListFile, String mapFile,
+ String signatureRepositoryDir, String[] packagesUnderTest,
+ String[] classesUnderTest, String classpath,
+ ArrayList<String> unaccountedTechPkgs, String optionalPkgToIgnore)
+ throws Exception {
+
+ SigTestResult result = new SigTestResult();
+
+ System.out.println("optionalPkgToIgnore = " + optionalPkgToIgnore);
+ String[] arrayOptionalPkgsToIgnore = null;
+ if (optionalPkgToIgnore != null) {
+ arrayOptionalPkgsToIgnore = optionalPkgToIgnore.split(",");
+ }
+
+ if (packagesUnderTest != null && packagesUnderTest.length > 0) {
+ System.out.println("********** BEGIN PACKAGE LEVEL SIGNATURE "
+ + "VALIDATION **********\n\n");
+ for (int i = 0; i < packagesUnderTest.length; i++) {
+
+ String packageName = packagesUnderTest[i];
+
+ System.out.println("********** BEGIN VALIDATE PACKAGE '"
+ + packagesUnderTest[i] + "' **********\n");
+
+ System.out.println(
+ "********** VALIDATE IN STATIC MODE - TO CHECK CONSANT VALUES ****");
+ System.out.println("Static mode supports checks of static constants values ");
+
+ String[] args = createTestArguments(packageListFile, mapFile,
+ signatureRepositoryDir, packageName, classpath, true);
+ dumpTestArguments(args);
+
+ if (runSignatureTest(packageName, args)) {
+ System.out.println("********** Package '" + packageName
+ + "' - PASSED (STATIC MODE) **********");
+ result.addPassedPkg(packageName + "(static mode)");
+ } else {
+ result.addFailedPkg(packageName + "(static mode)");
+ System.out.println("********** Package '" + packageName
+ + "' - FAILED (STATIC MODE) **********");
+ }
+
+ System.out.println("\n\n");
+ System.out.println("********** VALIDATE IN REFLECTIVE MODE ****");
+ System.out.println(
+ "Reflective mode supports verification within containers (ie ejb, servlet, etc)");
+
+ String[] args2 = createTestArguments(packageListFile, mapFile,
+ signatureRepositoryDir, packageName, classpath, false);
+ dumpTestArguments(args2);
+
+ if (runSignatureTest(packageName, args2)) {
+ System.out.println("********** Package '" + packageName
+ + "' - PASSED (REFLECTION MODE) **********");
+ result.addPassedPkg(packageName + "(reflection mode)");
+ } else {
+ result.addFailedPkg(packageName + "(reflection mode)");
+ System.out.println("********** Package '" + packageName
+ + "' - FAILED (REFLECTION MODE) **********");
+ }
+
+ System.out.println("********** END VALIDATE PACKAGE '"
+ + packagesUnderTest[i] + "' **********\n");
+
+ System.out.println("\n");
+ System.out.println("\n");
+
+ }
+ }
+
+ if (classesUnderTest != null && classesUnderTest.length > 0) {
+ System.out.println("********** BEGIN CLASS LEVEL SIGNATURE "
+ + "VALIDATION **********\n\n");
+
+ for (int i = 0; i < classesUnderTest.length; i++) {
+
+ String className = classesUnderTest[i];
+
+ System.out.println("********** BEGIN VALIDATE CLASS '"
+ + classesUnderTest[i] + "' **********\n");
+
+ System.out.println(
+ "********** VALIDATE IN STATIC MODE - TO CHECK CONSANT VALUES ****");
+ System.out.println("Static mode supports checks of static constants values ");
+
+ String[] args = createTestArguments(packageListFile, mapFile,
+ signatureRepositoryDir, className, classpath, true);
+ dumpTestArguments(args);
+
+ if (runSignatureTest(className, args)) {
+ System.out.println("********** Class '" + className
+ + "' - PASSED (STATIC MODE) **********");
+ result.addPassedClass(className + "(static mode)");
+ } else {
+ System.out.println("********** Class '" + className
+ + "' - FAILED (STATIC MODE) **********");
+ result.addFailedClass(className + "(static mode)");
+ }
+
+ System.out.println("\n\n");
+ System.out.println("********** VALIDATE IN REFLECTIVE MODE ****");
+ System.out.println(
+ "Reflective mode supports verification within containers (ie ejb, servlet, etc)");
+
+ String[] args2 = createTestArguments(packageListFile, mapFile,
+ signatureRepositoryDir, className, classpath, false);
+ dumpTestArguments(args2);
+
+ if (runSignatureTest(className, args2)) {
+ System.out.println("********** Class '" + className
+ + "' - PASSED (REFLECTION MODE) **********");
+ result.addPassedClass(className + "(reflection mode)");
+ } else {
+ System.out.println("********** Class '" + className
+ + "' - FAILED (REFLECTION MODE) **********");
+ result.addFailedClass(className + "(reflection mode)");
+ }
+
+ System.out.println("********** END VALIDATE CLASS '" + classesUnderTest[i]
+ + "' **********\n");
+
+ System.out.println("\n");
+ System.out.println("\n");
+
+ }
+ }
+
+ /*
+ * The following will check if there are Optional Technologies being
+ * implemented but not explicitly defined thru (ts.jte) javaee.level
+ * property. This is a problem because if an optional technolgy is defined
+ * (either whole or partially) than the TCK tests (and sig tests) for those
+ * Optional Technology(s) MUST be run according to related specs.
+ */
+ if (unaccountedTechPkgs != null) {
+ for (int ii = 0; ii < unaccountedTechPkgs.size(); ii++) {
+ // 'unaccountedTechPkgs' are t hose packages which do not beling to
+ // base technology nor one of the *declared* optionalal technologies.
+ // 'unaccountedTechPkgs' refers to packages for Optional Technologies
+ // which were not defined thru (ts.jte) javaee.level property.
+ // So, make sure there are no whole or partial implementations of
+ // undeclared optional technologies in the implementation
+
+ String packageName = unaccountedTechPkgs.get(ii);
+
+ // this is a special case exception to our validation of Optional
+ // Technologies. Normally any partial technology implementations
+ // would be a compatibility failure. HOWEVER, EE 7 Spec (see section
+ // EE 6.1.2 of the Platform spec in the footnote on p. 156.)
+ // requires us to add special handling to avoid testing 'certain' pkgs
+ // within an optional technology.
+ if (isIgnorePackageUnderTest(packageName, arrayOptionalPkgsToIgnore)) {
+ System.out.println(
+ "Ignoring special optional technology package: " + packageName);
+ continue;
+ }
+
+ System.out.println("\n\n");
+ System.out.println(
+ "********** CHECK IF OPTIONAL TECHNOLOGIES EXIST IN REFLECTIVE MODE ****");
+ System.out.println(
+ "Reflective mode supports verification within containers (ie ejb, servlet, etc)");
+
+ String[] args3 = createTestArguments(packageListFile, mapFile,
+ signatureRepositoryDir, packageName, classpath, false);
+ dumpTestArguments(args3);
+
+ // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
+ // - - - -
+ // NOTE: this is the opposite of above in that *if* we find that an
+ // undeclared
+ // optional technology package exists - then we want to raise a red
+ // flag.
+ // The user would have to either remove the technology from the impl if
+ // they do not want to include it in their impl -OR- they must
+ // explicitly
+ // set javaee.level (in ts.jte) to include that Optional Technology AND
+ // after setting this property, they have to pass all related TCK tests.
+ if (runPackageSearch(packageName, args3)) {
+ // if this passed we have an issue because it should not exist - thus
+ // should NOT pass.
+ System.out.println("********** Package '" + packageName
+ + "' - WAS FOUND BUT SHOULD NOT BE (REFLECTION MODE) **********");
+ String err = "ERROR: An area of concern has been identified. ";
+ err += "You must run sigtests with (ts.jte) javaee.level set to ";
+ err += "include all optional technology keywords. Whole and/or ";
+ err += "partial implementations of Optional Technologies ";
+ err += "must be implemented according to the specs AND must pass ";
+ err += "all related TCK tests. To properly pass the ";
+ err += "signature tests - you must identify all Optional Technology ";
+ err += "areas (via javaee.level) that you wish to pass signature tests for.";
+ System.out.println(err);
+ result.addFailedPkg(packageName
+ + " (Undeclared Optional Technology package found in reflection mode)");
+ } else {
+ System.out.println("********** Undeclared Optional Technology package '"
+ + packageName + "' - PASSED (REFLECTION MODE) **********");
+ }
+ }
+ }
+
+ return result;
+
+ } // END executeSigTest
+
+ // ------------------------------------------------------- Protected Methods
+
+ /**
+ * Using a common set of information, create arguments that are appropriate to
+ * be used with the underlying signature test framework.
+ *
+ * @param packageListFile
+ * - file containing the packages/classes that are to be verified
+ * @param mapFile
+ * sig-test.map file
+ * @param signatureRepositoryDir
+ * directory containing the recorded signatures
+ * @param packageOrClassUnderTest
+ * the class or package
+ * @param classpath
+ * The location of the API being verified. Normally the checked API
+ * will be available in the test environment and testClasspath will
+ * be null. In some rare cases the tested API may not be part of the
+ * test environment and will have to specified using this parameter.
+ */
+ protected abstract String[] createTestArguments(String packageListFile,
+ String mapFile, String signatureRepositoryDir,
+ String packageOrClassUnderTest, String classpath, boolean bStaticMode)
+ throws Exception;
+
+ /**
+ * Invoke the underlying signature test framework for the specified package or
+ * class.
+ *
+ * @param packageOrClassName
+ * the package or class to be validated
+ * @param testArguments
+ * the arguments necessary to invoke the signature test framework
+ *
+ * @return <code>true</code> if the test passed, otherwise <code>false</code>
+ */
+ protected abstract boolean runSignatureTest(String packageOrClassName,
+ String[] testArguments) throws Exception;
+
+ /**
+ * This checks if a class exists or not within the impl.
+ *
+ * @param packageOrClassName
+ * the package or class to be validated
+ *
+ * @return <code>true</code> if the package was found to exist, otherwise
+ * <code>false</code>
+ */
+ protected abstract boolean runPackageSearch(String packageOrClassName,
+ String[] testArguments) throws Exception;
+
+
+ /**
+ * This method checks whether JTA API jar contains classes from
+ * javax.transaction.xa package
+ *
+ * @param classpath
+ * the classpath, pointing JTA API jar
+ * @param repositoryDir
+ * the directory containing an empty signature file
+ *
+ * @return <code>true</code> if the package javax.transaction.xa is not
+ * found in the JTA API jar, otherwise <code>false</code>
+ */
+ protected abstract boolean verifyJTAJarForNoXA(String classpath,
+ String repositoryDir) throws Exception;
+
+ /**
+ * Loads the specified file into a Properties object provided the specified
+ * file exists and is a regular file. The call to new FileInputStream verifies
+ * that the specfied file is a regular file and exists.
+ *
+ * @param mapFile
+ * the path and name of the map file to be loaded
+ *
+ * @return Properties The Properties object initialized with the contents of
+ * the specified file
+ *
+ * @throws java.io.IOException
+ * If the specified map file does not exist or is not a regular
+ * file, can also be thrown if there is an error creating an input
+ * stream from the specified file.
+ */
+ public Properties loadMapFile(String mapFile)
+ throws IOException, FileNotFoundException {
+
+ FileInputStream in = null;
+ try {
+ File map = new File(mapFile);
+ Properties props = new Properties();
+ in = new FileInputStream(map);
+ props.load(in);
+ return props;
+ } finally {
+ try {
+ if (in != null) {
+ in.close();
+ }
+ } catch (Throwable t) {
+ // do nothing
+ }
+ }
+
+ } // END loadMapFile
+
+ /**
+ * This method will attempt to build a fully-qualified filename in the format
+ * of <code>respositoryDir</code> + </code>baseName</code> +
+ * <code>.sig_</code> + </code>version</code>.
+ *
+ * @param baseName
+ * the base portion of the signature filename
+ * @param repositoryDir
+ * the directory in which the signatures are stored
+ * @param version
+ * the version of the signature file
+ * @throws FileNotFoundException
+ * if the file cannot be validated as existing and is in fact a file
+ * @return a valid, fully qualified filename, appropriate for the system the
+ * test is being run on
+ */
+ protected String getSigFileName(String baseName, String repositoryDir,
+ String version) throws FileNotFoundException {
+
+ String sigFile;
+ if (repositoryDir.endsWith(File.separator)) {
+ sigFile = repositoryDir + baseName + SIG_FILE_EXT + SIG_FILE_VER_SEP
+ + version;
+ } else {
+ sigFile = repositoryDir + File.separator + baseName + SIG_FILE_EXT
+ + SIG_FILE_VER_SEP + version;
+ }
+
+ File testFile = new File(sigFile);
+
+ if (!testFile.exists() && !testFile.isFile()) {
+ throw new FileNotFoundException(
+ "Signature file \"" + sigFile + "\" does not exist.");
+ }
+
+ // we are actually requiring this normalizeFileName call to get
+ // things working on Windows. Without this, if we just return the
+ // testFile; we will fail on windows. (Solaris works either way)
+ // IMPORTANT UPDATE!! (4/5/2011)
+ // in sigtest 2.2: they stopped supporting the normalized version which
+ // created a string filename =
+ // "file://com/sun/ts/tests/signaturetest/foo.sig"
+ // so now use file path and name only.
+ // return normalizeFileName(testFile);
+ return testFile.toString();
+
+ } // END getSigFileName
+
+ protected abstract String normalizeFileName(File f);
+
+ /**
+ * Returns the name and path to the signature file that contains the specified
+ * package's signatures.
+ *
+ * @param packageName
+ * The package under test
+ * @param mapFile
+ * The name of the file that maps package names to versions
+ * @param repositoryDir
+ * The directory that conatisn all signature files
+ *
+ * @return String The path and name of the siganture file that contains the
+ * specified package's signatures
+ *
+ * @throws Exception
+ * if the determined signature file is not a regular file or does
+ * not exist
+ */
+ protected SignatureFileInfo getSigFileInfo(String packageName, String mapFile,
+ String repositoryDir) throws Exception {
+
+ String originalPackage = packageName;
+ String name = null;
+ String version = null;
+ Properties props = loadMapFile(mapFile);
+
+ while (true) {
+ boolean packageFound = false;
+ for (Enumeration<?> e = props.propertyNames(); e.hasMoreElements();) {
+ name = (String) (e.nextElement());
+ if (name.equals(packageName)) {
+ version = props.getProperty(name);
+ packageFound = true;
+ break;
+ } // end if
+ } // end for
+
+ if (packageFound) {
+ break;
+ }
+
+ /*
+ * If we get here we did not find a package name in the properties file
+ * that matches the package name under test. So we look for a package name
+ * in the properties file that could be the parent package for the package
+ * under test. We do this by removing the specified packages last package
+ * name section. So jakarta.ejb.spi would become jakarta.ejb
+ */
+ int index = packageName.lastIndexOf(".");
+ if (index <= 0) {
+ throw new Exception("Package \"" + originalPackage
+ + "\" not specified in mapping file \"" + mapFile + "\".");
+ }
+ packageName = packageName.substring(0, index);
+ } // end while
+
+ /* Return the expected name of the signature file */
+
+ return new SignatureFileInfo(getSigFileName(name, repositoryDir, version),
+ version);
+
+ } // END getSigFileInfo
+
+ // --------------------------------------------------------- Private Methods
+
+ /*
+ * This returns true is the passed in packageName matches one of the packages
+ * that are listed in the arrayOptionalPkgsToIgnore. arrayOptionalPkgsToIgnore
+ * is ultimately defined in the ts.jte property
+ * 'optional.tech.packages.to.ignore' If one of the entries in
+ * arrayOptionalPkgsToIgnore matches the packageName then that means we return
+ * TRUE to indicate we should ignore and NOT TEST that particular package.
+ */
+ private static boolean isIgnorePackageUnderTest(String packageName,
+ String[] arrayOptionalPkgsToIgnore) {
+
+ // if anything is null - consider no match
+ if ((packageName == null) || (arrayOptionalPkgsToIgnore == null)) {
+ return false;
+ }
+
+ for (int ii = 0; ii < arrayOptionalPkgsToIgnore.length; ii++) {
+ if (packageName.equals(arrayOptionalPkgsToIgnore[ii])) {
+ // we found a match -
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Prints the specified list of parameters to the message log. Used for
+ * debugging purposes only.
+ *
+ * @param params
+ * The list of parameters to dump.
+ */
+ private static void dumpTestArguments(String[] params) {
+
+ if (params != null && params.length > 0) {
+ System.out.println("----------------- BEGIN SIG PARAM DUMP -----------------");
+ for (int i = 0; i < params.length; i++) {
+ System.out.println(" Param[" + i + "]: " + params[i]);
+ }
+ System.out.println("------------------ END SIG PARAM DUMP ------------------");
+ }
+
+ } // END dumpTestArguments
+
+ // ----------------------------------------------------------- Inner Classes
+
+ /**
+ * A simple data structure containing the fully qualified path to the
+ * signature file as well as the version being tested.
+ */
+ protected static class SignatureFileInfo {
+
+ private String file;
+
+ private String version;
+
+ // -------------------------------------------------------- Constructors
+
+ public SignatureFileInfo(String file, String version) {
+
+ if (file == null) {
+ throw new IllegalArgumentException("'file' argument cannot be null");
+ }
+
+ if (version == null) {
+ throw new IllegalArgumentException("'version' argument cannot be null");
+ }
+
+ this.file = file;
+ this.version = version;
+
+ } // END SignatureFileInfo
+
+ // ------------------------------------------------------ Public Methods
+
+ public String getFile() {
+
+ return file;
+
+ } // END getFileIncludingPath
+
+ public String getVersion() {
+
+ return version;
+
+ } // END getVersion
+
+ }
+
+} // END SigTestDriver
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SignatureTestDriverFactory.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SignatureTestDriverFactory.java
new file mode 100644
index 0000000..4ec4908
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/SignatureTestDriverFactory.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package jakarta.jsonp.tck.signaturetest;
+
+/**
+ * <p>
+ * Factory to obtain SignatureTestDriver implementations.
+ * </p>
+ */
+public class SignatureTestDriverFactory {
+
+ /**
+ * <p>
+ * Identifier for the driver that uses API Check to perform signature
+ * validation.
+ * </p>
+ */
+ public static final String API_CHECK = "apicheck";
+
+ /**
+ * <p>
+ * Identifier for the driver that uses the Signature Test framwork for
+ * signature validation.
+ * </p>
+ */
+ public static final String SIG_TEST = "sigtest";
+
+ // ------------------------------------------------------------ Constructors
+
+ // Access via factory method
+ private SignatureTestDriverFactory() {
+ } // END SignatureTestDriverFactory
+
+ // ---------------------------------------------------------- Public Methods
+
+ /**
+ * <p>
+ * Obtain a {@link SignatureTestDriver} instance based on the
+ * <code>type</code> argument.
+ *
+ * @param type
+ * the driver type to create
+ * @return a {@link SignatureTestDriver} implementation
+ */
+ public static SignatureTestDriver getInstance(String type) {
+
+ if (type == null || type.length() == 0) {
+ throw new IllegalArgumentException("Type was null or empty");
+ }
+
+ if (API_CHECK.equals(type)) {
+ return new ApiCheckDriver();
+ } else if (SIG_TEST.equals(type)) {
+ return new SigTestDriver();
+ } else {
+ throw new IllegalArgumentException("Unknown Type: '" + type + '\'');
+ }
+
+ } // END getInstance
+
+} // END SignatureTestDriverFactory
diff --git a/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/jsonp/JSONPSigTest.java b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/jsonp/JSONPSigTest.java
new file mode 100644
index 0000000..e09f542
--- /dev/null
+++ b/tck/tck-tests/src/main/java/jakarta/jsonp/tck/signaturetest/jsonp/JSONPSigTest.java
@@ -0,0 +1,213 @@
+/*
+ * Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v. 2.0, which is available at
+ * http://www.eclipse.org/legal/epl-2.0.
+ *
+ * This Source Code may also be made available under the following Secondary
+ * Licenses when the conditions for such availability set forth in the
+ * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+ * version 2 with the GNU Classpath Exception, which is available at
+ * https://www.gnu.org/software/classpath/license.html.
+ *
+ * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+ */
+
+/*
+ * $Id$
+ */
+
+package jakarta.jsonp.tck.signaturetest.jsonp;
+
+import java.io.PrintWriter;
+import java.util.Properties;
+
+import org.junit.jupiter.api.Test;
+
+import jakarta.jsonp.tck.signaturetest.SigTestEE;
+import jakarta.jsonp.tck.signaturetest.SignatureTestDriver;
+import jakarta.jsonp.tck.signaturetest.SignatureTestDriverFactory;
+import jakarta.jsonp.tck.signaturetest.SigTestResult;
+
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.InputStreamReader;
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.io.PrintStream;
+
+import java.util.ArrayList;
+import java.util.Properties;
+
+
+/*
+ * This class is a simple example of a signature test that extends the
+ * SigTest framework class. This signature test is run outside of the
+ * Java EE containers. This class also contains the boilerplate
+ * code necessary to create a signature test using the test framework.
+ * To see a complete TCK example see the javaee directory for the Java EE
+ * TCK signature test class.
+ */
+public class JSONPSigTest extends SigTestEE {
+
+ public JSONPSigTest(){
+ setup();
+ }
+
+ /***** Abstract Method Implementation *****/
+
+ /**
+ * Returns a list of strings where each string represents a package name. Each
+ * package name will have it's signature tested by the signature test
+ * framework.
+ *
+ * @return String[] The names of the packages whose signatures should be
+ * verified.
+ */
+ protected String[] getPackages(String vehicleName) {
+ return new String[] { "jakarta.json", "jakarta.json.spi",
+ "jakarta.json.stream", };
+
+ }
+
+ /***** Boilerplate Code *****/
+
+
+ /*
+ * The following comments are specified in the base class that defines the
+ * signature tests. This is done so the test finders will find the right class
+ * to run. The implementation of these methods is inherited from the super
+ * class which is part of the signature test framework.
+ */
+
+ // NOTE: If the API under test is not part of your testing runtime
+ // environment, you may use the property sigTestClasspath to specify
+ // where the API under test lives. This should almost never be used.
+ // Normally the API under test should be specified in the classpath
+ // of the VM running the signature tests. Use either the first
+ // comment or the one below it depending on which properties your
+ // signature tests need. Please do not use both comments.
+
+ /*
+ * @class.setup_props: ts_home, The base path of this TCK; sigTestClasspath;
+ */
+ /*
+ * @testName: signatureTest
+ *
+ * @assertion: A JSONB container must implement the required classes and APIs
+ * specified in the JSONB Specification.
+ *
+ * @test_Strategy: Using reflection, gather the implementation specific
+ * classes and APIs. Compare these results with the expected (required)
+ * classes and APIs.
+ *
+ */
+ @Test
+ public void signatureTest() throws Fault {
+ System.out.println("$$$ JSONBSigTest.signatureTest() called");
+ SigTestResult results = null;
+ String mapFile = System.getProperty("signature.mapfile");
+ String repositoryDir = System.getProperty("signature.repositoryDir");
+ String[] packages = getPackages(testInfo.getVehicle());
+ String[] classes = getClasses(testInfo.getVehicle());
+ String packageFile = System.getProperty("signature.packagelist");
+ String testClasspath = System.getProperty("signature.sigTestClasspath");
+ String optionalPkgToIgnore = testInfo.getOptionalTechPackagesToIgnore();
+
+ // unlisted optional packages are technology packages for those optional
+ // technologies (e.g. jsr-88) that might not have been specified by the
+ // user.
+ // We want to ensure there are no full or partial implementations of an
+ // optional technology which were not declared
+ ArrayList<String> unlistedTechnologyPkgs = getUnlistedOptionalPackages();
+
+ // If testing with Java 9+, extract the JDK's modules so they can be used
+ // on the testcase's classpath.
+ Properties sysProps = System.getProperties();
+ String version = (String) sysProps.get("java.version");
+ if (!version.startsWith("1.")) {
+ String jimageDir = testInfo.getJImageDir();
+ File f = new File(jimageDir);
+ f.mkdirs();
+
+ String javaHome = (String) sysProps.get("java.home");
+ System.out.println("Executing JImage");
+
+ try {
+ ProcessBuilder pb = new ProcessBuilder(javaHome + "/bin/jimage", "extract", "--dir=" + jimageDir, javaHome + "/lib/modules");
+ System.out.println(javaHome + "/bin/jimage extract --dir=" + jimageDir + " " + javaHome + "/lib/modules");
+ pb.redirectErrorStream(true);
+ Process proc = pb.start();
+ BufferedReader out = new BufferedReader(new InputStreamReader(proc.getInputStream()));
+ String line = null;
+ while ((line = out.readLine()) != null) {
+ System.out.println(line);
+ }
+
+ int rc = proc.waitFor();
+ System.out.println("JImage RC = " + rc);
+ out.close();
+ } catch (Exception e) {
+ System.out.println("Exception while executing JImage! Some tests may fail.");
+ e.printStackTrace();
+ }
+ }
+
+ try {
+ results = getSigTestDriver().executeSigTest(packageFile, mapFile,
+ repositoryDir, packages, classes, testClasspath,
+ unlistedTechnologyPkgs, optionalPkgToIgnore);
+ System.out.println(results.toString());
+ if (!results.passed()) {
+ System.out.println("results.passed() returned false");
+ throw new Exception();
+ }
+
+ // Call verifyJtaJarTest based on some conditions, please check the
+ // comment for verifyJtaJarTest.
+ if ("standalone".equalsIgnoreCase(testInfo.getVehicle())) {
+ Properties mapFileAsProps = getSigTestDriver().loadMapFile(mapFile);
+ if (mapFileAsProps == null || mapFileAsProps.size() == 0) {
+ // empty signature file, something unusual
+ System.out.println("JSONBSigTest.signatureTest() returning, " +
+ "as signature map file is empty.");
+ return;
+ }
+
+ boolean isJTASigTest = false;
+
+ // Determine whether the signature map file contains package
+ // jakarta.transaction
+ String jtaVersion = mapFileAsProps.getProperty("jakarta.transaction");
+ if (jtaVersion == null || "".equals(jtaVersion.trim())) {
+ System.out.println("JSONBSigTest.signatureTest() returning, " +
+ "as this is neither JTA TCK run, not Java EE CTS run.");
+ return;
+ }
+
+ System.out.println("jtaVersion " + jtaVersion);
+ // Signature map packaged in JTA TCK will contain a single package
+ // jakarta.transaction
+ if (mapFileAsProps.size() == 1) {
+ isJTASigTest = true;
+ }
+
+ if (isJTASigTest || !jtaVersion.startsWith("1.2")) {
+ verifyJtaJarTest();
+ }
+ }
+ System.out.println("$$$ JSONBSigTest.signatureTest() returning");
+ } catch (Exception e) {
+ if (results != null && !results.passed()) {
+ throw new Fault("JSONBSigTest.signatureTest() failed!, diffs found");
+ } else {
+ System.out.println("Unexpected exception " + e.getMessage());
+ throw new Fault("signatureTest failed with an unexpected exception", e);
+ }
+ }
+ }
+
+
+} // end class JSONBSigTest
diff --git a/tck/tck-tests/src/main/resources/jakarta/jsonp/tck/signaturetest/jakarta.json.sig_2.1.0 b/tck/tck-tests/src/main/resources/jakarta/jsonp/tck/signaturetest/jakarta.json.sig_2.1.0
new file mode 100644
index 0000000..52d5b4b
--- /dev/null
+++ b/tck/tck-tests/src/main/resources/jakarta/jsonp/tck/signaturetest/jakarta.json.sig_2.1.0
@@ -0,0 +1,640 @@
+#Signature file v4.1
+#Version 2.1_se11
+
+CLSS public final jakarta.json.Json
+meth public static jakarta.json.JsonArrayBuilder createArrayBuilder()
+meth public static jakarta.json.JsonArrayBuilder createArrayBuilder(jakarta.json.JsonArray)
+meth public static jakarta.json.JsonArrayBuilder createArrayBuilder(java.util.Collection<?>)
+meth public static jakarta.json.JsonBuilderFactory createBuilderFactory(java.util.Map<java.lang.String,?>)
+meth public static jakarta.json.JsonMergePatch createMergeDiff(jakarta.json.JsonValue,jakarta.json.JsonValue)
+meth public static jakarta.json.JsonMergePatch createMergePatch(jakarta.json.JsonValue)
+meth public static jakarta.json.JsonNumber createValue(double)
+meth public static jakarta.json.JsonNumber createValue(int)
+meth public static jakarta.json.JsonNumber createValue(java.lang.Number)
+meth public static jakarta.json.JsonNumber createValue(java.math.BigDecimal)
+meth public static jakarta.json.JsonNumber createValue(java.math.BigInteger)
+meth public static jakarta.json.JsonNumber createValue(long)
+meth public static jakarta.json.JsonObjectBuilder createObjectBuilder()
+meth public static jakarta.json.JsonObjectBuilder createObjectBuilder(jakarta.json.JsonObject)
+meth public static jakarta.json.JsonObjectBuilder createObjectBuilder(java.util.Map<java.lang.String,?>)
+meth public static jakarta.json.JsonPatch createDiff(jakarta.json.JsonStructure,jakarta.json.JsonStructure)
+meth public static jakarta.json.JsonPatch createPatch(jakarta.json.JsonArray)
+meth public static jakarta.json.JsonPatchBuilder createPatchBuilder()
+meth public static jakarta.json.JsonPatchBuilder createPatchBuilder(jakarta.json.JsonArray)
+meth public static jakarta.json.JsonPointer createPointer(java.lang.String)
+meth public static jakarta.json.JsonReader createReader(java.io.InputStream)
+meth public static jakarta.json.JsonReader createReader(java.io.Reader)
+meth public static jakarta.json.JsonReaderFactory createReaderFactory(java.util.Map<java.lang.String,?>)
+meth public static jakarta.json.JsonString createValue(java.lang.String)
+meth public static jakarta.json.JsonWriter createWriter(java.io.OutputStream)
+meth public static jakarta.json.JsonWriter createWriter(java.io.Writer)
+meth public static jakarta.json.JsonWriterFactory createWriterFactory(java.util.Map<java.lang.String,?>)
+meth public static jakarta.json.stream.JsonGenerator createGenerator(java.io.OutputStream)
+meth public static jakarta.json.stream.JsonGenerator createGenerator(java.io.Writer)
+meth public static jakarta.json.stream.JsonGeneratorFactory createGeneratorFactory(java.util.Map<java.lang.String,?>)
+meth public static jakarta.json.stream.JsonParser createParser(java.io.InputStream)
+meth public static jakarta.json.stream.JsonParser createParser(java.io.Reader)
+meth public static jakarta.json.stream.JsonParserFactory createParserFactory(java.util.Map<java.lang.String,?>)
+meth public static java.lang.String decodePointer(java.lang.String)
+meth public static java.lang.String encodePointer(java.lang.String)
+supr java.lang.Object
+
+CLSS public abstract interface jakarta.json.JsonArray
+intf jakarta.json.JsonStructure
+intf java.util.List<jakarta.json.JsonValue>
+meth public <%0 extends java.lang.Object, %1 extends jakarta.json.JsonValue> java.util.List<{%%0}> getValuesAs(java.util.function.Function<{%%1},{%%0}>)
+meth public abstract <%0 extends jakarta.json.JsonValue> java.util.List<{%%0}> getValuesAs(java.lang.Class<{%%0}>)
+meth public abstract boolean getBoolean(int)
+meth public abstract boolean getBoolean(int,boolean)
+meth public abstract boolean isNull(int)
+meth public abstract int getInt(int)
+meth public abstract int getInt(int,int)
+meth public abstract jakarta.json.JsonArray getJsonArray(int)
+meth public abstract jakarta.json.JsonNumber getJsonNumber(int)
+meth public abstract jakarta.json.JsonObject getJsonObject(int)
+meth public abstract jakarta.json.JsonString getJsonString(int)
+meth public abstract java.lang.String getString(int)
+meth public abstract java.lang.String getString(int,java.lang.String)
+
+CLSS public abstract interface jakarta.json.JsonArrayBuilder
+meth public abstract jakarta.json.JsonArray build()
+meth public abstract jakarta.json.JsonArrayBuilder add(boolean)
+meth public abstract jakarta.json.JsonArrayBuilder add(double)
+meth public abstract jakarta.json.JsonArrayBuilder add(int)
+meth public abstract jakarta.json.JsonArrayBuilder add(jakarta.json.JsonArrayBuilder)
+meth public abstract jakarta.json.JsonArrayBuilder add(jakarta.json.JsonObjectBuilder)
+meth public abstract jakarta.json.JsonArrayBuilder add(jakarta.json.JsonValue)
+meth public abstract jakarta.json.JsonArrayBuilder add(java.lang.String)
+meth public abstract jakarta.json.JsonArrayBuilder add(java.math.BigDecimal)
+meth public abstract jakarta.json.JsonArrayBuilder add(java.math.BigInteger)
+meth public abstract jakarta.json.JsonArrayBuilder add(long)
+meth public abstract jakarta.json.JsonArrayBuilder addNull()
+meth public jakarta.json.JsonArrayBuilder add(int,boolean)
+meth public jakarta.json.JsonArrayBuilder add(int,double)
+meth public jakarta.json.JsonArrayBuilder add(int,int)
+meth public jakarta.json.JsonArrayBuilder add(int,jakarta.json.JsonArrayBuilder)
+meth public jakarta.json.JsonArrayBuilder add(int,jakarta.json.JsonObjectBuilder)
+meth public jakarta.json.JsonArrayBuilder add(int,jakarta.json.JsonValue)
+meth public jakarta.json.JsonArrayBuilder add(int,java.lang.String)
+meth public jakarta.json.JsonArrayBuilder add(int,java.math.BigDecimal)
+meth public jakarta.json.JsonArrayBuilder add(int,java.math.BigInteger)
+meth public jakarta.json.JsonArrayBuilder add(int,long)
+meth public jakarta.json.JsonArrayBuilder addAll(jakarta.json.JsonArrayBuilder)
+meth public jakarta.json.JsonArrayBuilder addNull(int)
+meth public jakarta.json.JsonArrayBuilder remove(int)
+meth public jakarta.json.JsonArrayBuilder set(int,boolean)
+meth public jakarta.json.JsonArrayBuilder set(int,double)
+meth public jakarta.json.JsonArrayBuilder set(int,int)
+meth public jakarta.json.JsonArrayBuilder set(int,jakarta.json.JsonArrayBuilder)
+meth public jakarta.json.JsonArrayBuilder set(int,jakarta.json.JsonObjectBuilder)
+meth public jakarta.json.JsonArrayBuilder set(int,jakarta.json.JsonValue)
+meth public jakarta.json.JsonArrayBuilder set(int,java.lang.String)
+meth public jakarta.json.JsonArrayBuilder set(int,java.math.BigDecimal)
+meth public jakarta.json.JsonArrayBuilder set(int,java.math.BigInteger)
+meth public jakarta.json.JsonArrayBuilder set(int,long)
+meth public jakarta.json.JsonArrayBuilder setNull(int)
+
+CLSS public abstract interface jakarta.json.JsonBuilderFactory
+meth public abstract jakarta.json.JsonArrayBuilder createArrayBuilder()
+meth public abstract jakarta.json.JsonObjectBuilder createObjectBuilder()
+meth public abstract java.util.Map<java.lang.String,?> getConfigInUse()
+meth public jakarta.json.JsonArrayBuilder createArrayBuilder(jakarta.json.JsonArray)
+meth public jakarta.json.JsonArrayBuilder createArrayBuilder(java.util.Collection<?>)
+meth public jakarta.json.JsonObjectBuilder createObjectBuilder(jakarta.json.JsonObject)
+meth public jakarta.json.JsonObjectBuilder createObjectBuilder(java.util.Map<java.lang.String,java.lang.Object>)
+
+CLSS public final jakarta.json.JsonConfig
+fld public final static java.lang.String KEY_STRATEGY = "jakarta.json.JsonConfig.keyStrategy"
+innr public final static !enum KeyStrategy
+supr java.lang.Object
+
+CLSS public final static !enum jakarta.json.JsonConfig$KeyStrategy
+ outer jakarta.json.JsonConfig
+fld public final static jakarta.json.JsonConfig$KeyStrategy FIRST
+fld public final static jakarta.json.JsonConfig$KeyStrategy LAST
+fld public final static jakarta.json.JsonConfig$KeyStrategy NONE
+meth public static jakarta.json.JsonConfig$KeyStrategy valueOf(java.lang.String)
+meth public static jakarta.json.JsonConfig$KeyStrategy[] values()
+supr java.lang.Enum<jakarta.json.JsonConfig$KeyStrategy>
+
+CLSS public jakarta.json.JsonException
+cons public init(java.lang.String)
+cons public init(java.lang.String,java.lang.Throwable)
+supr java.lang.RuntimeException
+hfds serialVersionUID
+
+CLSS public abstract interface jakarta.json.JsonMergePatch
+meth public abstract jakarta.json.JsonValue apply(jakarta.json.JsonValue)
+meth public abstract jakarta.json.JsonValue toJsonValue()
+
+CLSS public abstract interface jakarta.json.JsonNumber
+intf jakarta.json.JsonValue
+meth public abstract boolean equals(java.lang.Object)
+meth public abstract boolean isIntegral()
+meth public abstract double doubleValue()
+meth public abstract int hashCode()
+meth public abstract int intValue()
+meth public abstract int intValueExact()
+meth public abstract java.lang.String toString()
+meth public abstract java.math.BigDecimal bigDecimalValue()
+meth public abstract java.math.BigInteger bigIntegerValue()
+meth public abstract java.math.BigInteger bigIntegerValueExact()
+meth public abstract long longValue()
+meth public abstract long longValueExact()
+meth public java.lang.Number numberValue()
+
+CLSS public abstract interface jakarta.json.JsonObject
+intf jakarta.json.JsonStructure
+intf java.util.Map<java.lang.String,jakarta.json.JsonValue>
+meth public abstract boolean getBoolean(java.lang.String)
+meth public abstract boolean getBoolean(java.lang.String,boolean)
+meth public abstract boolean isNull(java.lang.String)
+meth public abstract int getInt(java.lang.String)
+meth public abstract int getInt(java.lang.String,int)
+meth public abstract jakarta.json.JsonArray getJsonArray(java.lang.String)
+meth public abstract jakarta.json.JsonNumber getJsonNumber(java.lang.String)
+meth public abstract jakarta.json.JsonObject getJsonObject(java.lang.String)
+meth public abstract jakarta.json.JsonString getJsonString(java.lang.String)
+meth public abstract java.lang.String getString(java.lang.String)
+meth public abstract java.lang.String getString(java.lang.String,java.lang.String)
+
+CLSS public abstract interface jakarta.json.JsonObjectBuilder
+meth public abstract jakarta.json.JsonObject build()
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,boolean)
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,double)
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,int)
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,jakarta.json.JsonArrayBuilder)
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,jakarta.json.JsonObjectBuilder)
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,jakarta.json.JsonValue)
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,java.lang.String)
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,java.math.BigDecimal)
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,java.math.BigInteger)
+meth public abstract jakarta.json.JsonObjectBuilder add(java.lang.String,long)
+meth public abstract jakarta.json.JsonObjectBuilder addNull(java.lang.String)
+meth public jakarta.json.JsonObjectBuilder addAll(jakarta.json.JsonObjectBuilder)
+meth public jakarta.json.JsonObjectBuilder remove(java.lang.String)
+
+CLSS public abstract interface jakarta.json.JsonPatch
+innr public final static !enum Operation
+meth public abstract <%0 extends jakarta.json.JsonStructure> {%%0} apply({%%0})
+meth public abstract jakarta.json.JsonArray toJsonArray()
+
+CLSS public final static !enum jakarta.json.JsonPatch$Operation
+ outer jakarta.json.JsonPatch
+fld public final static jakarta.json.JsonPatch$Operation ADD
+fld public final static jakarta.json.JsonPatch$Operation COPY
+fld public final static jakarta.json.JsonPatch$Operation MOVE
+fld public final static jakarta.json.JsonPatch$Operation REMOVE
+fld public final static jakarta.json.JsonPatch$Operation REPLACE
+fld public final static jakarta.json.JsonPatch$Operation TEST
+meth public java.lang.String operationName()
+meth public static jakarta.json.JsonPatch$Operation fromOperationName(java.lang.String)
+meth public static jakarta.json.JsonPatch$Operation valueOf(java.lang.String)
+meth public static jakarta.json.JsonPatch$Operation[] values()
+supr java.lang.Enum<jakarta.json.JsonPatch$Operation>
+hfds operationName
+
+CLSS public abstract interface jakarta.json.JsonPatchBuilder
+meth public abstract jakarta.json.JsonPatch build()
+meth public abstract jakarta.json.JsonPatchBuilder add(java.lang.String,boolean)
+meth public abstract jakarta.json.JsonPatchBuilder add(java.lang.String,int)
+meth public abstract jakarta.json.JsonPatchBuilder add(java.lang.String,jakarta.json.JsonValue)
+meth public abstract jakarta.json.JsonPatchBuilder add(java.lang.String,java.lang.String)
+meth public abstract jakarta.json.JsonPatchBuilder copy(java.lang.String,java.lang.String)
+meth public abstract jakarta.json.JsonPatchBuilder move(java.lang.String,java.lang.String)
+meth public abstract jakarta.json.JsonPatchBuilder remove(java.lang.String)
+meth public abstract jakarta.json.JsonPatchBuilder replace(java.lang.String,boolean)
+meth public abstract jakarta.json.JsonPatchBuilder replace(java.lang.String,int)
+meth public abstract jakarta.json.JsonPatchBuilder replace(java.lang.String,jakarta.json.JsonValue)
+meth public abstract jakarta.json.JsonPatchBuilder replace(java.lang.String,java.lang.String)
+meth public abstract jakarta.json.JsonPatchBuilder test(java.lang.String,boolean)
+meth public abstract jakarta.json.JsonPatchBuilder test(java.lang.String,int)
+meth public abstract jakarta.json.JsonPatchBuilder test(java.lang.String,jakarta.json.JsonValue)
+meth public abstract jakarta.json.JsonPatchBuilder test(java.lang.String,java.lang.String)
+
+CLSS public abstract interface jakarta.json.JsonPointer
+meth public abstract <%0 extends jakarta.json.JsonStructure> {%%0} add({%%0},jakarta.json.JsonValue)
+meth public abstract <%0 extends jakarta.json.JsonStructure> {%%0} remove({%%0})
+meth public abstract <%0 extends jakarta.json.JsonStructure> {%%0} replace({%%0},jakarta.json.JsonValue)
+meth public abstract boolean containsValue(jakarta.json.JsonStructure)
+meth public abstract jakarta.json.JsonValue getValue(jakarta.json.JsonStructure)
+meth public abstract java.lang.String toString()
+
+CLSS public abstract interface jakarta.json.JsonReader
+intf java.io.Closeable
+meth public abstract jakarta.json.JsonArray readArray()
+meth public abstract jakarta.json.JsonObject readObject()
+meth public abstract jakarta.json.JsonStructure read()
+meth public abstract void close()
+meth public jakarta.json.JsonValue readValue()
+
+CLSS public abstract interface jakarta.json.JsonReaderFactory
+meth public abstract jakarta.json.JsonReader createReader(java.io.InputStream)
+meth public abstract jakarta.json.JsonReader createReader(java.io.InputStream,java.nio.charset.Charset)
+meth public abstract jakarta.json.JsonReader createReader(java.io.Reader)
+meth public abstract java.util.Map<java.lang.String,?> getConfigInUse()
+
+CLSS public abstract interface jakarta.json.JsonString
+intf jakarta.json.JsonValue
+meth public abstract boolean equals(java.lang.Object)
+meth public abstract int hashCode()
+meth public abstract java.lang.CharSequence getChars()
+meth public abstract java.lang.String getString()
+
+CLSS public abstract interface jakarta.json.JsonStructure
+intf jakarta.json.JsonValue
+meth public jakarta.json.JsonValue getValue(java.lang.String)
+
+CLSS public abstract interface jakarta.json.JsonValue
+fld public final static jakarta.json.JsonArray EMPTY_JSON_ARRAY
+fld public final static jakarta.json.JsonObject EMPTY_JSON_OBJECT
+fld public final static jakarta.json.JsonValue FALSE
+fld public final static jakarta.json.JsonValue NULL
+fld public final static jakarta.json.JsonValue TRUE
+innr public final static !enum ValueType
+meth public abstract jakarta.json.JsonValue$ValueType getValueType()
+meth public abstract java.lang.String toString()
+meth public jakarta.json.JsonArray asJsonArray()
+meth public jakarta.json.JsonObject asJsonObject()
+
+CLSS public final static !enum jakarta.json.JsonValue$ValueType
+ outer jakarta.json.JsonValue
+fld public final static jakarta.json.JsonValue$ValueType ARRAY
+fld public final static jakarta.json.JsonValue$ValueType FALSE
+fld public final static jakarta.json.JsonValue$ValueType NULL
+fld public final static jakarta.json.JsonValue$ValueType NUMBER
+fld public final static jakarta.json.JsonValue$ValueType OBJECT
+fld public final static jakarta.json.JsonValue$ValueType STRING
+fld public final static jakarta.json.JsonValue$ValueType TRUE
+meth public static jakarta.json.JsonValue$ValueType valueOf(java.lang.String)
+meth public static jakarta.json.JsonValue$ValueType[] values()
+supr java.lang.Enum<jakarta.json.JsonValue$ValueType>
+
+CLSS public abstract interface jakarta.json.JsonWriter
+intf java.io.Closeable
+meth public abstract void close()
+meth public abstract void write(jakarta.json.JsonStructure)
+meth public abstract void writeArray(jakarta.json.JsonArray)
+meth public abstract void writeObject(jakarta.json.JsonObject)
+meth public void write(jakarta.json.JsonValue)
+
+CLSS public abstract interface jakarta.json.JsonWriterFactory
+meth public abstract jakarta.json.JsonWriter createWriter(java.io.OutputStream)
+meth public abstract jakarta.json.JsonWriter createWriter(java.io.OutputStream,java.nio.charset.Charset)
+meth public abstract jakarta.json.JsonWriter createWriter(java.io.Writer)
+meth public abstract java.util.Map<java.lang.String,?> getConfigInUse()
+
+CLSS public abstract jakarta.json.spi.JsonProvider
+cons protected init()
+meth public abstract jakarta.json.JsonArrayBuilder createArrayBuilder()
+meth public abstract jakarta.json.JsonBuilderFactory createBuilderFactory(java.util.Map<java.lang.String,?>)
+meth public abstract jakarta.json.JsonObjectBuilder createObjectBuilder()
+meth public abstract jakarta.json.JsonReader createReader(java.io.InputStream)
+meth public abstract jakarta.json.JsonReader createReader(java.io.Reader)
+meth public abstract jakarta.json.JsonReaderFactory createReaderFactory(java.util.Map<java.lang.String,?>)
+meth public abstract jakarta.json.JsonWriter createWriter(java.io.OutputStream)
+meth public abstract jakarta.json.JsonWriter createWriter(java.io.Writer)
+meth public abstract jakarta.json.JsonWriterFactory createWriterFactory(java.util.Map<java.lang.String,?>)
+meth public abstract jakarta.json.stream.JsonGenerator createGenerator(java.io.OutputStream)
+meth public abstract jakarta.json.stream.JsonGenerator createGenerator(java.io.Writer)
+meth public abstract jakarta.json.stream.JsonGeneratorFactory createGeneratorFactory(java.util.Map<java.lang.String,?>)
+meth public abstract jakarta.json.stream.JsonParser createParser(java.io.InputStream)
+meth public abstract jakarta.json.stream.JsonParser createParser(java.io.Reader)
+meth public abstract jakarta.json.stream.JsonParserFactory createParserFactory(java.util.Map<java.lang.String,?>)
+meth public jakarta.json.JsonArrayBuilder createArrayBuilder(jakarta.json.JsonArray)
+meth public jakarta.json.JsonArrayBuilder createArrayBuilder(java.util.Collection<?>)
+meth public jakarta.json.JsonMergePatch createMergeDiff(jakarta.json.JsonValue,jakarta.json.JsonValue)
+meth public jakarta.json.JsonMergePatch createMergePatch(jakarta.json.JsonValue)
+meth public jakarta.json.JsonNumber createValue(double)
+meth public jakarta.json.JsonNumber createValue(int)
+meth public jakarta.json.JsonNumber createValue(java.lang.Number)
+meth public jakarta.json.JsonNumber createValue(java.math.BigDecimal)
+meth public jakarta.json.JsonNumber createValue(java.math.BigInteger)
+meth public jakarta.json.JsonNumber createValue(long)
+meth public jakarta.json.JsonObjectBuilder createObjectBuilder(jakarta.json.JsonObject)
+meth public jakarta.json.JsonObjectBuilder createObjectBuilder(java.util.Map<java.lang.String,?>)
+meth public jakarta.json.JsonPatch createDiff(jakarta.json.JsonStructure,jakarta.json.JsonStructure)
+meth public jakarta.json.JsonPatch createPatch(jakarta.json.JsonArray)
+meth public jakarta.json.JsonPatchBuilder createPatchBuilder()
+meth public jakarta.json.JsonPatchBuilder createPatchBuilder(jakarta.json.JsonArray)
+meth public jakarta.json.JsonPointer createPointer(java.lang.String)
+meth public jakarta.json.JsonString createValue(java.lang.String)
+meth public static jakarta.json.spi.JsonProvider provider()
+supr java.lang.Object
+hfds DEFAULT_PROVIDER,JSONP_PROVIDER_FACTORY,OSGI_SERVICE_LOADER_CLASS_NAME
+hcls LazyFactoryLoader
+
+CLSS public final jakarta.json.stream.JsonCollectors
+meth public static <%0 extends jakarta.json.JsonArrayBuilder> java.util.stream.Collector<jakarta.json.JsonValue,java.util.Map<java.lang.String,{%%0}>,jakarta.json.JsonObject> groupingBy(java.util.function.Function<jakarta.json.JsonValue,java.lang.String>,java.util.stream.Collector<jakarta.json.JsonValue,{%%0},jakarta.json.JsonArray>)
+meth public static java.util.stream.Collector<jakarta.json.JsonValue,jakarta.json.JsonArrayBuilder,jakarta.json.JsonArray> toJsonArray()
+meth public static java.util.stream.Collector<jakarta.json.JsonValue,jakarta.json.JsonObjectBuilder,jakarta.json.JsonObject> toJsonObject(java.util.function.Function<jakarta.json.JsonValue,java.lang.String>,java.util.function.Function<jakarta.json.JsonValue,jakarta.json.JsonValue>)
+meth public static java.util.stream.Collector<jakarta.json.JsonValue,java.util.Map<java.lang.String,jakarta.json.JsonArrayBuilder>,jakarta.json.JsonObject> groupingBy(java.util.function.Function<jakarta.json.JsonValue,java.lang.String>)
+meth public static java.util.stream.Collector<java.util.Map$Entry<java.lang.String,jakarta.json.JsonValue>,jakarta.json.JsonObjectBuilder,jakarta.json.JsonObject> toJsonObject()
+supr java.lang.Object
+
+CLSS public jakarta.json.stream.JsonGenerationException
+cons public init(java.lang.String)
+cons public init(java.lang.String,java.lang.Throwable)
+supr jakarta.json.JsonException
+hfds serialVersionUID
+
+CLSS public abstract interface jakarta.json.stream.JsonGenerator
+fld public final static java.lang.String PRETTY_PRINTING = "jakarta.json.stream.JsonGenerator.prettyPrinting"
+intf java.io.Closeable
+intf java.io.Flushable
+meth public abstract jakarta.json.stream.JsonGenerator write(boolean)
+meth public abstract jakarta.json.stream.JsonGenerator write(double)
+meth public abstract jakarta.json.stream.JsonGenerator write(int)
+meth public abstract jakarta.json.stream.JsonGenerator write(jakarta.json.JsonValue)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.lang.String)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.lang.String,boolean)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.lang.String,double)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.lang.String,int)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.lang.String,jakarta.json.JsonValue)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.lang.String,java.lang.String)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.lang.String,java.math.BigDecimal)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.lang.String,java.math.BigInteger)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.lang.String,long)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.math.BigDecimal)
+meth public abstract jakarta.json.stream.JsonGenerator write(java.math.BigInteger)
+meth public abstract jakarta.json.stream.JsonGenerator write(long)
+meth public abstract jakarta.json.stream.JsonGenerator writeEnd()
+meth public abstract jakarta.json.stream.JsonGenerator writeKey(java.lang.String)
+meth public abstract jakarta.json.stream.JsonGenerator writeNull()
+meth public abstract jakarta.json.stream.JsonGenerator writeNull(java.lang.String)
+meth public abstract jakarta.json.stream.JsonGenerator writeStartArray()
+meth public abstract jakarta.json.stream.JsonGenerator writeStartArray(java.lang.String)
+meth public abstract jakarta.json.stream.JsonGenerator writeStartObject()
+meth public abstract jakarta.json.stream.JsonGenerator writeStartObject(java.lang.String)
+meth public abstract void close()
+meth public abstract void flush()
+
+CLSS public abstract interface jakarta.json.stream.JsonGeneratorFactory
+meth public abstract jakarta.json.stream.JsonGenerator createGenerator(java.io.OutputStream)
+meth public abstract jakarta.json.stream.JsonGenerator createGenerator(java.io.OutputStream,java.nio.charset.Charset)
+meth public abstract jakarta.json.stream.JsonGenerator createGenerator(java.io.Writer)
+meth public abstract java.util.Map<java.lang.String,?> getConfigInUse()
+
+CLSS public abstract interface jakarta.json.stream.JsonLocation
+meth public abstract long getColumnNumber()
+meth public abstract long getLineNumber()
+meth public abstract long getStreamOffset()
+
+CLSS public abstract interface jakarta.json.stream.JsonParser
+innr public final static !enum Event
+intf java.io.Closeable
+meth public abstract boolean hasNext()
+meth public abstract boolean isIntegralNumber()
+meth public abstract int getInt()
+meth public abstract jakarta.json.stream.JsonLocation getLocation()
+meth public abstract jakarta.json.stream.JsonParser$Event next()
+meth public abstract java.lang.String getString()
+meth public abstract java.math.BigDecimal getBigDecimal()
+meth public abstract long getLong()
+meth public abstract void close()
+meth public jakarta.json.JsonArray getArray()
+meth public jakarta.json.JsonObject getObject()
+meth public jakarta.json.JsonValue getValue()
+meth public jakarta.json.stream.JsonParser$Event currentEvent()
+meth public java.util.stream.Stream<jakarta.json.JsonValue> getArrayStream()
+meth public java.util.stream.Stream<jakarta.json.JsonValue> getValueStream()
+meth public java.util.stream.Stream<java.util.Map$Entry<java.lang.String,jakarta.json.JsonValue>> getObjectStream()
+meth public void skipArray()
+meth public void skipObject()
+
+CLSS public final static !enum jakarta.json.stream.JsonParser$Event
+ outer jakarta.json.stream.JsonParser
+fld public final static jakarta.json.stream.JsonParser$Event END_ARRAY
+fld public final static jakarta.json.stream.JsonParser$Event END_OBJECT
+fld public final static jakarta.json.stream.JsonParser$Event KEY_NAME
+fld public final static jakarta.json.stream.JsonParser$Event START_ARRAY
+fld public final static jakarta.json.stream.JsonParser$Event START_OBJECT
+fld public final static jakarta.json.stream.JsonParser$Event VALUE_FALSE
+fld public final static jakarta.json.stream.JsonParser$Event VALUE_NULL
+fld public final static jakarta.json.stream.JsonParser$Event VALUE_NUMBER
+fld public final static jakarta.json.stream.JsonParser$Event VALUE_STRING
+fld public final static jakarta.json.stream.JsonParser$Event VALUE_TRUE
+meth public static jakarta.json.stream.JsonParser$Event valueOf(java.lang.String)
+meth public static jakarta.json.stream.JsonParser$Event[] values()
+supr java.lang.Enum<jakarta.json.stream.JsonParser$Event>
+
+CLSS public abstract interface jakarta.json.stream.JsonParserFactory
+meth public abstract jakarta.json.stream.JsonParser createParser(jakarta.json.JsonArray)
+meth public abstract jakarta.json.stream.JsonParser createParser(jakarta.json.JsonObject)
+meth public abstract jakarta.json.stream.JsonParser createParser(java.io.InputStream)
+meth public abstract jakarta.json.stream.JsonParser createParser(java.io.InputStream,java.nio.charset.Charset)
+meth public abstract jakarta.json.stream.JsonParser createParser(java.io.Reader)
+meth public abstract java.util.Map<java.lang.String,?> getConfigInUse()
+
+CLSS public jakarta.json.stream.JsonParsingException
+cons public init(java.lang.String,jakarta.json.stream.JsonLocation)
+cons public init(java.lang.String,java.lang.Throwable,jakarta.json.stream.JsonLocation)
+meth public jakarta.json.stream.JsonLocation getLocation()
+supr jakarta.json.JsonException
+hfds location,serialVersionUID
+
+CLSS public abstract interface java.io.Closeable
+intf java.lang.AutoCloseable
+meth public abstract void close() throws java.io.IOException
+
+CLSS public abstract interface java.io.Flushable
+meth public abstract void flush() throws java.io.IOException
+
+CLSS public abstract interface java.io.Serializable
+
+CLSS public abstract interface java.lang.AutoCloseable
+meth public abstract void close() throws java.lang.Exception
+
+CLSS public abstract interface java.lang.Comparable<%0 extends java.lang.Object>
+meth public abstract int compareTo({java.lang.Comparable%0})
+
+CLSS public abstract java.lang.Enum<%0 extends java.lang.Enum<{java.lang.Enum%0}>>
+cons protected init(java.lang.String,int)
+intf java.io.Serializable
+intf java.lang.Comparable<{java.lang.Enum%0}>
+meth protected final java.lang.Object clone() throws java.lang.CloneNotSupportedException
+meth protected final void finalize()
+meth public final boolean equals(java.lang.Object)
+meth public final int compareTo({java.lang.Enum%0})
+meth public final int hashCode()
+meth public final int ordinal()
+meth public final java.lang.Class<{java.lang.Enum%0}> getDeclaringClass()
+meth public final java.lang.String name()
+meth public java.lang.String toString()
+meth public static <%0 extends java.lang.Enum<{%%0}>> {%%0} valueOf(java.lang.Class<{%%0}>,java.lang.String)
+supr java.lang.Object
+hfds name,ordinal
+
+CLSS public java.lang.Exception
+cons protected init(java.lang.String,java.lang.Throwable,boolean,boolean)
+cons public init()
+cons public init(java.lang.String)
+cons public init(java.lang.String,java.lang.Throwable)
+cons public init(java.lang.Throwable)
+supr java.lang.Throwable
+hfds serialVersionUID
+
+CLSS public abstract interface java.lang.Iterable<%0 extends java.lang.Object>
+meth public abstract java.util.Iterator<{java.lang.Iterable%0}> iterator()
+meth public java.util.Spliterator<{java.lang.Iterable%0}> spliterator()
+meth public void forEach(java.util.function.Consumer<? super {java.lang.Iterable%0}>)
+
+CLSS public java.lang.Object
+cons public init()
+meth protected java.lang.Object clone() throws java.lang.CloneNotSupportedException
+meth protected void finalize() throws java.lang.Throwable
+ anno 0 java.lang.Deprecated(boolean forRemoval=false, java.lang.String since="9")
+meth public boolean equals(java.lang.Object)
+meth public final java.lang.Class<?> getClass()
+meth public final void notify()
+meth public final void notifyAll()
+meth public final void wait() throws java.lang.InterruptedException
+meth public final void wait(long) throws java.lang.InterruptedException
+meth public final void wait(long,int) throws java.lang.InterruptedException
+meth public int hashCode()
+meth public java.lang.String toString()
+
+CLSS public java.lang.RuntimeException
+cons protected init(java.lang.String,java.lang.Throwable,boolean,boolean)
+cons public init()
+cons public init(java.lang.String)
+cons public init(java.lang.String,java.lang.Throwable)
+cons public init(java.lang.Throwable)
+supr java.lang.Exception
+hfds serialVersionUID
+
+CLSS public java.lang.Throwable
+cons protected init(java.lang.String,java.lang.Throwable,boolean,boolean)
+cons public init()
+cons public init(java.lang.String)
+cons public init(java.lang.String,java.lang.Throwable)
+cons public init(java.lang.Throwable)
+intf java.io.Serializable
+meth public final java.lang.Throwable[] getSuppressed()
+meth public final void addSuppressed(java.lang.Throwable)
+meth public java.lang.StackTraceElement[] getStackTrace()
+meth public java.lang.String getLocalizedMessage()
+meth public java.lang.String getMessage()
+meth public java.lang.String toString()
+meth public java.lang.Throwable fillInStackTrace()
+meth public java.lang.Throwable getCause()
+meth public java.lang.Throwable initCause(java.lang.Throwable)
+meth public void printStackTrace()
+meth public void printStackTrace(java.io.PrintStream)
+meth public void printStackTrace(java.io.PrintWriter)
+meth public void setStackTrace(java.lang.StackTraceElement[])
+supr java.lang.Object
+hfds CAUSE_CAPTION,EMPTY_THROWABLE_ARRAY,NULL_CAUSE_MESSAGE,SELF_SUPPRESSION_MESSAGE,SUPPRESSED_CAPTION,SUPPRESSED_SENTINEL,UNASSIGNED_STACK,backtrace,cause,depth,detailMessage,serialVersionUID,stackTrace,suppressedExceptions
+hcls PrintStreamOrWriter,SentinelHolder,WrappedPrintStream,WrappedPrintWriter
+
+CLSS public abstract interface java.util.Collection<%0 extends java.lang.Object>
+intf java.lang.Iterable<{java.util.Collection%0}>
+meth public <%0 extends java.lang.Object> {%%0}[] toArray(java.util.function.IntFunction<{%%0}[]>)
+meth public abstract <%0 extends java.lang.Object> {%%0}[] toArray({%%0}[])
+meth public abstract boolean add({java.util.Collection%0})
+meth public abstract boolean addAll(java.util.Collection<? extends {java.util.Collection%0}>)
+meth public abstract boolean contains(java.lang.Object)
+meth public abstract boolean containsAll(java.util.Collection<?>)
+meth public abstract boolean equals(java.lang.Object)
+meth public abstract boolean isEmpty()
+meth public abstract boolean remove(java.lang.Object)
+meth public abstract boolean removeAll(java.util.Collection<?>)
+meth public abstract boolean retainAll(java.util.Collection<?>)
+meth public abstract int hashCode()
+meth public abstract int size()
+meth public abstract java.lang.Object[] toArray()
+meth public abstract java.util.Iterator<{java.util.Collection%0}> iterator()
+meth public abstract void clear()
+meth public boolean removeIf(java.util.function.Predicate<? super {java.util.Collection%0}>)
+meth public java.util.Spliterator<{java.util.Collection%0}> spliterator()
+meth public java.util.stream.Stream<{java.util.Collection%0}> parallelStream()
+meth public java.util.stream.Stream<{java.util.Collection%0}> stream()
+
+CLSS public abstract interface java.util.List<%0 extends java.lang.Object>
+intf java.util.Collection<{java.util.List%0}>
+meth public !varargs static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0}[])
+ anno 0 java.lang.SafeVarargs()
+meth public abstract <%0 extends java.lang.Object> {%%0}[] toArray({%%0}[])
+meth public abstract boolean add({java.util.List%0})
+meth public abstract boolean addAll(int,java.util.Collection<? extends {java.util.List%0}>)
+meth public abstract boolean addAll(java.util.Collection<? extends {java.util.List%0}>)
+meth public abstract boolean contains(java.lang.Object)
+meth public abstract boolean containsAll(java.util.Collection<?>)
+meth public abstract boolean equals(java.lang.Object)
+meth public abstract boolean isEmpty()
+meth public abstract boolean remove(java.lang.Object)
+meth public abstract boolean removeAll(java.util.Collection<?>)
+meth public abstract boolean retainAll(java.util.Collection<?>)
+meth public abstract int hashCode()
+meth public abstract int indexOf(java.lang.Object)
+meth public abstract int lastIndexOf(java.lang.Object)
+meth public abstract int size()
+meth public abstract java.lang.Object[] toArray()
+meth public abstract java.util.Iterator<{java.util.List%0}> iterator()
+meth public abstract java.util.List<{java.util.List%0}> subList(int,int)
+meth public abstract java.util.ListIterator<{java.util.List%0}> listIterator()
+meth public abstract java.util.ListIterator<{java.util.List%0}> listIterator(int)
+meth public abstract void add(int,{java.util.List%0})
+meth public abstract void clear()
+meth public abstract {java.util.List%0} get(int)
+meth public abstract {java.util.List%0} remove(int)
+meth public abstract {java.util.List%0} set(int,{java.util.List%0})
+meth public java.util.Spliterator<{java.util.List%0}> spliterator()
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> copyOf(java.util.Collection<? extends {%%0}>)
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of()
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0})
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0},{%%0})
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0},{%%0},{%%0})
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0},{%%0},{%%0},{%%0})
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0},{%%0},{%%0},{%%0},{%%0})
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0},{%%0},{%%0},{%%0},{%%0},{%%0})
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0})
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0})
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0})
+meth public static <%0 extends java.lang.Object> java.util.List<{%%0}> of({%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0},{%%0})
+meth public void replaceAll(java.util.function.UnaryOperator<{java.util.List%0}>)
+meth public void sort(java.util.Comparator<? super {java.util.List%0}>)
+
+CLSS public abstract interface java.util.Map<%0 extends java.lang.Object, %1 extends java.lang.Object>
+innr public abstract interface static Entry
+meth public !varargs static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> ofEntries(java.util.Map$Entry<? extends {%%0},? extends {%%1}>[])
+ anno 0 java.lang.SafeVarargs()
+meth public abstract boolean containsKey(java.lang.Object)
+meth public abstract boolean containsValue(java.lang.Object)
+meth public abstract boolean equals(java.lang.Object)
+meth public abstract boolean isEmpty()
+meth public abstract int hashCode()
+meth public abstract int size()
+meth public abstract java.util.Collection<{java.util.Map%1}> values()
+meth public abstract java.util.Set<java.util.Map$Entry<{java.util.Map%0},{java.util.Map%1}>> entrySet()
+meth public abstract java.util.Set<{java.util.Map%0}> keySet()
+meth public abstract void clear()
+meth public abstract void putAll(java.util.Map<? extends {java.util.Map%0},? extends {java.util.Map%1}>)
+meth public abstract {java.util.Map%1} get(java.lang.Object)
+meth public abstract {java.util.Map%1} put({java.util.Map%0},{java.util.Map%1})
+meth public abstract {java.util.Map%1} remove(java.lang.Object)
+meth public boolean remove(java.lang.Object,java.lang.Object)
+meth public boolean replace({java.util.Map%0},{java.util.Map%1},{java.util.Map%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map$Entry<{%%0},{%%1}> entry({%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> copyOf(java.util.Map<? extends {%%0},? extends {%%1}>)
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of()
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1},{%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1},{%%0},{%%1},{%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1})
+meth public static <%0 extends java.lang.Object, %1 extends java.lang.Object> java.util.Map<{%%0},{%%1}> of({%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1},{%%0},{%%1})
+meth public void forEach(java.util.function.BiConsumer<? super {java.util.Map%0},? super {java.util.Map%1}>)
+meth public void replaceAll(java.util.function.BiFunction<? super {java.util.Map%0},? super {java.util.Map%1},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} compute({java.util.Map%0},java.util.function.BiFunction<? super {java.util.Map%0},? super {java.util.Map%1},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} computeIfAbsent({java.util.Map%0},java.util.function.Function<? super {java.util.Map%0},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} computeIfPresent({java.util.Map%0},java.util.function.BiFunction<? super {java.util.Map%0},? super {java.util.Map%1},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} getOrDefault(java.lang.Object,{java.util.Map%1})
+meth public {java.util.Map%1} merge({java.util.Map%0},{java.util.Map%1},java.util.function.BiFunction<? super {java.util.Map%1},? super {java.util.Map%1},? extends {java.util.Map%1}>)
+meth public {java.util.Map%1} putIfAbsent({java.util.Map%0},{java.util.Map%1})
+meth public {java.util.Map%1} replace({java.util.Map%0},{java.util.Map%1})
+
diff --git a/tck/tck-tests/src/main/resources/jakarta/jsonp/tck/signaturetest/sig-test-pkg-list.txt b/tck/tck-tests/src/main/resources/jakarta/jsonp/tck/signaturetest/sig-test-pkg-list.txt
new file mode 100644
index 0000000..d3704d0
--- /dev/null
+++ b/tck/tck-tests/src/main/resources/jakarta/jsonp/tck/signaturetest/sig-test-pkg-list.txt
@@ -0,0 +1,31 @@
+#
+# Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+#
+# $Id$
+#
+
+##
+# This file contains a list of all the packages
+# contained in the signature files for this
+# deliverable. This file is used to exclude valid
+# sub-packages from being verified when their
+# parent package's signature is checked.
+##
+
+jakarta.json
+jakarta.json.spi
+jakarta.json.stream
diff --git a/tck/tck-tests/src/main/resources/jakarta/jsonp/tck/signaturetest/sig-test.map b/tck/tck-tests/src/main/resources/jakarta/jsonp/tck/signaturetest/sig-test.map
new file mode 100644
index 0000000..cc71d4e
--- /dev/null
+++ b/tck/tck-tests/src/main/resources/jakarta/jsonp/tck/signaturetest/sig-test.map
@@ -0,0 +1,49 @@
+#
+# Copyright (c) 2021 Oracle and/or its affiliates. All rights reserved.
+#
+# This program and the accompanying materials are made available under the
+# terms of the Eclipse Public License v. 2.0, which is available at
+# http://www.eclipse.org/legal/epl-2.0.
+#
+# This Source Code may also be made available under the following Secondary
+# Licenses when the conditions for such availability set forth in the
+# Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
+# version 2 with the GNU Classpath Exception, which is available at
+# https://www.gnu.org/software/classpath/license.html.
+#
+# SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
+#
+
+#
+# $Id$
+#
+
+###############################################################
+#
+# IMPORTANT: this sig-test.map file for use with JDK 8 only!
+# Using this file with other version of JDK will yield errors.
+#
+# The signature test mapping file for the JSON-P 2.0.0 TCK. This file
+# should be formatted as a standard java properties file. The
+# name is the package name and the value is the version of the
+# package that should be tested by the signature tests.
+#
+# The resultant signature file name has a name that complies
+# with the following format:
+# <package>.sig_<technology_version>_<JavaSE_version_these_work_with>
+# Given this format, the following example breaks down as follows:
+# jakarta.json.sig_2.0.0_se8:
+# jakarta.json.sig_2.0.0_se11:
+# <package> = jakarta.json
+# <technology_version> = 2.0.0 (for JSON-P)
+# <JavaSE_version_these_work_with> = se8 and se11
+#
+# For this release valid versions are: "_se8", "_se11", or "_se8_se11"
+# This sig-test.map file is designed to be run using JDK 8 so any
+# signature file that ends with "_se8" or "se8_se11" will be valid.
+# if a signature file contains only "_se8" and no reference to "_se11"
+# in the signature name, than that means that signature file MUST only
+# be referenced when using JDK 8.
+#
+###############################################################
+jakarta.json=2.1.0
