/*

 * 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

 * @library /test/lib

 *          java.base/jdk.internal.module

 * @build ConfigurationTest

 *        jdk.test.lib.util.ModuleUtils

 * @run testng ConfigurationTest

 * @summary Basic tests for java.lang.module.Configuration

 */

import java.io.IOException;

import java.io.OutputStream;

import java.lang.module.Configuration;

import java.lang.module.FindException;

import java.lang.module.ModuleDescriptor;

import java.lang.module.ModuleDescriptor.Requires;

import java.lang.module.ModuleFinder;

import java.lang.module.ResolutionException;

import java.lang.module.ResolvedModule;

import java.nio.file.Files;

import java.nio.file.Path;

import java.nio.file.Paths;

import java.util.List;

import java.util.Set;

import jdk.test.lib.util.ModuleUtils;

import jdk.internal.module.ModuleInfoWriter;

import jdk.internal.module.ModuleTarget;

import org.testng.annotations.DataProvider;

import org.testng.annotations.Test;

import static org.testng.Assert.*;

@Test

public class ConfigurationTest {

    /**

     * Creates a "non-strict" builder for building a module. This allows the

     * test the create ModuleDescriptor objects that do not require java.base.

     */

    private static ModuleDescriptor.Builder newBuilder(String mn) {

        return SharedSecrets.getJavaLangModuleAccess()

                .newModuleBuilder(mn, false, Set.of());

    }

    /**

     * Basic test of resolver

     *     m1 requires m2, m2 requires m3

     */

    public void testBasic() {

        ModuleDescriptor descriptor1 = newBuilder("m1")

                .requires("m2")

                .build();

        ModuleDescriptor descriptor2 = newBuilder("m2")

                .requires("m3")

                .build();

        ModuleDescriptor descriptor3 = newBuilder("m3")

                .build();

        ModuleFinder finder

            = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);

        Configuration cf = resolve(finder, "m1");

        assertTrue(cf.modules().size() == 3);

        assertTrue(cf.findModule("m1").isPresent());

        assertTrue(cf.findModule("m2").isPresent());

        assertTrue(cf.findModule("m3").isPresent());

        assertTrue(cf.parents().size() == 1);

        assertTrue(cf.parents().get(0) == Configuration.empty());

        ResolvedModule m1 = cf.findModule("m1").get();

        ResolvedModule m2 = cf.findModule("m2").get();

        ResolvedModule m3 = cf.findModule("m3").get();

        // m1 reads m2

        assertTrue(m1.reads().size() == 1);

        assertTrue(m1.reads().contains(m2));

        // m2 reads m3

        assertTrue(m2.reads().size() == 1);

        assertTrue(m2.reads().contains(m3));

        // m3 reads nothing

        assertTrue(m3.reads().size() == 0);

        // toString

        assertTrue(cf.toString().contains("m1"));

        assertTrue(cf.toString().contains("m2"));

        assertTrue(cf.toString().contains("m3"));

    }

    /**

     * Basic test of "requires transitive":

     *     m1 requires m2, m2 requires transitive m3

     */

    public void testRequiresTransitive1() {

        // m1 requires m2, m2 requires transitive m3

        ModuleDescriptor descriptor1 = newBuilder("m1")

                .requires("m2")

                .build();

        ModuleDescriptor descriptor2 = newBuilder("m2")

                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m3")

                .build();

        ModuleDescriptor descriptor3 = newBuilder("m3")

                .build();

        ModuleFinder finder

            = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);

        Configuration cf = resolve(finder, "m1");

        assertTrue(cf.modules().size() == 3);

        assertTrue(cf.findModule("m1").isPresent());

        assertTrue(cf.findModule("m2").isPresent());

        assertTrue(cf.findModule("m3").isPresent());

        assertTrue(cf.parents().size() == 1);

        assertTrue(cf.parents().get(0) == Configuration.empty());

        ResolvedModule m1 = cf.findModule("m1").get();

        ResolvedModule m2 = cf.findModule("m2").get();

        ResolvedModule m3 = cf.findModule("m3").get();

        // m1 reads m2 and m3

        assertTrue(m1.reads().size() == 2);

        assertTrue(m1.reads().contains(m2));

        assertTrue(m1.reads().contains(m3));

        // m2 reads m3

        assertTrue(m2.reads().size() == 1);

        assertTrue(m2.reads().contains(m3));

        // m3 reads nothing

        assertTrue(m3.reads().size() == 0);

    }

    /**

     * Basic test of "requires transitive" with configurations.

     *

     * The test consists of three configurations:

     * - Configuration cf1: m1, m2 requires transitive m1

     * - Configuration cf2: m3 requires m2

     */

    public void testRequiresTransitive2() {

        // cf1: m1 and m2, m2 requires transitive m1

        ModuleDescriptor descriptor1 = newBuilder("m1")

                .build();

        ModuleDescriptor descriptor2 = newBuilder("m2")

                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")

                .build();

        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);

        Configuration cf1 = resolve(finder1, "m2");

        assertTrue(cf1.modules().size() == 2);

        assertTrue(cf1.findModule("m1").isPresent());

        assertTrue(cf1.findModule("m2").isPresent());

        assertTrue(cf1.parents().size() == 1);

        assertTrue(cf1.parents().get(0) == Configuration.empty());

        ResolvedModule m1 = cf1.findModule("m1").get();

        ResolvedModule m2 = cf1.findModule("m2").get();

        assertTrue(m1.reads().size() == 0);

        assertTrue(m2.reads().size() == 1);

        assertTrue(m2.reads().contains(m1));

        // cf2: m3, m3 requires m2

        ModuleDescriptor descriptor3 = newBuilder("m3")

                .requires("m2")

                .build();

        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3);

        Configuration cf2 = resolve(cf1, finder2, "m3");

        assertTrue(cf2.modules().size() == 1);

        assertTrue(cf2.findModule("m1").isPresent());  // in parent

        assertTrue(cf2.findModule("m2").isPresent());  // in parent

        assertTrue(cf2.findModule("m3").isPresent());

        assertTrue(cf2.parents().size() == 1);

        assertTrue(cf2.parents().get(0) == cf1);

        ResolvedModule m3 = cf2.findModule("m3").get();

        assertTrue(m3.configuration() == cf2);

        assertTrue(m3.reads().size() == 2);

        assertTrue(m3.reads().contains(m1));

        assertTrue(m3.reads().contains(m2));

    }

    /**

     * Basic test of "requires transitive" with configurations.

     *

     * The test consists of three configurations:

     * - Configuration cf1: m1

     * - Configuration cf2: m2 requires transitive m1, m3 requires m2

     */

    public void testRequiresTransitive3() {

        // cf1: m1

        ModuleDescriptor descriptor1 = newBuilder("m1").build();

        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);

        Configuration cf1 = resolve(finder1, "m1");

        assertTrue(cf1.modules().size() == 1);

        assertTrue(cf1.findModule("m1").isPresent());

        assertTrue(cf1.parents().size() == 1);

        assertTrue(cf1.parents().get(0) == Configuration.empty());

        ResolvedModule m1 = cf1.findModule("m1").get();

        assertTrue(m1.reads().size() == 0);

        // cf2: m2, m3: m2 requires transitive m1, m3 requires m2

        ModuleDescriptor descriptor2 = newBuilder("m2")

                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")

                .build();

        ModuleDescriptor descriptor3 = newBuilder("m3")

                .requires("m2")

                .build();

        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2, descriptor3);

        Configuration cf2 = resolve(cf1, finder2, "m3");

        assertTrue(cf2.modules().size() == 2);

        assertTrue(cf2.findModule("m1").isPresent());   // in parent

        assertTrue(cf2.findModule("m2").isPresent());

        assertTrue(cf2.findModule("m3").isPresent());

        assertTrue(cf2.parents().size() == 1);

        assertTrue(cf2.parents().get(0) == cf1);

        ResolvedModule m2 = cf2.findModule("m2").get();

        ResolvedModule m3 = cf2.findModule("m3").get();

        assertTrue(m2.configuration() == cf2);

        assertTrue(m2.reads().size() == 1);

        assertTrue(m2.reads().contains(m1));

        assertTrue(m3.configuration() == cf2);

        assertTrue(m3.reads().size() == 2);

        assertTrue(m3.reads().contains(m1));

        assertTrue(m3.reads().contains(m2));

    }

    /**

     * Basic test of "requires transitive" with configurations.

     *

     * The test consists of three configurations:

     * - Configuration cf1: m1

     * - Configuration cf2: m2 requires transitive m1

     * - Configuraiton cf3: m3 requires m2

     */

    public void testRequiresTransitive4() {

        // cf1: m1

        ModuleDescriptor descriptor1 = newBuilder("m1").build();

        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);

        Configuration cf1 = resolve(finder1, "m1");

        assertTrue(cf1.modules().size() == 1);

        assertTrue(cf1.findModule("m1").isPresent());

        assertTrue(cf1.parents().size() == 1);

        assertTrue(cf1.parents().get(0) == Configuration.empty());

        ResolvedModule m1 = cf1.findModule("m1").get();

        assertTrue(m1.reads().size() == 0);

        // cf2: m2 requires transitive m1

        ModuleDescriptor descriptor2 = newBuilder("m2")

                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")

                .build();

        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);

        Configuration cf2 = resolve(cf1, finder2, "m2");

        assertTrue(cf2.modules().size() == 1);

        assertTrue(cf2.findModule("m1").isPresent());  // in parent

        assertTrue(cf2.findModule("m2").isPresent());

        assertTrue(cf2.parents().size() == 1);

        assertTrue(cf2.parents().get(0) == cf1);

        ResolvedModule m2 = cf2.findModule("m2").get();

        assertTrue(m2.configuration() == cf2);

        assertTrue(m2.reads().size() == 1);

        assertTrue(m2.reads().contains(m1));

        // cf3: m3 requires m2

        ModuleDescriptor descriptor3 = newBuilder("m3")

                .requires("m2")

                .build();

        ModuleFinder finder3 = ModuleUtils.finderOf(descriptor3);

        Configuration cf3 = resolve(cf2, finder3, "m3");

        assertTrue(cf3.modules().size() == 1);

        assertTrue(cf3.findModule("m1").isPresent());  // in parent

        assertTrue(cf3.findModule("m2").isPresent());  // in parent

        assertTrue(cf3.findModule("m3").isPresent());

        assertTrue(cf3.parents().size() == 1);

        assertTrue(cf3.parents().get(0) == cf2);

        ResolvedModule m3 = cf3.findModule("m3").get();

        assertTrue(m3.configuration() == cf3);

        assertTrue(m3.reads().size() == 2);

        assertTrue(m3.reads().contains(m1));

        assertTrue(m3.reads().contains(m2));

    }

    /**

     * Basic test of "requires transitive" with configurations.

     *

     * The test consists of two configurations:

     * - Configuration cf1: m1, m2 requires transitive m1

     * - Configuration cf2: m3 requires transitive m2, m4 requires m3

     */

    public void testRequiresTransitive5() {

        // cf1: m1, m2 requires transitive m1

        ModuleDescriptor descriptor1 = newBuilder("m1")

                .build();

        ModuleDescriptor descriptor2 = newBuilder("m2")

                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")

                .build();

        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);

        Configuration cf1 = resolve(finder1, "m2");

        assertTrue(cf1.modules().size() == 2);

        assertTrue(cf1.findModule("m1").isPresent());

        assertTrue(cf1.findModule("m2").isPresent());

        assertTrue(cf1.parents().size() == 1);

        assertTrue(cf1.parents().get(0) == Configuration.empty());

        ResolvedModule m1 = cf1.findModule("m1").get();

        ResolvedModule m2 = cf1.findModule("m2").get();

        assertTrue(m1.configuration() == cf1);

        assertTrue(m1.reads().size() == 0);

        assertTrue(m2.configuration() == cf1);

        assertTrue(m2.reads().size() == 1);

        assertTrue(m2.reads().contains(m1));

        // cf2: m3 requires transitive m2, m4 requires m3

        ModuleDescriptor descriptor3 = newBuilder("m3")

                .requires(Set.of(Requires.Modifier.TRANSITIVE), "m2")

                .build();

        ModuleDescriptor descriptor4 = newBuilder("m4")

                .requires("m3")

                .build();

        ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3, descriptor4);

        Configuration cf2 = resolve(cf1, finder2, "m3", "m4");

        assertTrue(cf2.modules().size() == 2);

        assertTrue(cf2.findModule("m1").isPresent());   // in parent

        assertTrue(cf2.findModule("m2").isPresent());   // in parent

        assertTrue(cf2.findModule("m3").isPresent());

        assertTrue(cf2.findModule("m4").isPresent());

        assertTrue(cf2.parents().size() == 1);

        assertTrue(cf2.parents().get(0) == cf1);

        ResolvedModule m3 = cf2.findModule("m3").get();

        ResolvedModule m4 = cf2.findModule("m4").get();

        assertTrue(m3.configuration() == cf2);

        assertTrue(m3.reads().size() == 2);

        assertTrue(m3.reads().contains(m1));

        assertTrue(m3.reads().contains(m2));

        assertTrue(m4.configuration() == cf2);

        assertTrue(m4.reads().size() == 3);

        assertTrue(m4.reads().contains(m1));

        assertTrue(m4.reads().contains(m2));

        assertTrue(m4.reads().contains(m3));

    }

    /**

     * Basic test of "requires static":

     *     m1 requires static m2

     *     m2 is not observable

     *     resolve m1

     */

    public void testRequiresStatic1() {

        ModuleDescriptor descriptor1 = newBuilder("m1")

                .requires(Set.of(Requires.Modifier.STATIC), "m2")

                .build();

        ModuleFinder finder = ModuleUtils.finderOf(descriptor1);

        Configuration cf = resolve(finder, "m1");

        assertTrue(cf.modules().size() == 1);

        ResolvedModule m1 = cf.findModule("m1").get();

        assertTrue(m1.reads().size() == 0);

    }

    /**

     * Basic test of "requires static":

     *     m1 requires static m2

     *     m2

     *     resolve m1

     */

    public void testRequiresStatic2() {

        ModuleDescriptor descriptor1 = newBuilder("m1")

                .requires(Set.of(Requires.Modifier.STATIC), "m2")

                .build();

        ModuleDescriptor descriptor2 = newBuilder("m2")

                .build();

        ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);

        Configuration cf = resolve(finder, "m1");

        assertTrue(cf.modules().size() == 1);

        ResolvedModule m1 = cf.findModule("m1").get();

        assertTrue(m1.reads().size() == 0);

    }

    /**

     * Basic test of "requires static":

     *     m1 requires static m2

     *     m2

     *     resolve m1, m2

     */

    public void testRequiresStatic3() {

        ModuleDescriptor descriptor1 = newBuilder("m1")

                .requires(Set.of(Requires.Modifier.STATIC), "m2")

                .build();

        ModuleDescriptor descriptor2 = newBuilder("m2")

                .build();