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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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()); } } }