java.lang.reflect.Module

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

1. ImageReaderWriterSpi#getMetadataFormatClass()

Project: openjdk
File: ImageReaderWriterSpi.java
private Class<?> getMetadataFormatClass(String formatClassName) {
    Module thisModule = ImageReaderWriterSpi.class.getModule();
    Module targetModule = this.getClass().getModule();
    Class<?> c = Class.forName(targetModule, formatClassName);
    if (thisModule.equals(targetModule) || c == null) {
        return c;
    }
    if (thisModule.isNamed()) {
        int i = formatClassName.lastIndexOf(".");
        String pn = i > 0 ? formatClassName.substring(0, i) : "";
        if (!targetModule.isExported(pn, thisModule)) {
            throw new IllegalStateException("Class " + formatClassName + " in named module must be exported to java.desktop module.");
        }
    }
    return c;
}

2. IIOMetadata#getMetadataFormatClass()

Project: openjdk
File: IIOMetadata.java
private Class<?> getMetadataFormatClass(String formatClassName) {
    Module thisModule = IIOMetadata.class.getModule();
    Module targetModule = this.getClass().getModule();
    Class<?> c = Class.forName(targetModule, formatClassName);
    if (thisModule.equals(targetModule) || c == null) {
        return c;
    }
    if (thisModule.isNamed()) {
        int i = formatClassName.lastIndexOf(".");
        String pn = i > 0 ? formatClassName.substring(0, i) : "";
        if (!targetModule.isExported(pn, thisModule)) {
            throw new IllegalStateException("Class " + formatClassName + " in named module must be exported to java.desktop module.");
        }
    }
    return c;
}

3. FieldSetAccessibleTest#test()

Project: openjdk
File: FieldSetAccessibleTest.java
// Performs a series of test on the given class.
// At this time, we only call testSetFieldsAccessible(c)
public static boolean test(Class<?> c, boolean addExports) {
    Module self = FieldSetAccessibleTest.class.getModule();
    Module target = c.getModule();
    String pn = c.getPackage().getName();
    boolean exported = self.canRead(target) && target.isExported(pn, self);
    if (addExports && !exported) {
        Modules.addExports(target, pn, self);
        exported = true;
    }
    boolean expectException = !exported;
    classCount.incrementAndGet();
    // Call getDeclaredFields() and try to set their accessible flag.
    testSetFieldsAccessible(c, expectException);
    return c == Class.class;
}

4. TestMain#main()

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

5. Main#main()

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

6. Services#exportJVMCITo()

Project: openjdk
File: Services.java
/**
     * Performs any required security checks and dynamic reconfiguration to allow the module of a
     * given class to access the classes in the JVMCI module.
     *
     * Note: This API uses {@link Class} instead of {@link Module} to provide backwards
     * compatibility for JVMCI clients compiled against a JDK release earlier than 9.
     *
     * @param requestor a class requesting access to the JVMCI module for its module
     * @throws SecurityException if a security manager is present and it denies
     *             {@link JVMCIPermission}
     */
public static void exportJVMCITo(Class<?> requestor) {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        sm.checkPermission(new JVMCIPermission());
    }
    Module jvmci = Services.class.getModule();
    Module requestorModule = requestor.getModule();
    if (jvmci != requestorModule) {
        for (String pkg : jvmci.getPackages()) {
            // options on the JVM command line.
            if (!jvmci.isExported(pkg, requestorModule)) {
                jvmci.addExports(pkg, requestorModule);
            }
        }
    }
}

7. ScriptLoader#createModule()

Project: openjdk
File: ScriptLoader.java
private Module createModule(final String moduleName) {
    final Module structMod = context.getStructLoader().getModule();
    final ModuleDescriptor descriptor = new ModuleDescriptor.Builder(moduleName).requires(NASHORN_MODULE.getName()).requires(structMod.getName()).conceals(SCRIPTS_PKG).build();
    final Module mod = Context.createModuleTrusted(structMod.getLayer(), descriptor, this);
    loadModuleManipulator();
    return mod;
}

8. CallerSensitiveDynamicMethod#addModuleRead()

Project: openjdk
File: CallerSensitiveDynamicMethod.java
private static boolean addModuleRead(final MethodHandles.Lookup lookup, final Executable e) {
    // Don't add module read link if this is not a CallerSensitive member
    if (!e.isAnnotationPresent(CallerSensitive.class)) {
        return false;
    }
    // public lookup cannot unreflect caller sensitives anyway!
    if (lookup == MethodHandles.publicLookup()) {
        return false;
    }
    // try to add missing module read from using module to declararing module!
    final Class<?> declClass = e.getDeclaringClass();
    final Module useModule = lookup.lookupClass().getModule();
    final Module declModule = declClass.getModule();
    if (useModule != null && declModule != null && declModule.isExported(declClass.getPackageName())) {
        Modules.addReads(useModule, declModule);
        return true;
    }
    return false;
}

9. Main#proxiesForExportedTypes()

Project: openjdk
File: Main.java
/*
     * Test cases for proxy class to implement exported proxy interfaces
     * will result in the unnamed module.
     *
     * The proxy class is accessible to unnamed module.
     */
static Data[] proxiesForExportedTypes() {
    ClassLoader ld = Main.class.getClassLoader();
    Module unnamed = ld.getUnnamedModule();
    ClassLoader ld2 = new URLClassLoader(new URL[0], ld);
    Module unnamed2 = ld2.getUnnamedModule();
    return new Data[] { new Data(unnamed, ld, Runnable.class), new Data(unnamed, ld, p.one.I.class), new Data(unnamed, ld, p.one.I.class, p.two.A.class), new Data(unnamed, ld, p.one.I.class, unnamedModuleClass), new Data(unnamed2, ld2, Runnable.class), new Data(unnamed2, ld2, p.one.I.class), new Data(unnamed2, ld2, p.one.I.class, p.two.A.class), new Data(unnamed2, ld2, p.one.I.class, unnamedModuleClass), new Data(unnamed, m1.getClassLoader(), p.one.I.class), new Data(unnamed, m2.getClassLoader(), p.two.A.class), new Data(unnamed, m3.getClassLoader(), p.three.P.class) };
}

10. ProxyModuleMapping#verifyProxyClass()

Project: openjdk
File: ProxyModuleMapping.java
void verifyProxyClass() throws Exception {
    Class<?> c = Proxy.getProxyClass(loader, interfaces);
    Module m = c.getModule();
    if (target != null && m != target) {
        throw new RuntimeException(c.getModule() + " not expected: " + target);
    }
    // expect dynamic module
    if (target == null && (!m.isNamed() || !m.getName().startsWith("jdk.proxy"))) {
        throw new RuntimeException("Unexpected:" + m);
    }
    Module module = c.getModule();
    try {
        Constructor<?> cons = c.getConstructor(InvocationHandler.class);
        cons.newInstance(ih);
        if (module.isNamed()) {
            throw new RuntimeException("expected IAE not thrown");
        }
    } catch (IllegalAccessException e) {
        if (!module.isNamed()) {
            throw e;
        }
    }
}

11. WithSecurityManager#main()

Project: openjdk
File: WithSecurityManager.java
public static void main(String[] args) throws IOException {
    boolean allow = args[0].equals("allow");
    // base module, in the boot layer
    Module base = Object.class.getModule();
    // another module, in a child layer
    Module other = loadModuleInChildLayer(ANOTHER_MODULE);
    assertTrue(other.getLayer() != Layer.boot());
    System.setSecurityManager(new SecurityManager());
    test(base, "java/lang/Object.class", allow);
    test(other, ANOTHER_MODULE_RESOURCE, allow);
}

12. ModuleDescriptorTest#testRead()

Project: openjdk
File: ModuleDescriptorTest.java
public void testRead() throws Exception {
    Module base = Object.class.getModule();
    try (InputStream in = base.getResourceAsStream("module-info.class")) {
        ModuleDescriptor descriptor = ModuleDescriptor.read(in);
        // all bytes read
        assertTrue(in.read() == -1);
        assertEquals(descriptor.name(), "java.base");
    }
    try (InputStream in = base.getResourceAsStream("module-info.class")) {
        ByteBuffer bb = ByteBuffer.wrap(in.readAllBytes());
        ModuleDescriptor descriptor = ModuleDescriptor.read(bb);
        // no more remaining bytes
        assertFalse(bb.hasRemaining());
        assertEquals(descriptor.name(), "java.base");
    }
}

13. Logger#getAnonymousLogger()

Project: openjdk
File: Logger.java
/**
     * Create an anonymous Logger.  The newly created Logger is not
     * registered in the LogManager namespace.  There will be no
     * access checks on updates to the logger.
     * <p>
     * This factory method is primarily intended for use from applets.
     * Because the resulting Logger is anonymous it can be kept private
     * by the creating class.  This removes the need for normal security
     * checks, which in turn allows untrusted applet code to update
     * the control state of the Logger.  For example an applet can do
     * a setLevel or an addHandler on an anonymous Logger.
     * <p>
     * Even although the new logger is anonymous, it is configured
     * to have the root logger ("") as its parent.  This means that
     * by default it inherits its effective level and handlers
     * from the root logger.  Changing its parent via the
     * {@link #setParent(java.util.logging.Logger) setParent} method
     * will still require the security permission specified by that method.
     *
     * @param   resourceBundleName  name of ResourceBundle to be used for localizing
     *                          messages for this logger.
     *          May be null if none of the messages require localization.
     * @return a newly created private Logger
     * @throws MissingResourceException if the resourceBundleName is non-null and
     *             no corresponding resource can be found.
     */
// Synchronization is not required here. All synchronization for
// adding a new anonymous Logger object is handled by doSetParent().
@CallerSensitive
public static Logger getAnonymousLogger(String resourceBundleName) {
    LogManager manager = LogManager.getLogManager();
    // cleanup some Loggers that have been GC'ed
    manager.drainLoggerRefQueueBounded();
    final Class<?> callerClass = Reflection.getCallerClass();
    final Module module = callerClass.getModule();
    Logger result = new Logger(null, resourceBundleName, module, manager, false);
    result.anonymous = true;
    Logger root = manager.getLogger("");
    result.doSetParent(root);
    return result;
}

14. ResourceBundle#getBundleImpl()

Project: openjdk
File: ResourceBundle.java
/**
     * This method will find resource bundles using the legacy mechanism
     * if the caller is unnamed module or the given class loader is
     * not the class loader of the caller module getting the resource
     * bundle, i.e. find the class that is visible to the class loader
     * and properties from unnamed module.
     *
     * The module-aware resource bundle lookup mechanism will load
     * the service providers using the service loader mechanism
     * as well as properties local in the caller module.
     */
private static ResourceBundle getBundleImpl(String baseName, Locale locale, Class<?> caller, ClassLoader loader, Control control) {
    if (caller != null && caller.getModule().isNamed()) {
        Module module = caller.getModule();
        ClassLoader ml = getLoader(module);
        // if loader is the module's class loader
        if (loader == ml || (ml == null && loader == RBClassLoader.INSTANCE)) {
            return getBundleImpl(baseName, locale, loader, module, control);
        }
    }
    // find resource bundles from unnamed module
    Module module = loader != null ? loader.getUnnamedModule() : ClassLoader.getSystemClassLoader().getUnnamedModule();
    return getBundleImpl(baseName, locale, loader, module, control);
}

15. CheckResourceKeys#getResourceKeys()

Project: openjdk
File: CheckResourceKeys.java
/**
     * Get the set of keys from the javadoc resource bundles.
     */
Set<String> getResourceKeys() {
    Module jdk_javadoc = Layer.boot().findModule("jdk.javadoc").get();
    String[] names = { "com.sun.tools.doclets.formats.html.resources.standard", "com.sun.tools.doclets.internal.toolkit.resources.doclets", "com.sun.tools.javadoc.resources.javadoc" };
    Set<String> results = new TreeSet<String>();
    for (String name : names) {
        ResourceBundle b = ResourceBundle.getBundle(name, jdk_javadoc);
        results.addAll(b.keySet());
    }
    return results;
}

16. VerifyLintDescriptions#main()

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

17. CheckResourceKeys#getResourceKeys()

Project: openjdk
File: CheckResourceKeys.java
/**
     * Get the set of keys from the javadoc resource bundles.
     */
Set<String> getResourceKeys() {
    Module jdk_javadoc = Layer.boot().findModule("jdk.javadoc").get();
    String[] names = { "jdk.javadoc.internal.doclets.formats.html.resources.standard", "jdk.javadoc.internal.doclets.toolkit.resources.doclets", "jdk.javadoc.internal.tool.resources.javadoc" };
    Set<String> results = new TreeSet<String>();
    for (String name : names) {
        ResourceBundle b = ResourceBundle.getBundle(name, jdk_javadoc);
        results.addAll(b.keySet());
    }
    return results;
}

18. Test#main()

Project: openjdk
File: Test.java
public static void main(String[] args) {
    System.out.println(Test.class + " ...");
    for (String arg : args) {
        System.out.println(arg);
    }
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    ClassLoader cl1 = Test.class.getClassLoader();
    Module testModule = Test.class.getModule();
    ClassLoader cl2 = Layer.boot().findLoader(testModule.getName());
    if (cl1 != scl)
        throw new RuntimeException("Not loaded by system class loader");
    if (cl2 != scl)
        throw new RuntimeException("Not associated with system class loader");
}

19. Main#main()

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

20. CheckEncodingPropertiesFile#main()

Project: openjdk
File: CheckEncodingPropertiesFile.java
public static void main(String[] args) throws Exception {
    Properties props = new Properties();
    Module xmlModule = EncodingInfo.class.getModule();
    try (InputStreamReader is = new InputStreamReader(xmlModule.getResourceAsStream(ENCODINGS_FILE))) {
        props.load(is);
    }
    if (!props.containsKey("UTF8")) {
        // jaxp tree of the jdk forest.
        throw new RuntimeException("UTF8 key missing in " + ENCODINGS_FILE);
    }
    //printAllCharsets();
    test(props);
}

21. ProxyForMethodHandle#testRunnableMethodHandle()

Project: openjdk
File: ProxyForMethodHandle.java
/**
     * MethodHandleProxies will add qualified export of sun.invoke from java.base
     * to a dynamic module
     */
@Test
static void testRunnableMethodHandle() throws Exception {
    MethodHandles.Lookup lookup = MethodHandles.lookup();
    MethodType mt = MethodType.methodType(void.class);
    MethodHandle mh = lookup.findStatic(ProxyForMethodHandle.class, "runForRunnable", mt);
    Runnable proxy = MethodHandleProxies.asInterfaceInstance(Runnable.class, mh);
    proxy.run();
    Class<?> proxyClass = proxy.getClass();
    Module target = proxyClass.getModule();
    assertDynamicModule(target, proxyClass.getClassLoader(), proxyClass);
}

22. JVMGetModuleByPkgName#main()

Project: openjdk
File: JVMGetModuleByPkgName.java
public static void main(String args[]) throws Throwable {
    Module javaBase = ModuleHelper.GetModuleByPackageName(null, "java/lang");
    if (!javaBase.getName().equals("java.base")) {
        throw new RuntimeException("Failed to get module java.base for package java/lang");
    }
    if (ModuleHelper.GetModuleByPackageName(null, "bad.package.name") != null) {
        throw new RuntimeException("Failed to get null for bad.package.name");
    }
    ClassLoader systemLoader = ClassLoader.getSystemClassLoader();
    if (ModuleHelper.GetModuleByPackageName(systemLoader, "java/lang") != null) {
        throw new RuntimeException("Failed to get null for systemClassLoader and java/lang");
    }
    try {
        ModuleHelper.GetModuleByPackageName(systemLoader, null);
        throw new RuntimeException("Failed to throw NullPointerException for null package name");
    } catch (NullPointerException e) {
    }
    Module unnamedModule = ModuleHelper.GetModuleByPackageName(systemLoader, "");
    if (unnamedModule.isNamed()) {
        throw new RuntimeException("Unexpected named module returned for unnamed package");
    }
    p2.c2 obj = new p2.c2();
    unnamedModule = ModuleHelper.GetModuleByPackageName(systemLoader, "p2");
    if (unnamedModule.isNamed()) {
        throw new RuntimeException("Unexpected named module returned for package p2 in unnamed module");
    }
    MyClassLoader cl1 = new MyClassLoader();
    Module module1 = (Module) ModuleHelper.ModuleObject("module1", cl1, new String[] { "mypackage" });
    assertNotNull(module1, "Module should not be null");
    ModuleHelper.DefineModule(module1, "9.0", "module1/here", new String[] { "mypackage" });
    if (ModuleHelper.GetModuleByPackageName(cl1, "mypackage") != module1) {
        throw new RuntimeException("Wrong module returned for cl1 mypackage");
    }
}

23. BasicModuleTest#testDesktopModule()

Project: openjdk
File: BasicModuleTest.java
@Test
public void testDesktopModule() {
    Module desktop = java.awt.Component.class.getModule();
    Module base = Object.class.getModule();
    Module xml = javax.xml.XMLConstants.class.getModule();
    Module thisModule = BasicModuleTest.class.getModule();
    // name
    assertTrue(desktop.getName().equals("java.desktop"));
    // descriptor
    assertTrue(desktop.getDescriptor().exports().stream().anyMatch(doesExport("java.awt")));
    // getClassLoader
    assertTrue(desktop.getClassLoader() == null);
    // getLayer
    assertTrue(desktop.getLayer() == Layer.boot());
    // toString
    assertEquals(desktop.toString(), "module java.desktop");
    // getPackages
    assertTrue(contains(desktop.getPackages(), "java.awt"));
    assertTrue(contains(desktop.getPackages(), "sun.awt"));
    // canRead
    assertTrue(desktop.canRead(base));
    assertTrue(desktop.canRead(xml));
    // isExported
    assertTrue(desktop.isExported("java.awt"));
    assertTrue(desktop.isExported("java.awt", thisModule));
    assertFalse(desktop.isExported("java.wombat"));
    assertFalse(desktop.isExported("java.wombat", thisModule));
}

24. BasicModuleTest#testUnnamedModules()

Project: openjdk
File: BasicModuleTest.java
@Test
public void testUnnamedModules() {
    Module thisModule = BasicModuleTest.class.getModule();
    Module baseModule = Object.class.getModule();
    ClassLoader loader1 = ClassLoader.getSystemClassLoader();
    ClassLoader loader2 = loader1.getParent();
    Module m1 = loader1.getUnnamedModule();
    Module m2 = loader2.getUnnamedModule();
    assertTrue(m1 != m2);
    assertFalse(m1.isNamed());
    assertFalse(m2.isNamed());
    assertTrue(m1.getLayer() == null);
    assertTrue(m2.getLayer() == null);
    assertTrue(m1.toString().startsWith("unnamed module "));
    assertTrue(m2.toString().startsWith("unnamed module "));
    // unnamed module reads all modules
    assertTrue(m1.canRead(m2));
    assertTrue(m2.canRead(m1));
    testReadsAllBootModules(m1);
    testReadsAllBootModules(m2);
    assertTrue(m1.isExported(""));
    assertTrue(m1.isExported("", thisModule));
    assertTrue(m1.isExported("", baseModule));
    assertTrue(m1.isExported("p"));
    assertTrue(m1.isExported("p", thisModule));
    assertTrue(m1.isExported("p", baseModule));
}

25. BasicLayerTest#testImpliedReadabilityWithLayers4()

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

26. Main#main()

Project: openjdk
File: Main.java
public static void main(String[] args) throws Exception {
    Module thisModule = Main.class.getModule();
    assertTrue(thisModule.isNamed());
    Optional<Module> om = Layer.boot().findModule("target");
    assertTrue(om.isPresent());
    Module target = om.get();
    assertTrue(target.isExported("p"));
    assertTrue(target.isExported("p", thisModule));
    assertFalse(target.isExported("q"));
    assertFalse(target.isExported("q", thisModule));
    // thisModule does not read the target module
    assertFalse(thisModule.canRead(target));
    tryAccessPublicMembers("p.Exported", true);
    tryAccessPublicMembers("q.Internal", false);
    // thisModule reads the target module
    thisModule.addReads(target);
    assertTrue(thisModule.canRead(target));
    tryAccessPublicMembers("p.Exported", true);
    tryAccessPublicMembers("q.Internal", false);
    // change target module to export its internal package to thisModule
    targetAddExports("q", thisModule);
    assertFalse(target.isExported("q"));
    assertTrue(target.isExported("q", thisModule));
    tryAccessPublicMembers("p.Exported", true);
    tryAccessPublicMembers("q.Internal", true);
}

27. BasicLayerTest#testImpliedReadabilityWithLayers3()

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

28. BasicLayerTest#testImpliedReadabilityWithLayers2()

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

29. BasicLayerTest#testImpliedReadabilityWithLayers1()

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

30. BasicLayerTest#testLayerOnEmpty()

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

31. AutomaticModulesTest#testInLayer()

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

32. NoAccess#main()

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

33. TestLayer#main()

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

34. NoGetClassLoaderAccess#main()

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

35. ProcessArgumentMatcher#getExcludeStringFrom()

Project: openjdk
File: ProcessArgumentMatcher.java
private static String getExcludeStringFrom(Class<?> excludeClass) {
    if (excludeClass == null) {
        return "";
    }
    Module m = excludeClass.getModule();
    if (m.isNamed()) {
        return m.getName() + "/" + excludeClass.getName();
    }
    return excludeClass.getName();
}

36. Class#getResource()

Project: openjdk
File: Class.java
/**
     * Finds a resource with a given name. If this class is in a named {@link
     * Module Module}, and the caller of this method is in the same module,
     * then this method will attempt to find the resource in that module.
     * Otherwise, the rules for searching resources
     * associated with a given class are implemented by the defining
     * {@linkplain ClassLoader class loader} of the class.  This method
     * delegates to this object's class loader. If this object was loaded by
     * the bootstrap class loader, the method delegates to {@link
     * ClassLoader#getSystemResource}.
     *
     * <p> Before delegation, an absolute resource name is constructed from the
     * given resource name using this algorithm:
     *
     * <ul>
     *
     * <li> If the {@code name} begins with a {@code '/'}
     * (<tt>'\u002f'</tt>), then the absolute name of the resource is the
     * portion of the {@code name} following the {@code '/'}.
     *
     * <li> Otherwise, the absolute name is of the following form:
     *
     * <blockquote>
     *   {@code modified_package_name/name}
     * </blockquote>
     *
     * <p> Where the {@code modified_package_name} is the package name of this
     * object with {@code '/'} substituted for {@code '.'}
     * (<tt>'\u002e'</tt>).
     *
     * </ul>
     *
     * @param  name name of the desired resource
     * @return A {@link java.net.URL} object; {@code null} if no
     *         resource with this name is found or the resource cannot
     *         be located by a URL.
     * @since  1.1
     */
@CallerSensitive
public URL getResource(String name) {
    name = resolveName(name);
    // if this Class and the caller are in the same named module
    // then attempt to get URL to the resource in the module
    Module module = getModule();
    if (module.isNamed()) {
        Class<?> caller = Reflection.getCallerClass();
        if (caller != null && caller.getModule() == module) {
            String mn = getModule().getName();
            ClassLoader cl = getClassLoader0();
            try {
                if (cl == null) {
                    return BootLoader.findResource(mn, name);
                } else {
                    return cl.findResource(mn, name);
                }
            } catch (IOException ioe) {
                return null;
            }
        }
    }
    ClassLoader cl = getClassLoader0();
    if (cl == null) {
        return ClassLoader.getSystemResource(name);
    } else {
        return cl.getResource(name);
    }
}

37. Class#getResourceAsStream()

Project: openjdk
File: Class.java
/**
     * Finds a resource with a given name. If this class is in a named {@link
     * Module Module}, and the caller of this method is in the same module,
     * then this method will attempt to find the resource in that module.
     * Otherwise, the rules for searching resources
     * associated with a given class are implemented by the defining
     * {@linkplain ClassLoader class loader} of the class.  This method
     * delegates to this object's class loader.  If this object was loaded by
     * the bootstrap class loader, the method delegates to {@link
     * ClassLoader#getSystemResourceAsStream}.
     *
     * <p> Before finding a resource in the caller's module or delegation to a
     * class loader, an absolute resource name is constructed from the given
     * resource name using this algorithm:
     *
     * <ul>
     *
     * <li> If the {@code name} begins with a {@code '/'}
     * (<tt>'\u002f'</tt>), then the absolute name of the resource is the
     * portion of the {@code name} following the {@code '/'}.
     *
     * <li> Otherwise, the absolute name is of the following form:
     *
     * <blockquote>
     *   {@code modified_package_name/name}
     * </blockquote>
     *
     * <p> Where the {@code modified_package_name} is the package name of this
     * object with {@code '/'} substituted for {@code '.'}
     * (<tt>'\u002e'</tt>).
     *
     * </ul>
     *
     * @param  name name of the desired resource
     * @return  A {@link java.io.InputStream} object or {@code null} if
     *          no resource with this name is found
     * @throws  NullPointerException If {@code name} is {@code null}
     * @since  1.1
     */
@CallerSensitive
public InputStream getResourceAsStream(String name) {
    name = resolveName(name);
    // if this Class and the caller are in the same named module
    // then attempt to get an input stream to the resource in the
    // module
    Module module = getModule();
    if (module.isNamed()) {
        Class<?> caller = Reflection.getCallerClass();
        if (caller != null && caller.getModule() == module) {
            ClassLoader cl = getClassLoader0();
            String mn = module.getName();
            try {
                // need for a URL connection
                if (cl == null) {
                    return BootLoader.findResourceAsStream(mn, name);
                } else if (cl instanceof BuiltinClassLoader) {
                    return ((BuiltinClassLoader) cl).findResourceAsStream(mn, name);
                } else {
                    URL url = cl.findResource(mn, name);
                    return (url != null) ? url.openStream() : null;
                }
            } catch (IOExceptionSecurityException |  e) {
                return null;
            }
        }
    }
    // this Class and caller not in the same named module
    ClassLoader cl = getClassLoader0();
    if (cl == null) {
        return ClassLoader.getSystemResourceAsStream(name);
    } else {
        return cl.getResourceAsStream(name);
    }
}

38. Services#loadSingle()

Project: openjdk
File: Services.java
/**
     * Gets the JVMCI provider for a given service for which at most one provider must be available.
     *
     * @param service the service whose provider is being requested
     * @param required specifies if an {@link InternalError} should be thrown if no provider of
     *            {@code service} is available
     * @throws SecurityException if a security manager is present and it denies
     *             {@link JVMCIPermission}
     */
public static <S> S loadSingle(Class<S> service, boolean required) {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        sm.checkPermission(new JVMCIPermission());
    }
    Module jvmci = Services.class.getModule();
    jvmci.addUses(service);
    // Restrict JVMCI clients to be on the class path or module path
    Iterable<S> providers = ServiceLoader.load(service, ClassLoader.getSystemClassLoader());
    S singleProvider = null;
    try {
        for (Iterator<S> it = providers.iterator(); it.hasNext(); ) {
            singleProvider = it.next();
            if (it.hasNext()) {
                throw new InternalError(String.format("Multiple %s providers found", service.getName()));
            }
        }
    } catch (ServiceConfigurationError e) {
    }
    if (singleProvider == null && required) {
        String javaHome = System.getProperty("java.home");
        String vmName = System.getProperty("java.vm.name");
        Formatter errorMessage = new Formatter();
        errorMessage.format("The VM does not expose required service %s.%n", service.getName());
        errorMessage.format("Currently used Java home directory is %s.%n", javaHome);
        errorMessage.format("Currently used VM configuration is: %s", vmName);
        throw new UnsupportedOperationException(errorMessage.toString());
    }
    return singleProvider;
}

39. Services#load()

Project: openjdk
File: Services.java
/**
     * Gets an {@link Iterable} of the JVMCI providers available for a given service.
     *
     * @throws SecurityException if a security manager is present and it denies
     *             {@link JVMCIPermission}
     */
public static <S> Iterable<S> load(Class<S> service) {
    SecurityManager sm = System.getSecurityManager();
    if (sm != null) {
        sm.checkPermission(new JVMCIPermission());
    }
    Module jvmci = Services.class.getModule();
    jvmci.addUses(service);
    // Restrict JVMCI clients to be on the class path or module path
    return ServiceLoader.load(service, ClassLoader.getSystemClassLoader());
}

40. BasicModuleTest#testIsExportedToNull()

Project: openjdk
File: BasicModuleTest.java
@Test(expectedExceptions = { NullPointerException.class })
public void testIsExportedToNull() {
    Module thisModule = this.getClass().getModule();
    thisModule.isExported("", null);
}

41. BasicModuleTest#testIsExportedNull()

Project: openjdk
File: BasicModuleTest.java
@Test(expectedExceptions = { NullPointerException.class })
public void testIsExportedNull() {
    Module thisModule = this.getClass().getModule();
    thisModule.isExported(null, thisModule);
}

42. BasicModuleTest#testBaseModule()

Project: openjdk
File: BasicModuleTest.java
@Test
public void testBaseModule() {
    Module base = Object.class.getModule();
    Module thisModule = BasicModuleTest.class.getModule();
    // getName
    assertTrue(base.getName().equals("java.base"));
    // getDescriptor
    assertTrue(base.getDescriptor().exports().stream().anyMatch(doesExport("java.lang")));
    // getClassLoader
    assertTrue(base.getClassLoader() == null);
    // getLayer
    assertTrue(base.getLayer() == Layer.boot());
    // toString
    assertEquals(base.toString(), "module java.base");
    // getPackages
    assertTrue(contains(base.getPackages(), "java.lang"));
    // canRead
    assertTrue(base.canRead(base));
    // isExported
    assertTrue(base.isExported("java.lang"));
    assertTrue(base.isExported("java.lang", thisModule));
    assertFalse(base.isExported("java.wombat"));
    assertFalse(base.isExported("java.wombat", thisModule));
}

43. BasicModuleTest#testThisModule()

Project: openjdk
File: BasicModuleTest.java
@Test
public void testThisModule() {
    Module thisModule = BasicModuleTest.class.getModule();
    Module baseModule = Object.class.getModule();
    assertFalse(thisModule.isNamed());
    assertTrue(thisModule.getName() == null);
    assertTrue(thisModule.getDescriptor() == null);
    assertTrue(thisModule.getLayer() == null);
    assertTrue(thisModule.toString().startsWith("unnamed module "));
    ClassLoader thisLoader = BasicModuleTest.class.getClassLoader();
    assertTrue(thisLoader == thisModule.getClassLoader());
    assertTrue(thisLoader.getUnnamedModule() == thisModule);
    // unnamed modules read all other modules
    ClassLoader cl;
    cl = ClassLoader.getPlatformClassLoader();
    assertTrue(thisModule.canRead(cl.getUnnamedModule()));
    cl = ClassLoader.getSystemClassLoader();
    assertTrue(thisModule.canRead(cl.getUnnamedModule()));
    testReadsAllBootModules(thisModule);
    // unnamed modules export all packages
    assertTrue(thisModule.isExported(""));
    assertTrue(thisModule.isExported("", thisModule));
    assertTrue(thisModule.isExported("", baseModule));
    assertTrue(thisModule.isExported("p"));
    assertTrue(thisModule.isExported("p", thisModule));
    assertTrue(thisModule.isExported("p", baseModule));
    // this test is in the unnamed package
    assertTrue(contains(thisModule.getPackages(), ""));
}

44. Main#tryAccessPublicMembers()

Project: openjdk
File: Main.java
/**
     * Attempt to access public members in a target class.
     */
static void tryAccessPublicMembers(String cn, boolean shouldSucceed) throws Exception {
    Class<?> clazz = Class.forName(cn);
    Module thisModule = Main.class.getModule();
    Module targetModule = clazz.getModule();
    // check if the target class is in an exported package
    String pn = cn.substring(0, cn.lastIndexOf('.'));
    boolean exported = targetModule.isExported(pn, thisModule);
    assertTrue(exported == shouldSucceed);
    boolean shouldFail = !shouldSucceed;
    try {
        clazz.newInstance();
        assertTrue(shouldSucceed);
    } catch (IllegalAccessException e) {
        assertTrue(shouldFail);
    }
    // Constructor.newInstance and Constructor.setAccessible
    Constructor<?> ctor = clazz.getConstructor();
    try {
        ctor.newInstance();
        assertTrue(shouldSucceed);
    } catch (IllegalAccessException e) {
        assertTrue(shouldFail);
    }
    try {
        ctor.setAccessible(true);
        assertTrue(shouldSucceed);
        ctor.newInstance();
    } catch (InaccessibleObjectException e) {
        assertTrue(shouldFail);
    }
    // Method.invoke and Method.setAccessible
    Method m = clazz.getDeclaredMethod("run");
    try {
        m.invoke(null);
        assertTrue(shouldSucceed);
    } catch (IllegalAccessException e) {
        assertTrue(shouldFail);
    }
    try {
        m.setAccessible(true);
        assertTrue(shouldSucceed);
        m.invoke(null);
    } catch (InaccessibleObjectException e) {
        assertTrue(shouldFail);
    }
    // Field.get, Field.set and Field.setAccessible
    Field f = clazz.getDeclaredField("field");
    try {
        f.get(null);
        assertTrue(shouldSucceed);
    } catch (IllegalAccessException e) {
        assertTrue(shouldFail);
    }
    try {
        f.set(null, 100);
        assertTrue(shouldSucceed);
    } catch (IllegalAccessException e) {
        assertTrue(shouldFail);
    }
    try {
        f.setAccessible(true);
        f.get(null);
        f.set(null, 100);
        assertTrue(shouldSucceed);
    } catch (InaccessibleObjectException e) {
        assertTrue(shouldFail);
    }
}

45. BasicLayerTest#testLayerOnBoot()

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

46. StructureLoader#createModule()

Project: openjdk
File: StructureLoader.java
private Module createModule(final String moduleName) {
    final ModuleDescriptor descriptor = new ModuleDescriptor.Builder(moduleName).requires(NASHORN_MODULE.getName()).conceals(SCRIPTS_PKG).build();
    final Module mod = Context.createModuleTrusted(descriptor, this);
    loadModuleManipulator();
    return mod;
}

47. Context#createModuleTrusted()

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

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

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

48. CheckRestrictedPackage#isRestrictedClass()

Project: openjdk
File: CheckRestrictedPackage.java
/**
     * Returns true if the class is either not public, or it resides in a package with restricted access.
     * @param clazz the class to test
     * @return true if the class is either not public, or it resides in a package with restricted access.
     */
static boolean isRestrictedClass(final Class<?> clazz) {
    if (!Modifier.isPublic(clazz.getModifiers())) {
        // Non-public classes are always restricted
        return true;
    }
    final String name = clazz.getName();
    final int i = name.lastIndexOf('.');
    if (i == -1) {
        // Classes in default package are never restricted
        return false;
    }
    final String pkgName = name.substring(0, i);
    final Module module = clazz.getModule();
    if (module != null && !module.isExported(pkgName)) {
        return true;
    }
    final SecurityManager sm = System.getSecurityManager();
    if (sm == null) {
        // No further restrictions if we don't have a security manager
        return false;
    }
    // Do a package access check from within an access control context with no permissions
    try {
        AccessController.doPrivileged(new PrivilegedAction<Void>() {

            @Override
            public Void run() {
                sm.checkPackageAccess(pkgName);
                return null;
            }
        }, NO_PERMISSIONS_CONTEXT);
    } catch (final SecurityException e) {
        return true;
    }
    return false;
}

49. CheckResourceKeys#getResourceKeys()

Project: openjdk
File: CheckResourceKeys.java
/**
     * Get the set of keys from the javac resource bundles.
     */
Set<String> getResourceKeys() {
    Module jdk_compiler = Layer.boot().findModule("jdk.compiler").get();
    Set<String> results = new TreeSet<String>();
    for (String name : new String[] { "javac", "compiler" }) {
        ResourceBundle b = ResourceBundle.getBundle("com.sun.tools.javac.resources." + name, jdk_compiler);
        results.addAll(b.keySet());
    }
    return results;
}

50. CheckExamples#run()

Project: openjdk
File: CheckExamples.java
/**
     * Run the test.
     */
void run() throws Exception {
    Set<Example> examples = getExamples();
    Set<String> notYetList = getNotYetList();
    Set<String> declaredKeys = new TreeSet<String>();
    for (Example e : examples) {
        Set<String> e_decl = e.getDeclaredKeys();
        Set<String> e_actual = e.getActualKeys();
        for (String k : e_decl) {
            if (!e_actual.contains(k))
                error("Example " + e + " declares key " + k + " but does not generate it");
        }
        for (String k : e_actual) {
            if (!e_decl.contains(k))
                error("Example " + e + " generates key " + k + " but does not declare it");
        }
        for (String k : e.getDeclaredKeys()) {
            if (notYetList.contains(k))
                error("Example " + e + " declares key " + k + " which is also on the \"not yet\" list");
            declaredKeys.add(k);
        }
    }
    Module jdk_compiler = Layer.boot().findModule("jdk.compiler").get();
    ResourceBundle b = ResourceBundle.getBundle("com.sun.tools.javac.resources.compiler", jdk_compiler);
    Set<String> resourceKeys = new TreeSet<String>(b.keySet());
    for (String dk : declaredKeys) {
        if (!resourceKeys.contains(dk))
            error("Key " + dk + " is declared in tests but is not a valid key in resource bundle");
    }
    for (String nk : notYetList) {
        if (!resourceKeys.contains(nk))
            error("Key " + nk + " is declared in not-yet list but is not a valid key in resource bundle");
    }
    for (String rk : resourceKeys) {
        if (!declaredKeys.contains(rk) && !notYetList.contains(rk))
            error("Key " + rk + " is declared in resource bundle but is not in tests or not-yet list");
    }
    System.err.println(examples.size() + " examples checked");
    System.err.println(notYetList.size() + " keys on not-yet list");
    Counts declaredCounts = new Counts(declaredKeys);
    Counts resourceCounts = new Counts(resourceKeys);
    List<String> rows = new ArrayList<String>(Arrays.asList(Counts.prefixes));
    rows.add("other");
    rows.add("total");
    System.err.println();
    System.err.println(String.format("%-14s %15s %15s %4s", "prefix", "#keys in tests", "#keys in javac", "%"));
    for (String p : rows) {
        int d = declaredCounts.get(p);
        int r = resourceCounts.get(p);
        System.err.print(String.format("%-14s %15d %15d", p, d, r));
        if (r != 0)
            System.err.print(String.format(" %3d%%", (d * 100) / r));
        System.err.println();
    }
    if (errors > 0)
        throw new Exception(errors + " errors occurred.");
}

51. ResourceCheckTest#main()

Project: openjdk
File: ResourceCheckTest.java
public static void main(String... args) {
    List<String> errors = new ArrayList<>();
    // Ensure that all Message fields have a corresponding key/value
    // in the resource bundle and that mnemonics can be looked
    // up where applicable.
    Module module = sun.tools.jconsole.Messages.class.getModule();
    ResourceBundle rb = ResourceBundle.getBundle(RESOURCE_BUNDLE, module);
    for (Field field : Messages.class.getFields()) {
        if (isResourceKeyField(field)) {
            String resourceKey = field.getName();
            String message = readField(field);
            if (message.startsWith(MISSING_RESOURCE_KEY_PREFIX)) {
                errors.add("Can't find message (and perhaps mnemonic) for " + Messages.class.getSimpleName() + "." + resourceKey + " in resource bundle.");
            } else {
                String resourceMessage = rb.getString(resourceKey);
                if (hasMnemonicIdentifier(resourceMessage)) {
                    int mi = Resources.getMnemonicInt(message);
                    if (mi == 0) {
                        errors.add("Could not look up mnemonic for message '" + message + "'.");
                    }
                }
            }
        }
    }
    // Ensure that there is Message class field for every resource key.
    for (String key : Collections.list(rb.getKeys())) {
        try {
            Messages.class.getField(key);
        } catch (NoSuchFieldException nfe) {
            errors.add("Can't find static field (" + Messages.class.getSimpleName() + "." + key + ") matching '" + key + "' in resource bundle. Unused message?");
        }
    }
    if (errors.size() > 0) {
        throwError(errors);
    }
}

52. Main#main()

Project: openjdk
File: Main.java
public static void main(String[] args) {
    // local resource
    ResourceBundle.getBundle(TEST_RESOURCE_BUNDLE_NAME, Main.class.getModule());
    // resource in another module
    Module m1 = p1.Bundle.class.getModule();
    ResourceBundle rb1 = Bundle.getBundle(M1_RESOURCE_BUNDLE_NAME);
    ResourceBundle rb2 = ResourceBundle.getBundle(M1_RESOURCE_BUNDLE_NAME, m1);
    if (rb1 != rb2) {
        throw new RuntimeException("unexpected resource bundle");
    }
    System.setSecurityManager(new SecurityManager());
    // no permission needed for local resource
    ResourceBundle.getBundle(TEST_RESOURCE_BUNDLE_NAME, Main.class.getModule());
    // resource bundle through m1's exported API
    Bundle.getBundle(M1_RESOURCE_BUNDLE_NAME);
    try {
        // fail to get resource bundle in another module
        ResourceBundle.getBundle(M1_RESOURCE_BUNDLE_NAME, m1);
        throw new RuntimeException("should deny access");
    } catch (SecurityException e) {
    }
}

53. ResourceBundleTest#verifySetup()

Project: openjdk
File: ResourceBundleTest.java
static void verifySetup() {
    Module m = ResourceBundleTest.class.getModule();
    System.out.println("Module Name for ResourceBundleTest : " + m.getName());
    assertTrue(!m.isNamed());
    m = ModuleLoggerAccess.class.getModule();
    System.out.println("Module Name for ModuleLoggerAccess : " + m.getName());
    assertTrue(m.isNamed());
}

54. LocalizedLevelName#getLocalizedMessage()

Project: openjdk
File: LocalizedLevelName.java
private static String getLocalizedMessage(Locale locale, String key) {
    // this test verifies if the logging.properties in the java.logging module
    // is localized.
    Module module = java.util.logging.Level.class.getModule();
    ResourceBundle rb = ResourceBundle.getBundle(RBNAME, locale, module);
    return rb.getString(key);
}

55. DefaultProviderList#main()

Project: openjdk
File: DefaultProviderList.java
public static void main(String[] args) throws Exception {
    Provider[] defaultProvs = Security.getProviders();
    System.out.println("Providers: " + Arrays.asList(defaultProvs));
    System.out.println();
    ServiceLoader<Provider> sl = ServiceLoader.load(Provider.class);
    boolean failed = false;
    Module baseMod = Object.class.getModule();
    // through ServiceLoader
    for (Provider p : defaultProvs) {
        String pName = p.getName();
        Class pClass = p.getClass();
        if (pClass.getModule() != baseMod) {
            String pClassName = pClass.getName();
            Iterator<Provider> provIter = sl.iterator();
            boolean found = false;
            while (provIter.hasNext()) {
                Provider pFromSL = provIter.next();
                // will have a different name after being configured.
                if (pFromSL.getClass().getName().equals(pClassName)) {
                    found = true;
                    System.out.println("SL found provider " + pName);
                    break;
                }
            }
            if (!found) {
                failed = true;
                System.out.println("Error: SL cannot find provider " + pName);
            }
        }
    }
    // Test#2: check that all security providers found through ServiceLoader
    // are not from base module
    Iterator<Provider> provIter = sl.iterator();
    while (provIter.hasNext()) {
        Provider pFromSL = provIter.next();
        if (pFromSL.getClass().getModule() == baseMod) {
            failed = true;
            System.out.println("Error: base provider " + pFromSL.getName() + " loaded by SL");
        }
    }
    if (!failed) {
        System.out.println("Test Passed");
    } else {
        throw new Exception("One or more tests failed");
    }
}

56. Test#main()

Project: openjdk
File: Test.java
public static void main(String... args) {
    SecurityManager sm = System.getSecurityManager();
    Module module = sm.getClass().getModule();
    String s = System.getProperty("java.security.manager");
    String expected = s.isEmpty() ? "java.base" : "m";
    if (!module.isNamed() || !module.getName().equals(expected)) {
        throw new RuntimeException(module + " expected module m instead");
    }
}

57. Main#proxiesWithAddReads()

Project: openjdk
File: Main.java
/*
     * Test cases for proxy class to implement accessible proxy interfaces
     * after addReads. That does not change the target module.
     */
static Data[] proxiesWithAddReads() {
    Module unnamed = test.getClassLoader().getUnnamedModule();
    test.addReads(unnamed);
    return new Data[] { new Data(test.getClassLoader(), unnamedModuleClass, p.one.I.class, // module-private interface in test
    jdk.test.internal.R.class) };
}

58. ProxyModuleMapping#verifyNewProxyInstance()

Project: openjdk
File: ProxyModuleMapping.java
void verifyNewProxyInstance() throws Exception {
    Object o = Proxy.newProxyInstance(loader, interfaces, ih);
    Module m = o.getClass().getModule();
    if (target != null && m != target) {
        throw new RuntimeException(m + " not expected: " + target);
    }
    if (target == null && (!m.isNamed() || !m.getName().startsWith("jdk.proxy"))) {
        throw new RuntimeException(m + " not expected: dynamic module");
    }
}

59. ProxyModuleMapping#main()

Project: openjdk
File: ProxyModuleMapping.java
public static void main(String... args) throws Exception {
    ClassLoader ld = ProxyModuleMapping.class.getClassLoader();
    Module unnamed = ld.getUnnamedModule();
    new ProxyModuleMapping(unnamed, Runnable.class).test();
    // unnamed module gets access to sun.invoke package (e.g. via -XaddExports)
    new ProxyModuleMapping(sun.invoke.WrapperInstance.class).test();
    Class<?> modulePrivateIntf = Class.forName("sun.net.ProgressListener");
    new ProxyModuleMapping(modulePrivateIntf).test();
}

60. AddExportsTest#main()

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

61. LayerAndLoadersTest#testLoadFail()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Test that a class cannot be loaded via any of the class loaders of
     * the modules in the given layer.
     */
static void testLoadFail(Layer layer, String cn) throws Exception {
    for (Module m : layer.modules()) {
        ClassLoader l = m.getClassLoader();
        try {
            l.loadClass(cn);
            assertTrue(false);
        } catch (ClassNotFoundException expected) {
        }
    }
}

62. LayerAndLoadersTest#testLoad()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Test that a class can be loaded via the class loader of all modules
     * in the given layer.
     */
static void testLoad(Layer layer, String cn) throws Exception {
    for (Module m : layer.modules()) {
        ClassLoader l = m.getClassLoader();
        l.loadClass(cn);
    }
}

63. LayerAndLoadersTest#testServicesWithManyLoaders()

Project: openjdk
File: LayerAndLoadersTest.java
/**
     * Basic test of Layer defineModulesWithManyLoaders where one of the
     * modules is a service provider module.
     *
     * Test scenario:
     *    m1 requires m2 and m3
     *    m1 uses S
     *    m4 provides S with ...
     */
public void testServicesWithManyLoaders() throws Exception {
    Configuration cf = resolveRequiresAndUses("m1");
    ClassLoader scl = ClassLoader.getSystemClassLoader();
    Layer layer = Layer.boot().defineModulesWithManyLoaders(cf, scl);
    checkLayer(layer, "m1", "m2", "m3", "m4");
    ClassLoader cl1 = layer.findLoader("m1");
    ClassLoader cl2 = layer.findLoader("m2");
    ClassLoader cl3 = layer.findLoader("m3");
    ClassLoader cl4 = layer.findLoader("m4");
    assertTrue(cl1.getParent() == scl);
    assertTrue(cl2.getParent() == scl);
    assertTrue(cl3.getParent() == scl);
    assertTrue(cl4.getParent() == scl);
    assertTrue(cl2 != cl1);
    assertTrue(cl3 != cl1);
    assertTrue(cl3 != cl2);
    assertTrue(cl4 != cl1);
    assertTrue(cl4 != cl2);
    assertTrue(cl4 != cl3);
    Class<?> serviceType = cl1.loadClass("p.Service");
    assertTrue(serviceType.getClassLoader() == cl1);
    // the class loaders in the layer
    for (Module m : layer.modules()) {
        ClassLoader loader = m.getClassLoader();
        Iterator<?> iter = ServiceLoader.load(serviceType, loader).iterator();
        Object provider = iter.next();
        assertTrue(serviceType.isInstance(provider));
        assertTrue(provider.getClass().getClassLoader() == cl4);
        assertFalse(iter.hasNext());
    }
}

64. BasicLayerTest#testImmutableSet()

Project: openjdk
File: BasicLayerTest.java
// immutable sets
@Test(expectedExceptions = { UnsupportedOperationException.class })
public void testImmutableSet() {
    Module base = Object.class.getModule();
    Layer.boot().modules().add(base);
}

65. BasicLayerTest#testBoot()

Project: openjdk
File: BasicLayerTest.java
/**
     * Exercise Layer.boot()
     */
public void testBoot() {
    Layer bootLayer = Layer.boot();
    // configuration
    Configuration cf = bootLayer.configuration();
    assertTrue(cf.findModule("java.base").get().reference().descriptor().exports().stream().anyMatch( e -> (e.source().equals("java.lang") && !e.isQualified())));
    // modules
    Set<Module> modules = bootLayer.modules();
    assertTrue(modules.contains(Object.class.getModule()));
    int count = (int) modules.stream().map(Module::getName).count();
    // module names are unique
    assertEquals(count, modules.size());
    // findModule
    Module base = Object.class.getModule();
    assertTrue(bootLayer.findModule("java.base").get() == base);
    assertTrue(base.getLayer() == bootLayer);
    // findLoader
    assertTrue(bootLayer.findLoader("java.base") == null);
    // parent
    assertTrue(bootLayer.parent().get() == Layer.empty());
}

66. ModuleDescriptorTest#testReadWithNull()

Project: openjdk
File: ModuleDescriptorTest.java
public void testReadWithNull() throws Exception {
    Module base = Object.class.getModule();
    try {
        ModuleDescriptor.read((InputStream) null);
        assertTrue(false);
    } catch (NullPointerException expected) {
    }
    try (InputStream in = base.getResourceAsStream("module-info.class")) {
        try {
            ModuleDescriptor.read(in, null);
            assertTrue(false);
        } catch (NullPointerException expected) {
        }
    }
    try {
        ModuleDescriptor.read((ByteBuffer) null);
        assertTrue(false);
    } catch (NullPointerException expected) {
    }
    try (InputStream in = base.getResourceAsStream("module-info.class")) {
        ByteBuffer bb = ByteBuffer.wrap(in.readAllBytes());
        try {
            ModuleDescriptor.read(bb, null);
            assertTrue(false);
        } catch (NullPointerException expected) {
        }
    }
}

67. RedefineClassWithNativeMethodAgent#premain()

Project: openjdk
File: RedefineClassWithNativeMethodAgent.java
// just read the original class and redefine it via a Timer
public static void premain(String agentArgs, final Instrumentation inst) throws Exception {
    String s = agentArgs.substring(0, agentArgs.indexOf(".class"));
    clz = Class.forName(s.replace('/', '.'));
    InputStream in;
    Module m = clz.getModule();
    if (m != null) {
        in = m.getResourceAsStream(agentArgs);
    } else {
        ClassLoader loader = RedefineClassWithNativeMethodAgent.class.getClassLoader();
        in = loader.getResourceAsStream(agentArgs);
    }
    if (in == null) {
        throw new Exception("Cannot find class: " + agentArgs);
    }
    byte[] buffer = in.readAllBytes();
    new Timer(true).schedule(new TimerTask() {

        public void run() {
            try {
                System.out.println("Instrumenting");
                ClassDefinition cld = new ClassDefinition(clz, buffer);
                inst.redefineClasses(new ClassDefinition[] { cld });
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }, 500);
}

68. GetModuleTest#testGetModule()

Project: openjdk
File: GetModuleTest.java
@Test(dataProvider = "testclasses")
public void testGetModule(Class<?> type, String expected) {
    Module m = type.getModule();
    assertNotNull(m);
    if (expected == null) {
        assertTrue(m == TEST_MODULE);
    } else {
        assertEquals(m.getName(), expected);
    }
}

69. LogManager#demandSystemLogger()

Project: openjdk
File: LogManager.java
Logger demandSystemLogger(String name, String resourceBundleName, Class<?> caller) {
    final Module module = caller == null ? null : caller.getModule();
    return demandSystemLogger(name, resourceBundleName, module);
}

70. LogManager#demandLogger()

Project: openjdk
File: LogManager.java
// Find or create a specified logger instance. If a logger has
// already been created with the given name it is returned.
// Otherwise a new logger instance is created and registered
// in the LogManager global namespace.
// This method will always return a non-null Logger object.
// Synchronization is not required here. All synchronization for
// adding a new Logger object is handled by addLogger().
//
// This method must delegate to the LogManager implementation to
// add a new Logger or return the one that has been added previously
// as a LogManager subclass may override the addLogger, getLogger,
// readConfiguration, and other methods.
Logger demandLogger(String name, String resourceBundleName, Class<?> caller) {
    final Module module = caller == null ? null : caller.getModule();
    return demandLogger(name, resourceBundleName, module);
}

71. Logger#setupResourceInfo()

Project: openjdk
File: Logger.java
private void setupResourceInfo(String name, Class<?> caller) {
    final Module module = caller == null ? null : caller.getModule();
    setupResourceInfo(name, module);
}

72. Logger#findResourceBundle()

Project: openjdk
File: Logger.java
/**
     * Private utility method to map a resource bundle name to an
     * actual resource bundle, using a simple one-entry cache.
     * Returns null for a null name.
     * May also return null if we can't find the resource bundle and
     * there is no suitable previous cached value.
     *
     * @param name the ResourceBundle to locate
     * @param useCallersModule if true search using the caller's module.
     * @return ResourceBundle specified by name or null if not found
     */
private synchronized ResourceBundle findResourceBundle(String name, boolean useCallersModule) {
    // Return a null bundle for a null name.
    if (name == null) {
        return null;
    }
    Locale currentLocale = Locale.getDefault();
    final LoggerBundle lb = loggerBundle;
    // Normally we should hit on our simple one entry cache.
    if (lb.userBundle != null && name.equals(lb.resourceBundleName)) {
        return lb.userBundle;
    } else if (catalog != null && currentLocale.equals(catalogLocale) && name.equals(catalogName)) {
        return catalog;
    }
    // Use the thread's context ClassLoader.  If there isn't one, use the
    // {@linkplain java.lang.ClassLoader#getSystemClassLoader() system ClassLoader}.
    ClassLoader cl = Thread.currentThread().getContextClassLoader();
    if (cl == null) {
        cl = ClassLoader.getSystemClassLoader();
    }
    final Module callerModule = getCallerModule();
    // We also look in the TCCL if callerModule is null or unnamed.
    if (!useCallersModule || callerModule == null || !callerModule.isNamed()) {
        try {
            Module mod = cl.getUnnamedModule();
            PrivilegedAction<ResourceBundle> pa = () -> ResourceBundle.getBundle(name, currentLocale, mod);
            catalog = AccessController.doPrivileged(pa, null, GET_CLASS_LOADER_PERMISSION);
            catalogName = name;
            catalogLocale = currentLocale;
            return catalog;
        } catch (MissingResourceException ex) {
            if (useCallersModule && callerModule != null) {
                try {
                    PrivilegedAction<ClassLoader> getModuleClassLoader = () -> callerModule.getClassLoader();
                    ClassLoader moduleCL = AccessController.doPrivileged(getModuleClassLoader);
                    if (moduleCL == cl || moduleCL == null)
                        return null;
                    catalog = ResourceBundle.getBundle(name, currentLocale, moduleCL);
                    catalogName = name;
                    catalogLocale = currentLocale;
                    return catalog;
                } catch (MissingResourceException x) {
                    return null;
                }
            } else {
                return null;
            }
        }
    } else {
        // Try with the caller's module
        try {
            // Use the caller's module
            PrivilegedAction<ResourceBundle> pa = () -> ResourceBundle.getBundle(name, currentLocale, callerModule);
            catalog = AccessController.doPrivileged(pa, null, GET_CLASS_LOADER_PERMISSION);
            catalogName = name;
            catalogLocale = currentLocale;
            return catalog;
        } catch (MissingResourceException ex) {
            return null;
        }
    }
}

73. Level#computeLocalizedLevelName()

Project: openjdk
File: Level.java
private String computeLocalizedLevelName(Locale newLocale) {
    // Resource bundle should be loaded from the defining module
    // or its defining class loader, if it's unnamed module,
    // of this Level instance that can be a custom Level subclass;
    Module module = this.getClass().getModule();
    ResourceBundle rb = ResourceBundle.getBundle(resourceBundleName, newLocale, module);
    final String localizedName = rb.getString(name);
    final boolean isDefaultBundle = defaultBundle.equals(resourceBundleName);
    if (!isDefaultBundle)
        return localizedName;
    // This is a trick to determine whether the name has been translated
    // or not. If it has not been translated, we need to use Locale.ROOT
    // when calling toUpperCase().
    final Locale rbLocale = rb.getLocale();
    final Locale locale = Locale.ROOT.equals(rbLocale) || name.equals(localizedName.toUpperCase(Locale.ROOT)) ? Locale.ROOT : rbLocale;
    // to uppercase for compatibility reason.
    return Locale.ROOT.equals(locale) ? name : localizedName.toUpperCase(locale);
}

74. LauncherHelper#loadModuleMainClass()

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

75. AbstractResourceBundleProvider#getBundle()

Project: openjdk
File: AbstractResourceBundleProvider.java
/**
     * Returns a {@code ResourceBundle} for the given {@code baseName} and
     * {@code locale}. This method calls the
     * {@link #toBundleName(String, Locale) toBundleName} method to get the
     * bundle name for the {@code baseName} and {@code locale}. The formats
     * specified by the constructor will be searched to find the resource
     * bundle.
     *
     * @implNote
     * The default implementation of this method will find the resource bundle
     * local to the module of this provider.
     *
     * @param baseName the base bundle name of the resource bundle, a fully
     *                 qualified class name.
     * @param locale the locale for which the resource bundle should be instantiated
     * @return {@code ResourceBundle} of the given {@code baseName} and {@code locale},
     *         or null if no resource bundle is found
     * @throws NullPointerException if {@code baseName} or {@code locale} is null
     * @throws UncheckedIOException if any IO exception occurred during resource
     *         bundle loading
     */
@Override
public ResourceBundle getBundle(String baseName, Locale locale) {
    Module module = this.getClass().getModule();
    String bundleName = toBundleName(baseName, locale);
    ResourceBundle bundle = null;
    for (String format : formats) {
        try {
            if (FORMAT_CLASS.equals(format)) {
                PrivilegedAction<ResourceBundle> pa = () -> ResourceBundleProviderSupport.loadResourceBundle(module, bundleName);
                bundle = AccessController.doPrivileged(pa, null, GET_CLASSLOADER_PERMISSION);
            } else if (FORMAT_PROPERTIES.equals(format)) {
                bundle = ResourceBundleProviderSupport.loadPropertyResourceBundle(module, bundleName);
            }
            if (bundle != null) {
                break;
            }
        } catch (IOException e) {
            throw new UncheckedIOException(e);
        }
    }
    return bundle;
}

76. Main#belongToModule()

Project: openjdk
File: Main.java
/*
     * verify which module provides the xml factory
     */
private static boolean belongToModule(String factoryName, Object factory, Module expected) {
    Module actual = factory.getClass().getModule();
    if (!actual.equals(expected)) {
        System.err.println("Expect " + factoryName + " is provided by " + expected + ", but actual implementation " + factory.getClass() + " is provided by " + actual);
        return false;
    } else {
        System.out.println(factory.getClass() + " is provided by " + expected);
        return true;
    }
}

77. Main#main()

Project: openjdk
File: Main.java
/*
     * @param args, the names of provider modules, which have been loaded
     */
public static void main(String[] args) throws Exception {
    Module xml = Layer.boot().findModule("java.xml").get();
    Set<String> allServices = new HashSet<>(Arrays.asList(expectedAllServices));
    if (!allServices.equals(xml.getDescriptor().uses()))
        throw new AssertionError("Expect xml module uses: " + allServices + " But actually uses: " + xml.getDescriptor().uses());
    long violationCount = Stream.of(args).map( xmlProviderName -> Layer.boot().findModule(xmlProviderName).get()).mapToLong(// services provided by the implementation in provider module
     provider -> provider.getDescriptor().provides().keySet().stream().filter( serviceName -> {
        allServices.remove(serviceName);
        return !belongToModule(serviceName, instantiateXMLService(serviceName), provider);
    }).count()).sum();
    // the remaining services should be provided by the default implementation
    violationCount += allServices.stream().filter( serviceName -> !belongToModule(serviceName, instantiateXMLService(serviceName), xml)).count();
    if (violationCount > 0)
        throw new AssertionError(violationCount + " services are not provided by expected module");
}

78. TemplatesImpl#createModule()

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

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

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

79. JVMAddModuleExports#main()

Project: openjdk
File: JVMAddModuleExports.java
public static void main(String args[]) throws Throwable {
    MyClassLoader from_cl = new MyClassLoader();
    MyClassLoader to_cl = new MyClassLoader();
    Module from_module, to_module;
    from_module = ModuleHelper.ModuleObject("from_module", from_cl, new String[] { "mypackage", "this/package" });
    assertNotNull(from_module, "Module should not be null");
    ModuleHelper.DefineModule(from_module, "9.0", "from_module/here", new String[] { "mypackage", "this/package" });
    to_module = ModuleHelper.ModuleObject("to_module", to_cl, new String[] { "yourpackage", "that/package" });
    assertNotNull(to_module, "Module should not be null");
    ModuleHelper.DefineModule(to_module, "9.0", "to_module/here", new String[] { "yourpackage", "that/package" });
    // Null from_module argument, expect an NPE
    try {
        ModuleHelper.AddModuleExports((Module) null, "mypackage", to_module);
        throw new RuntimeException("Failed to get the expected NPE for null from_module");
    } catch (NullPointerException e) {
    }
    // Null to_module argument, expect an NPE
    try {
        ModuleHelper.AddModuleExports(from_module, "mypackage", (Module) null);
        throw new RuntimeException("Failed to get the expected NPE for null to_module");
    } catch (NullPointerException e) {
    }
    // Bad from_module argument, expect an IAE
    try {
        ModuleHelper.AddModuleExports(to_cl, "mypackage", to_module);
        throw new RuntimeException("Failed to get the expected IAE");
    } catch (IllegalArgumentException e) {
    }
    // Null package argument, expect an NPE
    try {
        ModuleHelper.AddModuleExports(from_module, null, to_module);
        throw new RuntimeException("Failed to get the expected NPE");
    } catch (NullPointerException e) {
    }
    // Bad to_module argument, expect an IAE
    try {
        ModuleHelper.AddModuleExports(from_module, "mypackage", from_cl);
        throw new RuntimeException("Failed to get the expected IAE");
    } catch (IllegalArgumentException e) {
    }
    // Exporting a package to the same module
    ModuleHelper.AddModuleExports(from_module, "mypackage", from_module);
    // Export a package that does not exist to to_module
    try {
        ModuleHelper.AddModuleExports(from_module, "notmypackage", to_module);
        throw new RuntimeException("Failed to get the expected IAE");
    } catch (IllegalArgumentException e) {
    }
    // Export a package, that is not in from_module, to to_module
    try {
        ModuleHelper.AddModuleExports(from_module, "yourpackage", to_module);
        throw new RuntimeException("Failed to get the expected IAE");
    } catch (IllegalArgumentException e) {
    }
    // Export a package, that does not exist, to from_module
    try {
        ModuleHelper.AddModuleExports(from_module, "notmypackage", from_module);
        throw new RuntimeException("Failed to get the expected IAE");
    } catch (IllegalArgumentException e) {
    }
    // Export a package, that is not in from_module, to from_module
    try {
        ModuleHelper.AddModuleExports(from_module, "that/package", from_module);
        throw new RuntimeException("Failed to get the expected IAE");
    } catch (IllegalArgumentException e) {
    }
    // Export the same package twice to the same module
    ModuleHelper.AddModuleExports(from_module, "this/package", to_module);
    ModuleHelper.AddModuleExports(from_module, "this/package", to_module);
    // Export a package, using '.' instead of '/'
    try {
        ModuleHelper.AddModuleExports(from_module, "this.package", to_module);
        throw new RuntimeException("Failed to get the expected IAE");
    } catch (IllegalArgumentException e) {
    }
    // Export a package to the unnamed module and then to a specific module.
    // The qualified export should be ignored.
    ModuleHelper.AddModuleExportsToAll(to_module, "that/package");
    ModuleHelper.AddModuleExports(to_module, "that/package", from_module);
}

80. Umod#test_looseModuleLayer()

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

81. ExportAllUnnamed#createLayerOnBoot()

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

82. DiffCL_Umod#test_looseModuleLayer()

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