Fix incorrect IncompatibleClassChangeError in ClassInfo.getDefaultMethod (#7)
[jpf-core.git] / src / tests / gov / nasa / jpf / test / vm / basic / MethodTest.java
1 /*
2  * Copyright (C) 2014, United States Government, as represented by the
3  * Administrator of the National Aeronautics and Space Administration.
4  * All rights reserved.
5  *
6  * The Java Pathfinder core (jpf-core) platform is licensed under the
7  * Apache License, Version 2.0 (the "License"); you may not use this file except
8  * in compliance with the License. You may obtain a copy of the License at
9  * 
10  *        http://www.apache.org/licenses/LICENSE-2.0. 
11  *
12  * Unless required by applicable law or agreed to in writing, software
13  * distributed under the License is distributed on an "AS IS" BASIS,
14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15  * See the License for the specific language governing permissions and 
16  * limitations under the License.
17  */
18 package gov.nasa.jpf.test.vm.basic;
19
20 import gov.nasa.jpf.util.test.TestJPF;
21
22 import org.junit.Test;
23
24
25 /**
26  * basic method invocation test
27  */
28
29
30 interface TMI {
31   void gna();
32 }
33
34 class TestMethodBase extends TestJPF implements TMI {
35   
36   int baseData;
37
38   static int sData;
39   
40   static {
41     sData = -1;
42   }
43   
44   static void taz () {
45     sData = 24;
46   }
47   
48   TestMethodBase (int a) {
49     assert a == 42;
50     baseData = 42;
51   }
52
53   boolean baz (boolean p, byte b, char c, short s, int i, long l, float f, double d, Object o) {
54     assert p;
55     assert b == 4;
56     assert c == '?';
57     assert s == 42;
58     assert i == 4242;
59     assert l == 424242;
60     assert f == 4.2f;
61     assert d == 4.242;
62     assert o.equals(new Integer(42));
63
64     baseData = 44;
65
66     return p;
67   }
68   
69   void faz () {
70     gna();
71   }
72   
73   @Override
74   public void gna () {
75     baseData = 0;
76   }
77   
78   int har () {
79     return priv();
80   }
81   
82   private int priv () {
83     return 7;
84   }
85 }
86
87 public class MethodTest extends TestMethodBase {
88   
89   int data;
90   
91   static void taz () {
92     sData = 9;
93   }
94   
95   public MethodTest () {
96     super(42);
97     
98     data = 42;
99   }
100
101   MethodTest (int a) {
102     super(a);
103     
104     data = a;
105   }
106   
107   double foo (boolean p, byte b, char c, short s, int i, long l, float f, double d, Object o) {
108     assert p;
109     assert b == 4;
110     assert c == '?';
111     assert s == 42;
112     assert i == 4242;
113     assert l == 424242;
114     assert f == 4.2f;
115     assert d == 4.242;
116     assert o.equals(new Integer(42));
117
118     data = 43;
119
120     return d;
121   }
122
123   @Override
124   public void gna () {
125     baseData = 45;
126   }
127   
128   int priv () {
129     return 8;
130   }
131   
132   @Test
133   public void testCtor() {
134     if (verifyNoPropertyViolation()) {
135       MethodTest o1 = new MethodTest();
136       assert o1.data == 42;
137       assert o1.baseData == 42;
138
139       MethodTest o2 = new MethodTest(42);
140       assert o2.data == 42;
141       assert o2.baseData == 42;
142     }
143   }
144
145   @Test
146   public void testCall() {
147     if (verifyNoPropertyViolation()) {
148       MethodTest o = new MethodTest();
149       assert o.foo(true, (byte) 4, '?', (short) 42, 4242, 424242, 4.2f, 4.242, new Integer(42)) == 4.242;
150       assert o.data == 43;
151     }
152   }
153
154   @Test
155   public void testInheritedCall() {
156     if (verifyNoPropertyViolation()) {
157       MethodTest o = new MethodTest();
158       assert o.baz(true, (byte) 4, '?', (short) 42, 4242, 424242, 4.2f, 4.242, new Integer(42));
159       assert o.baseData == 44;
160     }
161   }
162
163   @Test
164   public void testVirtualCall() {
165     if (verifyNoPropertyViolation()) {
166       MethodTest o = new MethodTest();
167       TestMethodBase b = o;
168
169       b.faz();
170       assert o.baseData == 45;
171     }
172   }
173
174   @Test
175   public void testSpecialCall() {
176     if (verifyNoPropertyViolation()) {
177       MethodTest o = new MethodTest();
178       assert o.har() == 7;
179     }
180   }
181
182   @Test
183   public void testStaticCall() {
184     if (verifyNoPropertyViolation()) {
185       assert TestMethodBase.sData == -1;
186
187       MethodTest.taz();
188       assert TestMethodBase.sData == 9;
189
190       TestMethodBase.taz();
191       assert TestMethodBase.sData == 24;
192
193       // used to be:
194       //TestMethod o = new TestMethod();
195       //o.taz();
196       // statically equiv. to this: (no warnings) - pcd
197       new MethodTest();
198       MethodTest.taz();
199
200       assert TestMethodBase.sData == 9;
201     }
202   }
203
204   @Test
205   public void testInterfaceCall() {
206     if (verifyNoPropertyViolation()) {
207       MethodTest o = new MethodTest();
208       TMI ifc = o;
209
210       ifc.gna();
211       assert o.baseData == 45;
212     }
213   }
214   
215   static class A {
216     public int foo () {
217       assert false : "should bever be invoked";
218       return -1;
219     }
220   }
221   
222   static class A0 extends A {
223     @Override
224         public int foo () {
225       return 0;
226     }
227   }
228   
229   static class A1 extends A {
230     @Override
231         public int foo () {
232       return 1;
233     }
234   }
235     
236   /**
237    * this is tricky - both the allocations and the foo() calls have to be
238    * the same instructions, and we have to remove all 'a' references before
239    * forcing a GC. Otherwise we don't allocate 'a's with the same reference values 
240    *
241    */
242   @Test public void testCallAcrossGC () {
243
244     if (verifyNoPropertyViolation()){
245       System.out.println("testing virtual calls on GC boundaries");
246       A a;
247
248       a = new A0();
249       assert a.foo() == 0 : "wrong A.foo() called for A0";
250
251       // do a GC
252       Runtime.getRuntime().gc(); // this should recycle 'a'
253
254       a = new A1();
255       assert a.foo() == 1 : "wrong A.foo() called for A1";
256     }
257   }
258
259
260   interface InterfaceWithDefaultMethod {
261     default int foo() {
262       return 42;
263     }
264   }
265
266   static class Base implements InterfaceWithDefaultMethod {
267   }
268
269   static class Child extends Base implements InterfaceWithDefaultMethod {
270   }
271
272   @Test
273   public void testDefaultMethodCall() {
274     if (verifyNoPropertyViolation()) {
275       assertEquals(42, new Child().foo());
276     }
277   }
278 }