This repository has been archived by the owner on Mar 8, 2024. It is now read-only.
-
Notifications
You must be signed in to change notification settings - Fork 153
/
TestHarness.java
314 lines (265 loc) · 11.2 KB
/
TestHarness.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
/*
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package separate;
import org.testng.ITestResult;
import org.testng.annotations.AfterMethod;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;
import java.util.HashSet;
import java.util.stream.Collectors;
import static separate.SourceModel.Class;
import static separate.SourceModel.*;
import static org.testng.Assert.*;
public class TestHarness {
/**
* Creates a per-thread persistent compiler object to allow as much
* sharing as possible, but still allows for parallel execution of tests.
*/
protected ThreadLocal<Compiler> compilerLocal = new ThreadLocal<Compiler>(){
protected synchronized Compiler initialValue() {
return new Compiler();
}
};
protected ThreadLocal<Boolean> verboseLocal = new ThreadLocal<Boolean>() {
protected synchronized Boolean initialValue() {
return Boolean.FALSE;
}
};
protected boolean verbose;
protected boolean canUseCompilerCache;
public static final String stdMethodName = SourceModel.stdMethodName;
private TestHarness() {
}
protected TestHarness(boolean verbose, boolean canUseCompilerCache) {
this.verbose = verbose;
this.canUseCompilerCache = canUseCompilerCache;
}
public void setTestVerbose() {
verboseLocal.set(Boolean.TRUE);
}
@AfterMethod
public void reset() {
if (!this.verbose) {
verboseLocal.set(Boolean.FALSE);
}
}
public Compiler.Flags[] compilerFlags() {
HashSet<Compiler.Flags> flags = new HashSet<>();
if (verboseLocal.get() == Boolean.TRUE) {
flags.add(Compiler.Flags.VERBOSE);
}
if (this.canUseCompilerCache) {
flags.add(Compiler.Flags.USECACHE);
}
return flags.toArray(new Compiler.Flags[0]);
}
@AfterMethod
public void printError(ITestResult result) {
if (result.getStatus() == ITestResult.FAILURE) {
String clsName = result.getTestClass().getName();
clsName = clsName.substring(clsName.lastIndexOf(".") + 1);
System.out.println("Test " + clsName + "." +
result.getName() + " FAILED");
}
}
private static final ConcreteMethod stdCM = ConcreteMethod.std("-1");
private static final AbstractMethod stdAM =
new AbstractMethod("int", stdMethodName);
/**
* Returns a class which has a static method with the same name as
* 'method', whose body creates an new instance of 'specimen' and invokes
* 'method' upon it via an invokevirtual instruction with 'args' as
* function call parameters.
*
* 'returns' is a dummy return value that need only match 'methods'
* return type (it is only used in the dummy class when compiling IV).
*/
private Class invokeVirtualHarness(
Class specimen, ConcreteMethod method,
String returns, String ... args) {
Method cm = new ConcreteMethod(
method.getReturnType(), method.getName(),
"return " + returns + ";", method.getElements());
Class stub = new Class(specimen.getName(), cm);
String params =
Arrays.asList(args).stream().collect(Collectors.joining(", ")).toString();
ConcreteMethod sm = new ConcreteMethod(
method.getReturnType(), method.getName(),
String.format("return (new %s()).%s(%s);",
specimen.getName(), method.getName(), params),
new AccessFlag("public"), new AccessFlag("static"));
Class iv = new Class("IV_" + specimen.getName(), sm);
iv.addCompilationDependency(stub);
iv.addCompilationDependency(cm);
return iv;
}
/**
* Returns a class which has a static method with the same name as
* 'method', whose body creates an new instance of 'specimen', casts it
* to 'iface' (including the type parameters) and invokes
* 'method' upon it via an invokeinterface instruction with 'args' as
* function call parameters.
*/
private Class invokeInterfaceHarness(Class specimen, Extends iface,
AbstractMethod method, String ... args) {
Interface istub = new Interface(
iface.getType().getName(), iface.getType().getAccessFlags(),
iface.getType().getParameters(),
null, Arrays.asList((Method)method));
Class cstub = new Class(specimen.getName());
String params = Arrays.asList(args).stream().collect(Collectors.joining(", ")).toString();
ConcreteMethod sm = new ConcreteMethod(
"int", SourceModel.stdMethodName,
String.format("return ((%s)(new %s())).%s(%s);", iface.toString(),
specimen.getName(), method.getName(), params),
new AccessFlag("public"), new AccessFlag("static"));
sm.suppressWarnings();
Class ii = new Class("II_" + specimen.getName() + "_" +
iface.getType().getName(), sm);
ii.addCompilationDependency(istub);
ii.addCompilationDependency(cstub);
ii.addCompilationDependency(method);
return ii;
}
/**
* Uses 'loader' to load class 'clzz', and calls the static method
* 'method'. If the return value does not equal 'value' (or if an
* exception is thrown), then a test failure is indicated.
*
* If 'value' is null, then no equality check is performed -- the assertion
* fails only if an exception is thrown.
*/
protected void assertStaticCallEquals(
ClassLoader loader, Class clzz, String method, Object value) {
java.lang.Class<?> cls = null;
try {
cls = java.lang.Class.forName(clzz.getName(), true, loader);
} catch (ClassNotFoundException e) {}
assertNotNull(cls);
java.lang.reflect.Method m = null;
try {
m = cls.getMethod(method);
} catch (NoSuchMethodException e) {}
assertNotNull(m);
try {
Object res = m.invoke(null);
assertNotNull(res);
if (value != null) {
assertEquals(res, value);
}
} catch (InvocationTargetException | IllegalAccessException e) {
fail("Unexpected exception thrown: " + e.getCause());
}
}
/**
* Creates a class which calls target::method(args) via invokevirtual,
* compiles and loads both the new class and 'target', and then invokes
* the method. If the returned value does not match 'value' then a
* test failure is indicated.
*/
public void assertInvokeVirtualEquals(
Object value, Class target, ConcreteMethod method,
String returns, String ... args) {
Compiler compiler = compilerLocal.get();
compiler.setFlags(compilerFlags());
Class iv = invokeVirtualHarness(target, method, returns, args);
ClassLoader loader = compiler.compile(iv, target);
assertStaticCallEquals(loader, iv, method.getName(), value);
compiler.cleanup();
}
/**
* Convenience method for above, which assumes stdMethodName,
* a return type of 'int', and no arguments.
*/
public void assertInvokeVirtualEquals(int value, Class target) {
assertInvokeVirtualEquals(
new Integer(value), target, stdCM, "-1");
}
/**
* Creates a class which calls target::method(args) via invokeinterface
* through 'iface', compiles and loads both it and 'target', and
* then invokes the method. If the returned value does not match
* 'value' then a test failure is indicated.
*/
public void assertInvokeInterfaceEquals(Object value, Class target,
Extends iface, AbstractMethod method, String ... args) {
Compiler compiler = compilerLocal.get();
compiler.setFlags(compilerFlags());
Class ii = invokeInterfaceHarness(target, iface, method, args);
ClassLoader loader = compiler.compile(ii, target);
assertStaticCallEquals(loader, ii, method.getName(), value);
compiler.cleanup();
}
/**
* Convenience method for above, which assumes stdMethodName,
* a return type of 'int', and no arguments.
*/
public void assertInvokeInterfaceEquals(
int value, Class target, Interface iface) {
Compiler compiler = compilerLocal.get();
compiler.setFlags(compilerFlags());
assertInvokeInterfaceEquals(
new Integer(value), target, new Extends(iface), stdAM);
compiler.cleanup();
}
/**
* Creates a class which calls target::method(args) via invokevirtual,
* compiles and loads both the new class and 'target', and then invokes
* the method. If an exception of type 'exceptionType' is not thrown,
* then a test failure is indicated.
*/
public void assertThrows(java.lang.Class<?> exceptionType, Class target,
ConcreteMethod method, String returns, String ... args) {
Compiler compiler = compilerLocal.get();
compiler.setFlags(compilerFlags());
Class iv = invokeVirtualHarness(target, method, returns, args);
ClassLoader loader = compiler.compile(iv, target);
java.lang.Class<?> cls = null;
try {
cls = java.lang.Class.forName(iv.getName(), true, loader);
} catch (ClassNotFoundException e) {}
assertNotNull(cls);
java.lang.reflect.Method m = null;
try {
m = cls.getMethod(method.getName());
} catch (NoSuchMethodException e) {}
assertNotNull(m);
try {
m.invoke(null);
fail("Exception should have been thrown");
} catch (InvocationTargetException | IllegalAccessException e) {
if (verboseLocal.get() == Boolean.TRUE) {
System.out.println(e.getCause());
}
assertEquals(e.getCause().getClass(), exceptionType);
}
compiler.cleanup();
}
/**
* Convenience method for above, which assumes stdMethodName,
* a return type of 'int', and no arguments.
*/
public void assertThrows(java.lang.Class<?> exceptionType, Class target) {
assertThrows(exceptionType, target, stdCM, "-1");
}
}