1 /*
2 * Copyright (c) 2013, 2018, 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 vm.runtime.defmeth;
25
26 import nsk.share.test.TestBase;
27 import vm.runtime.defmeth.shared.DefMethTest;
28 import vm.runtime.defmeth.shared.annotation.Crash;
29 import vm.runtime.defmeth.shared.data.*;
30 import vm.runtime.defmeth.shared.builder.TestBuilder;
31 import vm.runtime.defmeth.shared.annotation.NotApplicableFor;
32 import static vm.runtime.defmeth.shared.data.method.body.CallMethod.Invoke.*;
33 import static vm.runtime.defmeth.shared.data.method.body.CallMethod.IndexbyteOp.*;
34 import static vm.runtime.defmeth.shared.ExecutionMode.*;
35
36 /*
37 * Scenarios on static methods in interfaces.
38 */
39 public class StaticMethodsTest extends DefMethTest {
40
41 public static void main(String[] args) {
42 TestBase.runTest(new StaticMethodsTest(), args);
43 }
44
45 // static method in interface
46 /*
47 * testStaticMethod
48 *
49 * interface I {
50 * default static public int m() { return 1; }
51 * }
52 *
53 * class C implements I {}
54 */
55 public void testStaticMethod() {
56 TestBuilder b = factory.getBuilder();
57
58 Interface I = b.intf("I")
59 .defaultMethod("m", "()I")
60 .static_().public_().returns(1).build()
61 .build();
62
63 ConcreteClass C = b.clazz("C").implement(I).build();
64
65 b.test().staticCallSite(I, "m", "()I").returns(1).done()
66
67 .run();
68 }
69
70 // invoke[virtual|interface|special] from same/subintf
71 /*
72 * testInvokeVirtual
73 *
74 * interface I {
75 * default static public int staticM() { return 1; }
76 * default public int m() { return ((I)this).staticM(); }
77 * }
78 *
79 * class C implements I {}
80 */
81 public void testInvokeVirtual() {
82 TestBuilder b = factory.getBuilder();
83
84 Interface I = b.intf("I")
85 .defaultMethod("staticM", "()I")
86 .static_().public_().returns(1).build()
87
88 // force an invokevirtual MR of staticM()
89 .defaultMethod("m", "()I")
90 .invoke(VIRTUAL, b.intfByName("I"), null, "staticM", "()I", METHODREF).build()
91 .build();
92
93 ConcreteClass C = b.clazz("C").implement(I).build();
94
95 b.test().staticCallSite(I, "staticM", "()I").returns(1).done()
96
97 .test().callSite(I, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
98 .test().callSite(C, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
99
100 .run();
101 }
102
103 /*
104 * testInvokeIntf
105 *
106 * interface I {
107 * default static public int staticM() { return 1; }
108 * default public int m() { return ((I)this).staticM(); }
109 * }
110 *
111 * class C implements I {}
112 */
113 public void testInvokeIntf() {
114 TestBuilder b = factory.getBuilder();
115
116 Interface I = b.intf("I")
117 .defaultMethod("staticM", "()I")
118 .static_().public_().returns(1).build()
119
120 .defaultMethod("m", "()I")
121 .invoke(INTERFACE, b.intfByName("I"), null, "staticM", "()I", CALLSITE).build()
122 .build();
123
124 ConcreteClass C = b.clazz("C").implement(I).build();
125
126 b.test().staticCallSite(I, "staticM", "()I").returns(1).done()
127
128 .test().callSite(I, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
129 .test().callSite(C, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
130
131 .run();
132 }
133
134 /*
135 * testInvokeSpecial
136 *
137 * interface I {
138 * default static public int staticM() { return 1; }
139 * default public int m() { return I.super.staticM(); }
140 * }
141 *
142 * class C implements I {}
143 */
144 public void testInvokeSpecial() {
145 TestBuilder b = factory.getBuilder();
146
147 Interface I = b.intf("I")
148 .defaultMethod("staticM", "()I")
149 .static_().public_().returns(1).build()
150
151 .defaultMethod("m", "()I")
152 .invoke(SPECIAL, b.intfByName("I"), null, "staticM", "()I", CALLSITE).build()
153 .build();
154
155 ConcreteClass C = b.clazz("C").implement(I).build();
156
157 b.test().staticCallSite(I, "staticM", "()I").returns(1).done()
158
159 .test().callSite(I, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
160 .test().callSite(C, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
161
162 .run();
163 }
164
165 /*
166 * testStaticVsDefault
167 *
168 * interface I {
169 * default static public int m() { return 1; }
170 * default public int m() { return 2; }
171 * }
172 *
173 * class C implements I {}
174 */
175 public void testStaticVsDefault() {
176 TestBuilder b = factory.getBuilder();
177
178 Interface I = b.intf("I")
179 .defaultMethod("m", "()I")
180 .static_().public_().returns(1).build()
181 .defaultMethod("m", "()I")
182 .public_().returns(2).build()
183 .build();
184
185 ConcreteClass C = b.clazz("C").implement(I).build();
186
187 b.test().staticCallSite(I, "m", "()I").throws_(ClassFormatError.class).done()
188
189 // FIXME: throws exception during an attempt to lookup Test2.test() method
190
191 // Invalid test. ClassFormatError is thrown at verification time, rather
192 // than execution time.
193 // .test().callSite(I, C, "m", "()I").throws_(ClassFormatError.class).done()
194 .test().callSite(C, C, "m", "()I").throws_(ClassFormatError.class).done()
195
196 .run();
197 }
198
199 // call static method from default method
200 /*
201 * testInvokeFromDefaultMethod
202 *
203 * interface I {
204 * default static public int staticPublicM() { return 1; }
205 * default public int invokePublic() { return I.staticPublicM(); }
206 * default static private int staticPrivateM() { return 1; }
207 * default public int invokePrivate() { return I.staticPrivateM(); }
208 * }
209 *
210 * class C implements I {}
211 */
212 public void testInvokeFromDefaultMethod() throws Exception {
213 TestBuilder b = factory.getBuilder();
214
215 Interface I = b.intf("I")
216 .defaultMethod("staticPublicM", "()I")
217 .static_().public_().returns(1).build()
218 .defaultMethod("invokePublic", "()I")
219 .invokeStatic(b.intfByName("I"), "staticPublicM", "()I").build()
220
221 .defaultMethod("staticPrivateM", "()I")
222 .static_().private_().returns(1).build()
223 .defaultMethod("invokePrivate", "()I")
224 .invokeStatic(b.intfByName("I"), "staticPrivateM", "()I").build()
225 .build();
226
227 ConcreteClass C = b.clazz("C").implement(I).build();
228
229 Class expectedClass;
230 if (factory.getExecutionMode().equals("REFLECTION")) {
231 expectedClass = NoSuchMethodException.class;
232 } else {
233 expectedClass = IllegalAccessError.class;
234 }
235
236 // call static method from another class
237 b.test().staticCallSite(I, "staticPublicM", "()I").returns(1).done()
238 .test().staticCallSite(I, "staticPrivateM", "()I").throws_(expectedClass).done()
239
240 // call public static method from default method
241 .test().callSite(I, C, "invokePublic", "()I").returns(1).done()
242 .test().callSite(C, C, "invokePublic", "()I").returns(1).done()
243
244 // call private static method from default method
245 .test().callSite(I, C, "invokePrivate", "()I").returns(1).done()
246 .test().callSite(C, C, "invokePrivate", "()I").returns(1).done()
247
248 .run();
249 }
250
251 // call static method from implementing subclass
252 /*
253 * testInvokeFromSubclass
254 *
255 * interface I {
256 * default static public int staticPublicM() { return 1; }
257 * default static private int staticPrivateM() { return 1; }
258 * }
259 *
260 * class C implements I {
261 * public int invokePublic() { return I.staticPublicM(); }
262 * public int invokePrivate() { return I.staticPublicM(); }
263 *
264 * I.staticPublicM(); ==> returns 1;
265 * I.staticPrivateM(); ==> Either NSME or IAE depending on execution mode
266 * C c = new C(); c.invokePublic(); ==> returns 1 or if -ver < 52 IAE or VerifyError
267 * C c = new C(); c.invokePrivate() ==> IAE or if -ver < 52, IAE or VerifyError
268 * }
269 */
270
271 @NotApplicableFor(modes = { REDEFINITION }) // Can't redefine a class that gets error during loading
272 public void testInvokeFromSubclass() throws Exception {
273 TestBuilder b = factory.getBuilder();
274
275 Interface I = b.intf("I")
276 .defaultMethod("staticPublicM", "()I")
277 .static_().public_().returns(1).build()
278
279 .defaultMethod("staticPrivateM", "()I")
280 .static_().private_().returns(1).build()
281 .build();
282
283 ConcreteClass C = b.clazz("C").implement(I)
284 .concreteMethod("invokePublic", "()I")
285 .invokeStatic(b.intfByName("I"), "staticPublicM", "()I").build()
286 .concreteMethod("invokePrivate", "()I")
287 .invokeStatic(b.intfByName("I"), "staticPrivateM", "()I").build()
288 .build();
289
290 Class expectedError1;
291 if (factory.getExecutionMode().equals("REFLECTION")) {
292 expectedError1 = NoSuchMethodException.class;
293 } else {
294 expectedError1 = IllegalAccessError.class;
295 }
296
297 // Adjust for -ver < 52
298 if (factory.getVer() >=52) {
299 // call static method from another class
300 b.test().staticCallSite(I, "staticPublicM", "()I").returns(1).done()
301 .test().staticCallSite(I, "staticPrivateM", "()I").throws_(expectedError1).done()
302
303 // call static method from implementing subclass
304 .test().callSite(C, C, "invokePublic", "()I").returns(1).done()
305 .test().callSite(C, C, "invokePrivate", "()I").throws_(IllegalAccessError.class).done()
306
307 .run();
308 } else {
309 // call static method from another class
310 b.test().staticCallSite(I, "staticPublicM", "()I").returns(1).done()
311 .test().staticCallSite(I, "staticPrivateM", "()I").throws_(expectedError1).done()
312
313 // call static method from implementing subclass
314 // invokestatic IMR - not supported for ver < 52
315 .test().callSite(C, C, "invokePublic", "()I").throws_(VerifyError.class).done()
316 .test().callSite(C, C, "invokePrivate", "()I").throws_(VerifyError.class).done()
317
318 .run();
319 }
320 }
321
322 // static method doesn't participate in default method analysis:
323 // method overriding
324 /*
325 * testNotInherited
326 *
327 * interface I {
328 * default static public int m() { return 1; }
329 * }
330 *
331 * class C implements I {}
332 */
333 public void testNotInherited() {
334 TestBuilder b = factory.getBuilder();
335
336 Interface I = b.intf("I")
337 .defaultMethod("m", "()I")
338 .static_().public_().returns(1).build()
339 .build();
340
341 ConcreteClass C = b.clazz("C").implement(I).build();
342
343 if (!factory.getExecutionMode().equals("REFLECTION")) {
344 b.test().staticCallSite(I, "m", "()I").returns(1).done()
345 // invokeinterface to static method ==> ICCE
346 .test().callSite(I, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
347 .test().callSite(C, C, "m", "()I").throws_(NoSuchMethodError.class).done()
348 .run();
349 } else {
350 b.test().staticCallSite(I, "m", "()I").returns(1).done()
351 .test().callSite(I, C, "m", "()I").returns(1).done()
352 .test().callSite(C, C, "m", "()I").throws_(NoSuchMethodError.class).done()
353 .run();
354 }
355 }
356
357 /*
358 * testDefaultVsConcrete
359 *
360 * interface I {
361 * default static public int m() { return 1; }
362 * }
363 *
364 * class C implements I {
365 * public int m() { return 2; }
366 * }
367 * TEST: I o = new C(); o.m()I throws ICCE
368 * TEST: C o = new C(); o.m()I == 2
369 */
370 public void testDefaultVsConcrete() {
371 TestBuilder b = factory.getBuilder();
372
373 Interface I = b.intf("I")
374 .defaultMethod("m", "()I")
375 .static_().public_().returns(1).build()
376 .build();
377
378 ConcreteClass C = b.clazz("C").implement(I)
379 .concreteMethod("m", "()I").returns(2).build()
380 .build();
381
382 if (!factory.getExecutionMode().equals("REFLECTION")) {
383 // invokeinterface to static method ==> ICCE
384 b.test().callSite(I, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
385 .test().callSite(C, C, "m", "()I").returns(2).done().run();
386 } else {
387 b.test().callSite(I, C, "m", "()I").returns(1).done()
388 .test().callSite(C, C, "m", "()I").returns(2).done().run();
389 }
390
391 }
392
393 /*
394 * TEST: StaticMethodsTest.testOverrideStatic
395 *
396 * interface I {
397 * default static public int m() { return 1; }
398 * }
399 *
400 * interface J extends I {
401 * default public int m() { return 2; }
402 * }
403 *
404 * class C implements J {
405 * }
406 */
407 public void testOverrideStatic() {
408 TestBuilder b = factory.getBuilder();
409
410 Interface I = b.intf("I")
411 .defaultMethod("m", "()I")
412 .static_().public_().returns(1).build()
413 .build();
414
415 Interface J = b.intf("J").extend(I)
416 .defaultMethod("m", "()I")
417 .returns(2).build()
418 .build();
419
420 ConcreteClass C = b.clazz("C").implement(J).build();
421
422 if (!factory.getExecutionMode().equals("REFLECTION")) {
423 b.test().staticCallSite(I, "m", "()I").returns(1).done()
424 .test().callSite(I, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
425 .test().callSite(J, C, "m", "()I").returns(2).done()
426 .test().callSite(C, C, "m", "()I").returns(2).done()
427 .run();
428 } else {
429 b.test().staticCallSite(I, "m", "()I").returns(1).done()
430 .test().callSite(I, C, "m", "()I").returns(1).done()
431 .test().callSite(J, C, "m", "()I").returns(2).done()
432 .test().callSite(C, C, "m", "()I").returns(2).done()
433 .run();
434 }
435
436 }
437
438 /*
439 * testOverrideDefault
440 *
441 * interface I {
442 * default public int m() { return 1; }
443 * }
444 *
445 * interface J extends I {
446 * default static public int m() { return 2; }
447 * }
448 *
449 * class C implements J {}
450 *
451 * TEST: I o = new C(); o.m()I == 1
452 * TEST: J o = new C(); o.m()I == ICCE
453 * TEST: C o = new C(); o.m()I == 1
454 */
455 public void testOverrideDefault() {
456 TestBuilder b = factory.getBuilder();
457
458 Interface I = b.intf("I")
459 .defaultMethod("m", "()I")
460 .returns(1).build()
461 .build();
462
463 Interface J = b.intf("J").extend(I)
464 .defaultMethod("m", "()I")
465 .static_().public_().returns(2).build()
466 .build();
467
468 ConcreteClass C = b.clazz("C").implement(J).build();
469
470 if (!factory.getExecutionMode().equals("REFLECTION")) {
471 b.test().callSite(I, C, "m", "()I").returns(1).done()
472 .test().callSite(J, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
473 .test().callSite(C, C, "m", "()I").returns(1).done()
474
475 .run();
476
477 } else {
478 // Reflection correctly finds the static method defined in J and
479 // calls it with invokestatic.
480
481 b.test().callSite(I, C, "m", "()I").returns(1).done()
482 .test().callSite(J, C, "m", "()I").returns(2).done()
483 .test().callSite(C, C, "m", "()I").returns(1).done()
484
485 .run();
486 }
487 }
488
489 /*
490 * testReabstract
491 *
492 * interface I {
493 * default static public int m() { return 1; }
494 * }
495 *
496 * interface J extends I {
497 * abstract public int m();
498 * }
499 *
500 * class C implements J {}
501 *
502 * TEST: I o = new C(); o.m()I throws ICCE
503 * -mode reflect returns 1
504 * TEST: J o = new C(); o.m()I throws AME
505 * TEST: C o = new C(); o.m()I throws AME
506 */
507 public void testReabstract() {
508 TestBuilder b = factory.getBuilder();
509
510 Interface I = b.intf("I")
511 .defaultMethod("m", "()I")
512 .static_().public_().returns(1).build()
513 .build();
514
515 Interface J = b.intf("J").extend(I)
516 .abstractMethod("m", "()I").build()
517 .build();
518
519 ConcreteClass C = b.clazz("C").implement(J).build();
520
521 if (!factory.getExecutionMode().equals("REFLECTION")) {
522 b.test().callSite(I, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
523 .test().callSite(J, C, "m", "()I").throws_(AbstractMethodError.class).done()
524 .test().callSite(C, C, "m", "()I").throws_(AbstractMethodError.class).done()
525 .run();
526 } else {
527 b.test().callSite(I, C, "m", "()I").returns(1).done()
528 .test().callSite(J, C, "m", "()I").throws_(AbstractMethodError.class).done()
529 .test().callSite(C, C, "m", "()I").throws_(AbstractMethodError.class).done()
530 .run();
531 }
532 }
533
534 /*
535 * testOverrideAbstract
536 *
537 * interface I {
538 * abstract public int m();
539 * }
540 *
541 * interface J extends I {
542 * default static public int m() { return 1; }
543 * }
544 *
545 * class C implements J {}
546 *
547 * TEST: I o = new C(); o.m()I throws AME
548 * TEST: J o = new C(); o.m()I throws ICCE
549 * -mode reflect returns 1
550 * TEST: C o = new C(); o.m()I throws AME
551 */
552 public void testOverrideAbstract() {
553 TestBuilder b = factory.getBuilder();
554
555 Interface I = b.intf("I")
556 .abstractMethod("m", "()I").build()
557 .build();
558
559 Interface J = b.intf("J").extend(I)
560 .defaultMethod("m", "()I")
561 .static_().public_().returns(1).build()
562 .build();
563
564 ConcreteClass C = b.clazz("C").implement(J).build();
565
566 if (!factory.getExecutionMode().equals("REFLECTION")) {
567 b.test().callSite(I, C, "m", "()I").throws_(AbstractMethodError.class).done()
568 .test().callSite(J, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
569 .test().callSite(C, C, "m", "()I").throws_(AbstractMethodError.class).done()
570
571 .run();
572 } else {
573 b.test().callSite(I, C, "m", "()I").throws_(AbstractMethodError.class).done()
574 .test().callSite(J, C, "m", "()I").returns(1).done()
575 .test().callSite(C, C, "m", "()I").throws_(AbstractMethodError.class).done()
576
577 .run();
578 }
579 }
580
581 /*
582 * testInheritedDefault
583 *
584 * interface I {
585 * default static public int m() { return 1; }
586 * }
587 *
588 * class B implements I {}
589 *
590 * class C extends B {}
591 *
592 * TEST: I o = new C(); o.m()I throws IncompatibleClassChangeError
593 * -mode reflect returns 1
594 * TEST: B o = new C(); o.m()I throws NoSuchMethodError
595 * TEST: C o = new C(); o.m()I throws NoSuchMethodError
596 */
597 public void testInheritedDefault() {
598 TestBuilder b = factory.getBuilder();
599
600 Interface I = b.intf("I")
601 .defaultMethod("m", "()I")
602 .static_().public_().returns(1).build()
603 .build();
604
605 ConcreteClass B = b.clazz("B").implement(I).build();
606 ConcreteClass C = b.clazz("C").extend(B).build();
607
608 if (!factory.getExecutionMode().equals("REFLECTION")) {
609 b.test().callSite(I, C, "m","()I").throws_(IncompatibleClassChangeError.class).done()
610 .test().callSite(B, C, "m","()I").throws_(NoSuchMethodError.class).done()
611 .test().callSite(C, C, "m","()I").throws_(NoSuchMethodError.class).done()
612 .run();
613 } else {
614 b.test().callSite(I, C, "m","()I").returns(1).done()
615 .test().callSite(B, C, "m","()I").throws_(NoSuchMethodError.class).done()
616 .test().callSite(C, C, "m","()I").throws_(NoSuchMethodError.class).done()
617 .run();
618 }
619
620 }
621
622 /*
623 * testDefaultVsConcreteInherited
624 *
625 * interface I {
626 * default static public int m() { return 1; }
627 * }
628 *
629 * class B {
630 * public int m() { return 2; }
631 * }
632 *
633 * class C extends B implements I {}
634 *
635 */
636 public void testDefaultVsConcreteInherited() {
637 TestBuilder b = factory.getBuilder();
638
639 Interface I = b.intf("I")
640 .defaultMethod("m", "()I")
641 .static_().public_().returns(1).build()
642 .build();
643
644 ConcreteClass B = b.clazz("B")
645 .concreteMethod("m", "()I").returns(2).build()
646 .build();
647
648 ConcreteClass C = b.clazz("C").extend(B).implement(I).build();
649
650 if (!factory.getExecutionMode().equals("REFLECTION")) {
651 b.test().staticCallSite(I, "m","()I").returns(1).done()
652 .test().callSite(I, C, "m","()I").throws_(IncompatibleClassChangeError.class).done()
653 .test().callSite(B, C, "m","()I").returns(2).done()
654 .test().callSite(C, C, "m","()I").returns(2).done()
655 .run();
656 } else {
657 b.test().staticCallSite(I, "m","()I").returns(1).done()
658 .test().callSite(I, C, "m","()I").returns(1).done()
659 .test().callSite(B, C, "m","()I").returns(2).done()
660 .test().callSite(C, C, "m","()I").returns(2).done()
661 .run();
662 }
663
664 }
665
666 /*
667 * testDefaultVsStaticConflict
668 *
669 * interface I {
670 * default static public int m() { return 1; }
671 * }
672 *
673 * interface J {
674 * default public int m() { return 2; }
675 * }
676 *
677 * class C implements I, J {}
678 *
679 * TEST: I o = new C(); o.m()I throws ICCE
680 * -mode reflect returns 1
681 * TEST: J o = new C(); o.m()I == 2
682 * TEST: C o = new C(); o.m()I == 2
683 */
684 public void testDefaultVsStaticConflict() {
685 TestBuilder b = factory.getBuilder();
686
687 Interface I = b.intf("I")
688 .defaultMethod("m", "()I")
689 .static_().public_().returns(1).build()
690 .build();
691
692 Interface J = b.intf("J")
693 .defaultMethod("m", "()I").returns(2).build()
694 .build();
695
696 ConcreteClass C = b.clazz("C").implement(I,J).build();
697
698 if (!factory.getExecutionMode().equals("REFLECTION")) {
699 b.test().callSite(I, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
700 .test().callSite(J, C, "m", "()I").returns(2).done()
701 .test().callSite(C, C, "m", "()I").returns(2).done()
702 .run();
703 } else {
704 b.test().callSite(I, C, "m", "()I").returns(1).done()
705 .test().callSite(J, C, "m", "()I").returns(2).done()
706 .test().callSite(C, C, "m", "()I").returns(2).done()
707 .run();
708 }
709
710 }
711 /*
712 * testStaticSuperClassVsDefaultSuperInterface
713 *
714 * interface I {
715 * default public int m() { return 1; }
716 * }
717 *
718 * class A {
719 * public static int m() { return 2; }
720 * }
721 *
722 * class C extends A implements I {}
723 *
724 * TEST: C o = new C(); o.m()I throws ICCE
725 * -mode reflect returns 2
726 * TEST: I o = new C(); o.m()I == 1
727 */
728 public void testStaticSuperClassVsDefaultSuperInterface() {
729 TestBuilder b = factory.getBuilder();
730
731 Interface I = b.intf("I")
732 .defaultMethod("m", "()I")
733 .public_().returns(1).build()
734 .build();
735
736 ConcreteClass A = b.clazz("A")
737 .concreteMethod("m", "()I")
738 .static_().public_().returns(2).build()
739 .build();
740
741 ConcreteClass C = b.clazz("C").extend(A).implement(I).build();
742
743 if (!factory.getExecutionMode().equals("REFLECTION")) {
744 b.test().callSite(C, C, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
745 .test().callSite(I, C, "m", "()I").returns(1).done()
746 .run();
747 } else {
748 b.test().callSite(C, C, "m", "()I").returns(2).done()
749 .test().callSite(I, C, "m", "()I").returns(1).done()
750 .run();
751 }
752 }
753 /*
754 * testStaticLocalVsDefaultSuperInterface
755 *
756 * interface I {
757 * default public int m() { return 1; }
758 * }
759 *
760 * class A implements I {
761 * public static int m() { return 2; }
762 * }
763 *
764 * class C extends A implements I {}
765 *
766 * TEST: A o = new A(); o.m()I throws ICCE
767 * -mode reflect returns 2
768 * TEST: I o = new A(); o.m()I == 1
769 */
770 public void testStaticLocalVsDefaultSuperInterface() {
771 TestBuilder b = factory.getBuilder();
772
773 Interface I = b.intf("I")
774 .defaultMethod("m", "()I")
775 .public_().returns(1).build()
776 .build();
777
778 ConcreteClass A = b.clazz("A").implement(I)
779 .concreteMethod("m", "()I")
780 .static_().public_().returns(2).build()
781 .build();
782
783 ConcreteClass C = b.clazz("C").extend(A).implement(I).build();
784
785 if (!factory.getExecutionMode().equals("REFLECTION")) {
786 b.test().callSite(A, A, "m", "()I").throws_(IncompatibleClassChangeError.class).done()
787 .test().callSite(I, A, "m", "()I").returns(1).done()
788 .run();
789 } else {
790 b.test().callSite(A, A, "m", "()I").returns(2).done()
791 .test().callSite(I, A, "m", "()I").returns(1).done()
792 .run();
793 }
794 }
795 /*
796 * testConflictingDefaultsandStaticMethod
797 * @bug 8033150
798 *
799 * interface I {
800 * default public int m() { return 1; }
801 * }
802 *
803 * interface J {
804 * default public int m() { return 2; }
805 * }
806 *
807 * class A implements I, J {
808 * public static int m() { return 3; }
809 * }
810 *
811 * class C extends A {}
812 *
813 * TEST: C.m(); should call A.m, return value = 3
814 */
815 public void testConflictingDefaultsandStaticMethod() {
816 TestBuilder b = factory.getBuilder();
817
818 Interface I = b.intf("I")
819 .defaultMethod("m", "()I")
820 .public_().returns(1).build()
821 .build();
822
823 Interface J = b.intf("J")
824 .defaultMethod("m", "()I")
825 .public_().returns(2).build()
826 .build();
827
828 ConcreteClass A = b.clazz("A").implement(I,J)
829 .concreteMethod("m", "()I")
830 .static_().public_().returns(3).build()
831 .build();
832
833 ConcreteClass C = b.clazz("C").extend(A).build();
834
835 b.test().staticCallSite(C, "m", "()I").returns(3).done()
836 .run();
837 }
838 }