Mercurial > hg > Members > kono > jpf-core

comparison src/tests/gov/nasa/jpf/test/vm/basic/MethodTest.java @ 0:61d41facf527

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
initial v8 import (history reset)
author Peter Mehlitz <Peter.C.Mehlitz@nasa.gov>
date Fri, 23 Jan 2015 10:14:01 -0800
parents
children
comparison
equal deleted inserted replaced
-1:000000000000 0:61d41facf527
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 }