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 /**
25 * @test
26 * @bug 8031195
27 * @bug 8071657
28 * @bug 8165827
29 * @summary JDI: Add support for static, private and default methods in interfaces
30 *
31 * @run build TestScaffold VMConnection TargetListener TargetAdapter
32 * @run build InterfaceMethodsTest
33 * @run driver InterfaceMethodsTest
34 */
35 import com.sun.jdi.*;
36 import com.sun.jdi.event.*;
37 import java.util.Collections;
38 import java.util.Iterator;
39 import java.util.List;
40
41 public class InterfaceMethodsTest extends TestScaffold {
42 private static final int RESULT_A = 1;
43 private static final int RESULT_B = 2;
44 private static final int RESULT_TARGET = 3;
45
46 static interface InterfaceA {
47 static int staticMethodA() {
48 System.out.println("-InterfaceA: static interface method A-");
49 return RESULT_A;
50 }
51 static int staticMethodB() {
52 System.out.println("-InterfaceA: static interface method B-");
53 return RESULT_A;
54 }
55 default int defaultMethodA() {
56 System.out.println("-InterfaceA: default interface method A-");
57 return RESULT_A;
58 }
59 default int defaultMethodB() {
60 System.out.println("-InterfaceA: default interface method B-");
61 return RESULT_A;
62 }
63 default int defaultMethodC() {
64 System.out.println("-InterfaceA: default interface method C-");
65 return RESULT_A;
66 }
67 private int privateMethodA() {
68 System.out.println("-InterfaceA: private interface method A-");
69 return RESULT_A;
70 }
71 int implementedMethod();
72 }
73
74 static interface InterfaceB extends InterfaceA {
75 @Override
76 default int defaultMethodC() {
77 System.out.println("-InterfaceB: overridden default interface method C-");
78 return RESULT_B;
79 }
80 default int defaultMethodD() {
81 System.out.println("-InterfaceB: default interface method D-");
82 return RESULT_B;
83 }
84 static int staticMethodB() {
85 System.out.println("-InterfaceB: overridden static interface method B-");
86 return RESULT_B;
87 }
88 static int staticMethodC() {
89 System.out.println("-InterfaceB: static interface method C-");
90 return RESULT_B;
91 }
92 private int privateMethodB() {
93 System.out.println("-InterfaceB: private interface method B-");
94 return RESULT_B;
95 }
96 }
97
98 final static class TargetClass implements InterfaceB {
99 public int classMethod() {
100 System.out.println("-TargetClass: class only method-");
101 return RESULT_TARGET;
102 }
103
104 @Override
105 public int implementedMethod() {
106 System.out.println("-TargetClass: implemented non-default interface method-");
107 return RESULT_TARGET;
108 }
109
110 @Override
111 public int defaultMethodB() {
112 System.out.println("-TargetClass: overridden default interface method B");
113
114 return RESULT_TARGET;
115 }
116
117 public static void main(String[] args) {
118 TargetClass tc = new TargetClass();
119 tc.doTests(tc);
120 }
121
122 private void doTests(TargetClass ref) {
123 // break
124 }
125 }
126
127 public InterfaceMethodsTest(String[] args) {
128 super(args);
129 }
130
131 public static void main(String[] args) throws Exception {
132 new InterfaceMethodsTest(args).startTests();
133 }
134
135 private static final String TEST_CLASS_NAME = InterfaceMethodsTest.class.getName().replace('.', '/');
136 private static final String TARGET_CLASS_NAME = TargetClass.class.getName().replace('.', '/');
137 private static final String INTERFACEA_NAME = InterfaceA.class.getName().replace('.', '/');
138 private static final String INTERFACEB_NAME = InterfaceB.class.getName().replace('.', '/');
139
140 protected void runTests() throws Exception {
141 /*
142 * Get to the top of main()
143 * to determine targetClass and mainThread
144 */
145 BreakpointEvent bpe = startToMain(TARGET_CLASS_NAME);
146
147 bpe = resumeTo(TARGET_CLASS_NAME, "doTests", "(L" + TARGET_CLASS_NAME +";)V");
148
149 mainThread = bpe.thread();
150
151 StackFrame frame = mainThread.frame(0);
152 ObjectReference thisObject = frame.thisObject();
153 ObjectReference ref = (ObjectReference)frame.getArgumentValues().get(0);
154
155 ReferenceType targetClass = bpe.location().declaringType();
156 testImplementationClass(targetClass, thisObject);
157
158 testInterfaceA(ref);
159
160 testInterfaceB(ref);
161
162 /*
163 * resume the target listening for events
164 */
165 listenUntilVMDisconnect();
166
167 /*
168 * deal with results of test
169 * if anything has called failure("foo") testFailed will be true
170 */
171 if (!testFailed) {
172 println("InterfaceMethodsTest: passed");
173 } else {
174 throw new Exception("InterfaceMethodsTest: failed");
175 }
176 }
177
178 private void testInterfaceA(ObjectReference ref) {
179
180 ReferenceType ifaceClass = (ReferenceType)vm().classesByName(INTERFACEA_NAME).get(0);
181
182 /* Private method calls */
183
184 Method m = testLookup(ifaceClass, "privateMethodA", "()I", true, null); // should succeed
185
186 testInvokePos(m, ref, vm().mirrorOf(RESULT_A), false);
187 testInvokePos(m, ref, vm().mirrorOf(RESULT_A), true);
188
189 // Test non-virtual calls on InterfaceA
190
191 /* Default method calls */
192
193 // invoke the InterfaceA's "defaultMethodA"
194 testInvokePos(ifaceClass, ref, "defaultMethodA", "()I", vm().mirrorOf(RESULT_A));
195
196 // invoke the InterfaceA's "defaultMethodB"
197 testInvokePos(ifaceClass, ref, "defaultMethodB", "()I", vm().mirrorOf(RESULT_A));
198
199 // invoke the InterfaceA's "defaultMethodC"
200 testInvokePos(ifaceClass, ref, "defaultMethodC", "()I", vm().mirrorOf(RESULT_A));
201
202 // "defaultMethodD" from InterfaceB is not accessible from here
203 testInvokeNeg(ifaceClass, ref, "defaultMethodD", "()I", vm().mirrorOf(RESULT_B),
204 "Attempted to invoke non-existing method");
205
206 // non-virtual invoke of the abstract method "implementedMethod" fails
207 testInvokeNeg(ifaceClass, ref, "implementedMethod", "()I", vm().mirrorOf(TARGET_CLASS_NAME),
208 "Invocation of abstract methods is not supported");
209
210 /* Static method calls */
211
212 // invoke static interface method A
213 testInvokePos(ifaceClass, null, "staticMethodA", "()I", vm().mirrorOf(RESULT_A));
214
215 // invoking static method A on the instance fails because static method A is
216 // not inherited by TargetClass.
217 testInvokeNeg(ifaceClass, ref, "staticMethodA", "()I", vm().mirrorOf(RESULT_A),
218 "Invalid MethodID");
219
220 // invoke static interface method B
221 testInvokePos(ifaceClass, null, "staticMethodB", "()I", vm().mirrorOf(RESULT_A));
222
223 // invoking static method B on the instance fails because static method B is
224 // not inherited by TargetClass.
225 testInvokeNeg(ifaceClass, ref, "staticMethodB", "()I", vm().mirrorOf(RESULT_A),
226 "Invalid MethodID");
227
228 // try to invoke a virtual method
229 testInvokePos(ifaceClass, ref, "implementedMethod", "()I", vm().mirrorOf(RESULT_TARGET), true);
230 }
231
232 private void testInterfaceB(ObjectReference ref) {
233 // Test non-virtual calls on InterfaceB
234 ReferenceType ifaceClass = (ReferenceType)vm().classesByName(INTERFACEB_NAME).get(0);
235
236 /* private method calls */
237
238 /* These should fail but won't because of JDK-8167416
239 testLookup(ifaceClass, "privateMethodA", "()I", true, NoSuchMethodError.class); // should fail
240 testLookup(ifaceClass, "privateMethodA", "()I", false, NoSuchMethodError.class); // should fail
241 */
242 Method m = testLookup(ifaceClass, "privateMethodB", "()I", true, null); // should succeed
243 testInvokePos(m, ref, vm().mirrorOf(RESULT_B), false);
244 testInvokePos(m, ref, vm().mirrorOf(RESULT_B), true);
245
246 /* Default method calls */
247
248 // invoke the inherited "defaultMethodA"
249 testInvokePos(ifaceClass, ref, "defaultMethodA", "()I", vm().mirrorOf(RESULT_A));
250
251 // invoke the inherited "defaultMethodB"
252 testInvokePos(ifaceClass, ref, "defaultMethodB", "()I", vm().mirrorOf(RESULT_A));
253
254 // invoke the inherited and overridden "defaultMethodC"
255 testInvokePos(ifaceClass, ref, "defaultMethodC", "()I", vm().mirrorOf(RESULT_B));
256
257 // invoke InterfaceB only "defaultMethodD"
258 testInvokePos(ifaceClass, ref, "defaultMethodD", "()I", vm().mirrorOf(RESULT_B));
259
260 // "implementedMethod" is not present in InterfaceB
261 testInvokeNeg(ifaceClass, ref, "implementedMethod", "()I", vm().mirrorOf(RESULT_TARGET),
262 "Invocation of non-default methods is not supported");
263
264
265 /* Static method calls*/
266
267 // "staticMethodA" must not be inherited by InterfaceB
268 testInvokeNeg(ifaceClass, null, "staticMethodA", "()I", vm().mirrorOf(RESULT_A),
269 "Static interface methods are not inheritable");
270
271 // "staticMethodA" is not inherited by InterfaceB even from an actual instance
272 testInvokeNeg(ifaceClass, ref, "staticMethodA", "()I", vm().mirrorOf(RESULT_A),
273 "Static interface methods are not inheritable");
274
275 // "staticMethodB" is re-defined in InterfaceB
276 testInvokePos(ifaceClass, null, "staticMethodB", "()I", vm().mirrorOf(RESULT_B));
277
278 // the instance fails to invoke the re-defined form of "staticMethodB" from
279 // InterfaceB because staticMethodB is not inherited by TargetClass
280 testInvokeNeg(ifaceClass, ref, "staticMethodB", "()I", vm().mirrorOf(RESULT_B),
281 "Invalid MethodID");
282
283 // "staticMethodC" is present only in InterfaceB
284 testInvokePos(ifaceClass, null, "staticMethodC", "()I", vm().mirrorOf(RESULT_B));
285
286 // "staticMethodC" is not reachable from the instance because staticMethodC
287 // is not inherited by TargetClass.
288 testInvokeNeg(ifaceClass, ref, "staticMethodC", "()I", vm().mirrorOf(RESULT_B),
289 "Invalid MethodID");
290 }
291
292 private void testImplementationClass(ReferenceType targetClass, ObjectReference thisObject) {
293 // Test invocations on the implementation object
294
295 // Note: private interface calls have already been tested
296
297 /* Default method calls */
298
299 // "defaultMethodA" is accessible and not overridden
300 testInvokePos(targetClass, thisObject, "defaultMethodA", "()I", vm().mirrorOf(RESULT_A));
301
302 // "defaultMethodB" is accessible and overridden in TargetClass
303 testInvokePos(targetClass, thisObject, "defaultMethodB", "()I", vm().mirrorOf(RESULT_TARGET));
304
305 // "defaultMethodC" is accessible and overridden in InterfaceB
306 testInvokePos(targetClass, thisObject, "defaultMethodC", "()I", vm().mirrorOf(RESULT_B));
307
308 // "defaultMethodD" is accessible
309 testInvokePos(targetClass, thisObject, "defaultMethodD", "()I", vm().mirrorOf(RESULT_B));
310
311
312 /* Non-default instance method calls */
313
314 // "classMethod" declared in TargetClass is accessible
315 testInvokePos(targetClass, thisObject, "classMethod", "()I", vm().mirrorOf(RESULT_TARGET));
316
317 // the abstract "implementedMethod" has been implemented in TargetClass
318 testInvokePos(targetClass, thisObject, "implementedMethod", "()I", vm().mirrorOf(RESULT_TARGET));
319
320
321 /* Static method calls */
322
323 // All the static methods declared by the interfaces are not reachable from the instance of the implementor class
324 testInvokeNeg(targetClass, thisObject, "staticMethodA", "()I", vm().mirrorOf(RESULT_A),
325 "Static interface methods are not inheritable");
326
327 testInvokeNeg(targetClass, thisObject, "staticMethodB", "()I", vm().mirrorOf(RESULT_B),
328 "Static interface methods are not inheritable");
329
330 testInvokeNeg(targetClass, thisObject, "staticMethodC", "()I", vm().mirrorOf(RESULT_B),
331 "Static interface methods are not inheritable");
332
333 // All the static methods declared by the interfaces are not reachable through the implementor class
334 testInvokeNeg(targetClass, null, "staticMethodA", "()I", vm().mirrorOf(RESULT_A),
335 "Static interface methods are not inheritable");
336
337 testInvokeNeg(targetClass, null, "staticMethodB", "()I", vm().mirrorOf(RESULT_B),
338 "Static interface methods are not inheritable");
339
340 testInvokeNeg(targetClass, null, "staticMethodC", "()I", vm().mirrorOf(RESULT_B),
341 "Static interface methods are not inheritable");
342 }
343
344 // Non-virtual invocation
345 private void testInvokePos(ReferenceType targetClass, ObjectReference ref, String methodName,
346 String methodSig, Value value) {
347 testInvokePos(targetClass, ref, methodName, methodSig, value, false);
348 }
349
350 // Lookup the named method in the targetClass and invoke on the given object (for instance methods)
351 // using virtual, or non-virtual, invocation mode as specified, for instance methods. Verify the
352 // expected return value.
353 // Should succeed.
354 private void testInvokePos(ReferenceType targetClass, ObjectReference ref, String methodName,
355 String methodSig, Value value, boolean virtual) {
356 logInvocation(ref, methodName, methodSig, targetClass);
357 try {
358 invoke(targetClass, ref, methodName, methodSig, value, virtual);
359 System.err.println("--- PASSED");
360 } catch (Exception e) {
361 System.err.println("--- FAILED");
362 failure("FAILED: Invocation failed with error message " + e.getLocalizedMessage());
363 }
364 }
365
366 // Invoke the given Method on the given object (for instance methods)
367 // using virtual, or non-virtual, invocation mode as specified, for instance methods. Verify the
368 // expected return value.
369 // Should succeed.
370 private void testInvokePos(Method method, ObjectReference ref, Value value, boolean virtual) {
371 logInvocation(ref, method.name(), method.signature(), method.declaringType());
372 try {
373 invoke(method.declaringType(), ref, method, value, virtual);
374 System.err.println("--- PASSED");
375 } catch (Exception e) {
376 System.err.println("--- FAILED");
377 failure("FAILED: Invocation failed with error message " + e.getLocalizedMessage());
378 }
379 }
380
381 // Non-virtual invocation - with lookup in targetClass
382 private void testInvokeNeg(ReferenceType targetClass, ObjectReference ref, String methodName,
383 String methodSig, Value value, String msg) {
384 testInvokeNeg(targetClass, ref, methodName, methodSig, value, msg, false);
385 }
386
387 // Lookup the named method in the targetClass and invoke on the given object (for instance methods)
388 // using virtual, or non-virtual, invocation mode as specified, for instance methods. Verify the
389 // expected return value.
390 // Should fail - with msg decribing why failure was expected
391 private void testInvokeNeg(ReferenceType targetClass, ObjectReference ref, String methodName,
392 String methodSig, Value value, String msg, boolean virtual) {
393 logInvocation(ref, methodName, methodSig, targetClass);
394 try {
395 invoke(targetClass, ref, methodName, methodSig, value, virtual);
396 System.err.println("--- FAILED");
397 failure("FAILED: " + msg);
398 } catch (Exception e) {
399 System.err.println("--- PASSED");
400
401 }
402 }
403
404 private void invoke(ReferenceType targetClass, ObjectReference ref, String methodName,
405 String methodSig, Value value, boolean virtual) throws Exception {
406
407 Method method = getMethod(targetClass, methodName, methodSig);
408 if (method == null) {
409 throw new Exception("Can't find method: " + methodName + " for class = " + targetClass);
410 }
411 invoke(targetClass, ref, method, value, virtual);
412 }
413
414 private void invoke(ReferenceType targetClass, ObjectReference ref, Method method,
415 Value value, boolean virtual) throws Exception {
416
417 println("Invoking " + (method.isAbstract() ? "abstract " : " ") + "method: " + method);
418 println(method.declaringType().toString());
419
420 Value returnValue = null;
421 if (ref != null) {
422 if (virtual) {
423 returnValue = invokeVirtual(ref, method);
424 } else {
425 returnValue = invokeNonVirtual(ref, method);
426 }
427 } else {
428 returnValue = invokeStatic(targetClass, method);
429 }
430
431 println(" return val = " + returnValue);
432 // It has to be the same value as what we passed in!
433 if (returnValue.equals(value)) {
434 println(" " + method.name() + " return value matches: "
435 + value);
436 } else {
437 if (value != null) {
438 throw new Exception(method.name() + " returned: " + returnValue +
439 " expected: " + value );
440 } else {
441 println(" " + method.name() + " return value : " + returnValue);
442 }
443
444 }
445 }
446
447 private Value invokeNonVirtual(ObjectReference ref, Method method) throws Exception {
448 return ref.invokeMethod(mainThread, method, Collections.emptyList(), ObjectReference.INVOKE_NONVIRTUAL);
449 }
450
451 private Value invokeVirtual(ObjectReference ref, Method method) throws Exception {
452 return ref.invokeMethod(mainThread, method, Collections.emptyList(), 0);
453 }
454
455 private Value invokeStatic(ReferenceType refType, Method method) throws Exception {
456 if (refType instanceof ClassType) {
457 return ((ClassType)refType).invokeMethod(mainThread, method, Collections.emptyList(), ObjectReference.INVOKE_NONVIRTUAL);
458 } else {
459 return ((InterfaceType)refType).invokeMethod(mainThread, method, Collections.emptyList(), ObjectReference.INVOKE_NONVIRTUAL);
460 }
461 }
462
463 private Method getMethod(ReferenceType rt, String name, String signature) {
464 if (rt == null) return null;
465 Method m = findMethod(rt, name, signature);
466 if (m == null) {
467 if (rt instanceof ClassType) {
468 for (Object ifc : ((ClassType)rt).interfaces()) {
469 m = getMethod((ReferenceType)ifc, name, signature);
470 if (m != null) {
471 break;
472 }
473 }
474 if (m == null) {
475 m = getMethod(((ClassType)rt).superclass(), name, signature);
476 } else {
477 if (m.isStatic()) {
478 // interface static methods are not inherited
479 m = null;
480 }
481 }
482 } else if (rt instanceof InterfaceType) {
483 for(Object ifc : ((InterfaceType)rt).superinterfaces()) {
484 m = getMethod((ReferenceType)ifc, name, signature);
485 if (m != null) {
486 if (m.isStatic()) {
487 // interface static methods are not inherited
488 m = null;
489 }
490 break;
491 }
492 }
493 }
494 }
495
496 return m;
497 }
498
499 private void logInvocation(ObjectReference ref, String methodName, String methodSig, ReferenceType targetClass) {
500 if (ref != null) {
501 System.err.println("Invoking: " + ref.referenceType().name() + "." +
502 methodName + methodSig + " with target of type " +
503 targetClass.name());
504 } else {
505 System.err.println("Invoking static : " + targetClass.name() + "." +
506 methodName + methodSig);
507 }
508 }
509
510 private Method testLookup(ReferenceType targetClass, String methodName, String methodSig,
511 boolean declaredOnly, Class<?> expectedException) {
512
513 System.err.println("Looking up " + targetClass.name() + "." + methodName + methodSig);
514 try {
515 Method m = declaredOnly ?
516 lookupDeclaredMethod(targetClass, methodName, methodSig) :
517 lookupMethod(targetClass, methodName, methodSig);
518
519 if (expectedException == null) {
520 System.err.println("--- PASSED");
521 return m;
522 }
523 else {
524 System.err.println("--- FAILED");
525 failure("FAILED: lookup succeeded but expected exception "
526 + expectedException.getSimpleName());
527 return null;
528 }
529 }
530 catch (Throwable t) {
531 if (t.getClass() != expectedException) {
532 System.err.println("--- FAILED");
533 failure("FAILED: got exception " + t + " but expected exception "
534 + expectedException.getSimpleName());
535 return null;
536 }
537 else {
538 System.err.println("--- PASSED");
539 return null;
540 }
541 }
542 }
543
544 private Method lookupMethod(ReferenceType targetClass, String methodName, String methodSig) {
545 List methods = targetClass.allMethods();
546 Iterator iter = methods.iterator();
547 while (iter.hasNext()) {
548 Method method = (Method)iter.next();
549 if (method.name().equals(methodName) &&
550 method.signature().equals(methodSig)) {
551 return method;
552 }
553 }
554 throw new NoSuchMethodError();
555 }
556
557 private Method lookupDeclaredMethod(ReferenceType targetClass, String methodName, String methodSig) {
558 Method m = findMethod(targetClass, methodName, methodSig);
559 if (m == null)
560 throw new NoSuchMethodError();
561 return m;
562 }
563 }