/*

 * Copyright (c) 2015, 2017, 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 java.io.*;

import java.lang.module.ModuleDescriptor;

import java.lang.reflect.Method;

import java.nio.file.*;

import java.nio.file.attribute.BasicFileAttributes;

import java.util.*;

import java.util.function.Consumer;

import java.util.jar.JarEntry;

import java.util.jar.JarFile;

import java.util.jar.JarInputStream;

import java.util.jar.Manifest;

import java.util.regex.Pattern;

import java.util.stream.Collectors;

import java.util.stream.Stream;

import jdk.testlibrary.FileUtils;

import jdk.testlibrary.JDKToolFinder;

import org.testng.annotations.BeforeTest;

import org.testng.annotations.Test;

import static java.lang.String.format;

import static java.lang.System.out;

/*

 * @test

 * @library /lib/testlibrary

 * @modules jdk.compiler

 *          jdk.jartool

 * @build jdk.testlibrary.FileUtils jdk.testlibrary.JDKToolFinder

 * @compile Basic.java

 * @run testng Basic

 * @summary Tests for plain Modular jars & Multi-Release Modular jars

 */

public class Basic {

    static final Path TEST_SRC = Paths.get(System.getProperty("test.src", "."));

    static final Path TEST_CLASSES = Paths.get(System.getProperty("test.classes", "."));

    static final Path MODULE_CLASSES = TEST_CLASSES.resolve("build");

    static final Path MRJAR_DIR = MODULE_CLASSES.resolve("mrjar");

    static final String VM_OPTIONS = System.getProperty("test.vm.opts", "");

    static final String TOOL_VM_OPTIONS = System.getProperty("test.tool.vm.opts", "");

    static final String JAVA_OPTIONS = System.getProperty("test.java.opts", "");

    // Details based on the checked in module source

    static TestModuleData FOO = new TestModuleData("foo",

                                                   "1.123",

                                                   "jdk.test.foo.Foo",

                                                   "Hello World!!!",

                                                   null, // no hashes

                                                   Set.of("java.base"),

                                                   Set.of("jdk.test.foo"),

                                                   null, // no uses

                                                   null, // no provides

                                                   Set.of("jdk.test.foo.internal",

                                                          "jdk.test.foo.resources"));

    static TestModuleData BAR = new TestModuleData("bar",

                                                   "4.5.6.7",

                                                   "jdk.test.bar.Bar",

                                                   "Hello from Bar!",

                                                   null, // no hashes

                                                   Set.of("java.base", "foo"),

                                                   null, // no exports

                                                   null, // no uses

                                                   null, // no provides

                                                   Set.of("jdk.test.bar",

                                                          "jdk.test.bar.internal"));

    static class TestModuleData {

        final String moduleName;

        final Set<String> requires;

        final Set<String> exports;

        final Set<String> uses;

        final Set<String> provides;

        final String mainClass;

        final String version;

        final String message;

        final String hashes;

        final Set<String> packages;

        TestModuleData(String mn, String v, String mc, String m, String h,

                       Set<String> requires, Set<String> exports, Set<String> uses,

                       Set<String> provides, Set<String> contains) {

            moduleName = mn; mainClass = mc; version = v; message = m; hashes = h;

            this.requires = requires != null ? requires : Collections.emptySet();

            this.exports = exports != null ? exports : Collections.emptySet();

            this.uses = uses != null ? uses : Collections.emptySet();;

            this.provides = provides != null ? provides : Collections.emptySet();

            this.packages = Stream.concat(this.exports.stream(), contains.stream())

                                  .collect(Collectors.toSet());

        }

        static TestModuleData from(String s) {

            try {

                BufferedReader reader = new BufferedReader(new StringReader(s));

                String line;

                String message = null;

                String name = null, version = null, mainClass = null;

                String hashes = null;

                Set<String> requires, exports, uses, provides, conceals;

                requires = exports = uses = provides = conceals = null;

                while ((line = reader.readLine()) != null) {

                    if (line.startsWith("message:")) {

                        message = line.substring("message:".length());

                    } else if (line.startsWith("nameAndVersion:")) {

                        line = line.substring("nameAndVersion:".length());

                        int i = line.indexOf('@');

                        if (i != -1) {

                            name = line.substring(0, i);

                            version = line.substring(i + 1, line.length());

                        } else {

                            name = line;

                        }

                    } else if (line.startsWith("mainClass:")) {

                        mainClass = line.substring("mainClass:".length());

                    } else if (line.startsWith("requires:")) {

                        line = line.substring("requires:".length());

                        requires = stringToSet(line);

                    } else if (line.startsWith("exports:")) {

                        line = line.substring("exports:".length());

                        exports = stringToSet(line);

                    } else if (line.startsWith("uses:")) {

                        line = line.substring("uses:".length());

                        uses = stringToSet(line);

                    } else if (line.startsWith("provides:")) {

                        line = line.substring("provides:".length());

                        provides = stringToSet(line);

                    } else if (line.startsWith("hashes:")) {

                        hashes = line.substring("hashes:".length());

                    } else if (line.startsWith("contains:")) {

                        line = line.substring("contains:".length());

                        conceals = stringToSet(line);

                    } else {

                        throw new AssertionError("Unknown value " + line);

                    }

                }

                return new TestModuleData(name, version, mainClass, message,

                                          hashes, requires, exports, uses,

                                          provides, conceals);

            } catch (IOException x) {

                throw new UncheckedIOException(x);

            }

        }

        static Set<String> stringToSet(String commaList) {

            Set<String> s = new HashSet<>();

            int i = commaList.indexOf(',');

            if (i != -1) {

                String[] p = commaList.split(",");

                Stream.of(p).forEach(s::add);

            } else {

                s.add(commaList);

            }

            return s;

        }

    }

    static void assertModuleData(Result r, TestModuleData expected) {

        //out.printf("%s%n", r.output);

        TestModuleData received = TestModuleData.from(r.output);

        if (expected.message != null)

            assertTrue(expected.message.equals(received.message),

                       "Expected message:", expected.message, ", got:", received.message);

        assertTrue(expected.moduleName.equals(received.moduleName),

                   "Expected moduleName: ", expected.moduleName, ", got:", received.moduleName);

        assertTrue(expected.version.equals(received.version),

                   "Expected version: ", expected.version, ", got:", received.version);

        assertTrue(expected.mainClass.equals(received.mainClass),

                   "Expected mainClass: ", expected.mainClass, ", got:", received.mainClass);

        assertSetsEqual(expected.requires, received.requires);

        assertSetsEqual(expected.exports, received.exports);

        assertSetsEqual(expected.uses, received.uses);

        assertSetsEqual(expected.provides, received.provides);

        assertSetsEqual(expected.packages, received.packages);

    }

    static void assertSetsEqual(Set<String> s1, Set<String> s2) {

        if (!s1.equals(s2)) {

            org.testng.Assert.assertTrue(false, s1 + " vs " + s2);

        }

     }

    @BeforeTest

    public void compileModules() throws Exception {

        compileModule(FOO.moduleName);

        compileModule(BAR.moduleName, MODULE_CLASSES);

        compileModule("baz");  // for service provider consistency checking

        // copy resources

        copyResource(TEST_SRC.resolve("src").resolve(FOO.moduleName),

                     MODULE_CLASSES.resolve(FOO.moduleName),

                     "jdk/test/foo/resources/foo.properties");

        setupMRJARModuleInfo(FOO.moduleName);

        setupMRJARModuleInfo(BAR.moduleName);

        setupMRJARModuleInfo("baz");

    }

    @Test

    public void createFoo() throws IOException {

        Path mp = Paths.get("createFoo");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        jar("--create",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "--no-manifest",

            "-C", modClasses.toString(), ".")

            .assertSuccess();

        assertSetsEqual(readPackagesAttribute(modularJar),

                        Set.of("jdk.test.foo",

                               "jdk.test.foo.resources",

                               "jdk.test.foo.internal"));

        java(mp, FOO.moduleName + "/" + FOO.mainClass)

            .assertSuccess()

            .resultChecker(r -> assertModuleData(r, FOO));

        try (InputStream fis = Files.newInputStream(modularJar);

             JarInputStream jis = new JarInputStream(fis)) {

            assertTrue(!jarContains(jis, "./"),

                       "Unexpected ./ found in ", modularJar.toString());

        }

    }

    /** Similar to createFoo, but with a Multi-Release Modular jar. */

    @Test

    public void createMRMJarFoo() throws IOException {

        Path mp = Paths.get("createMRMJarFoo");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path mrjarDir = MRJAR_DIR.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        // Positive test, create

        jar("--create",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "-m", mrjarDir.resolve("META-INF/MANIFEST.MF").toRealPath().toString(),

            "-C", mrjarDir.toString(), "META-INF/versions/9/module-info.class",

            "-C", modClasses.toString(), ".")

            .assertSuccess();

        java(mp, FOO.moduleName + "/" + FOO.mainClass)

            .assertSuccess()

            .resultChecker(r -> assertModuleData(r, FOO));

    }

    @Test

    public void updateFoo() throws IOException {

        Path mp = Paths.get("updateFoo");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        jar("--create",

            "--file=" + modularJar.toString(),

            "--no-manifest",

            "-C", modClasses.toString(), "jdk")

            .assertSuccess();

        jar("--update",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "--no-manifest",

            "-C", modClasses.toString(), "module-info.class")

            .assertSuccess();

        java(mp, FOO.moduleName + "/" + FOO.mainClass)

            .assertSuccess()

            .resultChecker(r -> assertModuleData(r, FOO));

    }

    @Test

    public void updateMRMJarFoo() throws IOException {

        Path mp = Paths.get("updateMRMJarFoo");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path mrjarDir = MRJAR_DIR.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        jar("--create",

            "--file=" + modularJar.toString(),

            "--no-manifest",

            "-C", modClasses.toString(), "jdk")

            .assertSuccess();

        jar("--update",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "-m", mrjarDir.resolve("META-INF/MANIFEST.MF").toRealPath().toString(),

            "-C", mrjarDir.toString(), "META-INF/versions/9/module-info.class",

            "-C", modClasses.toString(), "module-info.class")

            .assertSuccess();

        java(mp, FOO.moduleName + "/" + FOO.mainClass)

            .assertSuccess()

            .resultChecker(r -> assertModuleData(r, FOO));

    }

    @Test

    public void partialUpdateFooMainClass() throws IOException {

        Path mp = Paths.get("partialUpdateFooMainClass");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        // A "bad" main class in first create ( and no version )

        jar("--create",

            "--file=" + modularJar.toString(),

            "--main-class=" + "jdk.test.foo.IAmNotTheEntryPoint",

            "--no-manifest",

            "-C", modClasses.toString(), ".")  // includes module-info.class

           .assertSuccess();

        jar("--update",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "--no-manifest")

            .assertSuccess();

        java(mp, FOO.moduleName + "/" + FOO.mainClass)

            .assertSuccess()

            .resultChecker(r -> assertModuleData(r, FOO));

    }

    @Test

    public void partialUpdateFooVersion() throws IOException {

        Path mp = Paths.get("partialUpdateFooVersion");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        // A "bad" version in first create ( and no main class )

        jar("--create",

            "--file=" + modularJar.toString(),

            "--module-version=" + "100000000",

            "--no-manifest",

            "-C", modClasses.toString(), ".")  // includes module-info.class

            .assertSuccess();

        jar("--update",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "--no-manifest")

            .assertSuccess();

        java(mp, FOO.moduleName + "/" + FOO.mainClass)

            .assertSuccess()

            .resultChecker(r -> assertModuleData(r, FOO));

    }

    @Test

    public void partialUpdateFooNotAllFiles() throws IOException {

        Path mp = Paths.get("partialUpdateFooNotAllFiles");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        // Not all files, and none from non-exported packages,

        // i.e. no concealed list in first create

        jar("--create",

            "--file=" + modularJar.toString(),

            "--no-manifest",

            "-C", modClasses.toString(), "module-info.class",

            "-C", modClasses.toString(), "jdk/test/foo/Foo.class",

            "-C", modClasses.toString(), "jdk/test/foo/resources/foo.properties")

            .assertSuccess();

        jar("--update",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "--no-manifest",

            "-C", modClasses.toString(), "jdk/test/foo/internal/Message.class")

            .assertSuccess();

        java(mp, FOO.moduleName + "/" + FOO.mainClass)

            .assertSuccess()

            .resultChecker(r -> assertModuleData(r, FOO));

    }

    @Test

    public void partialUpdateMRMJarFooNotAllFiles() throws IOException {

        Path mp = Paths.get("partialUpdateMRMJarFooNotAllFiles");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path mrjarDir = MRJAR_DIR.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        jar("--create",

            "--file=" + modularJar.toString(),

            "--module-version=" + FOO.version,

            "-C", modClasses.toString(), ".")

            .assertSuccess();

        jar("--update",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "-m", mrjarDir.resolve("META-INF/MANIFEST.MF").toRealPath().toString(),

            "-C", mrjarDir.toString(), "META-INF/versions/9/module-info.class")

            .assertSuccess();

        java(mp, FOO.moduleName + "/" + FOO.mainClass)

            .assertSuccess()

            .resultChecker(r -> assertModuleData(r, FOO));

    }

    @Test

    public void partialUpdateFooAllFilesAndAttributes() throws IOException {

        Path mp = Paths.get("partialUpdateFooAllFilesAndAttributes");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        // all attributes and files

        jar("--create",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "--no-manifest",

            "-C", modClasses.toString(), ".")

            .assertSuccess();

        jar("--update",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "--no-manifest",

            "-C", modClasses.toString(), ".")

            .assertSuccess();

        java(mp, FOO.moduleName + "/" + FOO.mainClass)

            .assertSuccess()

            .resultChecker(r -> assertModuleData(r, FOO));

    }

    @Test

    public void partialUpdateFooModuleInfo() throws IOException {

        Path mp = Paths.get("partialUpdateFooModuleInfo");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        Path barModInfo = MODULE_CLASSES.resolve(BAR.moduleName);

        jar("--create",

            "--file=" + modularJar.toString(),

            "--main-class=" + FOO.mainClass,

            "--module-version=" + FOO.version,

            "--no-manifest",

            "-C", modClasses.toString(), ".")

            .assertSuccess();

        jar("--update",

            "--file=" + modularJar.toString(),

            "--no-manifest",

            "-C", barModInfo.toString(), "module-info.class")  // stuff in bar's info

            .assertSuccess();

        jar("-d",

            "--file=" + modularJar.toString())

            .assertSuccess()

            .resultChecker(r -> {

                // Expect similar output: "bar, requires mandated foo, ...

                // conceals jdk.test.foo, conceals jdk.test.foo.internal"

                Pattern p = Pattern.compile("module bar \\(module-info.class\\)\\s+requires\\s++foo");

                assertTrue(p.matcher(r.output).find(),

                           "Expecting to find \"bar, requires foo,...\"",

                           "in output, but did not: [" + r.output + "]");

                p = Pattern.compile(

                        "contains\\s+jdk.test.foo\\s+contains\\s+jdk.test.foo.internal");

                assertTrue(p.matcher(r.output).find(),

                           "Expecting to find \"contains jdk.test.foo,...\"",

                           "in output, but did not: [" + r.output + "]");

            });

    }

    @Test

    public void partialUpdateFooPackagesAttribute() throws IOException {

        Path mp = Paths.get("partialUpdateFooPackagesAttribute");

        createTestDir(mp);

        Path modClasses = MODULE_CLASSES.resolve(FOO.moduleName);

        Path modularJar = mp.resolve(FOO.moduleName + ".jar");

        // Not all files, and none from non-exported packages,

        // i.e. no concealed list in first create

        jar("--create",

            "--file=" + modularJar.toString(),

            "--no-manifest",

            "-C", modClasses.toString(), "module-info.class",

            "-C", modClasses.toString(), "jdk/test/foo/Foo.class")