/*

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

 */

/*

 * @test

 * @bug 8153654 8176333

 * @summary Tests for jdeps tool with multi-release jar files

 * @modules jdk.jdeps/com.sun.tools.jdeps

 * @library mrjar mrjar/base mrjar/9 mrjar/10 mrjar/v9 mrjar/v10

 * @build test.* p.* q.* foo/* Main

 * @run testng MultiReleaseJar

 */

import org.testng.Assert;

import org.testng.annotations.AfterClass;

import org.testng.annotations.BeforeClass;

import org.testng.annotations.Test;

import java.io.File;

import java.io.InputStream;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.stream.Stream;

public class MultiReleaseJar {

    Path mrjar;

    String testJdk;

    String fileSep;

    Path cmdPath;

    @BeforeClass

    public void initialize() throws Exception {

        String testClassPath = System.getProperty("test.class.path", "");

        mrjar = Stream.of(testClassPath.split(File.pathSeparator))

                      .map(Paths::get)

                      .filter(e -> e.endsWith("mrjar"))

                      .findAny()

                      .orElseThrow(() -> new InternalError("mrjar not found"));

        testJdk = System.getProperty("test.jdk");

        fileSep = System.getProperty("file.separator");

        cmdPath = Paths.get(testJdk, "bin");

        // build Version.jar, Version_9.jar and main.jar

        Result r = run("jar -cf Version.jar -C base test --release 9 -C 9 test --release 10 -C 10 test");

        checkResult(r);

        r = run("jar -cf Version_9.jar -C base test --release 9 -C 9 test");

        checkResult(r);

        r = run("jar -cf Main.jar Main.class");

        checkResult(r);

        r = run("jar -cf Foo.jar -C base p");

        checkResult(r);

        Path foo = Paths.get(System.getProperty("test.classes")).resolve("modules").resolve("foo");

        r = run("jar -uf Foo.jar --release 9 -C " + foo.toString() + " module-info.class --release 10 -C v10 q");

        checkResult(r);

    }

    @Test

    public void basic() throws Exception {

        Result r = run("jdeps --multi-release 9  -v missing.jar");

        checkResult(r, false, "Warning: Path does not exist: missing.jar");

        r = run("jdeps -v Version.jar");

        checkResult(r, false, "--multi-release option is not set");

        r = run("jdeps --multi-release base  -v Version.jar");

        checkResult(r, true,

            "Version.jar ->",

            "test.Version",

            "test.Version"

        );

        r = run("jdeps --multi-release 9  -v Version.jar");

        checkResult(r, true,

            "Version.jar ->",

            "9/test.NonPublic",

            "9/test.NonPublic",

            "9/test.Version",

            "9/test.Version",

            "9/test.Version",

            "9/test.Version"

        );

        r = run("jdeps --multi-release 10  -v Version.jar");

        checkResult(r, true,

            "Version.jar ->",

            "10/test.Version",

            "10/test.Version",

            "10/test.Version",

            "10/test.Version",

            "9/test.NonPublic",

            "9/test.NonPublic"

        );

        r = run("jdeps --multi-release 8  -v Version.jar");

        checkResult(r, false, "Error: invalid argument for option: 8");

        r = run("jdeps --multi-release 9.1  -v Version.jar");

        checkResult(r, false, "Error: invalid argument for option: 9.1");

        runJdeps("Main.class");

        runJdeps("Main.jar");

    }

    private void runJdeps(String path) throws Exception {

        Result r = run("jdeps -v -R -cp Version.jar " + path);

        checkResult(r, false, "--multi-release option is not set");

        r = run("jdeps -v -R -cp Version.jar --module-path Foo.jar -multi-release 9 " + path);

        checkResult(r, false,

            "Error: unknown option: -multi-release",

            "Usage: jdeps <options> <path",

            "use --help"

        );

        r = run("jdeps -v -R -cp Version.jar --module-path Foo.jar --multi-release 9 " + path);

        String name = path;

        int index = path.lastIndexOf('/');

        if (index >= 0) {

            name = path.substring(index + 1, path.length());

        }

        checkResult(r, true,

            name + " -> Version.jar",

            name + " -> foo",

            name + " -> java.base",

            "Main",

            "Main",

            "Main",

            "Main",

            "Version.jar -> java.base",

            "9/test.NonPublic",

            "9/test.NonPublic",

            "9/test.Version",

            "9/test.Version",

            "9/test.Version",

            "9/test.Version",

            "foo",

            "Foo.jar",

            "requires mandated java.base",

            "foo -> java.base",

            "p.Foo"

        );

        r = run("jdeps -v -R -cp Version.jar --module-path Foo.jar --multi-release 10 " + path);

        checkResult(r, true,

            name + " -> Version.jar",

            name + " -> foo",

            name + " -> java.base",

            "Main",

            "Main",

            "Main",

            "Main",

            "Version.jar ->",

            "10/test.Version",

            "10/test.Version",

            "10/test.Version",

            "10/test.Version",

            "9/test.NonPublic",

            "9/test.NonPublic",

            "foo",

            "Foo.jar",

            "requires mandated java.base",

            "foo -> java.base",

            "p.Foo"

        );

        r = run("jdeps -v -R -cp Version.jar --module-path Foo.jar --multi-release base " + path);

        checkResult(r, true,

            name + " -> Version.jar",

            name + " -> foo",

            name + " -> java.base",

            "Main",

            "Main",

            "Main",

            "Main",

            "Version.jar ->",

            "test.Version",

            "test.Version",

            "foo",

            "Foo.jar",

            "requires mandated java.base",

            "foo -> java.base",

            "p.Foo"

        );

        r = run("jdeps -v -R -cp Version.jar --module-path  Foo.jar --multi-release 9.1 " + path);

        checkResult(r, false, "Error: invalid argument for option: 9.1");

        // Version_9.jar does not have any version 10 entry

        r = run("jdeps -v -R -cp Version_9.jar --module-path Foo.jar --multi-release 10 " + path);

        checkResult(r, true,

            name + " -> Version_9.jar",

            name + " -> foo",

            name + " -> java.base",

            "Main",

            "Main",

            "Main",

            "Main",

            "Version_9.jar ->",

            "9/test.NonPublic",

            "9/test.NonPublic",

            "9/test.Version",

            "9/test.Version",

            "9/test.Version",

            "9/test.Version",

            "foo",

            "Foo.jar",

            "requires mandated java.base",

            "foo -> java.base",

            "p.Foo"

        );

    }

    @Test

    public void ps_and_qs() throws Exception {

        // build the jar file

        Result r = run("jar -cf PQ.jar -C base p --release 9 -C v9 p -C v9 q --release 10 -C v10 q");

        checkResult(r);

        r = run("jdeps -v -R -cp PQ.jar --multi-release base PQ.jar");

        checkResult(r, true,

            "PQ.jar -> java.base",

            "p.Foo"

        );

        r = run("jdeps -v -R -cp PQ.jar --multi-release 9 PQ.jar");

        checkResult(r, true,

            "PQ.jar -> java.base",

            "9/p.Foo",

            "9/p.Foo",

            "9/q.Bar"

        );

        r = run("jdeps -v -R -cp PQ.jar --multi-release 10 PQ.jar");

        checkResult(r, true,

            "PQ.jar -> java.base",

            "10/q.Bar",

            "10/q.Bar",

            "10/q.Gee",

            "9/p.Foo",

            "9/p.Foo"

        );

    }

    @Test

    public void modularJar() throws Exception {

        Result r = run("jdeps -v --multi-release 10 --module-path Foo.jar -m foo");

        checkResult(r, true,

            "foo",                   // module name

            "Foo.jar",                      // the path to Foo.jar

            "requires mandated java.base",  // module dependences

            "foo -> java.base",

            "10/q.Bar",

            "10/q.Bar",

            "10/q.Gee",

            "p.Foo"

        );

        r = run("jdeps --multi-release 9 -cp Version.jar --module-path Foo.jar Main.jar");

        checkResult(r, true,

            "Main.jar -> Version.jar",

            "Main.jar -> foo",

            "Main.jar -> java.base",

            "-> java.lang",

            "-> p",

            "-> test"

        );

        r = run("jdeps --multi-release 10 -cp Version.jar --module-path Foo.jar Main.jar");

        checkResult(r, true,

            "Main.jar -> Version.jar",

            "Main.jar -> foo",

            "Main.jar -> java.base",

            "-> java.lang",

            "-> p",

            "-> test"

        );

    }

    static class Result {

        final String cmd;

        final int rc;

        final String out;

        final String err;

        Result(String cmd, int rc, String out, String err) {

            this.cmd = cmd;

            this.rc = rc;

            this.out = out;

            this.err = err;

        }

    }

    Result run(String cmd) throws Exception {

        String[] cmds = cmd.split(" +");

        cmds[0] = cmdPath.resolve(cmds[0]).toString();

        ProcessBuilder pb = new ProcessBuilder(cmds);

        pb.directory(mrjar.toFile());

        Process p = null;

        try {

            p = pb.start();

            p.waitFor();

            String out;

            try (InputStream is = p.getInputStream()) {

                out = new String(is.readAllBytes());

            }

            String err;

            try (InputStream is = p.getErrorStream()) {

                err = new String(is.readAllBytes());

            }

            return new Result(cmd, p.exitValue(), out, err);

        } catch (Throwable t) {

            if (p != null) {

                p.destroyForcibly().waitFor();

            }

            throw t;

        }

    }

    void checkResult(Result r) throws Exception {

        System.out.println(r.cmd);

        System.out.println(r.out);

        if (r.rc != 0) {

            System.out.println(r.err);

            throw new Exception("rc=" + r.rc);

        }

        System.out.println();

    }

    void checkResult(Result r, boolean checkrc, String... lines) throws Exception {

        System.out.println(r.cmd);

        System.out.println(r.out);

        if (checkrc && r.rc != 0) {

            System.out.println(r.err);

            throw new Exception("rc=" + r.rc);

        }

        String[] out = r.out.split("\r?\n");

        Assert.assertEquals(out.length, lines.length);

        int n = 0;

        for (String line : lines) {

            Assert.assertTrue(out[n++].contains(line), "\"" + line + "\"");

        }

        System.out.println();

    }

}