test/jdk/java/lang/module/AutomaticModulesTest.java

/*
 * Copyright (c) 2015, 2023, 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 8142968 8253751 8262944 8314986
 * @library /test/lib
 * @build AutomaticModulesTest
 *        jdk.test.lib.util.JarUtils
 *        jdk.test.lib.util.ModuleUtils
 * @run junit AutomaticModulesTest
 * @summary Basic tests for automatic modules
 */

import java.io.IOException;
import java.lang.module.Configuration;
import java.lang.module.FindException;
import java.lang.module.InvalidModuleDescriptorException;
import java.lang.module.ModuleDescriptor;
import java.lang.module.ModuleDescriptor.Requires.Modifier;
import java.lang.module.ModuleFinder;
import java.lang.module.ModuleReference;
import java.lang.module.ResolutionException;
import java.lang.module.ResolvedModule;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Optional;
import java.util.Set;
import java.util.jar.Attributes;
import java.util.jar.Manifest;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import jdk.test.lib.util.JarUtils;
import jdk.test.lib.util.ModuleUtils;

import org.junit.jupiter.api.Test;
import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.Arguments;
import org.junit.jupiter.params.provider.MethodSource;
import static org.junit.jupiter.api.Assertions.*;
import static org.junit.jupiter.params.provider.Arguments.arguments;

public class AutomaticModulesTest {
    private static final Path USER_DIR = Path.of(System.getProperty("user.dir"));

    // JAR file name to expected module name / version
    static Stream<Arguments> jarNames() {
        return Stream.of(
            arguments( "foo.jar",                    "foo" ),
            arguments( "foo4j.jar",                  "foo4j" ),

            arguments( "foo1.jar",                   "foo1" ),
            arguments( "foo10.jar",                  "foo10" ),

            arguments( "foo-1.jar",                  "foo/1" ),
            arguments( "foo-1.2.jar",                "foo/1.2" ),
            arguments( "foo-1.2.3.jar",              "foo/1.2.3" ),
            arguments( "foo-1.2.3.4.jar",            "foo/1.2.3.4" ),

            arguments( "foo-10.jar",                 "foo/10" ),
            arguments( "foo-10.20.jar",              "foo/10.20" ),
            arguments( "foo-10.20.30.jar",           "foo/10.20.30" ),
            arguments( "foo-10.20.30.40.jar",        "foo/10.20.30.40" ),

            arguments( "foo-bar.jar",                "foo.bar" ),
            arguments( "foo-bar-1.jar",              "foo.bar/1" ),
            arguments( "foo-bar-1.2.jar",            "foo.bar/1.2" ),
            arguments( "foo-bar-10.jar",             "foo.bar/10" ),
            arguments( "foo-bar-10.20.jar",          "foo.bar/10.20" ),

            arguments("foo.bar1.jar",                "foo.bar1" ),
            arguments( "foo.bar10.jar",              "foo.bar10" ),

            arguments( "foo-1.2-SNAPSHOT.jar",       "foo/1.2-SNAPSHOT" ),
            arguments( "foo-bar-1.2-SNAPSHOT.jar",   "foo.bar/1.2-SNAPSHOT" ),

            arguments( "foo--bar-1.0.jar",           "foo.bar/1.0" ),
            arguments( "-foo-bar-1.0.jar",           "foo.bar/1.0" ),
            arguments( "foo-bar--1.0.jar",           "foo.bar/1.0" )
        );
    }

    // JAR file names that do not map to a legal module name
    static Stream<String> barJarNames() {
        return Stream.of(
            ".jar",
            "_.jar",
            "foo.1.jar",
            "1foo.jar",
            "foo.1bar.jar"
        );
    }

    /**
     * Test mapping of JAR file names to module names
     */
    @ParameterizedTest
    @MethodSource("jarNames")
    public void testNames(String fn, String mid) throws IOException {
        String[] s = mid.split("/");
        String mn = s[0];
        String vs = (s.length == 2) ? s[1] : null;

        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        Path jf = dir.resolve(fn);

        // create empty JAR file
        createDummyJarFile(jf);

        // create a ModuleFinder to find modules in the directory
        ModuleFinder finder = ModuleFinder.of(dir);

        // a module with the expected name should be found
        Optional<ModuleReference> mref = finder.find(mn);
        assertTrue(mref.isPresent(), mn + " not found");

        ModuleDescriptor descriptor = mref.get().descriptor();
        assertTrue(descriptor.isAutomatic());
        assertEquals(mn, descriptor.name());
        if (vs == null) {
            assertFalse(descriptor.version().isPresent());
        } else {
            assertEquals(vs, descriptor.version().get().toString());
        }
    }

    /**
     * Test impossible mapping of JAR files to modules names
     */
    @ParameterizedTest
    @MethodSource("barJarNames")
    public void testBadNames(String fn) throws IOException {
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        Path jf = dir.resolve(fn);

        // create empty JAR file
        createDummyJarFile(jf);

        // should throw FindException
        var finder = ModuleFinder.of(dir);
        assertThrows(FindException.class, finder::findAll);
    }

    // Automatic-Module-Name attribute values and version in JAR file name
    static Stream<Arguments> automaticModuleNames() {
        return Stream.of(
            arguments( "foo",        null ),
            arguments( "foo",        "1.0" ),
            arguments( "foo.bar",    null ),
            arguments( "foo.bar",    "1.0" ),
            arguments( "class_",     null ),
            arguments( "class_",     "1.0" )
        );
    }

    // Bad Automatic-Module-Name attribute values
    static Stream<String> badAutomaticModuleNames() {
        return Stream.of(
            "",
            "666",
            "foo.class"
        );
    }

    /**
     * Test JAR files with the Automatic-Module-Name attribute
     */
    @ParameterizedTest
    @MethodSource("automaticModuleNames")
    public void testAutomaticModuleNameAttribute(String name, String vs)
        throws IOException
    {
        Manifest man = new Manifest();
        Attributes attrs = man.getMainAttributes();
        attrs.put(Attributes.Name.MANIFEST_VERSION, "1.0.0");
        attrs.put(new Attributes.Name("Automatic-Module-Name"), name);

        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        String jar;
        if (vs == null) {
            jar = "m.jar";
        } else {
            jar = "m-" + vs + ".jar";
        }
        createDummyJarFile(dir.resolve(jar), man);

        ModuleFinder finder = ModuleFinder.of(dir);

        assertTrue(finder.findAll().size() == 1);
        assertTrue(finder.find(name).isPresent());

        ModuleReference mref = finder.find(name).get();
        ModuleDescriptor descriptor = mref.descriptor();
        assertEquals(name, descriptor.name());
        assertEquals(vs, descriptor.version()
                .map(ModuleDescriptor.Version::toString)
                .orElse(null));
    }

    /**
     * Test JAR files with the Automatic-Module-Name attribute with a value
     * that is not a legal module name.
     */
    @ParameterizedTest
    @MethodSource("badAutomaticModuleNames")
    public void testBadAutomaticModuleNameAttribute(String name) throws IOException {
        assertThrows(FindException.class, () -> testAutomaticModuleNameAttribute(name, null));
    }

    /**
     * Test all packages are exported
     */
    @Test
    public void testPackages() throws IOException {
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("m.jar"),
                           "p/C1.class", "p/C2.class", "q/C1.class");

        ModuleFinder finder = ModuleFinder.of(dir);
        Optional<ModuleReference> mref = finder.find("m");
        assertTrue(mref.isPresent(), "m not found");

        ModuleDescriptor descriptor = mref.get().descriptor();
        assertTrue(descriptor.isAutomatic());

        assertTrue(descriptor.packages().size() == 2);
        assertTrue(descriptor.packages().contains("p"));
        assertTrue(descriptor.packages().contains("q"));

        assertTrue(descriptor.exports().isEmpty());
        assertTrue(descriptor.opens().isEmpty());
    }

    /**
     * Test class files in JAR file where the entry does not correspond to a
     * legal package name.
     */
    @Test
    public void testBadPackage() throws IOException {
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("m.jar"), "p/C1.class", "p-/C2.class");

        ModuleFinder finder = ModuleFinder.of(dir);
        Optional<ModuleReference> mref = finder.find("m");
        assertTrue(mref.isPresent(), "m not found");

        ModuleDescriptor descriptor = mref.get().descriptor();
        assertTrue(descriptor.isAutomatic());

        assertTrue(descriptor.packages().size() == 1);
        assertTrue(descriptor.packages().contains("p"));

        assertTrue(descriptor.exports().isEmpty());
        assertTrue(descriptor.opens().isEmpty());
    }

    /**
     * Test non-class resources in a JAR file.
     */
    @Test
    public void testNonClassResources() throws IOException {
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("m.jar"),
                "LICENSE",
                "README",
                "WEB-INF/tags",
                "p/Type.class",
                "p/resources/m.properties");

        ModuleFinder finder = ModuleFinder.of(dir);
        Optional<ModuleReference> mref = finder.find("m");
        assertTrue(mref.isPresent(), "m not found");

        ModuleDescriptor descriptor = mref.get().descriptor();
        assertTrue(descriptor.isAutomatic());

        assertTrue(descriptor.packages().size() == 1);
        assertTrue(descriptor.packages().contains("p"));
    }

    /**
     * Test .class file in unnamed package (top-level directory)
     */
    @Test
    public void testClassInUnnamedPackage() throws IOException {
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("m.jar"), "Mojo.class");
        var finder = ModuleFinder.of(dir);
        assertThrows(FindException.class, finder::findAll);
    }

    /**
     * Test JAR file with META-INF/services configuration file
     */
    @Test
    public void testServicesConfiguration() throws IOException {
        String service = "p.S";
        String provider = "p.S1";

        Path tmpdir = Files.createTempDirectory(USER_DIR, "tmp");

        // provider class
        Path providerClass = tmpdir.resolve(provider.replace('.', '/') + ".class");
        Files.createDirectories(providerClass.getParent());
        Files.createFile(providerClass);

        // services configuration file
        Path services = tmpdir.resolve("META-INF").resolve("services");
        Files.createDirectories(services);
        Files.write(services.resolve(service), Set.of(provider));

        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        JarUtils.createJarFile(dir.resolve("m.jar"), tmpdir);

        ModuleFinder finder = ModuleFinder.of(dir);

        Optional<ModuleReference> mref = finder.find("m");
        assertTrue(mref.isPresent(), "m not found");

        ModuleDescriptor descriptor = mref.get().descriptor();
        assertTrue(descriptor.provides().size() == 1);
        ModuleDescriptor.Provides provides = descriptor.provides().iterator().next();
        assertEquals(service, provides.service());
        assertTrue(provides.providers().size() == 1);
        assertTrue(provides.providers().contains((provider)));
    }

    // META-INF/services files that don't map to legal service names
    static Stream<Arguments> badServices() {
        return Stream.of(
            arguments( "-",  "p.S1" ),
            arguments( ".S", "p.S1" )
        );
    }

    /**
     * Test JAR file with META-INF/services configuration file with bad
     * values or names.
     */
    @ParameterizedTest
    @MethodSource("badServices")
    public void testBadServicesNames(String service, String provider)
        throws IOException
    {
        Path tmpdir = Files.createTempDirectory(USER_DIR, "tmp");
        Path services = tmpdir.resolve("META-INF").resolve("services");
        Files.createDirectories(services);
        Files.write(services.resolve(service), Set.of(provider));
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        JarUtils.createJarFile(dir.resolve("m.jar"), tmpdir);

        Optional<ModuleReference> omref = ModuleFinder.of(dir).find("m");
        assertTrue(omref.isPresent());
        ModuleDescriptor descriptor = omref.get().descriptor();
        assertTrue(descriptor.provides().isEmpty());
    }

    // META-INF/services configuration file entries that are not legal
    static Stream<Arguments> badProviders() {
        return Stream.of(
            arguments("p.S", "-"),
            arguments("p.S", "p..S1"),
            arguments("p.S", "S1.")
        );
    }

    /**
     * Test JAR file with META-INF/services configuration file with bad
     * values or names.
     */
    @ParameterizedTest
    @MethodSource("badProviders")
    public void testBadProviderNames(String service, String provider)
        throws IOException
    {
        Path tmpdir = Files.createTempDirectory(USER_DIR, "tmp");

        // provider class
        Path providerClass = tmpdir.resolve(provider.replace('.', '/') + ".class");
        Files.createDirectories(providerClass.getParent());
        Files.createFile(providerClass);

        // services configuration file
        Path services = tmpdir.resolve("META-INF").resolve("services");
        Files.createDirectories(services);
        Files.write(services.resolve(service), Set.of(provider));

        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        JarUtils.createJarFile(dir.resolve("m.jar"), tmpdir);

        // should throw FindException
        var finder = ModuleFinder.of(dir);
        assertThrows(FindException.class, finder::findAll);
    }

    /**
     * Test JAR file with META-INF/services configuration file listing a
     * provider that is not in the module.
     */
    @Test
    public void testMissingProviderPackage() throws IOException {
        Path tmpdir = Files.createTempDirectory(USER_DIR, "tmp");

        // services configuration file
        Path services = tmpdir.resolve("META-INF").resolve("services");
        Files.createDirectories(services);
        Files.write(services.resolve("p.S"), Set.of("q.P"));

        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        Path jarfile = dir.resolve("m.jar");
        JarUtils.createJarFile(jarfile, tmpdir);

        // FindException should be thrown with InvalidModuleDescriptorException as cause
        var finder = ModuleFinder.of(dir);
        FindException ex = assertThrows(FindException.class, () -> finder.findAll());
        Throwable cause = ex.getCause();
        assertTrue(cause instanceof InvalidModuleDescriptorException);
        var imde = (InvalidModuleDescriptorException) cause;
        assertEquals("Provider class q.P not in JAR file " + jarfile.getFileName(), imde.getMessage());
    }

    /**
     * Test that a JAR file with a Main-Class attribute results
     * in a module with a main class.
     */
    @Test
    public void testMainClass() throws IOException {
        String mainClass = "p.Main";

        Manifest man = new Manifest();
        Attributes attrs = man.getMainAttributes();
        attrs.put(Attributes.Name.MANIFEST_VERSION, "1.0.0");
        attrs.put(Attributes.Name.MAIN_CLASS, mainClass);

        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        String entry = mainClass.replace('.', '/') + ".class";
        createDummyJarFile(dir.resolve("m.jar"), man, entry);

        ModuleFinder finder = ModuleFinder.of(dir);

        Configuration parent = ModuleLayer.boot().configuration();
        Configuration cf = resolve(parent, finder, "m");

        ModuleDescriptor descriptor = findDescriptor(cf, "m");
        assertEquals(mainClass, descriptor.mainClass().get());
    }

    // Main-Class attribute values that do not map to a legal qualified type name
    static Stream<String> badMainClasses() {
        return Stream.of(
            "p..Main",
            "p-.Main"
        );
    }

    /**
     * Test that a JAR file with a Main-Class attribute that is not a qualified
     * type name.
     */
    @ParameterizedTest
    @MethodSource("badMainClasses")
    public void testBadMainClass(String mainClass) throws IOException {
        Manifest man = new Manifest();
        Attributes attrs = man.getMainAttributes();
        attrs.put(Attributes.Name.MANIFEST_VERSION, "1.0.0");
        attrs.put(Attributes.Name.MAIN_CLASS, mainClass);

        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        String entry = mainClass.replace('.', '/') + ".class";
        createDummyJarFile(dir.resolve("m.jar"), man, entry);

        // bad Main-Class value should be ignored
        Optional<ModuleReference> omref = ModuleFinder.of(dir).find("m");
        assertTrue(omref.isPresent());
        ModuleDescriptor descriptor = omref.get().descriptor();
        assertFalse(descriptor.mainClass().isPresent());
    }

    /**
     * Test that a JAR file with a Main-Class attribute that is not in the module
     */
    @Test
    public void testMissingMainClassPackage() throws IOException {
        Manifest man = new Manifest();
        Attributes attrs = man.getMainAttributes();
        attrs.put(Attributes.Name.MANIFEST_VERSION, "1.0.0");
        attrs.put(Attributes.Name.MAIN_CLASS, "p.Main");

        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("m.jar"), man);

        // Main-Class should be ignored because package p is not in module
        Optional<ModuleReference> omref = ModuleFinder.of(dir).find("m");
        assertTrue(omref.isPresent());
        ModuleDescriptor descriptor = omref.get().descriptor();
        assertFalse(descriptor.mainClass().isPresent());
    }

    /**
     * Basic test of a configuration created with automatic modules.
     *   a requires b*
     *   a requires c*
     *   b*
     *   c*
     */
    @Test
    public void testConfiguration1() throws Exception {
        ModuleDescriptor descriptor1
            = ModuleDescriptor.newModule("a")
                .requires("b")
                .requires("c")
                .requires("java.base")
                .build();

        // b and c are automatic modules
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("b.jar"), "p/T.class");
        createDummyJarFile(dir.resolve("c.jar"), "q/T.class");

        // module finder locates a and the modules in the directory
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
        ModuleFinder finder2 = ModuleFinder.of(dir);
        ModuleFinder finder = ModuleFinder.compose(finder1, finder2);

        Configuration parent = ModuleLayer.boot().configuration();
        Configuration cf = resolve(parent, finder, "a");

        assertTrue(cf.modules().size() == 3);
        assertTrue(cf.findModule("a").isPresent());
        assertTrue(cf.findModule("b").isPresent());
        assertTrue(cf.findModule("c").isPresent());

        ResolvedModule base = cf.findModule("java.base").get();
        assertTrue(base.configuration() == ModuleLayer.boot().configuration());
        ResolvedModule a = cf.findModule("a").get();
        ResolvedModule b = cf.findModule("b").get();
        ResolvedModule c = cf.findModule("c").get();

        // b && c only require java.base
        assertTrue(b.reference().descriptor().requires().size() == 1);
        assertTrue(c.reference().descriptor().requires().size() == 1);

        // readability

        assertTrue(a.reads().size() == 3);
        assertTrue(a.reads().contains(base));
        assertTrue(a.reads().contains(b));
        assertTrue(a.reads().contains(c));

        assertTrue(b.reads().contains(a));
        assertFalse(b.reads().contains(b));
        assertTrue(b.reads().contains(c));
        testReadAllBootModules(cf, "b");  // b reads all modules in boot layer

        assertTrue(c.reads().contains(a));
        assertTrue(c.reads().contains(b));
        assertFalse(c.reads().contains(c));
        testReadAllBootModules(cf, "c");  // c reads all modules in boot layer
    }

    /**
     * Basic test of a configuration created with automatic modules
     *   a requires b
     *   b requires c*
     *   c*
     *   d*
     */
    @Test
    public void testInConfiguration2() throws IOException {
        ModuleDescriptor descriptor1
            = ModuleDescriptor.newModule("a")
                .requires("b")
                .requires("java.base")
                .build();

        ModuleDescriptor descriptor2
            = ModuleDescriptor.newModule("b")
                .requires("c")
                .requires("java.base")
                .build();

        // c and d are automatic modules
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("c.jar"), "p/T.class");
        createDummyJarFile(dir.resolve("d.jar"), "q/T.class");

        // module finder locates a and the modules in the directory
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
        ModuleFinder finder2 = ModuleFinder.of(dir);
        ModuleFinder finder = ModuleFinder.compose(finder1, finder2);

        Configuration parent = ModuleLayer.boot().configuration();
        Configuration cf = resolve(parent, finder, "a", "d");

        assertTrue(cf.modules().size() == 4);
        assertTrue(cf.findModule("a").isPresent());
        assertTrue(cf.findModule("b").isPresent());
        assertTrue(cf.findModule("c").isPresent());
        assertTrue(cf.findModule("d").isPresent());

        // c && d should only require java.base
        assertTrue(findDescriptor(cf, "c").requires().size() == 1);
        assertTrue(findDescriptor(cf, "d").requires().size() == 1);

        // readability

        ResolvedModule base = cf.findModule("java.base").get();
        assertTrue(base.configuration() == ModuleLayer.boot().configuration());
        ResolvedModule a = cf.findModule("a").get();
        ResolvedModule b = cf.findModule("b").get();
        ResolvedModule c = cf.findModule("c").get();
        ResolvedModule d = cf.findModule("d").get();

        assertTrue(a.reads().size() == 2);
        assertTrue(a.reads().contains(b));
        assertTrue(a.reads().contains(base));

        assertTrue(b.reads().size() == 3);
        assertTrue(b.reads().contains(c));
        assertTrue(b.reads().contains(d));
        assertTrue(b.reads().contains(base));

        assertTrue(c.reads().contains(a));
        assertTrue(c.reads().contains(b));
        assertFalse(c.reads().contains(c));
        assertTrue(c.reads().contains(d));
        testReadAllBootModules(cf, "c");   // c reads all modules in boot layer

        assertTrue(d.reads().contains(a));
        assertTrue(d.reads().contains(b));
        assertTrue(d.reads().contains(c));
        assertFalse(d.reads().contains(d));
        testReadAllBootModules(cf, "d");    // d reads all modules in boot layer
    }

    /**
     * Basic test of a configuration created with automatic modules
     *   a requires b
     *   b requires transitive c*
     *   c*
     *   d*
     */
    @Test
    public void testInConfiguration3() throws IOException {
        ModuleDescriptor descriptor1
            = ModuleDescriptor.newModule("a")
                .requires("b")
                .requires("java.base")
                .build();

        ModuleDescriptor descriptor2
            = ModuleDescriptor.newModule("b")
                .requires(Set.of(Modifier.TRANSITIVE), "c")
                .requires("java.base")
                .build();

        // c and d are automatic modules
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("c.jar"), "p/T.class");
        createDummyJarFile(dir.resolve("d.jar"), "q/T.class");

        // module finder locates a and the modules in the directory
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
        ModuleFinder finder2 = ModuleFinder.of(dir);
        ModuleFinder finder = ModuleFinder.compose(finder1, finder2);

        Configuration parent = ModuleLayer.boot().configuration();
        Configuration cf = resolve(parent, finder, "a", "d");

        assertTrue(cf.modules().size() == 4);
        assertTrue(cf.findModule("a").isPresent());
        assertTrue(cf.findModule("b").isPresent());
        assertTrue(cf.findModule("c").isPresent());
        assertTrue(cf.findModule("d").isPresent());

        ResolvedModule base = cf.findModule("java.base").get();
        assertTrue(base.configuration() == ModuleLayer.boot().configuration());
        ResolvedModule a = cf.findModule("a").get();
        ResolvedModule b = cf.findModule("b").get();
        ResolvedModule c = cf.findModule("c").get();
        ResolvedModule d = cf.findModule("d").get();

        // c && d should only require java.base
        assertTrue(findDescriptor(cf, "c").requires().size() == 1);
        assertTrue(findDescriptor(cf, "d").requires().size() == 1);

        // readability

        assertTrue(a.reads().size() == 4);
        assertTrue(a.reads().contains(b));
        assertTrue(a.reads().contains(c));
        assertTrue(a.reads().contains(d));
        assertTrue(a.reads().contains(base));

        assertTrue(b.reads().size() == 3);
        assertTrue(b.reads().contains(c));
        assertTrue(b.reads().contains(d));
        assertTrue(b.reads().contains(base));

        assertTrue(c.reads().contains(a));
        assertTrue(c.reads().contains(b));
        assertFalse(c.reads().contains(c));
        assertTrue(c.reads().contains(d));
        testReadAllBootModules(cf, "c");   // c reads all modules in boot layer

        assertTrue(d.reads().contains(a));
        assertTrue(d.reads().contains(b));
        assertTrue(d.reads().contains(c));
        assertFalse(d.reads().contains(d));
        testReadAllBootModules(cf, "d");    // d reads all modules in boot layer
    }

    /**
     * Basic test to ensure that no automatic modules are resolved when
     * an automatic module is not a root or required by other modules.
     */
    @Test
    public void testInConfiguration4() throws IOException {
        ModuleDescriptor descriptor1
            = ModuleDescriptor.newModule("m1")
                .requires("java.base")
                .build();

        // automatic modules
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("auto1.jar"), "p1/C.class");
        createDummyJarFile(dir.resolve("auto2.jar"), "p2/C.class");
        createDummyJarFile(dir.resolve("auto3.jar"), "p3/C.class");

        // module finder locates m1 and the modules in the directory
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
        ModuleFinder finder2 =  ModuleFinder.of(dir);
        ModuleFinder finder = ModuleFinder.compose(finder1, finder2);

        Configuration parent = ModuleLayer.boot().configuration();
        Configuration cf = resolve(parent, finder, "m1");

        // ensure that no automatic module is resolved
        assertTrue(cf.modules().size() == 1);
        assertTrue(cf.findModule("m1").isPresent());
    }

    /**
     * Basic test to ensure that if an automatic module is resolved then
     * all observable automatic modules are resolved.
     */
    @Test
    public void testInConfiguration5() throws IOException {
        // m1 requires m2
        ModuleDescriptor descriptor1
            = ModuleDescriptor.newModule("m1")
                .requires("m2").build();

        // m2 requires automatic module
        ModuleDescriptor descriptor2
            = ModuleDescriptor.newModule("m2")
                .requires("auto1")
                .build();

        // automatic modules
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("auto1.jar"), "p1/C.class");
        createDummyJarFile(dir.resolve("auto2.jar"), "p2/C.class");
        createDummyJarFile(dir.resolve("auto3.jar"), "p3/C.class");

        // module finder locates m1, m2, and the modules in the directory
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
        ModuleFinder finder2 =  ModuleFinder.of(dir);
        ModuleFinder finder = ModuleFinder.compose(finder1, finder2);

        Configuration parent = ModuleLayer.boot().configuration();
        Configuration cf = resolve(parent, finder, "m1");

        // all automatic modules should be resolved
        assertTrue(cf.modules().size() == 5);
        assertTrue(cf.findModule("m1").isPresent());
        assertTrue(cf.findModule("m2").isPresent());
        assertTrue(cf.findModule("auto1").isPresent());
        assertTrue(cf.findModule("auto2").isPresent());
        assertTrue(cf.findModule("auto3").isPresent());

        ResolvedModule base = parent.findModule("java.base")
                                    .orElseThrow(() -> new RuntimeException());
        ResolvedModule m1 = cf.findModule("m1").get();
        ResolvedModule m2 = cf.findModule("m2").get();
        ResolvedModule auto1 = cf.findModule("auto1").get();
        ResolvedModule auto2 = cf.findModule("auto2").get();
        ResolvedModule auto3 = cf.findModule("auto3").get();

        // m1 does not read the automatic modules
        assertTrue(m1.reads().size() == 2);
        assertTrue(m1.reads().contains(m2));
        assertTrue(m1.reads().contains(base));

        // m2 should read all the automatic modules
        assertTrue(m2.reads().size() == 4);
        assertTrue(m2.reads().contains(auto1));
        assertTrue(m2.reads().contains(auto2));
        assertTrue(m2.reads().contains(auto3));
        assertTrue(m2.reads().contains(base));

        assertTrue(auto1.reads().contains(m1));
        assertTrue(auto1.reads().contains(m2));
        assertFalse(auto1.reads().contains(auto1));
        assertTrue(auto1.reads().contains(auto2));
        assertTrue(auto1.reads().contains(auto3));
        assertTrue(auto1.reads().contains(base));

        assertTrue(auto2.reads().contains(m1));
        assertTrue(auto2.reads().contains(m2));
        assertTrue(auto2.reads().contains(auto1));
        assertFalse(auto2.reads().contains(auto2));
        assertTrue(auto2.reads().contains(auto3));
        assertTrue(auto2.reads().contains(base));

        assertTrue(auto3.reads().contains(m1));
        assertTrue(auto3.reads().contains(m2));
        assertTrue(auto3.reads().contains(auto1));
        assertTrue(auto3.reads().contains(auto2));
        assertFalse(auto3.reads().contains(auto3));
        assertTrue(auto3.reads().contains(base));
    }

    /**
     * Basic test of automatic modules in a child configuration. All automatic
     * modules that are found with the before finder should be resolved. The
     * automatic modules that are found by the after finder and not shadowed
     * by the before finder, or parent configurations, should also be resolved.
     */
    @Test
    public void testInConfiguration6() throws IOException {
        // m1 requires auto1
        ModuleDescriptor descriptor1
            = ModuleDescriptor.newModule("m1")
                .requires("auto1")
                .build();

        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("auto1.jar"), "p1/C.class");

        // module finder locates m1 and auto1
        ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
        ModuleFinder finder2 =  ModuleFinder.of(dir);
        ModuleFinder finder = ModuleFinder.compose(finder1, finder2);

        Configuration parent = ModuleLayer.boot().configuration();
        Configuration cf1 = resolve(parent, finder, "m1");

        assertTrue(cf1.modules().size() == 2);
        assertTrue(cf1.findModule("m1").isPresent());
        assertTrue(cf1.findModule("auto1").isPresent());

        ResolvedModule base = parent.findModule("java.base")
                                    .orElseThrow(() -> new RuntimeException());
        ResolvedModule m1 = cf1.findModule("m1").get();
        ResolvedModule auto1 = cf1.findModule("auto1").get();

        assertTrue(m1.reads().size() == 2);
        assertTrue(m1.reads().contains(auto1));
        assertTrue(m1.reads().contains(base));

        assertTrue(auto1.reads().contains(m1));
        assertTrue(auto1.reads().contains(base));


        // create child configuration - the after finder locates auto1

        dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("auto2.jar"), "p2/C.class");
        ModuleFinder beforeFinder =  ModuleFinder.of(dir);

        dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("auto1.jar"), "p1/C.class");
        createDummyJarFile(dir.resolve("auto2.jar"), "p2/C.class");
        createDummyJarFile(dir.resolve("auto3.jar"), "p3/C.class");
        ModuleFinder afterFinder =  ModuleFinder.of(dir);

        Configuration cf2 = cf1.resolve(beforeFinder, afterFinder, Set.of("auto2"));

        // auto1 should be found in parent and should not be in cf2
        assertTrue(cf2.modules().size() == 2);
        assertTrue(cf2.findModule("auto2").isPresent());
        assertTrue(cf2.findModule("auto3").isPresent());

        ResolvedModule auto2 = cf2.findModule("auto2").get();
        ResolvedModule auto3 = cf2.findModule("auto3").get();

        assertTrue(auto2.reads().contains(m1));
        assertTrue(auto2.reads().contains(auto1));
        assertFalse(auto2.reads().contains(auto2));
        assertTrue(auto2.reads().contains(auto3));
        assertTrue(auto2.reads().contains(base));

        assertTrue(auto3.reads().contains(m1));
        assertTrue(auto3.reads().contains(auto1));
        assertTrue(auto3.reads().contains(auto2));
        assertFalse(auto3.reads().contains(auto3));
        assertTrue(auto3.reads().contains(base));
    }

    /**
     * Basic test for a module requiring an automatic module in a parent
     * configuration. If an explicit module in a child configuration reads an
     * automatic module in a parent configuration then it should read all
     * automatic modules in the parent configuration.
     */
    @Test
    public void testInConfiguration7() throws Exception {
        // m1 requires auto1
        ModuleDescriptor descriptor1 = ModuleDescriptor.newModule("m1")
                .requires("auto1")
                .build();

        Path dir1 = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir1.resolve("auto1.jar"), "p1/C.class");
        createDummyJarFile(dir1.resolve("auto2.jar"), "p2/C.class");

        // module finder locates m1, auto1, and auto2
        ModuleFinder finder1 = ModuleFinder.compose(ModuleUtils.finderOf(descriptor1),
                                                    ModuleFinder.of(dir1));

        Configuration parent = ModuleLayer.boot().configuration();
        ResolvedModule base = parent.findModule("java.base").orElseThrow();

        Configuration cf1 = resolve(parent, finder1, "m1");
        assertTrue(cf1.modules().size() == 3);

        ResolvedModule m1 = cf1.findModule("m1").orElseThrow();
        ResolvedModule auto1 = cf1.findModule("auto1").orElseThrow();
        ResolvedModule auto2 = cf1.findModule("auto2").orElseThrow();

        assertTrue(m1.reads().size() == 3);
        assertTrue(m1.reads().contains(base));
        assertTrue(m1.reads().contains(auto1));
        assertTrue(m1.reads().contains(auto2));

        assertTrue(auto1.reads().contains(base));
        assertTrue(auto1.reads().contains(m1));
        assertFalse(auto1.reads().contains(auto1));
        assertTrue(auto1.reads().contains(auto2));

        assertTrue(auto2.reads().contains(base));
        assertTrue(auto2.reads().contains(m1));
        assertTrue(auto2.reads().contains(auto1));
        assertFalse(auto2.reads().contains(auto2));

        // m2 requires auto1
        ModuleDescriptor descriptor2 = ModuleDescriptor.newModule("m2")
                .requires("auto1")
                .build();

        Path dir2 = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir1.resolve("auto3.jar"), "p3/C.class");

        // module finder locates m2 and auto3
        ModuleFinder finder2 = ModuleFinder.compose(ModuleUtils.finderOf(descriptor2),
                                                    ModuleFinder.of(dir2));

        Configuration cf2 = resolve(cf1, finder2, "m2");
        assertTrue(cf2.modules().size() == 1);   // auto3 should not be resolved

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

        assertTrue(m2.reads().size() == 3);
        assertTrue(m2.reads().contains(base));
        assertTrue(m2.reads().contains(auto1));
        assertTrue(m2.reads().contains(auto2));
    }

    /**
     * Basic test of a configuration created with automatic modules
     *   a requires b* and c*
     *   b* contains p
     *   c* contains p
     */
    @Test
    public void testDuplicateSuppliers1() throws IOException {
        ModuleDescriptor descriptor
            = ModuleDescriptor.newModule("a")
                .requires("b")
                .requires("c")
                .build();

        // c and d are automatic modules with the same package
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("b.jar"), "p/T.class");
        createDummyJarFile(dir.resolve("c.jar"), "p/T.class");

        // module finder locates 'a' and the modules in the directory
        ModuleFinder finder
            = ModuleFinder.compose(ModuleUtils.finderOf(descriptor),
                                   ModuleFinder.of(dir));

        Configuration parent = ModuleLayer.boot().configuration();
        assertThrows(ResolutionException.class, () -> resolve(parent, finder, "a"));
    }

    /**
     * Basic test of a configuration created with automatic modules
     *   a contains p, requires b*
     *   b* contains p
     */
    @Test
    public void testDuplicateSuppliers2() throws IOException {
        ModuleDescriptor descriptor
            = ModuleDescriptor.newModule("a")
                .packages(Set.of("p"))
                .requires("b")
                .build();

        // c and d are automatic modules with the same package
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("b.jar"), "p/T.class");

        // module finder locates 'a' and the modules in the directory
        ModuleFinder finder
            = ModuleFinder.compose(ModuleUtils.finderOf(descriptor),
                                   ModuleFinder.of(dir));

        Configuration parent = ModuleLayer.boot().configuration();
        assertThrows(ResolutionException.class, () -> resolve(parent, finder, "a"));
    }

    /**
     * Basic test of layer containing automatic modules
     */
    @Test
    public void testInLayer() throws IOException {
        ModuleDescriptor descriptor
            = ModuleDescriptor.newModule("a")
                .requires("b")
                .requires("c")
                .build();

        // b and c are simple JAR files
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        createDummyJarFile(dir.resolve("b.jar"), "p/T.class");
        createDummyJarFile(dir.resolve("c.jar"), "q/T2.class");

        // module finder locates a and the modules in the directory
        ModuleFinder finder
            = ModuleFinder.compose(ModuleUtils.finderOf(descriptor),
                ModuleFinder.of(dir));

        Configuration parent = ModuleLayer.boot().configuration();
        Configuration cf = resolve(parent, finder, "a");
        assertTrue(cf.modules().size() == 3);

        // each module gets its own loader
        ModuleLayer layer = ModuleLayer.boot().defineModules(cf, mn -> new ClassLoader() { });

        // an unnamed module
        Module unnamed = (new ClassLoader() { }).getUnnamedModule();

        Module b = layer.findModule("b").get();
        assertTrue(b.isNamed());
        assertTrue(b.canRead(unnamed));
        testsReadsAll(b, layer);

        Module c = layer.findModule("c").get();
        assertTrue(c.isNamed());
        assertTrue(b.canRead(unnamed));
        testsReadsAll(c, layer);
    }

    /**
     * Test miscellaneous methods.
     */
    @Test
    public void testMisc() throws IOException {
        Path dir = Files.createTempDirectory(USER_DIR, "mods");
        Path m_jar = createDummyJarFile(dir.resolve("m.jar"), "p/T.class");

        ModuleFinder finder = ModuleFinder.of(m_jar);

        assertTrue(finder.find("m").isPresent());
        ModuleDescriptor m = finder.find("m").get().descriptor();

        // test miscellaneous methods
        assertTrue(m.isAutomatic());
        assertFalse(m.modifiers().contains(ModuleDescriptor.Modifier.SYNTHETIC));
    }

    /**
     * Invokes parent.resolve to resolve the given root modules.
     */
    static Configuration resolve(Configuration parent,
                                 ModuleFinder finder,
                                 String... roots) {
        return parent.resolve(finder, ModuleFinder.of(), Set.of(roots));
    }

    /**
     * Finds a module in the given configuration or its parents, returning
     * the module descriptor (or null if not found)
     */
    static ModuleDescriptor findDescriptor(Configuration cf, String name) {
        Optional<ResolvedModule> om = cf.findModule(name);
        if (om.isPresent()) {
            return om.get().reference().descriptor();
        } else {
            return null;
        }
    }

    /**
     * Test that a module in a configuration reads all modules in the boot
     * configuration.
     */
    static void testReadAllBootModules(Configuration cf, String mn) {
        Set<String> bootModules = ModuleLayer.boot().modules().stream()
                .map(Module::getName)
                .collect(Collectors.toSet());
        bootModules.forEach(other -> assertTrue(reads(cf, mn, other)));
    }

    /**
     * Test that the given Module reads all module in the given layer
     * and its parent layers.
     */
    static void testsReadsAll(Module m, ModuleLayer layer) {
        // check that m reads all modules in the layer
        layer.configuration().modules().stream()
            .map(ResolvedModule::name)
            .map(layer::findModule)
            .map(Optional::get)
            .forEach(other -> assertTrue(m.canRead(other)));

        // also check parent layers
        layer.parents().forEach(l -> testsReadsAll(m, l));
    }

    /**
     * Returns {@code true} if the configuration contains module mn1
     * that reads module mn2.
     */
    static boolean reads(Configuration cf, String mn1, String mn2) {
        Optional<ResolvedModule> om = cf.findModule(mn1);
        if (!om.isPresent())
            return false;

        return om.get().reads().stream()
                .map(ResolvedModule::name)
                .anyMatch(mn2::equals);
    }

    /**
     * Creates a JAR file, optionally with a manifest, and with the given
     * entries. The entries will be empty in the resulting JAR file.
     */
    static Path createDummyJarFile(Path jarfile, Manifest man, String... entries)
        throws IOException
    {
        Path dir = Files.createTempDirectory(USER_DIR, "tmp");

        for (String entry : entries) {
            Path file = dir.resolve(entry);
            Path parent = file.getParent();
            if (parent != null)
                Files.createDirectories(parent);
            Files.createFile(file);
        }

        Path[] paths = Stream.of(entries).map(Path::of).toArray(Path[]::new);
        JarUtils.createJarFile(jarfile, man, dir, paths);
        return jarfile;
    }

    /**
     * Creates a JAR file and with the given entries. The entries will be empty
     * in the resulting JAR file.
     */
    static Path createDummyJarFile(Path jarfile, String... entries)
        throws IOException
    {
        return createDummyJarFile(jarfile, null, entries);
    }
}