--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/test/hotspot/jtreg/runtime/cds/appcds/JarBuilder.java Mon Jul 29 10:34:20 2019 -0400
@@ -0,0 +1,269 @@
+/*
+ * Copyright (c) 2015, 2019, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ *
+ */
+
+/*
+ * @summary Simple jar builder
+ * Input: jarName className1 className2 ...
+ * do not specify extensions, just the names
+ * E.g. prot_domain ProtDomainA ProtDomainB
+ * Output: A jar containing compiled classes, placed in a test classes folder
+ * @library /open/test/lib
+ */
+
+import jdk.test.lib.JDKToolFinder;
+import jdk.test.lib.compiler.CompilerUtils;
+import jdk.test.lib.process.OutputAnalyzer;
+import jdk.test.lib.process.ProcessTools;
+import java.io.File;
+import java.nio.file.Path;
+import java.util.ArrayList;
+import sun.tools.jar.Main;
+
+public class JarBuilder {
+ // to turn DEBUG on via command line: -DJarBuilder.DEBUG=[true, TRUE]
+ private static final boolean DEBUG = Boolean.parseBoolean(System.getProperty("JarBuilder.DEBUG", "false"));
+ private static final String classDir = System.getProperty("test.classes");
+
+ public static String getJarFilePath(String jarName) {
+ return classDir + File.separator + jarName + ".jar";
+ }
+
+ // jar all files under dir, with manifest file man, with an optional versionArgs
+ // for generating a multi-release jar.
+ // The jar command is as follows:
+ // jar cmf \
+ // <path to output jar> <path to the manifest file>\
+ // -C <path to the base classes> .\
+ // --release 9 -C <path to the versioned classes> .
+ // the last line begins with "--release" corresponds to the optional versionArgs.
+ public static void build(String jarName, File dir, String man, String ...versionArgs)
+ throws Exception {
+ ArrayList<String> args = new ArrayList<String>();
+ if (man != null) {
+ args.add("cfm");
+ } else {
+ args.add("cf");
+ }
+ args.add(classDir + File.separator + jarName + ".jar");
+ if (man != null) {
+ args.add(man);
+ }
+ args.add("-C");
+ args.add(dir.getAbsolutePath());
+ args.add(".");
+ for (String verArg : versionArgs) {
+ args.add(verArg);
+ }
+ createJar(args);
+ }
+
+ public static String build(String jarName, String ...classNames)
+ throws Exception {
+
+ return createSimpleJar(classDir, getJarFilePath(jarName), classNames);
+ }
+
+ public static String build(boolean classesInWorkDir, String jarName, String ...classNames)
+ throws Exception {
+ if (classesInWorkDir) {
+ return createSimpleJar(".", getJarFilePath(jarName), classNames);
+ } else {
+ return build(jarName, classNames);
+ }
+ }
+
+
+ public static String buildWithManifest(String jarName, String manifest,
+ String jarClassesDir, String ...classNames) throws Exception {
+ String jarPath = getJarFilePath(jarName);
+ ArrayList<String> args = new ArrayList<String>();
+ args.add("cvfm");
+ args.add(jarPath);
+ args.add(System.getProperty("test.src") + File.separator + "test-classes"
+ + File.separator + manifest);
+ addClassArgs(args, jarClassesDir, classNames);
+ createJar(args);
+
+ return jarPath;
+ }
+
+
+ // Execute: jar uvf $jarFile -C $dir .
+ static void update(String jarFile, String dir) throws Exception {
+ String jarExe = JDKToolFinder.getJDKTool("jar");
+
+ ArrayList<String> args = new ArrayList<>();
+ args.add(jarExe);
+ args.add("uvf");
+ args.add(jarFile);
+ args.add("-C");
+ args.add(dir);
+ args.add(".");
+
+ executeProcess(args.toArray(new String[1]));
+ }
+
+
+ private static String createSimpleJar(String jarclassDir, String jarName,
+ String[] classNames) throws Exception {
+
+ ArrayList<String> args = new ArrayList<String>();
+ args.add("cf");
+ args.add(jarName);
+ addClassArgs(args, jarclassDir, classNames);
+ createJar(args);
+
+ return jarName;
+ }
+
+ private static void addClassArgs(ArrayList<String> args, String jarclassDir,
+ String[] classNames) {
+
+ for (String name : classNames) {
+ args.add("-C");
+ args.add(jarclassDir);
+ args.add(name + ".class");
+ }
+ }
+
+ public static void createModularJar(String jarPath,
+ String classesDir,
+ String mainClass) throws Exception {
+ ArrayList<String> argList = new ArrayList<String>();
+ argList.add("--create");
+ argList.add("--file=" + jarPath);
+ if (mainClass != null) {
+ argList.add("--main-class=" + mainClass);
+ }
+ argList.add("-C");
+ argList.add(classesDir);
+ argList.add(".");
+ createJar(argList);
+ }
+
+ private static void createJar(ArrayList<String> args) {
+ if (DEBUG) printIterable("createJar args: ", args);
+
+ Main jarTool = new Main(System.out, System.err, "jar");
+ if (!jarTool.run(args.toArray(new String[1]))) {
+ throw new RuntimeException("jar operation failed");
+ }
+ }
+
+ // Many AppCDS tests use the same simple "Hello.jar" which contains
+ // simple Hello.class and does not specify additional attributes.
+ // For this common use case, use this method to get the jar path.
+ // The method will check if the jar already exists
+ // (created by another test or test run), and will create the jar
+ // if it does not exist
+ public static String getOrCreateHelloJar() throws Exception {
+ String jarPath = getJarFilePath("hello");
+
+ File jarFile = new File(jarPath);
+ if (jarFile.exists()) {
+ return jarPath;
+ } else {
+ return build("hello", "Hello");
+ }
+ }
+
+ public static void compile(String dstPath, String source, String... extraArgs) throws Exception {
+ ArrayList<String> args = new ArrayList<String>();
+ args.add(JDKToolFinder.getCompileJDKTool("javac"));
+ args.add("-d");
+ args.add(dstPath);
+ if (extraArgs != null) {
+ for (String s : extraArgs) {
+ args.add(s);
+ }
+ }
+ args.add(source);
+
+ if (DEBUG) printIterable("compile args: ", args);
+
+ ProcessBuilder pb = new ProcessBuilder(args);
+ OutputAnalyzer output = new OutputAnalyzer(pb.start());
+ output.shouldHaveExitValue(0);
+ }
+
+ public static void compileModule(Path src,
+ Path dest,
+ String modulePathArg // arg to --module-path
+ ) throws Exception {
+ boolean compiled = false;
+ if (modulePathArg == null) {
+ compiled = CompilerUtils.compile(src, dest);
+ } else {
+ compiled = CompilerUtils.compile(src, dest,
+ "--module-path", modulePathArg);
+ }
+ if (!compiled) {
+ throw new RuntimeException("module did not compile");
+ }
+ }
+
+
+ public static void signJar() throws Exception {
+ String keyTool = JDKToolFinder.getJDKTool("keytool");
+ String jarSigner = JDKToolFinder.getJDKTool("jarsigner");
+ String classDir = System.getProperty("test.classes");
+ String FS = File.separator;
+
+ executeProcess(keyTool,
+ "-genkey", "-keystore", "./keystore", "-alias", "mykey",
+ "-storepass", "abc123", "-keypass", "abc123",
+ "-dname", "CN=jvmtest")
+ .shouldHaveExitValue(0);
+
+ executeProcess(jarSigner,
+ "-keystore", "./keystore", "-storepass", "abc123", "-keypass",
+ "abc123", "-signedjar", classDir + FS + "signed_hello.jar",
+ classDir + FS + "hello.jar", "mykey")
+ .shouldHaveExitValue(0);
+ }
+
+ private static OutputAnalyzer executeProcess(String... cmds)
+ throws Exception {
+
+ JarBuilder.printArray("executeProcess: ", cmds);
+ return ProcessTools.executeProcess(new ProcessBuilder(cmds));
+ }
+
+ // diagnostic
+ public static void printIterable(String msg, Iterable<String> l) {
+ StringBuilder sum = new StringBuilder();
+ for (String s : l) {
+ sum.append(s).append(' ');
+ }
+ System.out.println(msg + sum.toString());
+ }
+
+ public static void printArray(String msg, String[] l) {
+ StringBuilder sum = new StringBuilder();
+ for (String s : l) {
+ sum.append(s).append(' ');
+ }
+ System.out.println(msg + sum.toString());
+ }
+}