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/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 }