1 /*
   2  * Copyright (c) 2014, 2018, 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 jdk.test.lib.Utils;
  26 import jdk.test.lib.BuildHelper;
  27 import jdk.test.lib.JDKToolFinder;
  28 import jdk.test.lib.Platform;
  29 import jdk.test.lib.cds.CDSOptions;
  30 import jdk.test.lib.cds.CDSTestUtils;
  31 import jdk.test.lib.cds.CDSTestUtils.Result;
  32 import jdk.test.lib.process.ProcessTools;
  33 import jdk.test.lib.process.OutputAnalyzer;
  34 import java.io.File;
  35 import java.text.SimpleDateFormat;
  36 import java.util.ArrayList;
  37 import java.util.Date;
  38 
  39 /**
  40  * This is a test utility class for common AppCDS test functionality.
  41  *
  42  * Various methods use (String ...) for passing VM options. Note that the order
  43  * of the VM options are important in certain cases. Many methods take arguments like
  44  *
  45  *    (String prefix[], String suffix[], String... opts)
  46  *
  47  * Note that the order of the VM options is:
  48  *
  49  *    prefix + opts + suffix
  50  */
  51 public class TestCommon extends CDSTestUtils {
  52     private static final String JSA_FILE_PREFIX = System.getProperty("user.dir") +
  53         File.separator + "appcds-";
  54 
  55     private static final SimpleDateFormat timeStampFormat =
  56         new SimpleDateFormat("HH'h'mm'm'ss's'SSS");
  57 
  58     private static final String timeoutFactor =
  59         System.getProperty("test.timeout.factor", "1.0");
  60 
  61     private static String currentArchiveName;
  62 
  63     // Call this method to start new archive with new unique name
  64     public static void startNewArchiveName() {
  65         deletePriorArchives();
  66         currentArchiveName = JSA_FILE_PREFIX +
  67             timeStampFormat.format(new Date()) + ".jsa";
  68     }
  69 
  70     // Call this method to get current archive name
  71     public static String getCurrentArchiveName() {
  72         return currentArchiveName;
  73     }
  74 
  75     // Attempt to clean old archives to preserve space
  76     // Archives are large artifacts (20Mb or more), and much larger than
  77     // most other artifacts created in jtreg testing.
  78     // Therefore it is a good idea to clean the old archives when they are not needed.
  79     // In most cases the deletion attempt will succeed; on rare occasion the
  80     // delete operation will fail since the system or VM process still holds a handle
  81     // to the file; in such cases the File.delete() operation will silently fail, w/o
  82     // throwing an exception, thus allowing testing to continue.
  83     public static void deletePriorArchives() {
  84         File dir = new File(System.getProperty("user.dir"));
  85         String files[] = dir.list();
  86         for (String name : files) {
  87             if (name.startsWith("appcds-") && name.endsWith(".jsa")) {
  88                 if (!(new File(dir, name)).delete())
  89                     System.out.println("deletePriorArchives(): delete failed for file " + name);
  90             }
  91         }
  92     }
  93 
  94 
  95     // Create AppCDS archive using most common args - convenience method
  96     // Legacy name preserved for compatibility
  97     public static OutputAnalyzer dump(String appJar, String appClasses[],
  98                                                String... suffix) throws Exception {
  99         return createArchive(appJar, appClasses, suffix);
 100     }
 101 
 102 
 103     // Create AppCDS archive using most common args - convenience method
 104     public static OutputAnalyzer createArchive(String appJar, String appClasses[],
 105                                                String... suffix) throws Exception {
 106         AppCDSOptions opts = (new AppCDSOptions()).setAppJar(appJar)
 107             .setAppClasses(appClasses);
 108         opts.addSuffix(suffix);
 109         return createArchive(opts);
 110     }
 111 
 112     // If you use -XX:+UseAppCDS or -XX:-UseAppCDS in your JVM command-line, call this method
 113     // to wrap the arguments. On commercial builds, -XX:+UnlockCommercialFeatures will be
 114     // prepended to the command-line. See JDK-8193664.
 115     public static String[] makeCommandLineForAppCDS(String... args) throws Exception {
 116         if (BuildHelper.isCommercialBuild()) {
 117             String[] newArgs = new String[args.length + 1];
 118             newArgs[0] = "-XX:+UnlockCommercialFeatures";
 119             System.arraycopy(args, 0, newArgs, 1, args.length);
 120             return newArgs;
 121         } else {
 122             return args;
 123         }
 124     }
 125 
 126     // Create AppCDS archive using appcds options
 127     public static OutputAnalyzer createArchive(AppCDSOptions opts)
 128         throws Exception {
 129 
 130         ArrayList<String> cmd = new ArrayList<String>();
 131         File classList = makeClassList(opts.appClasses);
 132         startNewArchiveName();
 133 
 134         for (String p : opts.prefix) cmd.add(p);
 135 
 136         if (opts.appJar != null) {
 137             cmd.add("-cp");
 138             cmd.add(opts.appJar);
 139         } else {
 140             cmd.add("-cp");
 141             cmd.add("\"\"");
 142         }
 143 
 144         cmd.add("-Xshare:dump");
 145         cmd.add("-Xlog:cds,cds+hashtables");
 146         cmd.add("-XX:+UseAppCDS");
 147         cmd.add("-XX:ExtraSharedClassListFile=" + classList.getPath());
 148 
 149         if (opts.archiveName == null)
 150             opts.archiveName = getCurrentArchiveName();
 151 
 152         cmd.add("-XX:SharedArchiveFile=" + opts.archiveName);
 153 
 154         for (String s : opts.suffix) cmd.add(s);
 155 
 156         String[] cmdLine = cmd.toArray(new String[cmd.size()]);
 157         ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(true, makeCommandLineForAppCDS(cmdLine));
 158         return executeAndLog(pb, "dump");
 159     }
 160 
 161 
 162     // Execute JVM using AppCDS archive with specified AppCDSOptions
 163     public static OutputAnalyzer runWithArchive(AppCDSOptions opts)
 164         throws Exception {
 165 
 166         ArrayList<String> cmd = new ArrayList<String>();
 167 
 168         for (String p : opts.prefix) cmd.add(p);
 169 
 170         cmd.add("-Xshare:" + opts.xShareMode);
 171         cmd.add("-XX:+UseAppCDS");
 172         cmd.add("-showversion");
 173         cmd.add("-XX:SharedArchiveFile=" + getCurrentArchiveName());
 174         cmd.add("-Dtest.timeout.factor=" + timeoutFactor);
 175 
 176         if (opts.appJar != null) {
 177             cmd.add("-cp");
 178             cmd.add(opts.appJar);
 179         }
 180 
 181         for (String s : opts.suffix) cmd.add(s);
 182 
 183         String[] cmdLine = cmd.toArray(new String[cmd.size()]);
 184         ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(true, makeCommandLineForAppCDS(cmdLine));
 185         return executeAndLog(pb, "exec");
 186     }
 187 
 188 
 189     public static OutputAnalyzer execCommon(String... suffix) throws Exception {
 190         AppCDSOptions opts = (new AppCDSOptions());
 191         opts.addSuffix(suffix);
 192         return runWithArchive(opts);
 193     }
 194 
 195     // This is the new API for running a Java process with CDS enabled.
 196     // See comments in the CDSTestUtils.Result class for how to use this method.
 197     public static Result run(String... suffix) throws Exception {
 198         AppCDSOptions opts = (new AppCDSOptions());
 199         opts.addSuffix(suffix);
 200         return new Result(opts, runWithArchive(opts));
 201     }
 202 
 203 
 204     public static OutputAnalyzer exec(String appJar, String... suffix) throws Exception {
 205         AppCDSOptions opts = (new AppCDSOptions()).setAppJar(appJar);
 206         opts.addSuffix(suffix);
 207         return runWithArchive(opts);
 208     }
 209 
 210 
 211     public static OutputAnalyzer execAuto(String... suffix) throws Exception {
 212         AppCDSOptions opts = (new AppCDSOptions());
 213         opts.addSuffix(suffix).setXShareMode("auto");
 214         return runWithArchive(opts);
 215     }
 216 
 217     public static OutputAnalyzer execOff(String... suffix) throws Exception {
 218         AppCDSOptions opts = (new AppCDSOptions());
 219         opts.addSuffix(suffix).setXShareMode("off");
 220         return runWithArchive(opts);
 221     }
 222 
 223     public static OutputAnalyzer execModule(String prefix[], String upgrademodulepath, String modulepath,
 224                                             String mid, String... testClassArgs)
 225         throws Exception {
 226 
 227         AppCDSOptions opts = (new AppCDSOptions());
 228 
 229         opts.addPrefix(prefix);
 230         if (upgrademodulepath == null) {
 231             opts.addSuffix("-p", modulepath, "-m", mid);
 232         } else {
 233             opts.addSuffix("--upgrade-module-path", upgrademodulepath,
 234                            "-p", modulepath, "-m", mid);
 235         }
 236         opts.addSuffix(testClassArgs);
 237 
 238         return runWithArchive(opts);
 239     }
 240 
 241 
 242     // A common operation: dump, then check results
 243     public static OutputAnalyzer testDump(String appJar, String appClasses[],
 244                                           String... suffix) throws Exception {
 245         OutputAnalyzer output = dump(appJar, appClasses, suffix);
 246         output.shouldContain("Loading classes to share");
 247         output.shouldHaveExitValue(0);
 248         return output;
 249     }
 250 
 251 
 252     /**
 253      * Simple test -- dump and execute appJar with the given appClasses in classlist.
 254      */
 255     public static OutputAnalyzer test(String appJar, String appClasses[], String... args)
 256         throws Exception {
 257         testDump(appJar, appClasses);
 258 
 259         OutputAnalyzer output = exec(appJar, args);
 260         return checkExec(output);
 261     }
 262 
 263 
 264     public static OutputAnalyzer checkExecReturn(OutputAnalyzer output, int ret,
 265                            boolean checkContain, String... matches) throws Exception {
 266         try {
 267             for (String s : matches) {
 268                 if (checkContain) {
 269                     output.shouldContain(s);
 270                 } else {
 271                     output.shouldNotContain(s);
 272                 }
 273             }
 274             output.shouldHaveExitValue(ret);
 275         } catch (Exception e) {
 276             checkCommonExecExceptions(output, e);
 277         }
 278 
 279         return output;
 280     }
 281 
 282 
 283     // Convenience concatenation utils
 284     public static String[] list(String ...args) {
 285         return args;
 286     }
 287 
 288 
 289     public static String[] list(String arg, int count) {
 290         ArrayList<String> stringList = new ArrayList<String>();
 291         for (int i = 0; i < count; i++) {
 292             stringList.add(arg);
 293         }
 294 
 295         String outputArray[] = stringList.toArray(new String[stringList.size()]);
 296         return outputArray;
 297     }
 298 
 299 
 300     public static String[] concat(String... args) {
 301         return list(args);
 302     }
 303 
 304 
 305     public static String[] concat(String prefix[], String... extra) {
 306         ArrayList<String> list = new ArrayList<String>();
 307         for (String s : prefix) {
 308             list.add(s);
 309         }
 310         for (String s : extra) {
 311             list.add(s);
 312         }
 313 
 314         return list.toArray(new String[list.size()]);
 315     }
 316 
 317 
 318     // ===================== Concatenate paths
 319     public static String concatPaths(String... paths) {
 320         String prefix = "";
 321         String s = "";
 322         for (String p : paths) {
 323             s += prefix;
 324             s += p;
 325             prefix = File.pathSeparator;
 326         }
 327         return s;
 328     }
 329 
 330 
 331     public static String getTestJar(String jar) {
 332         File jarFile = CDSTestUtils.getTestArtifact(jar, true);
 333         if (!jarFile.isFile()) {
 334             throw new RuntimeException("Not a regular file: " + jarFile.getPath());
 335         }
 336         return jarFile.getPath();
 337     }
 338 
 339 
 340     public static String getTestDir(String d) {
 341         File dirFile = CDSTestUtils.getTestArtifact(d, true);
 342         if (!dirFile.isDirectory()) {
 343             throw new RuntimeException("Not a directory: " + dirFile.getPath());
 344         }
 345         return dirFile.getPath();
 346     }
 347 }