1 /*
2 * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 *
23 */
24
25 import java.io.File;
26 import jdk.test.lib.process.OutputAnalyzer;
27 import jdk.test.lib.process.ProcessTools;
28 import jdk.test.lib.cds.CDSOptions;
29 import jdk.test.lib.cds.CDSTestUtils;
30 import jdk.test.lib.cds.CDSTestUtils.Result;
31
32 /**
33 * Base class for test cases in test/hotspot/jtreg/runtime/cds/appcds/dynamicArchive/
34 */
35 class DynamicArchiveTestBase {
36 private static boolean executedIn_run = false;
37
38 public static interface DynamicArchiveTest {
39 public void run() throws Exception;
40 }
41
42 public static interface DynamicArchiveTestWithArgs {
43 public void run(String args[]) throws Exception;
44 }
45
46
47 /*
48 * Tests for dynamic archives should be written using this pattern:
49 *
50 * public class HelloDynamic extends DynamicArchiveTestBase {
51 * public static void main(String[] args) throws Exception {
52 * runTest(HelloDynamic::testDefaultBase); // launch one test case
53 * }
54 *
55 * // the body of a test case
56 * static void testDefaultBase() throws Exception {
57 * String topArchiveName = getNewArchiveName("top");
58 * doTest(null, topArchiveName);
59 * }
60 * }
61 *
62 * The reason for this is so that we can clean up the archive files
63 * created by prior test cases. Otherwise tests with lots of
64 * test cases may fill up the scratch directory.
65 */
66 public static void runTest(DynamicArchiveTest t) throws Exception {
67 executedIn_run = true;
68 try {
69 TestCommon.deletePriorArchives();
70 t.run();
71 } finally {
72 executedIn_run = false;
73 }
74 }
75
76 public static void runTest(DynamicArchiveTestWithArgs t, String... args) throws Exception {
77 executedIn_run = true;
78 try {
79 TestCommon.deletePriorArchives();
80 t.run(args);
81 } finally {
82 executedIn_run = false;
83 }
84 }
85
86 public static String getNewArchiveName() {
87 return TestCommon.getNewArchiveName();
88 }
89 public static String getNewArchiveName(String stem) {
90 return TestCommon.getNewArchiveName(stem);
91 }
92
93 /**
94 * Execute a JVM using the base archive (given by baseArchiveName) with the command line
95 * (given by cmdLineSuffix). At JVM exit, dump all eligible classes into the top archive
96 * (give by topArchiveName).
97 *
98 * If baseArchiveName is null, use the JDK's default archive as the base archive.
99 */
100 public static Result dump2(String baseArchiveName, String topArchiveName, String ... cmdLineSuffix)
101 throws Exception
102 {
103 String[] cmdLine = TestCommon.concat(
104 "-XX:ArchiveClassesAtExit=" + topArchiveName);
105 // to allow dynamic archive tests to be run in the "rt-non-cds-mode"
106 cmdLine = TestCommon.concat(cmdLine, "-Xshare:auto");
107 if (baseArchiveName != null) {
108 cmdLine = TestCommon.concat(cmdLine, "-XX:SharedArchiveFile=" + baseArchiveName);
109 }
110 cmdLine = TestCommon.concat(cmdLine, cmdLineSuffix);
111 return execProcess("dump", null, cmdLine);
112 }
113
114 public static Result dump2_WB(String baseArchiveName, String topArchiveName, String ... cmdLineSuffix)
115 throws Exception
116 {
117 return dump2(baseArchiveName, topArchiveName,
118 TestCommon.concat(wbRuntimeArgs(), cmdLineSuffix));
119 }
120
121 /**
122 * A convenience method similar to dump2, but always use the JDK's default archive
123 * as the base archive.
124 *
125 * Most dynamicArchive/*.java test cases should be using this method instead of run2.
126 */
127 public static Result dump(String topArchiveName, String ... cmdLineSuffix)
128 throws Exception
129 {
130 return dump2(null, topArchiveName, cmdLineSuffix);
131 }
132
133 /**
134 * Dump the base archive. The JDK's default class list is used (unless otherwise specified
135 * in cmdLineSuffix).
136 */
137 public static void dumpBaseArchive(String baseArchiveName, String ... cmdLineSuffix)
138 throws Exception
139 {
140 CDSOptions opts = new CDSOptions();
141 opts.setArchiveName(baseArchiveName);
142 opts.addSuffix(cmdLineSuffix);
143 opts.addSuffix("-Djava.class.path=");
144 OutputAnalyzer out = CDSTestUtils.createArchive(opts);
145 CDSTestUtils.checkDump(out);
146 }
147
148 /**
149 * Same as dumpBaseArchive, but also add WhiteBox to the bootcp
150 */
151 public static void dumpBaseArchive_WB(String baseArchiveName, String ... cmdLineSuffix)
152 throws Exception
153 {
154 dumpBaseArchive(baseArchiveName,
155 TestCommon.concat("-Xbootclasspath/a:" + getWhiteBoxJar(), cmdLineSuffix));
156 }
157
158 private static String getWhiteBoxJar() {
159 String wbJar = ClassFileInstaller.getJarPath("WhiteBox.jar");
160 if (!(new File(wbJar)).exists()) {
161 throw new RuntimeException("Test error: your test must have " +
162 "'@run driver ClassFileInstaller -jar WhiteBox.jar sun.hotspot.WhiteBox'");
163 }
164 return wbJar;
165 }
166
167 private static String[] wbRuntimeArgs() {
168 return TestCommon.concat("-Xbootclasspath/a:" + getWhiteBoxJar(),
169 "-XX:+UnlockDiagnosticVMOptions",
170 "-XX:+WhiteBoxAPI");
171 }
172
173 /**
174 * Execute a JVM using the base archive (given by baseArchiveName) and the top archive
175 * (give by topArchiveName), using the command line (given by cmdLineSuffix).
176 *
177 * If baseArchiveName is null, use the JDK's default archive as the base archive.
178 */
179 public static Result run2(String baseArchiveName, String topArchiveName, String ... cmdLineSuffix)
180 throws Exception {
181 if (baseArchiveName == null && topArchiveName == null) {
182 throw new RuntimeException("Both baseArchiveName and topArchiveName cannot be null at the same time.");
183 }
184 String archiveFiles = (baseArchiveName == null) ? topArchiveName :
185 (topArchiveName == null) ? baseArchiveName :
186 baseArchiveName + File.pathSeparator + topArchiveName;
187 String[] cmdLine = TestCommon.concat(
188 "-Xshare:on",
189 "-XX:SharedArchiveFile=" + archiveFiles);
190 cmdLine = TestCommon.concat(cmdLine, cmdLineSuffix);
191 return execProcess("exec", null, cmdLine);
192 }
193
194 public static Result runWithRelativePath(String baseArchiveName, String topArchiveName,
195 String jarDir, String ... cmdLineSuffix)
196 throws Exception {
197 if (baseArchiveName == null && topArchiveName == null) {
198 throw new RuntimeException("Both baseArchiveName and topArchiveName cannot be null at the same time.");
199 }
200 String archiveFiles = (baseArchiveName == null) ? topArchiveName :
201 (topArchiveName == null) ? baseArchiveName :
202 baseArchiveName + File.pathSeparator + topArchiveName;
203 String[] cmdLine = TestCommon.concat(
204 "-Xshare:on",
205 "-XX:SharedArchiveFile=" + archiveFiles);
206 cmdLine = TestCommon.concat(cmdLine, cmdLineSuffix);
207 return execProcess("exec", jarDir, cmdLine);
208 }
209
210 public static Result run2_WB(String baseArchiveName, String topArchiveName, String ... cmdLineSuffix)
211 throws Exception
212 {
213 return run2(baseArchiveName, topArchiveName,
214 TestCommon.concat(wbRuntimeArgs(), cmdLineSuffix));
215 }
216
217 /**
218 * A convenience method similar to run2, but always use the JDK's default archive
219 * as the base archive.
220 *
221 * Most dynamicArchive/*.java test cases should be using this method instead of run2.
222 */
223 public static Result run(String topArchiveName, String ... cmdLineSuffix)
224 throws Exception
225 {
226 return run2(null, topArchiveName, cmdLineSuffix);
227 }
228
229 private static String getXshareMode(String[] cmdLine) {
230 for (int i = 0; i <= cmdLine.length - 1; i++) {
231 int j = cmdLine[i].indexOf("-Xshare:");
232 if (j != -1) {
233 return (cmdLine[i].substring(j));
234 }
235 }
236 return null;
237 }
238
239
240 private static Result execProcess(String mode, String jarDir, String[] cmdLine) throws Exception {
241 if (!executedIn_run) {
242 throw new Exception("Test error: dynamic archive tests must be executed via DynamicArchiveTestBase.run()");
243 }
244 ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(true, cmdLine);
245 if (jarDir != null) {
246 pb.directory(new File(jarDir));
247 }
248 OutputAnalyzer output = TestCommon.executeAndLog(pb, mode);
249 CDSOptions opts = new CDSOptions();
250 String xShareMode = getXshareMode(cmdLine);
251 if (xShareMode != null) {
252 opts.setXShareMode(xShareMode);
253 }
254 return new Result(opts, output);
255 }
256
257 /**
258 * A convenience method for dumping and running, using the default CDS archive from the
259 * JDK. Both dumping and running should exit normally.
260 */
261 public static void dumpAndRun(String topArchiveName, String ... cmdLineSuffix) throws Exception {
262 dump(topArchiveName, cmdLineSuffix).assertNormalExit();
263 run(topArchiveName, cmdLineSuffix).assertNormalExit();
264 }
265 }