1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
|
/*
* Copyright (c) 2016, 2018, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/**
* @test
* @summary Verifies the JVMTI GetAllModules API
* @library /test/lib
* @run main/othervm/native -agentlib:JvmtiGetAllModulesTest JvmtiGetAllModulesTest
*
*/
import java.lang.module.ModuleReference;
import java.lang.module.ModuleFinder;
import java.lang.module.ModuleReader;
import java.lang.module.ModuleDescriptor;
import java.lang.module.Configuration;
import java.util.Arrays;
import java.util.Set;
import java.util.Map;
import java.util.function.Supplier;
import java.util.Objects;
import java.util.Optional;
import java.net.URI;
import java.util.HashSet;
import java.util.HashMap;
import java.util.stream.Collectors;
import jdk.test.lib.Asserts;
public class JvmtiGetAllModulesTest {
static class MyModuleReference extends ModuleReference {
public MyModuleReference(ModuleDescriptor descriptor, URI uri) {
super(descriptor, uri);
}
// Trivial implementation to make the class non-abstract
public ModuleReader open() {
return null;
}
}
private static native Module[] getModulesNative();
private static Set<Module> getModulesJVMTI() {
Set<Module> modules = Arrays.stream(getModulesNative()).collect(Collectors.toSet());
// JVMTI reports unnamed modules, Java API does not
// remove the unnamed modules here, so the resulting report can be expected
// to be equal to what Java reports
modules.removeIf(mod -> !mod.isNamed());
// jdk.proxy1 and jdk.proxy2 modules are dynamically initialized by Graal code in case Graal VM is used.
// We need to filter them out because they are not part of boot modules. See more details in JDK-8195156.
modules.removeIf(mod -> mod.getName().startsWith("jdk.proxy"));
return modules;
}
public static void main(String[] args) throws Exception {
final String MY_MODULE_NAME = "myModule";
// Verify that JVMTI reports exactly the same info as Java regarding the named modules
Asserts.assertEquals(ModuleLayer.boot().modules(), getModulesJVMTI());
// Load a new named module
ModuleDescriptor descriptor = ModuleDescriptor.newModule(MY_MODULE_NAME).build();
ModuleFinder finder = finderOf(descriptor);
ClassLoader loader = new ClassLoader() {};
Configuration parent = ModuleLayer.boot().configuration();
Configuration cf = parent.resolve(finder, ModuleFinder.of(), Set.of(MY_MODULE_NAME));
ModuleLayer my = ModuleLayer.boot().defineModules(cf, m -> loader);
// Verify that the loaded module is indeed reported by JVMTI
Set<Module> jvmtiModules = getModulesJVMTI();
for (Module mod : my.modules()) {
if (!jvmtiModules.contains(mod)) {
throw new RuntimeException("JVMTI did not report the loaded named module: " + mod.getName());
}
}
}
/**
* Returns a ModuleFinder that finds modules with the given module
* descriptors.
*/
static ModuleFinder finderOf(ModuleDescriptor... descriptors) {
// Create a ModuleReference for each module
Map<String, ModuleReference> namesToReference = new HashMap<>();
for (ModuleDescriptor descriptor : descriptors) {
String name = descriptor.name();
URI uri = URI.create("module:/" + name);
ModuleReference mref = new MyModuleReference(descriptor, uri);
namesToReference.put(name, mref);
}
return new ModuleFinder() {
@Override
public Optional<ModuleReference> find(String name) {
Objects.requireNonNull(name);
return Optional.ofNullable(namesToReference.get(name));
}
@Override
public Set<ModuleReference> findAll() {
return new HashSet<>(namesToReference.values());
}
};
}
}
|
