1 /*
2 * Copyright (c) 2014, 2017, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24 import java.lang.module.ModuleDescriptor.Exports;
25 import java.lang.module.ResolvedModule;
26 import java.lang.reflect.Layer;
27 import java.lang.reflect.Module;
28 import java.nio.file.spi.FileSystemProvider; // service type in java.base
29 import java.util.function.Predicate;
30 import java.util.stream.Stream;
31 import javax.print.PrintServiceLookup; // service type in java.desktop
32
33 import org.testng.annotations.Test;
34 import static org.testng.Assert.*;
35
36 /*
37 * @test
38 * @summary Basic test of java.lang.reflect.Module
39 * @modules java.desktop java.xml
40 * @run testng BasicModuleTest
41 */
42
43 public class BasicModuleTest {
44
45 /**
46 * Tests that the given module reads all modules in the boot Layer.
47 */
48 private void testReadsAllBootModules(Module m) {
49 Layer bootLayer = Layer.boot();
50 bootLayer.configuration()
51 .modules()
52 .stream()
53 .map(ResolvedModule::name)
54 .map(bootLayer::findModule)
55 .forEach(target -> assertTrue(m.canRead(target.get())));
56 }
57
58 /**
59 * Returns {@code true} if the array contains the given object.
60 */
61 private <T> boolean contains(T[] array, T obj) {
62 return Stream.of(array).anyMatch(obj::equals);
63 }
64
65 /**
66 * Returns a {@code Predicate} to test if a package is exported.
67 */
68 private Predicate<Exports> doesExport(String pn) {
69 return e -> (e.source().equals(pn) && !e.isQualified());
70 }
71
72
73
74 @Test
75 public void testThisModule() {
76 Module thisModule = BasicModuleTest.class.getModule();
77 Module baseModule = Object.class.getModule();
78
79 assertFalse(thisModule.isNamed());
80 assertTrue(thisModule.getName() == null);
81 assertTrue(thisModule.getDescriptor() == null);
82 assertTrue(thisModule.getLayer() == null);
83 assertTrue(thisModule.toString().startsWith("unnamed module "));
84
85 ClassLoader thisLoader = BasicModuleTest.class.getClassLoader();
86 assertTrue(thisLoader == thisModule.getClassLoader());
87 assertTrue(thisLoader.getUnnamedModule() == thisModule);
88
89 // unnamed modules read all other modules
90 ClassLoader cl;
91 cl = ClassLoader.getPlatformClassLoader();
92 assertTrue(thisModule.canRead(cl.getUnnamedModule()));
93 cl = ClassLoader.getSystemClassLoader();
94 assertTrue(thisModule.canRead(cl.getUnnamedModule()));
95 testReadsAllBootModules(thisModule);
96
97 // unnamed modules export all packages
98 assertTrue(thisModule.isExported(""));
99 assertTrue(thisModule.isExported("", thisModule));
100 assertTrue(thisModule.isExported("", baseModule));
101 assertTrue(thisModule.isExported("p"));
102 assertTrue(thisModule.isExported("p", thisModule));
103 assertTrue(thisModule.isExported("p", baseModule));
104
105 // this test is in the unnamed package
106 assertTrue(contains(thisModule.getPackages(), ""));
107 }
108
109
110 @Test
111 public void testUnnamedModules() {
112 Module thisModule = BasicModuleTest.class.getModule();
113 Module baseModule = Object.class.getModule();
114
115 ClassLoader loader1 = ClassLoader.getSystemClassLoader();
116 ClassLoader loader2 = loader1.getParent();
117
118 Module m1 = loader1.getUnnamedModule();
119 Module m2 = loader2.getUnnamedModule();
120
121 assertTrue(m1 != m2);
122
123 assertFalse(m1.isNamed());
124 assertFalse(m2.isNamed());
125
126 assertTrue(m1.getLayer() == null);
127 assertTrue(m2.getLayer() == null);
128
129 assertTrue(m1.toString().startsWith("unnamed module "));
130 assertTrue(m2.toString().startsWith("unnamed module "));
131
132 // unnamed module reads all modules
133 assertTrue(m1.canRead(m2));
134 assertTrue(m2.canRead(m1));
135
136 testReadsAllBootModules(m1);
137 testReadsAllBootModules(m2);
138
139 assertTrue(m1.isExported(""));
140 assertTrue(m1.isExported("", thisModule));
141 assertTrue(m1.isExported("", baseModule));
142 assertTrue(m1.isExported("p"));
143 assertTrue(m1.isExported("p", thisModule));
144 assertTrue(m1.isExported("p", baseModule));
145 }
146
147
148
149 @Test
150 public void testBaseModule() {
151 Module base = Object.class.getModule();
152 Module thisModule = BasicModuleTest.class.getModule();
153
154 // getName
155 assertTrue(base.getName().equals("java.base"));
156
157 // getDescriptor
158 assertTrue(base.getDescriptor().exports().stream()
159 .anyMatch(doesExport("java.lang")));
160
161 // getClassLoader
162 assertTrue(base.getClassLoader() == null);
163
164 // getLayer
165 assertTrue(base.getLayer() == Layer.boot());
166
167 // toString
168 assertEquals(base.toString(), "module java.base");
169
170 // getPackages
171 assertTrue(contains(base.getPackages(), "java.lang"));
172
173 // canRead
174 assertTrue(base.canRead(base));
175 assertFalse(base.canRead(thisModule));
176
177 // addReads
178 try {
179 base.addReads(thisModule);
180 assertTrue(false);
181 } catch (IllegalCallerException expected) { }
182 assertFalse(base.canRead(thisModule));
183
184 // isExported
185 assertTrue(base.isExported("java.lang"));
186 assertTrue(base.isExported("java.lang", thisModule));
187 assertTrue(base.isExported("java.lang", base));
188 assertFalse(base.isExported("jdk.internal.misc"));
189 assertFalse(base.isExported("jdk.internal.misc", thisModule));
190 assertTrue(base.isExported("jdk.internal.misc", base));
191 assertFalse(base.isExported("java.wombat"));
192 assertFalse(base.isExported("java.wombat", thisModule));
193 assertFalse(base.isExported("java.wombat", base));
194
195 // addExports
196 try {
197 base.addExports("java.lang", thisModule);
198 assertTrue(false);
199 } catch (IllegalCallerException expected) { }
200 try {
201 base.addExports("jdk.internal.misc", thisModule);
202 assertTrue(false);
203 } catch (IllegalCallerException expected) { }
204 assertFalse(base.isExported("jdk.internal.misc"));
205 assertFalse(base.isExported("jdk.internal.misc", thisModule));
206
207 // isOpen
208 assertFalse(base.isOpen("java.lang"));
209 assertFalse(base.isOpen("java.lang", thisModule));
210 assertTrue(base.isOpen("java.lang", base));
211 assertFalse(base.isOpen("jdk.internal.misc"));
212 assertFalse(base.isOpen("jdk.internal.misc", thisModule));
213 assertTrue(base.isOpen("jdk.internal.misc", base));
214 assertFalse(base.isOpen("java.wombat"));
215 assertFalse(base.isOpen("java.wombat", thisModule));
216 assertFalse(base.isOpen("java.wombat", base));
217
218 // addOpens
219 try {
220 base.addOpens("jdk.internal.misc", thisModule);
221 assertTrue(false);
222 } catch (IllegalCallerException expected) { }
223 assertFalse(base.isOpen("jdk.internal.misc"));
224 assertFalse(base.isOpen("jdk.internal.misc", thisModule));
225
226 // canUse
227 assertTrue(base.canUse(FileSystemProvider.class));
228 assertFalse(base.canUse(Thread.class));
229
230 // addUses
231 try {
232 base.addUses(FileSystemProvider.class);
233 assertTrue(false);
234 } catch (IllegalCallerException expected) { }
235 try {
236 base.addUses(Thread.class);
237 assertTrue(false);
238 } catch (IllegalCallerException expected) { }
239 assertFalse(base.canUse(Thread.class));
240 }
241
242
243 @Test
244 public void testDesktopModule() {
245 Module desktop = java.awt.Component.class.getModule();
246 Module base = Object.class.getModule();
247 Module xml = javax.xml.XMLConstants.class.getModule();
248 Module thisModule = BasicModuleTest.class.getModule();
249
250 // name
251 assertTrue(desktop.getName().equals("java.desktop"));
252
253 // descriptor
254 assertTrue(desktop.getDescriptor().exports().stream()
255 .anyMatch(doesExport("java.awt")));
256
257 // getClassLoader
258 assertTrue(desktop.getClassLoader() == null);
259
260 // getLayer
261 assertTrue(desktop.getLayer() == Layer.boot());
262
263 // toString
264 assertEquals(desktop.toString(), "module java.desktop");
265
266 // getPackages
267 assertTrue(contains(desktop.getPackages(), "java.awt"));
268 assertTrue(contains(desktop.getPackages(), "sun.awt"));
269
270 // canRead
271 assertTrue(desktop.canRead(base));
272 assertTrue(desktop.canRead(xml));
273
274 // addReads
275 try {
276 desktop.addReads(thisModule);
277 assertTrue(false);
278 } catch (IllegalCallerException expected) { }
279 assertFalse(desktop.canRead(thisModule));
280
281 // isExported
282 assertTrue(desktop.isExported("java.awt"));
283 assertTrue(desktop.isExported("java.awt", thisModule));
284 assertFalse(desktop.isExported("sun.awt"));
285 assertFalse(desktop.isExported("sun.awt", thisModule));
286 assertTrue(desktop.isExported("sun.awt", desktop));
287 assertFalse(desktop.isExported("java.wombat"));
288 assertFalse(desktop.isExported("java.wombat", thisModule));
289 assertFalse(desktop.isExported("java.wombat", base));
290
291 // addExports
292 try {
293 desktop.addExports("java.awt", thisModule);
294 assertTrue(false);
295 } catch (IllegalCallerException expected) { }
296 try {
297 desktop.addExports("sun.awt", thisModule);
298 assertTrue(false);
299 } catch (IllegalCallerException expected) { }
300 assertFalse(desktop.isExported("sun.awt"));
301 assertFalse(desktop.isExported("sun.awt", thisModule));
302
303 // isOpen
304 assertFalse(desktop.isOpen("java.awt"));
305 assertFalse(desktop.isOpen("java.awt", thisModule));
306 assertTrue(desktop.isOpen("java.awt", desktop));
307 assertFalse(desktop.isOpen("sun.awt"));
308 assertFalse(desktop.isOpen("sun.awt", thisModule));
309 assertTrue(desktop.isOpen("sun.awt", desktop));
310 assertFalse(desktop.isOpen("java.wombat"));
311 assertFalse(desktop.isOpen("java.wombat", thisModule));
312 assertFalse(desktop.isOpen("java.wombat", desktop));
313
314 // addOpens
315 try {
316 base.addOpens("sun.awt", thisModule);
317 assertTrue(false);
318 } catch (IllegalCallerException expected) { }
319 assertFalse(desktop.isOpen("sun.awt"));
320 assertFalse(desktop.isOpen("sun.awt", thisModule));
321
322 // canUse
323 assertTrue(base.canUse(FileSystemProvider.class));
324 assertFalse(base.canUse(Thread.class));
325
326 // addUses
327 try {
328 desktop.addUses(PrintServiceLookup.class);
329 assertTrue(false);
330 } catch (IllegalCallerException expected) { }
331 try {
332 desktop.addUses(Thread.class);
333 assertTrue(false);
334 } catch (IllegalCallerException expected) { }
335 assertFalse(desktop.canUse(Thread.class));
336 }
337
338 }