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