1 /*
2 * Copyright (c) 2015, 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 package p1;
25
26 import java.lang.invoke.MethodHandle;
27 import java.lang.invoke.MethodHandles;
28 import java.lang.invoke.MethodHandles.Lookup;
29 import java.lang.invoke.MethodType;
30 import java.lang.reflect.Layer;
31 import java.lang.reflect.Module;
32
33 import static java.lang.invoke.MethodHandles.Lookup.*;
34
35 import org.testng.annotations.BeforeTest;
36 import org.testng.annotations.Test;
37 import static org.testng.Assert.*;
38
39 /**
40 * Basic test case for module access checks and Lookup.in.
41 */
42
43 @Test
44 public class Main {
45
46 private Class<?> p1_Type1; // m1, exported
47 private Class<?> p2_Type2; // m1, not exported
48 private Class<?> q1_Type1; // m2, exported
49 private Class<?> q2_Type2; // m2, not exported
50 private Class<?> x500NameClass; // java.base, not exported
51 private Class<?> unnamedClass; // class in unnamed module
52
53 @BeforeTest
54 public void setup() throws Exception {
55 try {
56 p1_Type1 = Class.forName("p1.Type1");
57 p2_Type2 = Class.forName("p2.Type2");
58 q1_Type1 = Class.forName("q1.Type1");
59 q2_Type2 = Class.forName("q2.Type2");
60 x500NameClass = Class.forName("sun.security.x509.X500Name");
61 unnamedClass = Class.forName("Unnamed");
62 } catch (ClassNotFoundException e) {
63 throw new AssertionError(e);
64 }
65
66 // check setup
67 Module m1 = Layer.boot().findModule("m1").orElse(null);
68 assertNotNull(m1);
69 assertTrue(p1_Type1.getModule() == m1);
70 assertTrue(p2_Type2.getModule() == m1);
71 assertTrue(m1.isExported("p1"));
72 assertFalse(m1.isExported("p2"));
73
74 Module m2 = Layer.boot().findModule("m2").orElse(null);
75 assertNotNull(m2);
76 assertTrue(q1_Type1.getModule() == m2);
77 assertTrue(q2_Type2.getModule() == m2);
78 assertTrue(m2.isExported("q1"));
79 assertFalse(m2.isExported("q2"));
80
81 Module unnamedModule = unnamedClass.getModule();
82 assertFalse(unnamedModule.isNamed());
83
84 // m1 needs to read unnamed module
85 Main.class.getModule().addReads(unnamedModule);
86 }
87
88 /**
89 * MethodHandles.lookup()
90 *
91 * [A0] has module access
92 * [A1] can access all public types in m1
93 * [A2] can access public types in packages exported by modules that m1 reads
94 * [A3] cannot access public types in non-exported modules of modules that m1 reads
95 */
96 public void testLookup() throws Exception {
97 Lookup lookup = MethodHandles.lookup();
98 assertTrue((lookup.lookupModes() & MODULE) == MODULE); // [A0]
99
100 // m1
101 findConstructor(lookup, p1_Type1, void.class); // [A1]
102 findConstructor(lookup, p2_Type2, void.class); // [A1]
103
104 // m2
105 findConstructor(lookup, q1_Type1, void.class); // [A2]
106 findConstructorExpectingIAE(lookup, q2_Type2, void.class); // [A3]
107
108 // java.base
109 findConstructor(lookup, Object.class, void.class); // [A2]
110 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class); // [A3]
111
112 // unnamed
113 findConstructor(lookup, unnamedClass, void.class); // [A3]
114 }
115
116 /**
117 * Hop to lookup class in the same module
118 *
119 * [A0] module and public access is not lost
120 */
121 public void testToSameModule() throws Exception {
122 Lookup lookup = MethodHandles.lookup().in(p2_Type2);
123 assertTrue(lookup.lookupModes() == (MODULE|PUBLIC)); // [A0]
124
125 // m1
126 findConstructor(lookup, p1_Type1, void.class);
127 findConstructor(lookup, p2_Type2, void.class);
128
129 // m2
130 findConstructor(lookup, q1_Type1, void.class);
131 findConstructorExpectingIAE(lookup, q2_Type2, void.class);
132
133 // java.base
134 findConstructor(lookup, Object.class, void.class);
135 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class);
136
137 // unnamed
138 findConstructor(lookup, unnamedClass, void.class);
139 }
140
141 /**
142 * Hop to lookup class in another named module
143 *
144 * [A0] has no access
145 */
146 public void testFromNamedToNamedModule() throws Exception {
147 Lookup lookup = MethodHandles.lookup().in(q1_Type1);
148 assertTrue(lookup.lookupModes() == 0); // [A0]
149
150 // m1
151 findConstructorExpectingIAE(lookup, p1_Type1, void.class);
152 findConstructorExpectingIAE(lookup, p2_Type2, void.class);
153
154 // m2
155 findConstructorExpectingIAE(lookup, q1_Type1, void.class);
156 findConstructorExpectingIAE(lookup, q2_Type2, void.class);
157
158 // java.base
159 findConstructorExpectingIAE(lookup, Object.class, void.class);
160 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class);
161
162 // unnamed
163 findConstructorExpectingIAE(lookup, unnamedClass, void.class);
164 }
165
166 /**
167 * Hop to lookup class in an unnamed module
168 *
169 * [A0] has no access
170 */
171 public void testFromNamedToUnnamedModule() throws Exception {
172 Lookup lookup = MethodHandles.lookup().in(unnamedClass);
173 assertTrue(lookup.lookupModes() == 0); // [A0]
174
175 // m1
176 findConstructorExpectingIAE(lookup, p1_Type1, void.class);
177 findConstructorExpectingIAE(lookup, p2_Type2, void.class);
178
179 // m2
180 findConstructorExpectingIAE(lookup, q1_Type1, void.class);
181 findConstructorExpectingIAE(lookup, q2_Type2, void.class);
182
183 // java.base
184 findConstructorExpectingIAE(lookup, Object.class, void.class);
185 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class);
186
187 // unnamed
188 findConstructorExpectingIAE(lookup, unnamedClass, void.class);
189 }
190
191 /**
192 * Hop from unnamed to named module.
193 *
194 * [A0] retains PUBLIC access
195 */
196 public void testFromUnnamedToNamedModule() throws Exception {
197 Lookup lookup = MethodHandles.lookup();
198 lookup = MethodHandles.privateLookupIn(unnamedClass, lookup).in(p1_Type1);
199 assertTrue(lookup.lookupModes() == PUBLIC); // A0
200
201 // m1
202 findConstructor(lookup, p1_Type1, void.class);
203 findConstructorExpectingIAE(lookup, p2_Type2, void.class);
204
205 // m2
206 findConstructor(lookup, q1_Type1, void.class);
207 findConstructorExpectingIAE(lookup, q2_Type2, void.class);
208
209 // java.base
210 findConstructor(lookup, Object.class, void.class);
211 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class);
212
213 // unnamed
214 findConstructor(lookup, unnamedClass, void.class);
215 }
216
217 /**
218 * MethodHandles.publicLookup()
219 *
220 * [A0] has PUBLIC|UNCONDITIONAL access
221 */
222 public void testPublicLookup() throws Exception {
223 Lookup lookup = MethodHandles.publicLookup();
224 assertTrue(lookup.lookupModes() == (PUBLIC|UNCONDITIONAL)); // A0
225
226 // m1
227 findConstructor(lookup, p1_Type1, void.class);
228 findConstructorExpectingIAE(lookup, p2_Type2, void.class);
229
230 // m2
231 findConstructor(lookup, q1_Type1, void.class);
232 findConstructorExpectingIAE(lookup, q2_Type2, void.class);
233
234 // java.base
235 findConstructor(lookup, Object.class, void.class);
236 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class);
237
238 // unnamed
239 findConstructor(lookup, unnamedClass, void.class);
240 }
241
242 /**
243 * Hop from publicLookup to accessible type in java.base
244 */
245 public void testPublicLookupToBaseModule() throws Exception {
246 Lookup lookup = MethodHandles.publicLookup().in(String.class);
247 assertTrue(lookup.lookupModes() == PUBLIC); // A0
248
249 // m1
250 findConstructorExpectingIAE(lookup, p1_Type1, void.class);
251 findConstructorExpectingIAE(lookup, p2_Type2, void.class);
252
253 // m2
254 findConstructorExpectingIAE(lookup, q1_Type1, void.class);
255 findConstructorExpectingIAE(lookup, q2_Type2, void.class);
256
257 // java.base
258 findConstructor(lookup, Object.class, void.class);
259 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class);
260
261 // unnamed
262 findConstructorExpectingIAE(lookup, unnamedClass, void.class);
263 }
264
265
266 /**
267 * Hop from publicLookup to accessible type in named module.
268 *
269 * [A0] has PUBLIC access
270 */
271 public void testPublicLookupToAccessibleTypeInNamedModule() throws Exception {
272 Lookup lookup = MethodHandles.publicLookup().in(p1_Type1);
273 assertTrue(lookup.lookupModes() == PUBLIC); // A0
274
275 // m1
276 findConstructor(lookup, p1_Type1, void.class);
277 findConstructorExpectingIAE(lookup, p2_Type2, void.class);
278
279 // m2
280 findConstructor(lookup, q1_Type1, void.class);
281 findConstructorExpectingIAE(lookup, q2_Type2, void.class);
282
283 // java.base
284 findConstructor(lookup, Object.class, void.class);
285 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class);
286
287 // unnamed
288 findConstructor(lookup, unnamedClass, void.class);
289 }
290
291 /**
292 * Teleport from publicLookup to inaccessible type in named module.
293 *
294 * [A0] has no access
295 */
296 public void testPublicLookupToInaccessibleTypeInNamedModule() throws Exception {
297 Lookup lookup = MethodHandles.publicLookup().in(p2_Type2);
298 assertTrue(lookup.lookupModes() == 0); // A0
299
300 // m1
301 findConstructorExpectingIAE(lookup, p1_Type1, void.class);
302 findConstructorExpectingIAE(lookup, p2_Type2, void.class);
303
304 // m2
305 findConstructorExpectingIAE(lookup, q1_Type1, void.class);
306 findConstructorExpectingIAE(lookup, q2_Type2, void.class);
307
308 // java.base
309 findConstructorExpectingIAE(lookup, Object.class, void.class);
310 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class);
311
312 // unnamed
313 findConstructorExpectingIAE(lookup, unnamedClass, void.class);
314 }
315
316 /**
317 * Teleport from publicLookup to public type in unnamed module
318 *
319 * [A0] has PUBLIC access
320 */
321 public void testPublicLookupToUnnamedModule() throws Exception {
322 Lookup lookup = MethodHandles.publicLookup().in(unnamedClass);
323 assertTrue(lookup.lookupModes() == PUBLIC); // A0
324
325 // m1
326 findConstructor(lookup, p1_Type1, void.class);
327 findConstructorExpectingIAE(lookup, p2_Type2, void.class);
328
329 // m2
330 findConstructor(lookup, q1_Type1, void.class);
331 findConstructorExpectingIAE(lookup, q2_Type2, void.class);
332
333 // java.base
334 findConstructor(lookup, Object.class, void.class);
335 findConstructorExpectingIAE(lookup, x500NameClass, void.class, String.class);
336
337 // unnamed
338 findConstructor(lookup, unnamedClass, void.class);
339 }
340
341 /**
342 * Invokes Lookup findConstructor with a method type constructored from the
343 * given return and parameter types, expecting IllegalAccessException to be
344 * thrown.
345 */
346 static void findConstructorExpectingIAE(Lookup lookup,
347 Class<?> clazz,
348 Class<?> rtype,
349 Class<?>... ptypes) throws Exception {
350 try {
351 findConstructor(lookup, clazz, rtype, ptypes);
352 assertTrue(false);
353 } catch (IllegalAccessException expected) { }
354 }
355
356 /**
357 * Invokes Lookup findConstructor with a method type constructored from the
358 * given return and parameter types.
359 */
360 static MethodHandle findConstructor(Lookup lookup,
361 Class<?> clazz,
362 Class<?> rtype,
363 Class<?>... ptypes) throws Exception {
364 MethodType mt = MethodType.methodType(rtype, ptypes);
365 return lookup.findConstructor(clazz, mt);
366 }
367 }