1 /*
2 * Copyright (c) 2014, 2016, 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.util.function.Predicate;
29 import java.util.stream.Stream;
30
31 import org.testng.annotations.Test;
32 import static org.testng.Assert.*;
33
34 /*
35 * @test
36 * @summary Basic test of java.lang.reflect.Module
37 * @modules java.desktop java.xml
38 * @run testng BasicModuleTest
39 */
40
41 public class BasicModuleTest {
42
43 /**
44 * Tests that the given module reads all modules in the boot Layer.
45 */
46 private void testReadsAllBootModules(Module m) {
47 Layer bootLayer = Layer.boot();
48 bootLayer.configuration()
49 .modules()
153 assertTrue(base.getName().equals("java.base"));
154
155 // getDescriptor
156 assertTrue(base.getDescriptor().exports().stream()
157 .anyMatch(doesExport("java.lang")));
158
159 // getClassLoader
160 assertTrue(base.getClassLoader() == null);
161
162 // getLayer
163 assertTrue(base.getLayer() == Layer.boot());
164
165 // toString
166 assertEquals(base.toString(), "module java.base");
167
168 // getPackages
169 assertTrue(contains(base.getPackages(), "java.lang"));
170
171 // canRead
172 assertTrue(base.canRead(base));
173
174 // isExported
175 assertTrue(base.isExported("java.lang"));
176 assertTrue(base.isExported("java.lang", thisModule));
177 assertTrue(base.isExported("java.lang", base));
178 assertFalse(base.isExported("jdk.internal.misc"));
179 assertFalse(base.isExported("jdk.internal.misc", thisModule));
180 assertTrue(base.isExported("jdk.internal.misc", base));
181 assertFalse(base.isExported("java.wombat"));
182 assertFalse(base.isExported("java.wombat", thisModule));
183 assertFalse(base.isExported("java.wombat", base));
184
185 // isOpen
186 assertFalse(base.isOpen("java.lang"));
187 assertFalse(base.isOpen("java.lang", thisModule));
188 assertTrue(base.isOpen("java.lang", base));
189 assertFalse(base.isOpen("jdk.internal.misc"));
190 assertFalse(base.isOpen("jdk.internal.misc", thisModule));
191 assertTrue(base.isOpen("jdk.internal.misc", base));
192 assertFalse(base.isOpen("java.wombat"));
193 assertFalse(base.isOpen("java.wombat", thisModule));
194 assertFalse(base.isOpen("java.wombat", base));
195 }
196
197
198 @Test
199 public void testDesktopModule() {
200 Module desktop = java.awt.Component.class.getModule();
201 Module base = Object.class.getModule();
202 Module xml = javax.xml.XMLConstants.class.getModule();
203 Module thisModule = BasicModuleTest.class.getModule();
204
205 // name
206 assertTrue(desktop.getName().equals("java.desktop"));
207
208 // descriptor
209 assertTrue(desktop.getDescriptor().exports().stream()
210 .anyMatch(doesExport("java.awt")));
211
212 // getClassLoader
213 assertTrue(desktop.getClassLoader() == null);
214
215 // getLayer
216 assertTrue(desktop.getLayer() == Layer.boot());
217
218 // toString
219 assertEquals(desktop.toString(), "module java.desktop");
220
221 // getPackages
222 assertTrue(contains(desktop.getPackages(), "java.awt"));
223 assertTrue(contains(desktop.getPackages(), "sun.awt"));
224
225 // canRead
226 assertTrue(desktop.canRead(base));
227 assertTrue(desktop.canRead(xml));
228
229 // isExported
230 assertTrue(desktop.isExported("java.awt"));
231 assertTrue(desktop.isExported("java.awt", thisModule));
232 assertFalse(desktop.isExported("java.wombat"));
233 assertFalse(desktop.isExported("java.wombat", thisModule));
234 }
235
236
237 @Test(expectedExceptions = { NullPointerException.class })
238 public void testIsExportedNull() {
239 Module thisModule = this.getClass().getModule();
240 thisModule.isExported(null, thisModule);
241 }
242
243
244 @Test(expectedExceptions = { NullPointerException.class })
245 public void testIsExportedToNull() {
246 Module thisModule = this.getClass().getModule();
247 thisModule.isExported("", null);
248 }
249
250
251 }
|
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()
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 }
|