/*

 * Copyright (c) 2014, 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.

 *

 */

import jdk.test.lib.Utils;

import jdk.test.lib.BuildHelper;

import jdk.test.lib.JDKToolFinder;

import jdk.test.lib.Platform;

import jdk.test.lib.cds.CDSOptions;

import jdk.test.lib.cds.CDSTestUtils;

import jdk.test.lib.cds.CDSTestUtils.Result;

import jdk.test.lib.process.ProcessTools;

import jdk.test.lib.process.OutputAnalyzer;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileOutputStream;

import java.io.InputStream;

import java.net.URI;

import java.nio.file.DirectoryStream;

import java.nio.file.Files;

import java.nio.file.FileSystem;

import java.nio.file.FileSystems;

import java.nio.file.Path;

import java.text.SimpleDateFormat;

import java.util.Arrays;

import java.util.ArrayList;

import java.util.Date;

import java.util.Enumeration;

import java.util.regex.Matcher;

import java.util.regex.Pattern;

import java.util.zip.ZipEntry;

import java.util.zip.ZipFile;

import java.util.zip.ZipOutputStream;

import jtreg.SkippedException;

import cdsutils.DynamicDumpHelper;

/**

 * This is a test utility class for common AppCDS test functionality.

 *

 * Various methods use (String ...) for passing VM options. Note that the order

 * of the VM options are important in certain cases. Many methods take arguments like

 *

 *    (String prefix[], String suffix[], String... opts)

 *

 * Note that the order of the VM options is:

 *

 *    prefix + opts + suffix

 */

public class TestCommon extends CDSTestUtils {

    private static final String JSA_FILE_PREFIX = System.getProperty("user.dir") +

        File.separator;

    private static final SimpleDateFormat timeStampFormat =

        new SimpleDateFormat("HH'h'mm'm'ss's'SSS");

    private static final String timeoutFactor =

        System.getProperty("test.timeout.factor", "1.0");

    private static String currentArchiveName;

    // Call this method to start new archive with new unique name

    public static void startNewArchiveName() {

        deletePriorArchives();

        currentArchiveName = getNewArchiveName();

    }

    // Call this method to get current archive name

    public static String getCurrentArchiveName() {

        return currentArchiveName;

    }

    public static String getNewArchiveName() {

        return getNewArchiveName(null);

    }

    public static String getNewArchiveName(String stem) {

        if (stem == null) {

            stem = "appcds";

        }

        return JSA_FILE_PREFIX + stem + "-" +

            timeStampFormat.format(new Date()) + ".jsa";

    }

    // Attempt to clean old archives to preserve space

    // Archives are large artifacts (20Mb or more), and much larger than

    // most other artifacts created in jtreg testing.

    // Therefore it is a good idea to clean the old archives when they are not needed.

    // In most cases the deletion attempt will succeed; on rare occasion the

    // delete operation will fail since the system or VM process still holds a handle

    // to the file; in such cases the File.delete() operation will silently fail, w/o

    // throwing an exception, thus allowing testing to continue.

    public static void deletePriorArchives() {

        File dir = new File(System.getProperty("user.dir"));

        String files[] = dir.list();

        for (String name : files) {

            if (name.startsWith("appcds-") && name.endsWith(".jsa")) {

                if (!(new File(dir, name)).delete())

                    System.out.println("deletePriorArchives(): delete failed for file " + name);

            }

        }

    }

    // Create AppCDS archive using most common args - convenience method

    // Legacy name preserved for compatibility

    public static OutputAnalyzer dump(String appJar, String classList[],

                                               String... suffix) throws Exception {

        return createArchive(appJar, classList, suffix);

    }

    // Create AppCDS archive using most common args - convenience method

    public static OutputAnalyzer createArchive(String appJar, String classList[],

                                               String... suffix) throws Exception {

        AppCDSOptions opts = (new AppCDSOptions()).setAppJar(appJar);

        opts.setClassList(classList);

        opts.addSuffix(suffix);

        return createArchive(opts);

    }

    // Simulate -Xshare:dump with -XX:ArchiveClassesAtExit. See comments around patchJarForDynamicDump()

    private static final Class tmp = DynamicDumpHelper.class;

    // Create AppCDS archive using appcds options

    public static OutputAnalyzer createArchive(AppCDSOptions opts)

        throws Exception {

        ArrayList<String> cmd = new ArrayList<String>();

        startNewArchiveName();

        for (String p : opts.prefix) cmd.add(p);

        if (opts.appJar != null) {

            cmd.add("-cp");

            cmd.add(opts.appJar);

            File jf = new File(opts.appJar);

            if (DYNAMIC_DUMP && !jf.isDirectory()) {

                patchJarForDynamicDump(opts.appJar);

            }

        } else {

            cmd.add("-Djava.class.path=");

        }

        if (opts.archiveName == null) {

            opts.archiveName = getCurrentArchiveName();

        }

        if (DYNAMIC_DUMP) {

            cmd.add("-Xshare:on");

            cmd.add("-XX:ArchiveClassesAtExit=" + opts.archiveName);

            cmd.add("-Xlog:cds");

            cmd.add("-Xlog:cds+dynamic");

            boolean mainModuleSpecified = false;

            boolean patchModuleSpecified = false;

            for (String s : opts.suffix) {

                if (s.length() == 0) {

                    continue;

                }

                if (s.equals("-m")) {

                    mainModuleSpecified = true;

                }

                if (s.startsWith("--patch-module=")) {

                    patchModuleSpecified = true;

                }

                cmd.add(s);

            }

            if (opts.appJar != null) {

                // classlist is supported only when we have a Jar file to patch (to insert

                // cdsutils.DynamicDumpHelper)

                if (opts.classList == null) {

                    throw new RuntimeException("test.dynamic.dump requires classList file");

                }

                if (!mainModuleSpecified && !patchModuleSpecified) {

                    cmd.add("cdsutils.DynamicDumpHelper");

                    File classListFile = makeClassList(opts.classList);

                    cmd.add(classListFile.getPath());

                }

            } else {

                if (!mainModuleSpecified && !patchModuleSpecified) {

                    // If you have an empty classpath, you cannot specify a classlist!

                    if (opts.classList != null && opts.classList.length > 0) {

                        throw new RuntimeException("test.dynamic.dump not supported empty classpath with non-empty classlist");

                    }

                    cmd.add("-version");

                }

            }

        } else {

            // static dump

            cmd.add("-Xshare:dump");

            cmd.add("-XX:SharedArchiveFile=" + opts.archiveName);

            if (opts.classList != null) {

                File classListFile = makeClassList(opts.classList);

                cmd.add("-XX:ExtraSharedClassListFile=" + classListFile.getPath());

            }

            for (String s : opts.suffix) {

                cmd.add(s);

            }

        }

        String[] cmdLine = cmd.toArray(new String[cmd.size()]);

        ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(true, cmdLine);

        return executeAndLog(pb, "dump");

    }

    // This allows you to run the AppCDS tests with JFR enabled at runtime (though not at

    // dump time, as that's uncommon for typical AppCDS users).

    //

    // To run in this special mode, add the following to your jtreg command-line

    //    -Dtest.cds.run.with.jfr=true

    //

    // Some AppCDS tests are not compatible with this mode. See the group

    // hotspot_appcds_with_jfr in ../../TEST.ROOT for details.

    private static final boolean RUN_WITH_JFR = Boolean.getBoolean("test.cds.run.with.jfr");

    // This method simulates -Xshare:dump with -XX:ArchiveClassesAtExit. This way, we

    // can re-use many tests (outside of the ./dynamicArchive directory) for testing

    // general features of JDK-8215311 (JEP 350: Dynamic CDS Archives).

    //

    // We insert the cdsutils/DynamicDumpHelper.class into the first Jar file in

    // the classpath. We use this class to load all the classes specified in the classlist.

    //

    // There's no need to change the run-time command-line: in this special mode, two

    // archives are involved. The command-line specifies only the top archive. However,

    // the location of the base archive is recorded in the top archive, so it can be

    // determined by the JVM at runtime start-up.

    //

    // To run in this special mode, specify the following in your jtreg command-line

    //    -Dtest.dynamic.cds.archive=true

    //

    // Note that some tests are not compatible with this special mode, including

    //    + Tests in ./dynamicArchive: these tests are specifically written for

    //      dynamic archive, and do not use TestCommon.createArchive(), which works

    //      together with patchJarForDynamicDump().

    //    + Tests related to cached objects and shared strings: dynamic dumping

    //      does not support these.

    //    + Custom loader tests: DynamicDumpHelper doesn't support the required

    //      classlist syntax. (FIXME).

    //    + Extra symbols and extra strings.

    // See the hotspot_appcds_dynamic in ../../TEST.ROOT for details.

    //

    // To run all tests that are compatible with this mode:

    //    cd test/hotspot/jtreg

    //    jtreg -Dtest.dynamic.cds.archive=true :hotspot_appcds_dynamic

    //

    private static void patchJarForDynamicDump(String cp) throws Exception {

        System.out.println("patchJarForDynamicDump: classpath = " + cp);

        String firstJar = cp;

        int n = firstJar.indexOf(File.pathSeparator);

        if (n > 0) {

            firstJar = firstJar.substring(0, n);

        }

        String classDir = System.getProperty("test.classes");

        String expected1 = classDir + File.separator;

        String expected2 = System.getProperty("user.dir") + File.separator;

        if (!firstJar.startsWith(expected1) && !firstJar.startsWith(expected2)) {

            throw new RuntimeException("FIXME: jar file not at a supported location ('"

                                       + expected1 + "', or '" + expected2 + "'): " + firstJar);

        }

        String replaceJar = firstJar + ".tmp";

        String patchClass = "cdsutils/DynamicDumpHelper.class";

        ZipFile zipFile = new ZipFile(firstJar);

        byte[] buf = new byte[1024];

        int len;

        if (zipFile.getEntry(patchClass) == null) {

            FileOutputStream fout = new FileOutputStream(replaceJar);

            final ZipOutputStream zos = new ZipOutputStream(fout);

            zos.putNextEntry(new ZipEntry(patchClass));

            InputStream is = new FileInputStream(classDir + File.separator + patchClass);

            while ((len = (is.read(buf))) > 0) {

                zos.write(buf, 0, len);

            }

            zos.closeEntry();

            is.close();

            for (Enumeration e = zipFile.entries(); e.hasMoreElements(); ) {

                ZipEntry entryIn = (ZipEntry) e.nextElement();

                zos.putNextEntry(entryIn);

                is = zipFile.getInputStream(entryIn);

                while ((len = is.read(buf)) > 0) {

                    zos.write(buf, 0, len);

                }

                zos.closeEntry();

                is.close();

            }

            zos.close();

            fout.close();

            zipFile.close();

            File oldFile = new File(firstJar);

            File newFile = new File(replaceJar);

            oldFile.delete();

            newFile.renameTo(oldFile);

            System.out.println("firstJar = " + firstJar + " Modified");

        } else {

            System.out.println("firstJar = " + firstJar);

        }

    }

    // Execute JVM using AppCDS archive with specified AppCDSOptions

    public static OutputAnalyzer runWithArchive(AppCDSOptions opts)

        throws Exception {

        ArrayList<String> cmd = new ArrayList<String>();

        for (String p : opts.prefix) cmd.add(p);

        cmd.add("-Xshare:" + opts.xShareMode);

        cmd.add("-showversion");

        cmd.add("-XX:SharedArchiveFile=" + getCurrentArchiveName());

        cmd.add("-Dtest.timeout.factor=" + timeoutFactor);

        if (opts.appJar != null) {

            cmd.add("-cp");

            cmd.add(opts.appJar);

        }

        for (String s : opts.suffix) cmd.add(s);

        if (RUN_WITH_JFR) {

            boolean usesJFR = false;

            for (String s : cmd) {

                if (s.startsWith("-XX:StartFlightRecording=") || s.startsWith("-XX:FlightRecorderOptions")) {

                    System.out.println("JFR option might have been specified. Don't interfere: " + s);

                    usesJFR = true;

                    break;

                }

            }

            if (!usesJFR) {

                System.out.println("JFR option not specified. Enabling JFR ...");

                cmd.add(0, "-XX:StartFlightRecording=dumponexit=true");

                System.out.println(cmd);

            }

        }

        String[] cmdLine = cmd.toArray(new String[cmd.size()]);

        ProcessBuilder pb = ProcessTools.createJavaProcessBuilder(true, cmdLine);

        return executeAndLog(pb, "exec");

    }

    public static OutputAnalyzer execCommon(String... suffix) throws Exception {

        AppCDSOptions opts = (new AppCDSOptions());

        opts.addSuffix(suffix);

        return runWithArchive(opts);

    }

    // This is the new API for running a Java process with CDS enabled.

    // See comments in the CDSTestUtils.Result class for how to use this method.

    public static Result run(String... suffix) throws Exception {

        AppCDSOptions opts = (new AppCDSOptions());

        opts.addSuffix(suffix);

        return new Result(opts, runWithArchive(opts));

    }

    public static OutputAnalyzer exec(String appJar, String... suffix) throws Exception {

        AppCDSOptions opts = (new AppCDSOptions()).setAppJar(appJar);

        opts.addSuffix(suffix);

        return runWithArchive(opts);

    }

    public static Result runWithModules(String prefix[], String upgrademodulepath, String modulepath,

                                            String mid, String... testClassArgs) throws Exception {

        AppCDSOptions opts = makeModuleOptions(prefix, upgrademodulepath, modulepath,

                                               mid, testClassArgs);

        return new Result(opts, runWithArchive(opts));

    }

    public static OutputAnalyzer execAuto(String... suffix) throws Exception {

        AppCDSOptions opts = (new AppCDSOptions());

        opts.addSuffix(suffix).setXShareMode("auto");

        return runWithArchive(opts);

    }

    public static OutputAnalyzer execOff(String... suffix) throws Exception {

        AppCDSOptions opts = (new AppCDSOptions());

        opts.addSuffix(suffix).setXShareMode("off");

        return runWithArchive(opts);

    }

    private static AppCDSOptions makeModuleOptions(String prefix[], String upgrademodulepath, String modulepath,

                                            String mid, String testClassArgs[]) {

        AppCDSOptions opts = (new AppCDSOptions());

        opts.addPrefix(prefix);

        if (upgrademodulepath == null) {

            opts.addSuffix("-p", modulepath, "-m", mid);

        } else {

            opts.addSuffix("--upgrade-module-path", upgrademodulepath,

                           "-p", modulepath, "-m", mid);

        }

        opts.addSuffix(testClassArgs);

        return opts;

    }

    public static OutputAnalyzer execModule(String prefix[], String upgrademodulepath, String modulepath,

                                            String mid, String... testClassArgs)

        throws Exception {

        AppCDSOptions opts = makeModuleOptions(prefix, upgrademodulepath, modulepath,

                                               mid, testClassArgs);

        return runWithArchive(opts);

    }

    // A common operation: dump, then check results

    public static OutputAnalyzer testDump(String appJar, String classList[],

                                          String... suffix) throws Exception {

        OutputAnalyzer output = dump(appJar, classList, suffix);

        if (DYNAMIC_DUMP) {

            if (isUnableToMap(output)) {

                throw new SkippedException(UnableToMapMsg);

            }

            output.shouldContain("Written dynamic archive");

        } else {

            output.shouldContain("Loading classes to share");

        }

        output.shouldHaveExitValue(0);

        return output;

    }

    /**

     * Simple test -- dump and execute appJar with the given classList in classlist.

     */

    public static OutputAnalyzer test(String appJar, String classList[], String... args)

        throws Exception {

        testDump(appJar, classList);

        OutputAnalyzer output = exec(appJar, args);

        return checkExec(output);

    }

    public static OutputAnalyzer checkExecReturn(OutputAnalyzer output, int ret,

                           boolean checkContain, String... matches) throws Exception {

        try {

            for (String s : matches) {

                if (checkContain) {

                    output.shouldContain(s);