java.lang.reflect.Layer

Here are the examples of the java api class java.lang.reflect.Layer taken from open source projects.

1. ProxyLayerTest#testNoReadAccess()

Project: openjdk
File: ProxyLayerTest.java
/**
     * Test proxy implementing interfaces that the target module has no access
     */
@Test
public void testNoReadAccess() throws Exception {
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    Layer bootLayer = Layer.boot();
    Configuration cf = bootLayer.configuration().resolveRequiresAndUses(ModuleFinder.of(), finder, Arrays.asList(modules));
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer 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), // non-public interface but exported package
    Class.forName("p.two.B", false, loader) };
    checkIAE(loader, interfaces);
}

2. ProxyClassAccessTest#testNoReadAccess()

Project: openjdk
File: ProxyClassAccessTest.java
/**
     * Test unnamed module has no access to other proxy interface
     */
@Test
public void testNoReadAccess() throws Exception {
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    Layer bootLayer = Layer.boot();
    Configuration cf = bootLayer.configuration().resolveRequiresAndUses(ModuleFinder.of(), finder, modules);
    ClassLoader parentLoader = this.getClass().getClassLoader();
    Layer layer = bootLayer.defineModulesWithOneLoader(cf, parentLoader);
    ClassLoader loader = layer.findLoader("m1");
    Class<?>[] interfaces = new Class<?>[] { Class.forName("p.one.I", false, loader), // non-public interface in unnamed module
    Class.forName("q.NP", false, loader) };
    checkIAE(loader, interfaces);
}

3. VerifyLintDescriptions#main()

Project: openjdk
File: VerifyLintDescriptions.java
public static void main(String... args) {
    Layer boot = Layer.boot();
    Module jdk_compiler = boot.findModule("jdk.compiler").get();
    ResourceBundle b = ResourceBundle.getBundle("com.sun.tools.javac.resources.javac", Locale.US, jdk_compiler);
    List<String> missing = new ArrayList<>();
    for (LintCategory lc : LintCategory.values()) {
        try {
            b.getString(PrefixKind.JAVAC.key("opt.Xlint.desc." + lc.option));
        } catch (MissingResourceException ex) {
            missing.add(lc.option);
        }
    }
    if (!missing.isEmpty()) {
        throw new UnsupportedOperationException("Lints that are missing description: " + missing);
    }
}

4. Main#main()

Project: openjdk
File: Main.java
public static void main(String[] args) throws Exception {
    Module httpModule = HttpServer.class.getModule();
    // automatic modules are named
    assertTrue(httpModule.isNamed());
    // and read all unnamed modules
    ClassLoader cl;
    cl = ClassLoader.getPlatformClassLoader();
    assertTrue(httpModule.canRead(cl.getUnnamedModule()));
    cl = ClassLoader.getSystemClassLoader();
    assertTrue(httpModule.canRead(cl.getUnnamedModule()));
    // and read all modules in the boot Layer
    Layer layer = Layer.boot();
    layer.modules().forEach( m -> assertTrue(httpModule.canRead(m)));
    // run code in the automatic modue, ensures access is allowed
    HttpServer http = HttpServer.create(80);
    http.start();
}

5. VerifyModuleDelegation#checkLoaderDelegation()

Project: openjdk
File: VerifyModuleDelegation.java
@Test
public void checkLoaderDelegation() {
    Layer boot = Layer.boot();
    MREFS.stream().map(ModuleReference::descriptor).forEach( md -> md.requires().stream().forEach( req -> {
        ClassLoader loader1 = boot.findLoader(md.name());
        ClassLoader loader2 = boot.findLoader(req.name());
        if (loader1 != loader2 && !isAncestor(loader2, loader1)) {
            throw new Error(md.name() + " can't delegate to " + "find classes from " + req.name());
        }
    }));
}

6. LayerAndLoadersTest#testOverlappingPackages()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Test defineModulesWithXXX when modules that have overlapping packages.
     *
     * Test scenario:
     *   m1 exports p
     *   m2 exports p
     */
public void testOverlappingPackages() {
    ModuleDescriptor descriptor1 = new ModuleDescriptor.Builder("m1").exports("p").build();
    ModuleDescriptor descriptor2 = new ModuleDescriptor.Builder("m2").exports("p").build();
    ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1", "m2"));
    // cannot define both module m1 and m2 to the same class loader
    try {
        Layer.boot().defineModulesWithOneLoader(cf, null);
        assertTrue(false);
    } catch (LayerInstantiationException expected) {
    }
    // should be okay to have one module per class loader
    Layer layer = Layer.boot().defineModulesWithManyLoaders(cf, null);
    checkLayer(layer, "m1", "m2");
}

7. LayerAndLoadersTest#testDelegationToParent()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Tests that the class loaders created by defineModulesWithXXX delegate
     * to the given parent class loader.
     */
public void testDelegationToParent() throws Exception {
    Configuration cf = resolveRequires("m1");
    ClassLoader parent = this.getClass().getClassLoader();
    String cn = this.getClass().getName();
    // one loader
    Layer layer = Layer.boot().defineModulesWithOneLoader(cf, parent);
    testLoad(layer, cn);
    // one loader with boot loader as parent
    layer = Layer.boot().defineModulesWithOneLoader(cf, null);
    testLoadFail(layer, cn);
    // many loaders
    layer = Layer.boot().defineModulesWithManyLoaders(cf, parent);
    testLoad(layer, cn);
    // many loader with boot loader as parent
    layer = Layer.boot().defineModulesWithManyLoaders(cf, null);
    testLoadFail(layer, cn);
}

8. LayerAndLoadersTest#testWithManyLoaders()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Basic test of Layer defineModulesWithManyLoaders
     *
     * Test scenario:
     *   m1 requires m2 and m3
     */
public void testWithManyLoaders() throws Exception {
    Configuration cf = resolveRequires("m1");
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer = Layer.boot().defineModulesWithManyLoaders(cf, scl);
    checkLayer(layer, "m1", "m2", "m3");
    ClassLoader cl1 = layer.findLoader("m1");
    ClassLoader cl2 = layer.findLoader("m2");
    ClassLoader cl3 = layer.findLoader("m3");
    assertTrue(cl1.getParent() == scl);
    assertTrue(cl2.getParent() == scl);
    assertTrue(cl3.getParent() == scl);
    assertTrue(cl2 != cl1);
    assertTrue(cl3 != cl1);
    assertTrue(cl3 != cl2);
    invoke(layer, "m1", "p.Main");
}

9. LayerAndLoadersTest#testWithOneLoader()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Basic test of Layer defineModulesWithOneLoader
     *
     * Test scenario:
     *   m1 requires m2 and m3
     */
public void testWithOneLoader() throws Exception {
    Configuration cf = resolveRequires("m1");
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer = Layer.boot().defineModulesWithOneLoader(cf, scl);
    checkLayer(layer, "m1", "m2", "m3");
    ClassLoader cl1 = layer.findLoader("m1");
    ClassLoader cl2 = layer.findLoader("m2");
    ClassLoader cl3 = layer.findLoader("m3");
    assertTrue(cl1.getParent() == scl);
    assertTrue(cl2 == cl1);
    assertTrue(cl3 == cl1);
    invoke(layer, "m1", "p.Main");
}

10. BasicLayerTest#testConcealSamePackageAsBootLayer()

Project: openjdk
File: BasicLayerTest.java
/**
     * Exercise Layer defineModules with a configuration that contains a module
     * that has a concealed package that is the same name as a non-exported
     * package in a parent layer.
     */
public void testConcealSamePackageAsBootLayer() {
    // check assumption that java.base contains sun.launcher
    ModuleDescriptor base = Object.class.getModule().getDescriptor();
    assertTrue(base.conceals().contains("sun.launcher"));
    ModuleDescriptor descriptor = new ModuleDescriptor.Builder("m1").requires("java.base").conceals("sun.launcher").build();
    ModuleFinder finder = ModuleUtils.finderOf(descriptor);
    Configuration parent = Layer.boot().configuration();
    Configuration cf = parent.resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    assertTrue(cf.modules().size() == 1);
    ClassLoader loader = new ClassLoader() {
    };
    Layer layer = Layer.boot().defineModules(cf,  mn -> loader);
    assertTrue(layer.modules().size() == 1);
}

11. BasicLayerTest#testEmpty()

Project: openjdk
File: BasicLayerTest.java
/**
     * Exercise Layer.empty()
     */
public void testEmpty() {
    Layer emptyLayer = Layer.empty();
    assertFalse(emptyLayer.parent().isPresent());
    assertTrue(emptyLayer.configuration() == Configuration.empty());
    assertTrue(emptyLayer.modules().isEmpty());
    assertFalse(emptyLayer.findModule("java.base").isPresent());
    try {
        emptyLayer.findLoader("java.base");
        assertTrue(false);
    } catch (IllegalArgumentException expected) {
    }
}

12. TestMain#main()

Project: openjdk
File: TestMain.java
public static void main(String[] args) throws Exception {
    Layer boot = Layer.boot();
    Module m1 = boot.findModule("m1").get();
    Module m2 = boot.findModule("m2").get();
    // find exported and non-exported class from a named module
    findClass(m1, "p1.A");
    findClass(m1, "p1.internal.B");
    findClass(m2, "p2.C");
    // find class from unnamed module
    ClassLoader loader = TestMain.class.getClassLoader();
    findClass(loader.getUnnamedModule(), "TestDriver");
    // check if clinit should not be initialized
    // compile without module-path; so use reflection
    Class<?> c = Class.forName(m1, "p1.Initializer");
    Method m = c.getMethod("isInited");
    Boolean isClinited = (Boolean) m.invoke(null);
    if (isClinited.booleanValue()) {
        throw new RuntimeException("clinit should not be invoked");
    }
}

13. Main#main()

Project: openjdk
File: Main.java
public static void main(String... args) throws Exception {
    Layer boot = Layer.boot();
    Module m1 = boot.findModule("m1").get();
    Module m2 = Main.class.getModule();
    // find exported and non-exported class from a named module
    findClass(m1, "p1.A");
    findClass(m1, "p1.internal.B");
    findClass(m2, "p2.C");
    // find class from unnamed module
    ClassLoader loader = m2.getClassLoader();
    findClass(loader.getUnnamedModule(), "TestDriver");
    try {
        Class<?> c = findClass(m1, "p1.internal.B");
        c.newInstance();
        throw new RuntimeException(c.getName() + " is not exported to m2");
    } catch (IllegalAccessException e) {
    }
}

14. LayerModularXMLParserTest#testOneLayer()

Project: openjdk
File: LayerModularXMLParserTest.java
/*
     * layer 1 is created on top of boot layer, layer1 includes module provider1.
     *
     * Instantiate each XML service, verify the services provided by provider1
     * are loaded from layer 1, the other services are loaded from boot layer
     */
public void testOneLayer() throws Exception {
    ModuleFinder finder1 = ModuleFinder.of(MOD_DIR1);
    Configuration cf1 = Layer.boot().configuration().resolveRequiresAndUses(finder1, ModuleFinder.of(), Set.of("test"));
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer1 = Layer.boot().defineModulesWithManyLoaders(cf1, scl);
    ClassLoader cl1 = layer1.findLoader("test");
    Method m = cl1.loadClass("test.XMLFactoryHelper").getMethod("instantiateXMLService", String.class);
    for (String service : services1) {
        Object o = m.invoke(null, service);
        Layer providerLayer = o.getClass().getModule().getLayer();
        assertSame(providerLayer, layer1);
    }
    for (String service : services2) {
        Object o = m.invoke(null, service);
        Layer providerLayer = o.getClass().getModule().getLayer();
        assertSame(providerLayer, Layer.boot());
    }
}

15. BasicLayerTest#testImpliedReadabilityWithLayers3()

Project: openjdk
File: BasicLayerTest.java
/**
     * Test layers with implied readability.
     *
     * The test consists of three configurations:
     * - Configuration/layer1: m1
     * - Configuration/layer2: m2 requires public m1
     * - Configuration/layer3: m3 requires m1
     */
public void testImpliedReadabilityWithLayers3() {
    // cf1: m1
    ModuleDescriptor descriptor1 = new ModuleDescriptor.Builder("m1").build();
    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
    Configuration cf1 = resolveRequires(finder1, "m1");
    ClassLoader cl1 = new ClassLoader() {
    };
    Layer layer1 = Layer.empty().defineModules(cf1,  mn -> cl1);
    // cf2: m2 requires public m1
    ModuleDescriptor descriptor2 = new ModuleDescriptor.Builder("m2").requires(ModuleDescriptor.Requires.Modifier.PUBLIC, "m1").build();
    ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2);
    Configuration cf2 = resolveRequires(cf1, finder2, "m2");
    ClassLoader cl2 = new ClassLoader() {
    };
    Layer layer2 = layer1.defineModules(cf2,  mn -> cl2);
    // cf3: m3 requires m2
    ModuleDescriptor descriptor3 = new ModuleDescriptor.Builder("m3").requires("m2").build();
    ModuleFinder finder3 = ModuleUtils.finderOf(descriptor3);
    Configuration cf3 = resolveRequires(cf2, finder3, "m3");
    ClassLoader cl3 = new ClassLoader() {
    };
    Layer layer3 = layer2.defineModules(cf3,  mn -> cl3);
    assertTrue(layer1.parent().get() == Layer.empty());
    assertTrue(layer2.parent().get() == layer1);
    assertTrue(layer3.parent().get() == layer2);
    Module m1 = layer3.findModule("m1").get();
    Module m2 = layer3.findModule("m2").get();
    Module m3 = layer3.findModule("m3").get();
    assertTrue(m1.getLayer() == layer1);
    assertTrue(m2.getLayer() == layer2);
    assertTrue(m3.getLayer() == layer3);
    assertTrue(m1.canRead(m1));
    assertFalse(m1.canRead(m2));
    assertFalse(m1.canRead(m3));
    assertTrue(m2.canRead(m1));
    assertTrue(m2.canRead(m2));
    assertFalse(m2.canRead(m3));
    assertTrue(m3.canRead(m1));
    assertTrue(m3.canRead(m2));
    assertTrue(m3.canRead(m3));
}

16. ServicesTest#testWithCustomLayer()

Project: openjdk
File: ServicesTest.java
/**
     * Exercise ServiceLoader.load(Layer, Class).
     */
public void testWithCustomLayer() throws Exception {
    ServiceLoader<ScriptEngineFactory> sl;
    // BananaScriptEngine should not be in the boot Layer
    sl = ServiceLoader.load(Layer.boot(), ScriptEngineFactory.class);
    assertTrue(find("BananaScriptEngine", sl) == null);
    // create a custom Layer
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    Layer bootLayer = Layer.boot();
    Configuration parent = bootLayer.configuration();
    Configuration cf = parent.resolveRequiresAndUses(finder, ModuleFinder.of(), Set.of());
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer = bootLayer.defineModulesWithOneLoader(cf, scl);
    assertTrue(layer.findModule("bananascript").isPresent());
    ClassLoader loader = layer.findLoader("bananascript");
    sl = ServiceLoader.load(layer, ScriptEngineFactory.class);
    ScriptEngineFactory factory = find("BananaScriptEngine", sl);
    assertTrue(factory != null);
    assertEquals(factory.getClass().getModule().getName(), "bananascript");
    assertTrue(factory.getClass().getClassLoader() == loader);
}

17. ProxyLayerTest#testProxyInDynamicModule()

Project: openjdk
File: ProxyLayerTest.java
/**
     * Test proxy implementing interfaces in a Layer and defined in a
     * dynamic module
     */
@Test
public void testProxyInDynamicModule() throws Exception {
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    Layer bootLayer = Layer.boot();
    Configuration cf = bootLayer.configuration().resolveRequiresAndUses(ModuleFinder.of(), finder, Arrays.asList(modules));
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer 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.internal.J", false, loader) };
    Object o = Proxy.newProxyInstance(loader, interfaces, handler);
    Class<?> proxyClass = o.getClass();
    Package pkg = proxyClass.getPackage();
    assertTrue(proxyClass.getModule().isNamed());
    assertTrue(pkg.isSealed());
    assertEquals(proxyClass.getModule().getLayer(), null);
}

18. ProxyLayerTest#testProxyInUnnamed()

Project: openjdk
File: ProxyLayerTest.java
/**
     * Test proxy implementing interfaces in a Layer defined in
     * an unnamed module
     */
@Test
public void testProxyInUnnamed() throws Exception {
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    Layer bootLayer = Layer.boot();
    Configuration cf = bootLayer.configuration().resolveRequiresAndUses(ModuleFinder.of(), finder, Arrays.asList(modules));
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer 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.A", false, loader), Class.forName("p.three.P", false, loader) };
    Object o = Proxy.newProxyInstance(loader, interfaces, handler);
    Class<?> proxyClass = o.getClass();
    Package pkg = proxyClass.getPackage();
    assertFalse(proxyClass.getModule().isNamed());
    assertFalse(pkg.isSealed());
    assertEquals(proxyClass.getModule().getLayer(), null);
}

19. WithSecurityManager#loadModuleInChildLayer()

Project: openjdk
File: WithSecurityManager.java
/**
     * Create a module layer that contains the given system module.
     */
static Module loadModuleInChildLayer(String mn) {
    Optional<ModuleReference> omref = ModuleFinder.ofSystem().find(mn);
    assertTrue("module " + mn + " not a system module", omref.isPresent());
    // create a ModuleFinder that only finds this module
    ModuleReference mref = omref.get();
    ModuleFinder finder = new ModuleFinder() {

        @Override
        public Optional<ModuleReference> find(String name) {
            if (name.equals(mn))
                return Optional.of(mref);
            else
                return Optional.empty();
        }

        @Override
        public Set<ModuleReference> findAll() {
            return Collections.singleton(mref);
        }
    };
    // create a child configuration and layer with this module
    Layer bootLayer = Layer.boot();
    Configuration cf = bootLayer.configuration().resolveRequires(finder, ModuleFinder.of(), Set.of(ANOTHER_MODULE));
    Layer layer = bootLayer.defineModulesWithOneLoader(cf, null);
    Optional<Module> om = layer.findModule(mn);
    assertTrue("module " + mn + " not in child layer", om.isPresent());
    return om.get();
}

20. LayerAndLoadersTest#testOverriding4()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Test Layer defineModulesWithXXX when the modules that override same
     * named modules in the parent layer.
     *
     * layer1: m1, m2, m3 => loader pool
     * layer2: m1, m3 => loader pool
     */
public void testOverriding4() throws Exception {
    Configuration cf1 = resolveRequires("m1");
    Layer layer1 = Layer.boot().defineModulesWithManyLoaders(cf1, null);
    checkLayer(layer1, "m1", "m2", "m3");
    ModuleFinder finder = finderFor("m1", "m3");
    Configuration cf2 = cf1.resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    Layer layer2 = layer1.defineModulesWithManyLoaders(cf2, null);
    checkLayer(layer2, "m1", "m3");
    invoke(layer1, "m1", "p.Main");
    ClassLoader loader1 = layer1.findLoader("m1");
    ClassLoader loader2 = layer1.findLoader("m2");
    ClassLoader loader3 = layer1.findLoader("m3");
    ClassLoader loader4 = layer2.findLoader("m1");
    ClassLoader loader5 = layer2.findLoader("m2");
    ClassLoader loader6 = layer2.findLoader("m3");
    assertTrue(loader4 != loader1);
    // m2 not overridden
    assertTrue(loader5 == loader2);
    assertTrue(loader6 != loader3);
    assertTrue(loader1.loadClass("p.Main").getClassLoader() == loader1);
    assertTrue(loader1.loadClass("q.Hello").getClassLoader() == loader2);
    assertTrue(loader1.loadClass("w.Hello").getClassLoader() == loader3);
    assertTrue(loader2.loadClass("q.Hello").getClassLoader() == loader2);
    assertTrue(loader3.loadClass("w.Hello").getClassLoader() == loader3);
    assertTrue(loader4.loadClass("p.Main").getClassLoader() == loader4);
    assertTrue(loader4.loadClass("q.Hello").getClassLoader() == loader2);
    assertTrue(loader4.loadClass("w.Hello").getClassLoader() == loader6);
    assertTrue(loader6.loadClass("w.Hello").getClassLoader() == loader6);
}

21. LayerAndLoadersTest#testOverriding3()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Test Layer defineModulesWithXXX when the modules that override same
     * named modules in the parent layer.
     *
     * layer1: m1, m2, m3 => same loader
     * layer2: m1, m3 => same loader
     */
public void testOverriding3() throws Exception {
    Configuration cf1 = resolveRequires("m1");
    Layer layer1 = Layer.boot().defineModulesWithOneLoader(cf1, null);
    checkLayer(layer1, "m1", "m2", "m3");
    ModuleFinder finder = finderFor("m1", "m3");
    Configuration cf2 = cf1.resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    Layer layer2 = layer1.defineModulesWithOneLoader(cf2, null);
    checkLayer(layer2, "m1", "m3");
    invoke(layer1, "m1", "p.Main");
    ClassLoader loader1 = layer1.findLoader("m1");
    ClassLoader loader2 = layer2.findLoader("m1");
    assertTrue(loader1.loadClass("p.Main").getClassLoader() == loader1);
    assertTrue(loader1.loadClass("q.Hello").getClassLoader() == loader1);
    assertTrue(loader1.loadClass("w.Hello").getClassLoader() == loader1);
    assertTrue(loader2.loadClass("p.Main").getClassLoader() == loader2);
    assertTrue(loader2.loadClass("q.Hello").getClassLoader() == loader1);
    assertTrue(loader2.loadClass("w.Hello").getClassLoader() == loader2);
}

22. LayerAndLoadersTest#testOverriding2()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Test Layer defineModulesWithXXX when the modules that override same
     * named modules in the parent layer.
     *
     * Test scenario:
     *   layer1: m1, m2, m3 => loader pool
     *   layer2: m1, m2, m3 => loader pool
     */
public void testOverriding2() throws Exception {
    Configuration cf1 = resolveRequires("m1");
    Layer layer1 = Layer.boot().defineModulesWithManyLoaders(cf1, null);
    checkLayer(layer1, "m1", "m2", "m3");
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    Configuration cf2 = cf1.resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    Layer layer2 = layer1.defineModulesWithManyLoaders(cf2, null);
    checkLayer(layer2, "m1", "m2", "m3");
    invoke(layer1, "m1", "p.Main");
    ClassLoader loader1 = layer1.findLoader("m1");
    ClassLoader loader2 = layer1.findLoader("m2");
    ClassLoader loader3 = layer1.findLoader("m3");
    ClassLoader loader4 = layer2.findLoader("m1");
    ClassLoader loader5 = layer2.findLoader("m2");
    ClassLoader loader6 = layer2.findLoader("m3");
    assertTrue(loader4 != loader1);
    assertTrue(loader5 != loader2);
    assertTrue(loader6 != loader3);
    assertTrue(loader1.loadClass("p.Main").getClassLoader() == loader1);
    assertTrue(loader1.loadClass("q.Hello").getClassLoader() == loader2);
    assertTrue(loader1.loadClass("w.Hello").getClassLoader() == loader3);
    // p.Main is not visible via loader2
    try {
        loader2.loadClass("p.Main");
        assertTrue(false);
    } catch (ClassNotFoundException expected) {
    }
    // w.Hello is not visible via loader2
    try {
        loader2.loadClass("w.Hello");
        assertTrue(false);
    } catch (ClassNotFoundException expected) {
    }
    // p.Main is not visible via loader3
    try {
        loader3.loadClass("p.Main");
        assertTrue(false);
    } catch (ClassNotFoundException expected) {
    }
    // q.Hello is not visible via loader3
    try {
        loader3.loadClass("q.Hello");
        assertTrue(false);
    } catch (ClassNotFoundException expected) {
    }
    assertTrue(loader4.loadClass("p.Main").getClassLoader() == loader4);
    assertTrue(loader5.loadClass("q.Hello").getClassLoader() == loader5);
    assertTrue(loader6.loadClass("w.Hello").getClassLoader() == loader6);
    // p.Main is not visible via loader5
    try {
        loader5.loadClass("p.Main");
        assertTrue(false);
    } catch (ClassNotFoundException expected) {
    }
    // w.Hello is not visible via loader5
    try {
        loader5.loadClass("w.Hello");
        assertTrue(false);
    } catch (ClassNotFoundException expected) {
    }
    // p.Main is not visible via loader6
    try {
        loader6.loadClass("p.Main");
        assertTrue(false);
    } catch (ClassNotFoundException expected) {
    }
    // q.Hello is not visible via loader6
    try {
        loader6.loadClass("q.Hello");
        assertTrue(false);
    } catch (ClassNotFoundException expected) {
    }
}

23. LayerAndLoadersTest#testOverriding1()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Test Layer defineModulesWithXXX when the modules that override same
     * named modules in the parent layer.
     *
     * Test scenario:
     *   layer1: m1, m2, m3 => same loader
     *   layer2: m1, m2, m4 => same loader
     */
public void testOverriding1() throws Exception {
    Configuration cf1 = resolveRequires("m1");
    Layer layer1 = Layer.boot().defineModulesWithOneLoader(cf1, null);
    checkLayer(layer1, "m1", "m2", "m3");
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    Configuration cf2 = cf1.resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    Layer layer2 = layer1.defineModulesWithOneLoader(cf2, null);
    checkLayer(layer2, "m1", "m2", "m3");
    invoke(layer1, "m1", "p.Main");
    ClassLoader loader1 = layer1.findLoader("m1");
    ClassLoader loader2 = layer1.findLoader("m2");
    ClassLoader loader3 = layer1.findLoader("m3");
    ClassLoader loader4 = layer2.findLoader("m1");
    ClassLoader loader5 = layer2.findLoader("m2");
    ClassLoader loader6 = layer2.findLoader("m3");
    assertTrue(loader1 == loader2);
    assertTrue(loader1 == loader3);
    assertTrue(loader4 == loader5);
    assertTrue(loader4 == loader6);
    assertTrue(loader4 != loader1);
    assertTrue(loader1.loadClass("p.Main").getClassLoader() == loader1);
    assertTrue(loader1.loadClass("q.Hello").getClassLoader() == loader1);
    assertTrue(loader1.loadClass("w.Hello").getClassLoader() == loader1);
    assertTrue(loader4.loadClass("p.Main").getClassLoader() == loader4);
    assertTrue(loader4.loadClass("q.Hello").getClassLoader() == loader4);
    assertTrue(loader4.loadClass("w.Hello").getClassLoader() == loader4);
}

24. LayerAndLoadersTest#testSplitDelegation()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Test Layer defineModulesWithXXX with split delegation.
     *
     * Test scenario:
     *   layer1: m1 exports p, m2 exports p
     *   layer2: m3 reads m1, m4 reads m2
     */
public void testSplitDelegation() {
    ModuleDescriptor descriptor1 = new ModuleDescriptor.Builder("m1").exports("p").build();
    ModuleDescriptor descriptor2 = new ModuleDescriptor.Builder("m2").exports("p").build();
    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
    Configuration cf1 = Layer.boot().configuration().resolveRequires(finder1, ModuleFinder.of(), Set.of("m1", "m2"));
    Layer layer1 = Layer.boot().defineModulesWithManyLoaders(cf1, null);
    checkLayer(layer1, "m1", "m2");
    ModuleDescriptor descriptor3 = new ModuleDescriptor.Builder("m3").requires("m1").build();
    ModuleDescriptor descriptor4 = new ModuleDescriptor.Builder("m4").requires("m2").build();
    ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3, descriptor4);
    Configuration cf2 = cf1.resolveRequires(finder2, ModuleFinder.of(), Set.of("m3", "m4"));
    // package p cannot be supplied by two class loaders
    try {
        layer1.defineModulesWithOneLoader(cf2, null);
        assertTrue(false);
    } catch (LayerInstantiationException expected) {
    }
    // no split delegation when modules have their own class loader
    Layer layer2 = layer1.defineModulesWithManyLoaders(cf2, null);
    checkLayer(layer2, "m3", "m4");
}

25. LayerAndLoadersTest#testServicesWithManyLoaders()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Basic test of Layer 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 = resolveRequiresAndUses("m1");
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer = Layer.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);
    // 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());
    }
}

26. BasicLayerTest#testPackageAlreadyInNamedModule()

Project: openjdk
File: BasicLayerTest.java
/**
     * Attempt to use Layer defineModules to create a Layer with a module
     * containing package {@code p} where the class loader already has a module
     * defined to it containing package {@code p}.
     */
@Test(expectedExceptions = { LayerInstantiationException.class })
public void testPackageAlreadyInNamedModule() {
    ModuleDescriptor md1 = new ModuleDescriptor.Builder("m1").conceals("p").requires("java.base").build();
    ModuleDescriptor md2 = new ModuleDescriptor.Builder("m2").conceals("p").requires("java.base").build();
    ModuleFinder finder = ModuleUtils.finderOf(md1, md2);
    ClassLoader loader = new ClassLoader() {
    };
    // define m1 containing package p to class loader
    Configuration parent = Layer.boot().configuration();
    Configuration cf1 = parent.resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    Layer layer1 = Layer.boot().defineModules(cf1,  mn -> loader);
    // attempt to define m2 containing package p to class loader
    Configuration cf2 = parent.resolveRequires(finder, ModuleFinder.of(), Set.of("m2"));
    // should throw exception because p already in m1
    Layer layer2 = Layer.boot().defineModules(cf2,  mn -> loader);
}

27. BasicLayerTest#testImpliedReadabilityWithLayers4()

Project: openjdk
File: BasicLayerTest.java
/**
     * Test layers with implied readability.
     *
     * The test consists of two configurations:
     * - Configuration/layer1: m1, m2 requires public m1
     * - Configuration/layer2: m3 requires public m2, m4 requires m3
     */
public void testImpliedReadabilityWithLayers4() {
    // cf1: m1, m2 requires public m1
    ModuleDescriptor descriptor1 = new ModuleDescriptor.Builder("m1").build();
    ModuleDescriptor descriptor2 = new ModuleDescriptor.Builder("m2").requires(ModuleDescriptor.Requires.Modifier.PUBLIC, "m1").build();
    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
    Configuration cf1 = resolveRequires(finder1, "m2");
    ClassLoader cl1 = new ClassLoader() {
    };
    Layer layer1 = Layer.empty().defineModules(cf1,  mn -> cl1);
    // cf2: m3 requires public m2, m4 requires m3
    ModuleDescriptor descriptor3 = new ModuleDescriptor.Builder("m3").requires(ModuleDescriptor.Requires.Modifier.PUBLIC, "m2").build();
    ModuleDescriptor descriptor4 = new ModuleDescriptor.Builder("m4").requires("m3").build();
    ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3, descriptor4);
    Configuration cf2 = resolveRequires(cf1, finder2, "m3", "m4");
    ClassLoader cl2 = new ClassLoader() {
    };
    Layer layer2 = layer1.defineModules(cf2,  mn -> cl2);
    assertTrue(layer1.parent().get() == Layer.empty());
    assertTrue(layer2.parent().get() == layer1);
    Module m1 = layer2.findModule("m1").get();
    Module m2 = layer2.findModule("m2").get();
    Module m3 = layer2.findModule("m3").get();
    Module m4 = layer2.findModule("m4").get();
    assertTrue(m1.getLayer() == layer1);
    assertTrue(m2.getLayer() == layer1);
    assertTrue(m3.getLayer() == layer2);
    assertTrue(m4.getLayer() == layer2);
    assertTrue(m1.canRead(m1));
    assertFalse(m1.canRead(m2));
    assertFalse(m1.canRead(m3));
    assertFalse(m1.canRead(m4));
    assertTrue(m2.canRead(m1));
    assertTrue(m2.canRead(m2));
    assertFalse(m1.canRead(m3));
    assertFalse(m1.canRead(m4));
    assertTrue(m3.canRead(m1));
    assertTrue(m3.canRead(m2));
    assertTrue(m3.canRead(m3));
    assertFalse(m3.canRead(m4));
    assertTrue(m4.canRead(m1));
    assertTrue(m4.canRead(m2));
    assertTrue(m4.canRead(m3));
    assertTrue(m4.canRead(m4));
}

28. BasicLayerTest#testImpliedReadabilityWithLayers2()

Project: openjdk
File: BasicLayerTest.java
/**
     * Test layers with implied readability.
     *
     * The test consists of three configurations:
     * - Configuration/layer1: m1
     * - Configuration/layer2: m2 requires public m3, m3 requires m2
     */
public void testImpliedReadabilityWithLayers2() {
    // cf1: m1
    ModuleDescriptor descriptor1 = new ModuleDescriptor.Builder("m1").build();
    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1);
    Configuration cf1 = resolveRequires(finder1, "m1");
    ClassLoader cl1 = new ClassLoader() {
    };
    Layer layer1 = Layer.empty().defineModules(cf1,  mn -> cl1);
    // cf2: m2, m3: m2 requires public m1, m3 requires m2
    ModuleDescriptor descriptor2 = new ModuleDescriptor.Builder("m2").requires(ModuleDescriptor.Requires.Modifier.PUBLIC, "m1").build();
    ModuleDescriptor descriptor3 = new ModuleDescriptor.Builder("m3").requires("m2").build();
    ModuleFinder finder2 = ModuleUtils.finderOf(descriptor2, descriptor3);
    Configuration cf2 = resolveRequires(cf1, finder2, "m3");
    ClassLoader cl2 = new ClassLoader() {
    };
    Layer layer2 = layer1.defineModules(cf2,  mn -> cl2);
    assertTrue(layer1.parent().get() == Layer.empty());
    assertTrue(layer2.parent().get() == layer1);
    Module m1 = layer2.findModule("m1").get();
    Module m2 = layer2.findModule("m2").get();
    Module m3 = layer2.findModule("m3").get();
    assertTrue(m1.getLayer() == layer1);
    assertTrue(m2.getLayer() == layer2);
    assertTrue(m3.getLayer() == layer2);
    assertTrue(m1.canRead(m1));
    assertFalse(m1.canRead(m2));
    assertFalse(m1.canRead(m3));
    assertTrue(m2.canRead(m1));
    assertTrue(m2.canRead(m2));
    assertFalse(m2.canRead(m3));
    assertTrue(m3.canRead(m1));
    assertTrue(m3.canRead(m2));
    assertTrue(m3.canRead(m3));
}

29. BasicLayerTest#testImpliedReadabilityWithLayers1()

Project: openjdk
File: BasicLayerTest.java
/**
     * Test layers with implied readability.
     *
     * The test consists of three configurations:
     * - Configuration/layer1: m1, m2 requires public m1
     * - Configuration/layer2: m3 requires m1
     */
public void testImpliedReadabilityWithLayers1() {
    // cf1: m1 and m2, m2 requires public m1
    ModuleDescriptor descriptor1 = new ModuleDescriptor.Builder("m1").build();
    ModuleDescriptor descriptor2 = new ModuleDescriptor.Builder("m2").requires(ModuleDescriptor.Requires.Modifier.PUBLIC, "m1").build();
    ModuleFinder finder1 = ModuleUtils.finderOf(descriptor1, descriptor2);
    Configuration cf1 = resolveRequires(finder1, "m2");
    ClassLoader cl1 = new ClassLoader() {
    };
    Layer layer1 = Layer.empty().defineModules(cf1,  mn -> cl1);
    // cf2: m3, m3 requires m2
    ModuleDescriptor descriptor3 = new ModuleDescriptor.Builder("m3").requires("m2").build();
    ModuleFinder finder2 = ModuleUtils.finderOf(descriptor3);
    Configuration cf2 = resolveRequires(cf1, finder2, "m3");
    ClassLoader cl2 = new ClassLoader() {
    };
    Layer layer2 = layer1.defineModules(cf2,  mn -> cl2);
    assertTrue(layer1.parent().get() == Layer.empty());
    assertTrue(layer2.parent().get() == layer1);
    Module m1 = layer2.findModule("m1").get();
    Module m2 = layer2.findModule("m2").get();
    Module m3 = layer2.findModule("m3").get();
    assertTrue(m1.getLayer() == layer1);
    assertTrue(m2.getLayer() == layer1);
    assertTrue(m3.getLayer() == layer2);
    assertTrue(m1.getClassLoader() == cl1);
    assertTrue(m2.getClassLoader() == cl1);
    assertTrue(m3.getClassLoader() == cl2);
    assertTrue(m1.canRead(m1));
    assertFalse(m1.canRead(m2));
    assertFalse(m1.canRead(m3));
    assertTrue(m2.canRead(m1));
    assertTrue(m2.canRead(m2));
    assertFalse(m2.canRead(m3));
    assertTrue(m3.canRead(m1));
    assertTrue(m3.canRead(m2));
    assertTrue(m3.canRead(m3));
}

30. NoAccess#main()

Project: openjdk
File: NoAccess.java
public static void main(String[] args) throws Exception {
    // disable security manager until Class.forName is called.
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        System.setSecurityManager(null);
    }
    ModuleFinder finder = ModuleFinder.of(Paths.get("mods1"), Paths.get("mods2"));
    Layer bootLayer = Layer.boot();
    Configuration parent = bootLayer.configuration();
    Configuration cf = parent.resolveRequiresAndUses(finder, ModuleFinder.of(), Set.of("m1", "m2"));
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer = bootLayer.defineModulesWithManyLoaders(cf, scl);
    if (sm != null) {
        System.setSecurityManager(sm);
    }
    Module m1 = bootLayer.findModule("m1").get();
    Module m2 = bootLayer.findModule("m2").get();
    Module m3 = bootLayer.findModule("m3").get();
    findClass(m1, "p1.internal.B");
    findClass(m2, "p2.C");
    findClass(m3, "p3.internal.Foo");
    // permissions granted
    findClass(m1, "p1.A");
    findClass(m1, "p1.internal.B");
    findClass(m2, "p2.C");
    findClass(m3, "p3.internal.Foo");
    // m1 and m2 from a different layer
    m1 = layer.findModule("m1").get();
    m2 = layer.findModule("m2").get();
    m3 = layer.findModule("m3").get();
    findClass(m1, "p1.A");
    findClass(m3, "p3.internal.Foo");
    // no permission
    Path path = MODS_DIR1.resolve("p1").resolve("internal").resolve("B.class");
    findClass(m1, "p1.internal.B", new FilePermission(path.toString(), "read"));
    path = MODS_DIR2.resolve("p2").resolve("C.class");
    findClass(m2, "p2.C", new FilePermission(path.toString(), "read"));
}

31. LayerModularXMLParserTest#testTwoLayerWithDuplicate()

Project: openjdk
File: LayerModularXMLParserTest.java
/*
     * layer 1 is created on top of boot layer, layer 1 includes module provider1 and provider2.
     * layer 2 is created on top of layer 1, layer 2 includes module provider2.
     *
     * Instantiate each XML service, verify the services provided by provider1
     * are loaded from layer 1, the services provided by provider2 are loaded from layer 2
     */
public void testTwoLayerWithDuplicate() throws Exception {
    ModuleFinder finder1 = ModuleFinder.of(MOD_DIR1, MOD_DIR2);
    Configuration cf1 = Layer.boot().configuration().resolveRequiresAndUses(finder1, ModuleFinder.of(), Set.of("test"));
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer1 = Layer.boot().defineModulesWithManyLoaders(cf1, scl);
    ModuleFinder finder2 = ModuleFinder.of(MOD_DIR2);
    Configuration cf2 = cf1.resolveRequiresAndUses(finder2, ModuleFinder.of(), Set.of("test"));
    Layer layer2 = layer1.defineModulesWithOneLoader(cf2, layer1.findLoader("test"));
    ClassLoader cl2 = layer2.findLoader("test");
    Method m = cl2.loadClass("test.XMLFactoryHelper").getMethod("instantiateXMLService", String.class);
    for (String service : services1) {
        Object o = m.invoke(null, service);
        Layer providerLayer = o.getClass().getModule().getLayer();
        assertSame(providerLayer, layer1);
    }
    for (String service : services2) {
        Object o = m.invoke(null, service);
        Layer providerLayer = o.getClass().getModule().getLayer();
        assertSame(providerLayer, layer2);
    }
}

32. LayerModularXMLParserTest#testTwoLayer()

Project: openjdk
File: LayerModularXMLParserTest.java
/*
     * layer 1 is created on top of boot layer, layer 1 includes module provider1.
     * layer 2 is created on top of layer 1, layer 2 includes module provider2.
     *
     * Instantiate each XML service, verify the services provided by provider1
     * are loaded from layer 1, the services provided by provider2 are loaded from layer 2
     */
public void testTwoLayer() throws Exception {
    ModuleFinder finder1 = ModuleFinder.of(MOD_DIR1);
    Configuration cf1 = Layer.boot().configuration().resolveRequiresAndUses(finder1, ModuleFinder.of(), Set.of("test"));
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer1 = Layer.boot().defineModulesWithManyLoaders(cf1, scl);
    ModuleFinder finder2 = ModuleFinder.of(MOD_DIR2);
    Configuration cf2 = cf1.resolveRequiresAndUses(finder2, ModuleFinder.of(), Set.of("test"));
    Layer layer2 = layer1.defineModulesWithOneLoader(cf2, layer1.findLoader("test"));
    ClassLoader cl2 = layer2.findLoader("test");
    Method m = cl2.loadClass("test.XMLFactoryHelper").getMethod("instantiateXMLService", String.class);
    for (String service : services1) {
        Object o = m.invoke(null, service);
        Layer providerLayer = o.getClass().getModule().getLayer();
        assertSame(providerLayer, layer1);
    }
    for (String service : services2) {
        Object o = m.invoke(null, service);
        Layer providerLayer = o.getClass().getModule().getLayer();
        assertSame(providerLayer, layer2);
    }
}

33. TemplatesImpl#createModule()

Project: openjdk
File: TemplatesImpl.java
/**
     * Creates a module layer with one module that is defined to the given class
     * loader.
     */
private Module createModule(ModuleDescriptor descriptor, ClassLoader loader) {
    String mn = descriptor.name();
    ModuleReference mref = new ModuleReference(descriptor, null, () -> {
        IOException ioe = new IOException("<dynamic module>");
        throw new UncheckedIOException(ioe);
    });
    ModuleFinder finder = new ModuleFinder() {

        @Override
        public Optional<ModuleReference> find(String name) {
            if (name.equals(mn)) {
                return Optional.of(mref);
            } else {
                return Optional.empty();
            }
        }

        @Override
        public Set<ModuleReference> findAll() {
            return Set.of(mref);
        }
    };
    Layer bootLayer = Layer.boot();
    Configuration cf = bootLayer.configuration().resolveRequires(finder, ModuleFinder.of(), Set.of(mn));
    PrivilegedAction<Layer> pa = () -> bootLayer.defineModules(cf,  name -> loader);
    Layer layer = AccessController.doPrivileged(pa);
    Module m = layer.findModule(mn).get();
    assert m.getLayer() == layer;
    return m;
}

34. Context#createModuleTrusted()

Project: openjdk
File: Context.java
/**
     * Creates a module layer with one module that is defined to the given class
     * loader.
     *
     * @param parent the parent layer of the new module
     * @param descriptor the module descriptor for the newly created module
     * @param loader the class loader of the module
     * @return the new Module
     */
static Module createModuleTrusted(final Layer parent, final ModuleDescriptor descriptor, final ClassLoader loader) {
    final String mn = descriptor.name();
    final ModuleReference mref = new ModuleReference(descriptor, null, () -> {
        IOException ioe = new IOException("<dynamic module>");
        throw new UncheckedIOException(ioe);
    });
    final ModuleFinder finder = new ModuleFinder() {

        @Override
        public Optional<ModuleReference> find(String name) {
            if (name.equals(mn)) {
                return Optional.of(mref);
            } else {
                return Optional.empty();
            }
        }

        @Override
        public Set<ModuleReference> findAll() {
            return Set.of(mref);
        }
    };
    final Configuration cf = parent.configuration().resolveRequires(finder, ModuleFinder.of(), Set.of(mn));
    final PrivilegedAction<Layer> pa = () -> parent.defineModules(cf,  name -> loader);
    final Layer layer = AccessController.doPrivileged(pa, GET_LOADER_ACC_CTXT);
    final Module m = layer.findModule(mn).get();
    assert m.getLayer() == layer;
    return m;
}

35. Main#start()

Project: openjdk
File: Main.java
static void start(String appModulePath, String appModuleName, String appMainClass) throws Exception {
    System.out.format("Starting %s/%s ...%n", appModuleName, appMainClass);
    String[] dirs = appModulePath.split(File.pathSeparator);
    Path[] paths = new Path[dirs.length];
    int i = 0;
    for (String dir : dirs) {
        paths[i++] = Paths.get(dir);
    }
    ModuleFinder finder = ModuleFinder.of(paths);
    Configuration cf = Layer.boot().configuration().resolveRequiresAndUses(finder, ModuleFinder.of(), Set.of(appModuleName));
    System.out.println("Resolved");
    cf.modules().stream().map(ResolvedModule::name).sorted().forEach( mn -> System.out.format("  %s%n", mn));
    // reify the configuration as a Layer
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer = Layer.boot().defineModulesWithManyLoaders(cf, scl);
    // invoke application main method
    ClassLoader loader = layer.findLoader(appModuleName);
    Class<?> c = loader.loadClass(appMainClass);
    Main.class.getModule().addReads(c.getModule());
    Method mainMethod = c.getMethod("main", String[].class);
    // set TCCL as that is the EE thing to do
    ClassLoader tccl = Thread.currentThread().getContextClassLoader();
    try {
        Thread.currentThread().setContextClassLoader(loader);
        mainMethod.invoke(null, (Object) new String[0]);
    } finally {
        Thread.currentThread().setContextClassLoader(tccl);
    }
    System.out.println();
}

36. BasicModuleTest#testReadsAllBootModules()

Project: openjdk
File: BasicModuleTest.java
/**
     * Tests that the given module reads all modules in the boot Layer.
     */
private void testReadsAllBootModules(Module m) {
    Layer bootLayer = Layer.boot();
    bootLayer.configuration().modules().stream().map(ResolvedModule::name).map(bootLayer::findModule).forEach( target -> assertTrue(m.canRead(target.get())));
}

37. AddExportsTest#main()

Project: openjdk
File: AddExportsTest.java
public static void main(String[] args) {
    String addExports = System.getProperty("jdk.launcher.addexports.0");
    assertTrue(addExports != null, "Expected to be run with -XaddExports");
    Layer bootLayer = Layer.boot();
    Module unnamedModule = AddExportsTest.class.getModule();
    assertFalse(unnamedModule.isNamed());
    for (String expr : addExports.split(",")) {
        String[] s = expr.split("=");
        assertTrue(s.length == 2);
        // $MODULE/$PACKAGE
        String[] moduleAndPackage = s[0].split("/");
        assertTrue(moduleAndPackage.length == 2);
        String mn = moduleAndPackage[0];
        String pn = moduleAndPackage[1];
        // source module
        Module source;
        Optional<Module> om = bootLayer.findModule(mn);
        assertTrue(om.isPresent(), mn + " not in boot layer");
        source = om.get();
        // package should not be exported unconditionally
        assertFalse(source.isExported(pn), pn + " should not be exported unconditionally");
        // $TARGET
        String tn = s[1];
        if ("ALL-UNNAMED".equals(tn)) {
            // package is exported to all unnamed modules
            assertTrue(source.isExported(pn, unnamedModule), pn + " should be exported to all unnamed modules");
        } else {
            om = bootLayer.findModule(tn);
            assertTrue(om.isPresent());
            Module target = om.get();
            // package should be exported to target module
            assertTrue(source.isExported(pn, target), pn + " should be exported to " + target);
            // package should not be exported to unnamed modules
            assertFalse(source.isExported(pn, unnamedModule), pn + " should not be exported to unnamed modules");
        }
    }
}

38. LayerAndLoadersTest#testServicesWithOneLoader()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Basic test of Layer 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 = resolveRequiresAndUses("m1");
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer = Layer.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());
}

39. BasicLayerTest#testLayerOnBoot()

Project: openjdk
File: BasicLayerTest.java
/**
     * Exercise Layer defineModules, created with boot layer as parent
     */
public void testLayerOnBoot() {
    ModuleDescriptor descriptor1 = new ModuleDescriptor.Builder("m1").requires("m2").requires("java.base").exports("p1").build();
    ModuleDescriptor descriptor2 = new ModuleDescriptor.Builder("m2").requires("java.base").build();
    ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2);
    Configuration parent = Layer.boot().configuration();
    Configuration cf = resolveRequires(parent, finder, "m1");
    ClassLoader loader = new ClassLoader() {
    };
    Layer layer = Layer.boot().defineModules(cf,  mn -> loader);
    // configuration
    assertTrue(layer.configuration() == cf);
    assertTrue(layer.configuration().modules().size() == 2);
    // modules
    Set<Module> modules = layer.modules();
    assertTrue(modules.size() == 2);
    Set<String> names = modules.stream().map(Module::getName).collect(Collectors.toSet());
    assertTrue(names.contains("m1"));
    assertTrue(names.contains("m2"));
    // findModule
    Module m1 = layer.findModule("m1").get();
    Module m2 = layer.findModule("m2").get();
    assertEquals(m1.getName(), "m1");
    assertEquals(m2.getName(), "m2");
    assertTrue(m1.getDescriptor() == descriptor1);
    assertTrue(m2.getDescriptor() == descriptor2);
    assertTrue(m1.getLayer() == layer);
    assertTrue(m2.getLayer() == layer);
    assertTrue(modules.contains(m1));
    assertTrue(modules.contains(m2));
    assertTrue(layer.findModule("java.base").get() == Object.class.getModule());
    assertFalse(layer.findModule("godot").isPresent());
    // findLoader
    assertTrue(layer.findLoader("m1") == loader);
    assertTrue(layer.findLoader("m2") == loader);
    assertTrue(layer.findLoader("java.base") == null);
    // parent
    assertTrue(layer.parent().get() == Layer.boot());
}

40. BasicLayerTest#testLayerOnEmpty()

Project: openjdk
File: BasicLayerTest.java
/**
     * Exercise Layer defineModules, created with empty layer as parent
     */
public void testLayerOnEmpty() {
    ModuleDescriptor descriptor1 = new ModuleDescriptor.Builder("m1").requires("m2").exports("p1").build();
    ModuleDescriptor descriptor2 = new ModuleDescriptor.Builder("m2").requires("m3").build();
    ModuleDescriptor descriptor3 = new ModuleDescriptor.Builder("m3").build();
    ModuleFinder finder = ModuleUtils.finderOf(descriptor1, descriptor2, descriptor3);
    Configuration cf = resolveRequires(finder, "m1");
    // map each module to its own class loader for this test
    ClassLoader loader1 = new ClassLoader() {
    };
    ClassLoader loader2 = new ClassLoader() {
    };
    ClassLoader loader3 = new ClassLoader() {
    };
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", loader1);
    map.put("m2", loader2);
    map.put("m3", loader3);
    Layer layer = Layer.empty().defineModules(cf, map::get);
    // configuration
    assertTrue(layer.configuration() == cf);
    assertTrue(layer.configuration().modules().size() == 3);
    // modules
    Set<Module> modules = layer.modules();
    assertTrue(modules.size() == 3);
    Set<String> names = modules.stream().map(Module::getName).collect(Collectors.toSet());
    assertTrue(names.contains("m1"));
    assertTrue(names.contains("m2"));
    assertTrue(names.contains("m3"));
    // findModule
    Module m1 = layer.findModule("m1").get();
    Module m2 = layer.findModule("m2").get();
    Module m3 = layer.findModule("m3").get();
    assertEquals(m1.getName(), "m1");
    assertEquals(m2.getName(), "m2");
    assertEquals(m3.getName(), "m3");
    assertTrue(m1.getDescriptor() == descriptor1);
    assertTrue(m2.getDescriptor() == descriptor2);
    assertTrue(m3.getDescriptor() == descriptor3);
    assertTrue(m1.getLayer() == layer);
    assertTrue(m2.getLayer() == layer);
    assertTrue(m3.getLayer() == layer);
    assertTrue(modules.contains(m1));
    assertTrue(modules.contains(m2));
    assertTrue(modules.contains(m3));
    assertFalse(layer.findModule("godot").isPresent());
    // findLoader
    assertTrue(layer.findLoader("m1") == loader1);
    assertTrue(layer.findLoader("m2") == loader2);
    assertTrue(layer.findLoader("m3") == loader3);
    try {
        ClassLoader loader = layer.findLoader("godot");
        assertTrue(false);
    } catch (IllegalArgumentException ignore) {
    }
    // parent
    assertTrue(layer.parent().get() == Layer.empty());
}

41. BasicLayerTest#testBoot()

Project: openjdk
File: BasicLayerTest.java
/**
     * Exercise Layer.boot()
     */
public void testBoot() {
    Layer bootLayer = Layer.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();
    // module names are unique
    assertEquals(count, modules.size());
    // findModule
    Module base = Object.class.getModule();
    assertTrue(bootLayer.findModule("java.base").get() == base);
    assertTrue(base.getLayer() == bootLayer);
    // findLoader
    assertTrue(bootLayer.findLoader("java.base") == null);
    // parent
    assertTrue(bootLayer.parent().get() == Layer.empty());
}

42. AutomaticModulesTest#testInLayer()

Project: openjdk
File: AutomaticModulesTest.java
/**
     * Basic test of Layer containing automatic modules
     */
public void testInLayer() throws IOException {
    ModuleDescriptor descriptor = new ModuleDescriptor.Builder("m1").requires("m2").requires("m3").build();
    // m2 and m3 are simple JAR files
    Path dir = Files.createTempDirectory(USER_DIR, "mods");
    createDummyJarFile(dir.resolve("m2.jar"), "p/T.class");
    createDummyJarFile(dir.resolve("m3.jar"), "q/T2.class");
    // module finder locates m1 and the modules in the directory
    ModuleFinder finder = ModuleFinder.compose(ModuleUtils.finderOf(descriptor), ModuleFinder.of(dir));
    Configuration parent = Layer.boot().configuration();
    Configuration cf = resolve(parent, finder, "m1");
    assertTrue(cf.modules().size() == 3);
    // each module gets its own loader
    Layer layer = Layer.boot().defineModules(cf,  mn -> new ClassLoader() {
    });
    // an unnamed module
    Module unnamed = (new ClassLoader() {
    }).getUnnamedModule();
    Module m2 = layer.findModule("m2").get();
    assertTrue(m2.isNamed());
    assertTrue(m2.canRead(unnamed));
    testsReadsAll(m2, layer);
    Module m3 = layer.findModule("m3").get();
    assertTrue(m3.isNamed());
    assertTrue(m2.canRead(unnamed));
    testsReadsAll(m3, layer);
}

43. TestLayer#main()

Project: openjdk
File: TestLayer.java
public static void main(String[] args) throws Exception {
    // disable security manager until Class.forName is called.
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        System.setSecurityManager(null);
    }
    ModuleFinder finder = ModuleFinder.of(MODS_DIR);
    Configuration parent = Layer.boot().configuration();
    Configuration cf = parent.resolveRequiresAndUses(ModuleFinder.of(), finder, modules);
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer = Layer.boot().defineModulesWithManyLoaders(cf, scl);
    Module m1 = layer.findModule("m1").get();
    Module m2 = layer.findModule("m2").get();
    if (sm != null) {
        System.setSecurityManager(sm);
    }
    // find exported and non-exported class from a named module
    findClass(m1, "p1.A");
    findClass(m1, "p1.internal.B");
    findClass(m2, "p2.C");
    // find class from unnamed module
    ClassLoader ld = TestLayer.class.getClassLoader();
    findClass(ld.getUnnamedModule(), "TestDriver");
    // check if clinit should not be initialized
    // compile without module-path; so use reflection
    Class<?> c = Class.forName(m1, "p1.Initializer");
    Method m = c.getMethod("isInited");
    Boolean isClinited = (Boolean) m.invoke(null);
    if (isClinited.booleanValue()) {
        throw new RuntimeException("clinit should not be invoked");
    }
}

44. NoGetClassLoaderAccess#main()

Project: openjdk
File: NoGetClassLoaderAccess.java
public static void main(String[] args) throws Exception {
    Layer boot = Layer.boot();
    System.setSecurityManager(new SecurityManager());
    Module m1 = boot.findModule("m1").get();
    Module m2 = boot.findModule("m2").get();
    findClass(m1, "p1.A");
    findClass(m1, "p1.internal.B");
    findClass(m2, "p2.C");
    findClass(m3, "p3.internal.Foo");
}

45. LauncherHelper#loadModuleMainClass()

Project: openjdk
File: LauncherHelper.java
/**
     * Returns the main class for a module. The query is either a module name
     * or module-name/main-class. For the former then the module's main class
     * is obtained from the module descriptor (MainClass attribute).
     */
private static Class<?> loadModuleMainClass(String what) {
    int i = what.indexOf('/');
    String mainModule;
    String mainClass;
    if (i == -1) {
        mainModule = what;
        mainClass = null;
    } else {
        mainModule = what.substring(0, i);
        mainClass = what.substring(i + 1);
    }
    // main module is in the boot layer
    Layer layer = Layer.boot();
    Optional<Module> om = layer.findModule(mainModule);
    if (!om.isPresent()) {
        // should not happen
        throw new InternalError("Module " + mainModule + " not in boot Layer");
    }
    Module m = om.get();
    // get main class
    if (mainClass == null) {
        Optional<String> omc = m.getDescriptor().mainClass();
        if (!omc.isPresent()) {
            abort(null, "java.launcher.module.error1", mainModule);
        }
        mainClass = omc.get();
    }
    // load the class from the module
    Class<?> c = Class.forName(m, mainClass);
    if (c == null && System.getProperty("os.name", "").contains("OS X") && Normalizer.isNormalized(mainClass, Normalizer.Form.NFD)) {
        String cn = Normalizer.normalize(mainClass, Normalizer.Form.NFC);
        c = Class.forName(m, cn);
    }
    if (c == null) {
        abort(null, "java.launcher.module.error2", mainClass, mainModule);
    }
    System.setProperty("jdk.module.main.class", c.getName());
    return c;
}

46. Umod_PkgNotExp#createLayerOnBoot()

Project: openjdk
File: Umod_PkgNotExp.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: none
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").conceals("p2").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to the same class loader for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    // Create Layer that contains m1 and m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MySameClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is not exported)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

47. Umod_ExpUnqual#createLayerOnBoot()

Project: openjdk
File: Umod_ExpUnqual.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: p2 is exported unqualifiedly
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MySameClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, an unnamed module can access public type " + "p2.c2 since it is exported unqualifiedly");
    }
}

48. Umod_ExpQualOther#createLayerOnBoot()

Project: openjdk
File: Umod_ExpQualOther.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1 (need to define m1 to establish the Layer successfully)
    // Can read:          java.base, m2, m3
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").requires("m3").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: p2 is exported to m3
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2", "m3").build();
    // Define module:     m3
    // Can read:          java.base
    // Packages:          p3
    // Packages exported: none
    ModuleDescriptor descriptor_m3 = new ModuleDescriptor.Builder("m3").requires("java.base").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2, descriptor_m3);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    map.put("m3", MySameClassLoader.loader1);
    // Create Layer that contains m1, m2 and m3
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m3") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MySameClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is exported to m3, not unqualifiedly to everyone)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

49. UmodUpkg_NotExp#createLayerOnBoot()

Project: openjdk
File: UmodUpkg_NotExp.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p6
    // Packages exported: none
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").conceals("p6").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to the same class loader for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    // Create Layer that contains m1 and m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class c5
    Class c5_class = MySameClassLoader.loader1.loadClass("c5");
    try {
        c5_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p6 in m2 is not exported)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

50. UmodUpkg_ExpQualOther#createLayerOnBoot()

Project: openjdk
File: UmodUpkg_ExpQualOther.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1 (need to define m1 to establish the Layer successfully)
    // Can read:          java.base, m2, m3
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").requires("m3").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p6
    // Packages exported: p6 is exported to m3
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p6", "m3").build();
    // Define module:     m3
    // Can read:          java.base
    // Packages:          p3
    // Packages exported: none
    ModuleDescriptor descriptor_m3 = new ModuleDescriptor.Builder("m3").requires("java.base").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2, descriptor_m3);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    map.put("m3", MySameClassLoader.loader1);
    // Create Layer that contains m1, m2 and m3
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m3") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class c5
    Class c5_class = MySameClassLoader.loader1.loadClass("c5");
    try {
        c5_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p6 in m2 is exported to m3, not unqualifiedly to everyone)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

51. UmodUpkgDiffCL_NotExp#createLayerOnBoot()

Project: openjdk
File: UmodUpkgDiffCL_NotExp.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p6
    // Packages exported: none
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").conceals("p6").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class c5
    // NOTE: module m1 does not define any packages.
    //       c5 will be loaded in an unnamed module.
    Class c5_class = MyDiffClassLoader.loader1.loadClass("c5");
    try {
        c5_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p6 in m2 is not exported to " + "an unnamed module that c5 is defined within)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

52. UmodUpkgDiffCL_ExpQualOther#createLayerOnBoot()

Project: openjdk
File: UmodUpkgDiffCL_ExpQualOther.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p6
    // Packages exported: p6 exported to m1
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p6", "m1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class c5
    Class c5_class = MyDiffClassLoader.loader1.loadClass("c5");
    try {
        c5_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p6 in m2 is exported to m1, not unqualifiedly");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

53. UmodUPkg#test_strictModuleUnnamedReadableLayer()

Project: openjdk
File: UmodUPkg.java
// Module m1 is a strict module and has established
// readability to an unnamed module that c4 is defined in.
public void test_strictModuleUnnamedReadableLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p3
    // Packages exported: p3 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p3").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    MySameClassLoader loader = new MySameClassLoader();
    // map module m1 to class loader.
    // class c4 will be loaded in an unnamed module/loader.
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", loader);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == loader);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p3.c3ReadEdge
    Class p3_c3_class = loader.loadClass("p3.c3ReadEdge");
    try {
        // Read edge between m1 and the unnamed module that loads c4 is established in
        // c3ReadEdge's ctor before attempting access.
        p3_c3_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, module m1, type p3.c3ReadEdge, has established readability to " + "c4 loader's unnamed module, access should be allowed: " + e.getMessage());
    }
}

54. UmodUPkg#test_strictModuleLayer()

Project: openjdk
File: UmodUPkg.java
// Create Layers over the boot layer to test different
// accessing scenarios of a named module to an unnamed module.
// Module m1 is a strict module and has not established
// readability to an unnamed module that c4 is defined in.
public void test_strictModuleLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p3
    // Packages exported: p3 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p3").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map module m1 to class loader.
    // class c4 will be loaded in an unnamed module/loader.
    MySameClassLoader loader = new MySameClassLoader();
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", loader);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == loader);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p3.c3
    Class p3_c3_class = loader.loadClass("p3.c3");
    // Attempt access
    try {
        p3_c3_class.newInstance();
        throw new RuntimeException("Test Failed, strict module m1, type p3.c3, should not be able to access " + "public type c4 defined in unnamed module");
    } catch (IllegalAccessError e) {
    }
}

55. UmodDiffCL_PkgNotExp#createLayerOnBoot()

Project: openjdk
File: UmodDiffCL_PkgNotExp.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: none
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").conceals("p2").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    // NOTE: module m1 does not define a package named p1.
    //       p1 will be loaded in an unnamed module.
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is not exported to an unnamed module)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

56. UmodDiffCL_ExpUnqual#createLayerOnBoot()

Project: openjdk
File: UmodDiffCL_ExpUnqual.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: none
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // NOTE: module m1 does not define a package named p1.
    //       p1 will be loaded in an unnamed module.
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, p1.c1 defined in unnamed module can access p2.c2 in module m2");
    }
}

57. UmodDiffCL_ExpQualOther#createLayerOnBoot()

Project: openjdk
File: UmodDiffCL_ExpQualOther.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: none
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2", "m1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    // NOTE: module m1 does not define a package named p1.
    //       p1 will be loaded in an unnamed module.
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is exported to m1, not unqualifiedly");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

58. Umod#test_looseModuleLayer()

Project: openjdk
File: Umod.java
// Module m1 is a loose module and thus can read all unnamed modules.
public void test_looseModuleLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    MySameClassLoader loader = new MySameClassLoader();
    // map module m1 to class loader.
    // class c2 will be loaded in an unnamed module/loader.
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", loader);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == loader);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1Loose
    Class p1_c1_class = loader.loadClass("p1.c1Loose");
    // change m1 to read all unnamed modules
    Module m1 = layer.findModule("m1").get();
    jdk.internal.module.Modules.addReadsAllUnnamed(m1);
    try {
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, strict module m1, type p1.c1Loose, should be able to acccess public type " + "p2.c2 defined in unnamed module: " + e.getMessage());
    }
}

59. Umod#test_strictModuleUnnamedReadableLayer()

Project: openjdk
File: Umod.java
// Module m1 is a strict module and has established
// readability to an unnamed module that p2.c2 is defined in.
public void test_strictModuleUnnamedReadableLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    MySameClassLoader loader = new MySameClassLoader();
    // map module m1 to class loader.
    // class c2 will be loaded in an unnamed module/loader.
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", loader);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == loader);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1ReadEdge
    Class p1_c1_class = loader.loadClass("p1.c1ReadEdge");
    try {
        // Read edge between m1 and the unnamed module that loads p2.c2 is established in
        // c1ReadEdge's ctor before attempting access.
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, strict module m1, type p1.c1ReadEdge, should be able to acccess public type " + "p2.c2 defined in unnamed module: " + e.getMessage());
    }
}

60. Umod#test_strictModuleLayer()

Project: openjdk
File: Umod.java
// Create Layers over the boot layer to test different
// accessing scenarios of a named module to an unnamed module.
// Module m1 is a strict module and has not established
// readability to an unnamed module that p2.c2 is defined in.
public void test_strictModuleLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map module m1 to class loader.
    // class c2 will be loaded in an unnamed module/loader.
    MySameClassLoader loader = new MySameClassLoader();
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", loader);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == loader);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = loader.loadClass("p1.c1");
    // Attempt access
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Test Failed, strict module m1, type p1.c1, should not be able " + "to access public type p2.c2 defined in unnamed module");
    } catch (IllegalAccessError e) {
    }
}

61. PkgNotExp#createLayerOnBoot()

Project: openjdk
File: PkgNotExp.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: none
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").conceals("p2").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to the same class loader for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    // Create Layer that contains m1 and m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MySameClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is not exported)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

62. ExpUnqual#createLayerOnBoot()

Project: openjdk
File: ExpUnqual.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: p2 is exported unqualifiedly
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to the same class loader for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MySameClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, an IAE should not be thrown since p2 is exported unqualifiedly.");
    }
}

63. ExpQualToM1#createLayerOnBoot()

Project: openjdk
File: ExpQualToM1.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: p2 is exported qualifiedly to m1
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2", "m1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to the same class loader for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MySameClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, an IAE should not be thrown since p2 is exported qualifiedly to m1");
    }
}

64. ExpQualOther#createLayerOnBoot()

Project: openjdk
File: ExpQualOther.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2, m3
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").requires("m3").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: p2 is exported to m3
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2", "m3").build();
    // Define module:     m3
    // Can read:          java.base, m2
    // Packages:          p3
    // Packages exported: none
    ModuleDescriptor descriptor_m3 = new ModuleDescriptor.Builder("m3").requires("java.base").requires("m2").conceals("p3").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2, descriptor_m3);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    map.put("m3", MySameClassLoader.loader1);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m3") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MySameClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is exported to m3 not to m1)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

65. ExportAllUnnamed#createLayerOnBoot()

Project: openjdk
File: ExportAllUnnamed.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          none
    // Packages exported: none
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: p2 is exported unqualifiedly
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2", "m1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    Class p2_c2_class = MySameClassLoader.loader1.loadClass("p2.c2");
    Module m2 = p2_c2_class.getModule();
    // Export m2/p2 to all unnamed modules.
    jdk.internal.module.Modules.addExportsToAllUnnamed(m2, "p2");
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MySameClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, unnamed module failed to access public type p2.c2 " + "that was exported to all unnamed");
    }
}

66. DiffCL_UmodUpkg#test_strictModuleUnnamedReadableLayer()

Project: openjdk
File: DiffCL_UmodUpkg.java
// Module m1 is a strict module and has established
// readability to an unnamed module that c4 is defined in.
public void test_strictModuleUnnamedReadableLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p3
    // Packages exported: p3 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p3").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    MyDiffClassLoader.loader1 = new MyDiffClassLoader();
    MyDiffClassLoader.loader2 = new MyDiffClassLoader();
    // map module m1 to class loader.
    // class c2 will be loaded in an unnamed module/loader2
    // to achieve differing class loaders.
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p3.c3ReadEdgeDiffLoader
    Class p3_c3_class = MyDiffClassLoader.loader1.loadClass("p3.c3ReadEdgeDiffLoader");
    try {
        // Read edge between m1 and the unnamed module that loads c4 is established in
        // C3ReadEdgeDiffLoader's ctor before attempting access.
        p3_c3_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, module m1 has established readability to " + "c4 loader's unnamed module, access should be allowed: " + e.getMessage());
    }
}

67. DiffCL_UmodUpkg#test_strictModuleLayer()

Project: openjdk
File: DiffCL_UmodUpkg.java
// Create Layers over the boot layer to test different
// accessing scenarios of a named module to an unnamed module.
// Module m1 is a strict module and has not established
// readability to an unnamed module that c4 is defined in.
public void test_strictModuleLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p3
    // Packages exported: p3 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p3").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    MyDiffClassLoader.loader1 = new MyDiffClassLoader();
    MyDiffClassLoader.loader2 = new MyDiffClassLoader();
    // map module m1 to class loader.
    // class c2 will be loaded in an unnamed module/loader2
    // to achieve differing class loaders.
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p3.c3
    Class p3_c3_class = MyDiffClassLoader.loader1.loadClass("p3.c3");
    // Attempt access
    try {
        p3_c3_class.newInstance();
        throw new RuntimeException("Test Failed, strict module m1 should not be able to access " + "public type c4 defined in unnamed module");
    } catch (IllegalAccessError e) {
    }
}

68. DiffCL_Umod#test_looseModuleLayer()

Project: openjdk
File: DiffCL_Umod.java
// Module m1 is a loose module and thus can read all unnamed modules.
public void test_looseModuleLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    MyDiffClassLoader.loader1 = new MyDiffClassLoader();
    MyDiffClassLoader.loader2 = new MyDiffClassLoader();
    // map module m1 to class loader.
    // class c2 will be loaded in an unnamed module/loader2
    // to achieve differing class loaders.
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1Loose
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1Loose");
    // change m1 to read all unnamed modules
    Module m1 = layer.findModule("m1").get();
    jdk.internal.module.Modules.addReadsAllUnnamed(m1);
    try {
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, loose module m1 should be able to access " + "public type p2.c2 defined in unnamed module: " + e.getMessage());
    }
}

69. DiffCL_Umod#test_strictModuleUnnamedReadableLayer()

Project: openjdk
File: DiffCL_Umod.java
// Module m1 is a strict module and has established
// readability to an unnamed module that p2.c2 is defined in.
public void test_strictModuleUnnamedReadableLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    MyDiffClassLoader.loader1 = new MyDiffClassLoader();
    MyDiffClassLoader.loader2 = new MyDiffClassLoader();
    // map module m1 to class loader.
    // class c2 will be loaded in an unnamed module/loader2
    // to achieve differing class loaders.
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1ReadEdgeDiffLoader
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1ReadEdgeDiffLoader");
    try {
        // Read edge between m1 and the unnamed module that loads p2.c2 is established in
        // c1ReadEdgeDiffLoader's ctor before attempting access.
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, module m1 has established readability to p2/c2 loader's " + "unnamed module, access should be allowed: " + e.getMessage());
    }
}

70. DiffCL_Umod#test_strictModuleLayer()

Project: openjdk
File: DiffCL_Umod.java
// Create Layers over the boot layer to test different
// accessing scenarios of a named module to an unnamed module.
// Module m1 is a strict module and has not established
// readability to an unnamed module that p2.c2 is defined in.
public void test_strictModuleLayer() throws Throwable {
    // Define module:     m1
    // Can read:          java.base
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").exports("p1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    MyDiffClassLoader.loader1 = new MyDiffClassLoader();
    MyDiffClassLoader.loader2 = new MyDiffClassLoader();
    // map module m1 to class loader.
    // class c2 will be loaded in an unnamed module/loader2
    // to achieve differing class loaders.
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    // Create Layer that contains m1
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1");
    // Attempt access
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Test Failed, strict module m1 should not be able " + "to access public type p2.c2 defined in unnamed module");
    } catch (IllegalAccessError e) {
    }
}

71. DiffCL_PkgNotExp#createLayerOnBoot()

Project: openjdk
File: DiffCL_PkgNotExp.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: none
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").conceals("p2").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is not exported)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

72. DiffCL_ExpUnqual#createLayerOnBoot()

Project: openjdk
File: DiffCL_ExpUnqual.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: package p2 is exported to m1
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, an IAE should not be thrown since p2 is exported qualifiedly to m1");
    }
}

73. DiffCL_ExpQualToM1#createLayerOnBoot()

Project: openjdk
File: DiffCL_ExpQualToM1.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2
    // Packages:          p1
    // Packages exported: p1 is exported to unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: package p2 is exported to m1
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2", "m1").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
    } catch (IllegalAccessError e) {
        throw new RuntimeException("Test Failed, an IAE should not be thrown since p2 is exported qualifiedly to m1");
    }
}

74. DiffCL_ExpQualOther#createLayerOnBoot()

Project: openjdk
File: DiffCL_ExpQualOther.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publically defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m2, m3
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m2").requires("m3").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base, m3
    // Packages:          p2
    // Packages exported: p2 is exported to m3
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2", "m3").build();
    // Define module:     m3
    // Can read:          java.base, m2
    // Packages:          p3
    // Packages exported: none
    ModuleDescriptor descriptor_m3 = new ModuleDescriptor.Builder("m3").requires("java.base").requires("m2").conceals("p3").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2, descriptor_m3);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    map.put("m3", MyDiffClassLoader.loader2);
    // Create Layer that contains m1 & m2
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("m3") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is exported to m3 not to m1)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("does not export")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

75. DiffCL_CheckRead#createLayerOnBoot()

Project: openjdk
File: DiffCL_CheckRead.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publicly defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m3
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m3").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: p2 is exported to m1
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2", "m1").build();
    // Define module:     m3
    // Can read:          java.base, m2
    // Packages:          p3
    // Packages exported: none
    ModuleDescriptor descriptor_m3 = new ModuleDescriptor.Builder("m3").requires("java.base").requires("m2").conceals("p3").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2, descriptor_m3);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MyDiffClassLoader.loader1);
    map.put("m2", MyDiffClassLoader.loader2);
    map.put("m3", MyDiffClassLoader.loader2);
    // Create Layer that contains m1, m2 and m3
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MyDiffClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("m3") == MyDiffClassLoader.loader2);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MyDiffClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is exported to m1 but m2 is not readable from m1)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("cannot access")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}

76. CheckRead#createLayerOnBoot()

Project: openjdk
File: CheckRead.java
// Create a Layer over the boot layer.
// Define modules within this layer to test access between
// publicly defined classes within packages of those modules.
public void createLayerOnBoot() throws Throwable {
    // Define module:     m1
    // Can read:          java.base, m3
    // Packages:          p1
    // Packages exported: p1 is exported unqualifiedly
    ModuleDescriptor descriptor_m1 = new ModuleDescriptor.Builder("m1").requires("java.base").requires("m3").exports("p1").build();
    // Define module:     m2
    // Can read:          java.base
    // Packages:          p2
    // Packages exported: p2 is exported to m1
    ModuleDescriptor descriptor_m2 = new ModuleDescriptor.Builder("m2").requires("java.base").exports("p2", "m1").build();
    // Define module:     m3
    // Can read:          java.base, m2
    // Packages:          p3
    // Packages exported: none
    ModuleDescriptor descriptor_m3 = new ModuleDescriptor.Builder("m3").requires("java.base").requires("m2").conceals("p3").build();
    // Set up a ModuleFinder containing all modules for this layer.
    ModuleFinder finder = ModuleLibrary.of(descriptor_m1, descriptor_m2, descriptor_m3);
    // Resolves "m1"
    Configuration cf = Layer.boot().configuration().resolveRequires(finder, ModuleFinder.of(), Set.of("m1"));
    // map each module to differing class loaders for this test
    Map<String, ClassLoader> map = new HashMap<>();
    map.put("m1", MySameClassLoader.loader1);
    map.put("m2", MySameClassLoader.loader1);
    map.put("m3", MySameClassLoader.loader1);
    // Create Layer that contains m1, m2 and m3
    Layer layer = Layer.boot().defineModules(cf, map::get);
    assertTrue(layer.findLoader("m1") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m2") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("m3") == MySameClassLoader.loader1);
    assertTrue(layer.findLoader("java.base") == null);
    // now use the same loader to load class p1.c1
    Class p1_c1_class = MySameClassLoader.loader1.loadClass("p1.c1");
    try {
        p1_c1_class.newInstance();
        throw new RuntimeException("Failed to get IAE (p2 in m2 is exported to m1 but m2 is not readable from m1)");
    } catch (IllegalAccessError e) {
        System.out.println(e.getMessage());
        if (!e.getMessage().contains("cannot access")) {
            throw new RuntimeException("Wrong message: " + e.getMessage());
        }
    }
}