/**
 * Test unnamed module has no access to other proxy interface
 */
@Test
public void testNoReadAccess() throws Exception {
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    ModuleLayer bootLayer = ModuleLayer.boot();
    Configuration cf = bootLayer
            .configuration()
            .resolveAndBind(ModuleFinder.of(), finder, modules);
    ClassLoader parentLoader = this.getClass().getClassLoader();
    ModuleLayer layer = bootLayer.defineModulesWithOneLoader(cf, parentLoader);

    ClassLoader loader = layer.findLoader("m1");
    Class<?>[] interfaces = new Class<?>[] {
            Class.forName("p.one.I", false, loader),
            Class.forName("q.NP", false, loader)     // non-public interface in unnamed module
    };
    checkIAE(loader, interfaces);
}
 

/**
 * Test the scenario where a module contains a package p and reads
 * a module that also contains a package p.
 */
public void testContainsPackageInSelfAndOther() {
    ModuleDescriptor descriptor1 = newBuilder("m1")
            .requires("m2")
            .packages(Set.of("p"))
            .build();

    ModuleDescriptor descriptor2 = newBuilder("m2")
            .packages(Set.of("p"))
            .build();

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

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

    assertTrue(cf.modules().size() == 2);
    assertTrue(cf.findModule("m1").isPresent());
    assertTrue(cf.findModule("m2").isPresent());

    // m1 reads m2, m2 reads nothing
    ResolvedModule m1 = cf.findModule("m1").get();
    ResolvedModule m2 = cf.findModule("m2").get();
    assertTrue(m1.reads().size() == 1);
    assertTrue(m1.reads().contains(m2));
    assertTrue(m2.reads().size() == 0);
}
 

/**
 * Creates a pool of class loaders. Each module in the given configuration
 * is mapped to its own class loader in the pool. The class loader is
 * created with the given parent class loader as its parent.
 */
public LoaderPool(Configuration cf,
                  List<ModuleLayer> parentLayers,
                  ClassLoader parentLoader)
{
    Map<String, Loader> loaders = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        Loader loader = new Loader(resolvedModule, this, parentLoader);
        String mn = resolvedModule.name();
        loaders.put(mn, loader);
    }
    this.loaders = loaders;

    // complete the initialization
    loaders.values().forEach(l -> l.initRemotePackageMap(cf, parentLayers));
}
 

/**
 * Service provider dependency not found
 */
@Test(expectedExceptions = { FindException.class })
public void testServiceProviderDependencyNotFound() {

    // service provider dependency (on m3) not found

    ModuleDescriptor descriptor1 = newBuilder("m1")
            .exports("p")
            .uses("p.S")
            .build();

    ModuleDescriptor descriptor2 = newBuilder("m2")
            .requires("m1")
            .requires("m3")
            .provides("p.S", List.of("q.T"))
            .build();

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

    // should throw ResolutionException because m3 is not found
    Configuration cf = resolveAndBind(finder, "m1");
}
 

/**
 * Tests that the class loaders created by defineModulesWithXXX delegate
 * to the given parent class loader.
 */
public void testDelegationToParent() throws Exception {
    Configuration cf = resolve("m1");

    ClassLoader parent = this.getClass().getClassLoader();
    String cn = this.getClass().getName();

    // one loader
    ModuleLayer layer = ModuleLayer.boot().defineModulesWithOneLoader(cf, parent);
    testLoad(layer, cn);

     // one loader with boot loader as parent
    layer = ModuleLayer.boot().defineModulesWithOneLoader(cf, null);
    testLoadFail(layer, cn);

    // many loaders
    layer = ModuleLayer.boot().defineModulesWithManyLoaders(cf, parent);
    testLoad(layer, cn);

    // many loader with boot loader as parent
    layer = ModuleLayer.boot().defineModulesWithManyLoaders(cf, null);
    testLoadFail(layer, cn);
}
 

/**
  * Exercise defineModules with a configuration with a module that
  * contains a package that is the same name as a non-exported package in
  * a parent layer.
  */
 public void testContainsSamePackageAsBootLayer() {

     // check assumption that java.base contains sun.launcher
     ModuleDescriptor base = Object.class.getModule().getDescriptor();
     assertTrue(base.packages().contains("sun.launcher"));

     ModuleDescriptor descriptor = newBuilder("m1")
            .requires("java.base")
            .packages(Set.of("sun.launcher"))
            .build();

     ModuleFinder finder = ModuleUtils.finderOf(descriptor);

     Configuration parent = ModuleLayer.boot().configuration();
     Configuration cf = parent.resolve(finder, ModuleFinder.of(), Set.of("m1"));
     assertTrue(cf.modules().size() == 1);

     ClassLoader loader = new ClassLoader() { };
     ModuleLayer layer = ModuleLayer.boot().defineModules(cf, mn -> loader);
     assertTrue(layer.modules().size() == 1);
}
 

/**
 * Basic test to detect reading a module with the same name as itself
 *
 * The test consists of three configurations:
 * - Configuration cf1: m1, m2 requires transitive m1
 * - Configuration cf2: m1 requires m2
 */
@Test(expectedExceptions = { ResolutionException.class })
public void testReadModuleWithSameNameAsSelf() {
    ModuleDescriptor descriptor1_v1 = newBuilder("m1")
            .build();

    ModuleDescriptor descriptor2 = newBuilder("m2")
            .requires(Set.of(Requires.Modifier.TRANSITIVE), "m1")
            .build();

    ModuleDescriptor descriptor1_v2 = newBuilder("m1")
            .requires("m2")
            .build();

    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1_v1, descriptor2);
    Configuration cf1 = resolve(finder1, "m2");
    assertTrue(cf1.modules().size() == 2);

    // resolve should throw ResolutionException
    ModuleFinder finder2 = ModuleUtils.finderOf(descriptor1_v2);
    resolve(cf1, finder2, "m1");
}
 

/**
 * Checks incubating status of modules in the configuration
 */
private static void checkIncubatingStatus(Configuration cf) {
    String incubating = null;
    for (ResolvedModule resolvedModule : cf.modules()) {
        ModuleReference mref = resolvedModule.reference();

        // emit warning if the WARN_INCUBATING module resolution bit set
        if (ModuleResolution.hasIncubatingWarning(mref)) {
            String mn = mref.descriptor().name();
            if (incubating == null) {
                incubating = mn;
            } else {
                incubating += ", " + mn;
            }
        }
    }
    if (incubating != null)
        warn("Using incubator modules: " + incubating);
}
 

/**
 * Test proxy implementing interfaces that the target module has no access
 */
@Test
public void testNoReadAccess() throws Exception {
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    ModuleLayer bootLayer = ModuleLayer.boot();
    Configuration cf = bootLayer
            .configuration()
            .resolveAndBind(ModuleFinder.of(), finder, Arrays.asList(modules));
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    ModuleLayer layer = bootLayer.defineModulesWithOneLoader(cf, scl);

    ClassLoader loader = layer.findLoader("m1");

    assertTrue(layer.findModule("m1").isPresent());
    assertTrue(layer.findModule("m2").isPresent());
    assertTrue(layer.findModule("m3").isPresent());

    Class<?>[] interfaces = new Class<?>[] {
            Class.forName("p.one.I", false, loader),
            Class.forName("p.two.B", false, loader)   // non-public interface but exported package
    };
    checkIAE(loader, interfaces);
}
 

/**
 * Creates a pool of class loaders. Each module in the given configuration
 * will be loaded its own class loader in the pool. The class loader is
 * created with the given parent class loader as its parent.
 */
public LoaderPool(Configuration cf,
                  List<ModuleLayer> parentLayers,
                  ClassLoader parentLoader)
{
    Map<String, Loader> loaders = new HashMap<>();
    for (ResolvedModule resolvedModule : cf.modules()) {
        Loader loader = new Loader(resolvedModule, this, parentLoader);
        String mn = resolvedModule.name();
        loaders.put(mn, loader);
    }
    this.loaders = loaders;

    // complete the initialization
    loaders.values().forEach(l -> l.initRemotePackageMap(cf, parentLayers));
}
 

/**
 * Generate dotfile of the given path
 */
public void genDotFile(Path path, String name,
                       Configuration configuration,
                       Attributes attributes)
    throws IOException
{
    // transitive reduction
    Graph<String> graph = apiOnly
            ? requiresTransitiveGraph(configuration, Set.of(name))
            : gengraph(configuration);

    DotGraphBuilder builder = new DotGraphBuilder(name, graph, attributes);
    builder.subgraph("se", "java", attributes.javaSubgraphColor(),
                     DotGraphBuilder.JAVA_SE_SUBGRAPH)
           .subgraph("jdk", "jdk", attributes.jdkSubgraphColor(),
                     DotGraphBuilder.JDK_SUBGRAPH)
           .modules(graph.nodes().stream()
                             .map(mn -> configuration.findModule(mn).get()
                                            .reference().descriptor()));
    // build dot file
    builder.build(path);
}
 

/**
 * Basic test of a configuration created with automatic modules
 *   a requires b* and c*
 *   b* contains p
 *   c* contains p
 */
@Test(expectedExceptions = { ResolutionException.class })
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();
    resolve(parent, finder, "a");
}
 

static ModuleLayer createPluginsLayer(List<Path> paths) {

        Path[] dirs = paths.toArray(new Path[0]);
        ModuleFinder finder = ModulePath.of(Runtime.version(), true, dirs);
        Configuration bootConfiguration = ModuleLayer.boot().configuration();
        try {
            Configuration cf = bootConfiguration
                .resolveAndBind(ModuleFinder.of(),
                                finder,
                                Collections.emptySet());
            ClassLoader scl = ClassLoader.getSystemClassLoader();
            return ModuleLayer.boot().defineModulesWithOneLoader(cf, scl);
        } catch (Exception ex) {
            // Malformed plugin modules (e.g.: same package in multiple modules).
            throw new PluginException("Invalid modules in the plugins path: " + ex);
        }
    }
 

/**
 * Basic test of ModuleLayer.defineModulesWithManyLoaders where one of the
 * modules is a service provider module.
 *
 * Test scenario:
 *    m1 requires m2 and m3
 *    m1 uses S
 *    m4 provides S with ...
 */
public void testServicesWithManyLoaders() throws Exception {
    Configuration cf = resolveAndBind("m1");

    ClassLoader scl = ClassLoader.getSystemClassLoader();

    ModuleLayer layer = ModuleLayer.boot().defineModulesWithManyLoaders(cf, scl);

    checkLayer(layer, "m1", "m2", "m3", "m4");

    ClassLoader cl1 = layer.findLoader("m1");
    ClassLoader cl2 = layer.findLoader("m2");
    ClassLoader cl3 = layer.findLoader("m3");
    ClassLoader cl4 = layer.findLoader("m4");

    assertTrue(cl1.getParent() == scl);
    assertTrue(cl2.getParent() == scl);
    assertTrue(cl3.getParent() == scl);
    assertTrue(cl4.getParent() == scl);
    assertTrue(cl2 != cl1);
    assertTrue(cl3 != cl1);
    assertTrue(cl3 != cl2);
    assertTrue(cl4 != cl1);
    assertTrue(cl4 != cl2);
    assertTrue(cl4 != cl3);

    Class<?> serviceType = cl1.loadClass("p.Service");
    assertTrue(serviceType.getClassLoader() == cl1);

    // Test that the service provider can be located via any of
    // the class loaders in the layer
    for (Module m : layer.modules()) {
        ClassLoader loader = m.getClassLoader();
        Iterator<?> iter = ServiceLoader.load(serviceType, loader).iterator();
        Object provider = iter.next();
        assertTrue(serviceType.isInstance(provider));
        assertTrue(provider.getClass().getClassLoader() == cl4);
        assertFalse(iter.hasNext());
    }
}
 

/**
 * Returns true if target is an upgradeable module but not required
 * by the source module directly and indirectly.
 */
private static boolean accept(ModuleDescriptor source, String target) {
    if (HashedModules.contains(target))
        return false;

    if (!ModuleFinder.ofSystem().find(target).isPresent())
        return false;

    Configuration cf = Configuration.empty().resolve(ModuleFinder.of(),
                                                     ModuleFinder.ofSystem(),
                                                     Set.of(source.name()));
    return !cf.findModule(target).isPresent();
}
 

private static ClassLoader createModuleLoader(final ClassLoader cl,
        final String modulePath, final String addModules) {
    if (addModules == null) {
        throw new IllegalArgumentException("--module-path specified with no --add-modules");
    }

    final Path[] paths = Stream.of(modulePath.split(File.pathSeparator)).
        map(s -> Paths.get(s)).
        toArray(sz -> new Path[sz]);
    final ModuleFinder mf = ModuleFinder.of(paths);
    final Set<ModuleReference> mrefs = mf.findAll();
    if (mrefs.isEmpty()) {
        throw new RuntimeException("No modules in script --module-path: " + modulePath);
    }

    final Set<String> rootMods;
    if (addModules.equals("ALL-MODULE-PATH")) {
        rootMods = mrefs.stream().
            map(mr->mr.descriptor().name()).
            collect(Collectors.toSet());
    } else {
        rootMods = Stream.of(addModules.split(",")).
            map(String::trim).
            collect(Collectors.toSet());
    }

    final ModuleLayer boot = ModuleLayer.boot();
    final Configuration conf = boot.configuration().
        resolve(mf, ModuleFinder.of(), rootMods);
    final String firstMod = rootMods.iterator().next();
    return boot.defineModulesWithOneLoader(conf, cl).findLoader(firstMod);
}
 

/**
 * Basic test of ModuleLayer.defineModulesWithOneLoader where one of the
 * modules is a service provider module.
 *
 * Test scenario:
 *    m1 requires m2 and m3
 *    m1 uses S
 *    m4 provides S with ...
 */
public void testServicesWithOneLoader() throws Exception {
    Configuration cf = resolveAndBind("m1");

    ClassLoader scl = ClassLoader.getSystemClassLoader();

    ModuleLayer layer = ModuleLayer.boot().defineModulesWithOneLoader(cf, scl);

    checkLayer(layer, "m1", "m2", "m3", "m4");

    ClassLoader cl1 = layer.findLoader("m1");
    ClassLoader cl2 = layer.findLoader("m2");
    ClassLoader cl3 = layer.findLoader("m3");
    ClassLoader cl4 = layer.findLoader("m4");

    assertTrue(cl1.getParent() == scl);
    assertTrue(cl2 == cl1);
    assertTrue(cl3 == cl1);
    assertTrue(cl4 == cl1);

    Class<?> serviceType = cl1.loadClass("p.Service");
    assertTrue(serviceType.getClassLoader() == cl1);

    Iterator<?> iter = ServiceLoader.load(serviceType, cl1).iterator();
    Object provider = iter.next();
    assertTrue(serviceType.isInstance(provider));
    assertTrue(provider.getClass().getClassLoader() == cl1);
    assertFalse(iter.hasNext());
}
 

/**
 * Attempt to create a layer with a module defined to the platform loader
 */
@Test(expectedExceptions = { LayerInstantiationException.class })
public void testLayerWithPlatformLoader() {
    ModuleDescriptor descriptor = newBuilder("m1").build();

    ModuleFinder finder = ModuleUtils.finderOf(descriptor);

    Configuration cf = ModuleLayer.boot()
            .configuration()
            .resolve(finder, ModuleFinder.of(), Set.of("m1"));
    assertTrue(cf.modules().size() == 1);

    ClassLoader cl = ClassLoader.getPlatformClassLoader();
    ModuleLayer.boot().defineModules(cf, mn -> cl );
}
 

/**
 * Constructs a Hasher to compute hashes.
 *
 * If a module name `M` is specified, it will compute the hashes of
 * modules that depend upon M directly or indirectly matching the
 * specified --hash-modules pattern and record in the ModuleHashes
 * attribute in M's module-info.class.
 *
 * @param name    name of the module to record hashes
 * @param finder  module finder for the specified --module-path
 */
Hasher(String name, ModuleFinder finder) {
    // Determine the modules that matches the pattern {@code modulesToHash}
    Set<String> roots = finder.findAll().stream()
        .map(mref -> mref.descriptor().name())
        .filter(mn -> options.modulesToHash.matcher(mn).find())
        .collect(Collectors.toSet());

    // use system module path unless it creates a JMOD file for
    // a module that is present in the system image e.g. upgradeable
    // module
    ModuleFinder system;
    if (name != null && ModuleFinder.ofSystem().find(name).isPresent()) {
        system = ModuleFinder.of();
    } else {
        system = ModuleFinder.ofSystem();
    }
    // get a resolved module graph
    Configuration config = null;
    try {
        config = Configuration.empty().resolve(system, finder, roots);
    } catch (FindException | ResolutionException e) {
        throw new CommandException("err.module.resolution.fail", e.getMessage());
    }

    this.moduleName = name;
    this.configuration = config;

    // filter modules resolved from the system module finder
    this.modules = config.modules().stream()
        .map(ResolvedModule::name)
        .filter(mn -> roots.contains(mn) && !system.find(mn).isPresent())
        .collect(Collectors.toSet());

    this.hashesBuilder = new ModuleHashesBuilder(config, modules);
}
 

/**
 * Test "provides p.S" where p is contained in the same module.
 */
public void testContainsService3() {
    ModuleDescriptor descriptor1 = newBuilder("m1")
            .packages(Set.of("p", "q"))
            .provides("p.S", List.of("q.S1"))
            .build();

    ModuleFinder finder = ModuleUtils.finderOf(descriptor1);

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

    assertTrue(cf.modules().size() == 1);
    assertTrue(cf.findModule("m1").isPresent());
}
 

/**
 * Returns the location of the module if this named package is in
 * a named module; otherwise, returns null.
 */
URI location() {
    if (module.isNamed() && module.getLayer() != null) {
        Configuration cf = module.getLayer().configuration();
        ModuleReference mref
            = cf.findModule(module.getName()).get().reference();
        return mref.location().orElse(null);
    }
    return null;
}
 

/**
 * Basic test with two module finders.
 *
 * Module m2 can be found by both the before and after finders.
 */
public void testWithTwoFinders1() {

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

    ModuleDescriptor descriptor2_v1 = newBuilder("m2")
            .version("1.0")
            .build();

    ModuleDescriptor descriptor2_v2 = newBuilder("m2")
            .version("2.0")
            .build();

    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor2_v1);
    ModuleFinder finder2 = ModuleUtils.finderOf(descriptor1, descriptor2_v2);

    Configuration cf = resolve(finder1, finder2, "m1");

    assertTrue(cf.modules().size() == 2);
    assertTrue(cf.findModule("m1").isPresent());
    assertTrue(cf.findModule("m2").isPresent());

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

    assertEquals(m1.reference().descriptor(), descriptor1);
    assertEquals(m2.reference().descriptor(), descriptor2_v1);
}
 

private ArchivedModuleGraph(String mainModule,
                            boolean hasSplitPackages,
                            boolean hasIncubatorModules,
                            ModuleFinder finder,
                            Configuration configuration,
                            Map<String, Set<String>> concealedPackagesToOpen,
                            Map<String, Set<String>> exportedPackagesToOpen) {
    this.mainModule = mainModule;
    this.hasSplitPackages = hasSplitPackages;
    this.hasIncubatorModules = hasIncubatorModules;
    this.finder = finder;
    this.configuration = configuration;
    this.concealedPackagesToOpen = concealedPackagesToOpen;
    this.exportedPackagesToOpen = exportedPackagesToOpen;
}
 

/**
 * Returns a {@link Configuration} of the given module path,
 * root modules with no service binding.
 */
public Configuration resolve()
{
    return Configuration.empty().resolve(finder,
                                         ModuleFinder.of(),
                                         modules);
}
 

/**
 * Basic test of ServiceLoader.load where the service provider module is an
 * automatic module.
 */
@Test
public void testWithAutomaticModule() throws Exception {
    Path classes = Paths.get(System.getProperty("test.classes"));
    Path jar = Files.createTempDirectory("lib").resolve("pearscript.jar");
    JarUtils.createJarFile(jar, classes, "META-INF", "org");

    ModuleFinder finder = ModuleFinder.of(jar);
    ModuleLayer bootLayer = ModuleLayer.boot();
    Configuration parent = bootLayer.configuration();
    Configuration cf = parent.resolveAndBind(finder, ModuleFinder.of(), Set.of());
    assertTrue(cf.modules().size() == 1);

    ClassLoader scl = ClassLoader.getSystemClassLoader();
    ModuleLayer layer = bootLayer.defineModulesWithOneLoader(cf, scl);
    assertTrue(layer.modules().size() == 1);

    ClassLoader loader = layer.findLoader("pearscript");
    ScriptEngineFactory factory;

    // load using the class loader as context
    factory = ServiceLoader.load(ScriptEngineFactory.class, loader)
            .findFirst()
            .orElse(null);
    assertNotNull(factory);
    assertTrue(factory.getClass().getClassLoader() == loader);

    // load using the layer as context
    factory = ServiceLoader.load(layer, ScriptEngineFactory.class)
            .findFirst()
            .orElse(null);
    assertNotNull(factory);
    assertTrue(factory.getClass().getClassLoader() == loader);
}
 

/**
 * Basic test of "requires static":
 * - Configuration cf1: m2 requires transitive static m1
 * - Configuration cf2: m3 requires m2
 */
public void testRequiresStatic8() {
    ModuleDescriptor descriptor1 = null;  // not observable

    ModuleDescriptor descriptor2 = newBuilder("m2")
            .requires(Set.of(Requires.Modifier.TRANSITIVE,
                            Requires.Modifier.STATIC),
                    "m1")
            .build();

    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor2);

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

    assertTrue(cf1.modules().size() == 1);
    assertTrue(cf1.findModule("m2").isPresent());
    ResolvedModule m2 = cf1.findModule("m2").get();
    assertTrue(m2.reads().isEmpty());

    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("m3").isPresent());
    ResolvedModule m3 = cf2.findModule("m3").get();
    assertTrue(m3.reads().size() == 1);
    assertTrue(m3.reads().contains(m2));
}
 

/**
 * Basic test of binding services with configurations.
 *
 * The test consists of two configurations:
 * - Configuration cf1: m1 uses p.S
 * - Configuration cf2: m2 provides p.S
 */
public void testServiceBindingWithConfigurations1() {

    ModuleDescriptor descriptor1 = newBuilder("m1")
            .exports("p")
            .uses("p.S")
            .build();

    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);

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

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

    ModuleDescriptor descriptor2 = newBuilder("m2")
            .requires("m1")
            .provides("p.S", List.of("q.T"))
            .build();

    ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);

    Configuration cf2 = resolveAndBind(cf1, finder2); // no roots

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

    assertTrue(cf2.modules().size() == 1);
    assertTrue(cf2.findModule("m2").isPresent());

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

    assertTrue(m2.reads().size() == 1);
    assertTrue(m2.reads().contains(m1));
}
 

/**
 * Test layers with a qualified export. The module exporting the package
 * does not read the target module in the parent layer.
 *
 * - Configuration/layer1: m1 { }
 * - Configuration/layer2: m2 { exports p to m1; }
 */
public void testQualifiedExports3() {
    // create layer1 with m1
    ModuleDescriptor descriptor1 = newBuilder("m1").build();
    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
    Configuration cf1 = resolve(finder1, "m1");
    ClassLoader cl1 = new ClassLoader() { };
    ModuleLayer layer1 = ModuleLayer.empty().defineModules(cf1, mn -> cl1);
    assertTrue(layer1.modules().size() == 1);

    // create layer2 with m2
    ModuleDescriptor descriptor2 = newBuilder("m2")
            .exports("p", Set.of("m1"))
            .build();
    ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);
    Configuration cf2 = resolve(cf1, finder2, "m2");
    ClassLoader cl2 = new ClassLoader() { };
    ModuleLayer layer2 = layer1.defineModules(cf2, mn -> cl2);
    assertTrue(layer2.modules().size() == 1);

    Module m1 = layer1.findModule("m1").get();
    Module m2 = layer2.findModule("m2").get();

    // check m2 exports p to layer1/m1
    assertFalse(m2.isExported("p"));
    assertTrue(m2.isExported("p", m1));
    assertFalse(m2.isOpen("p", m1));
}
 

/**
 * Basic test of using the beforeFinder to override a module in a parent
 * configuration.
 */
public void testOverriding1() {
    ModuleDescriptor descriptor1 = newBuilder("m1").build();

    ModuleFinder finder = ModuleUtils.finderOf(descriptor1);

    Configuration cf1 = resolve(finder, "m1");
    assertTrue(cf1.modules().size() == 1);
    assertTrue(cf1.findModule("m1").isPresent());

    Configuration cf2 = resolve(cf1, finder, "m1");
    assertTrue(cf2.modules().size() == 1);
    assertTrue(cf2.findModule("m1").isPresent());
}
 

/**
 * Exercise ModuleLayer.boot()
 */
public void testBoot() {
    ModuleLayer bootLayer = ModuleLayer.boot();

    // configuration
    Configuration cf = bootLayer.configuration();
    assertTrue(cf.findModule("java.base").get()
            .reference()
            .descriptor()
            .exports()
            .stream().anyMatch(e -> (e.source().equals("java.lang")
                                     && !e.isQualified())));

    // modules
    Set<Module> modules = bootLayer.modules();
    assertTrue(modules.contains(Object.class.getModule()));
    int count = (int) modules.stream().map(Module::getName).count();
    assertEquals(count, modules.size()); // module names are unique

    // findModule
    Module base = Object.class.getModule();
    assertTrue(bootLayer.findModule("java.base").get() == base);
    assertTrue(base.getLayer() == bootLayer);

    // findLoader
    assertTrue(bootLayer.findLoader("java.base") == null);

    // parents
    assertTrue(bootLayer.parents().size() == 1);
    assertTrue(bootLayer.parents().get(0) == ModuleLayer.empty());
}