13476
|
1 |
/*
|
|
2 |
* Copyright (c) 2012, 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 |
/*
|
|
26 |
* @test Test7116786
|
|
27 |
* @summary verify that VerifyError messages are as expected
|
|
28 |
* @library testcases.jar
|
|
29 |
* @run main/othervm -Xverify:all Test7116786
|
|
30 |
*/
|
|
31 |
|
|
32 |
|
|
33 |
/**
|
|
34 |
* This class contains information regarding when a VerifyError is thrown
|
|
35 |
* in the verifier. Most of the data is informational-only, and can be
|
|
36 |
* used to track down where and why VerifyErrors are thrown. As such it
|
|
37 |
* is possible the information may go out-of-date.
|
|
38 |
*
|
|
39 |
* The only fields used for the purpose of testing is the 'caseName' and
|
|
40 |
* the 'message'. The 'caseName' corresponds to a classfile which exhibits
|
|
41 |
* the VerifyError, and the 'message' is a regular expression which we expect
|
|
42 |
* to match the verify error message. If the 'message' doesn't match what
|
|
43 |
* we expect, it warrents investigation to see if we are still triggering
|
|
44 |
* the VerifyError that we expect. It could simply just be that the message
|
|
45 |
* changed, which is fine.
|
|
46 |
*
|
|
47 |
* Some cases are not testable, either because the code is probably unreachable
|
|
48 |
* or the test classfile would be too onerous to create. These cases are
|
|
49 |
* marked with 'testable' == false, and the test runner will skip them.
|
|
50 |
*/
|
|
51 |
class Case {
|
|
52 |
private String caseName; // Name of the case
|
|
53 |
private String file; // Source file where VerifyError is thrown
|
|
54 |
private String location; // enclosing function or switch case
|
|
55 |
private String description; // What causes this VerifyError
|
|
56 |
private String message; // The VerifyError message used.
|
|
57 |
|
|
58 |
private boolean testable; // Whether this case is testable or not.
|
|
59 |
|
|
60 |
public Case(String caseName, String file, boolean testable,
|
|
61 |
String location, String description, String message) {
|
|
62 |
this.caseName = caseName;
|
|
63 |
this.file = file;
|
|
64 |
this.testable = testable;
|
|
65 |
this.location = location;
|
|
66 |
this.description = description;
|
|
67 |
this.message = message;
|
|
68 |
}
|
|
69 |
|
|
70 |
String getCaseName() { return this.caseName; }
|
|
71 |
String getFile() { return this.file; }
|
|
72 |
String getLocation() { return this.location; }
|
|
73 |
String getDescription() { return this.description; }
|
|
74 |
String getMessage() { return this.message; }
|
|
75 |
|
|
76 |
boolean isTestable() { return this.testable; }
|
|
77 |
}
|
|
78 |
|
|
79 |
/**
|
|
80 |
* These are the locations in the source code where VerifyErrors are thrown
|
|
81 |
* as of today, 2012/07/18. These may change as the verification code is
|
|
82 |
* modified, which is ok. This test is trying to provide coverage for all
|
|
83 |
* VerifyErrors (just to make sure there are no crashes) and it's probably
|
|
84 |
* not necessary to update it every time the VM changes.
|
|
85 |
*/
|
|
86 |
class VerifyErrorCases {
|
|
87 |
public static final Case[] cases = {
|
|
88 |
|
|
89 |
new Case("case00", "stackMapFrame.cpp", true, "pop_stack_ex",
|
|
90 |
"stack underflow",
|
|
91 |
"Operand stack underflow"),
|
|
92 |
|
|
93 |
new Case("case01", "stackMapFrame.cpp", true, "pop_stack_ex",
|
|
94 |
"stack pop not assignable to expected",
|
|
95 |
"Bad type on operand stack"),
|
|
96 |
|
|
97 |
new Case("case02", "stackMapFrame.cpp", true, "get_local",
|
|
98 |
"local index out-of-bounds",
|
|
99 |
"Local variable table overflow"),
|
|
100 |
|
|
101 |
new Case("case03", "stackMapFrame.cpp", true, "get_local",
|
|
102 |
"local not assignable to expected",
|
|
103 |
"Bad local variable type"),
|
|
104 |
|
|
105 |
new Case("case04", "stackMapFrame.cpp", true, "get_local_2",
|
|
106 |
"local index out-of-bounds [type2]",
|
|
107 |
"get long/double overflows locals"),
|
|
108 |
|
|
109 |
new Case("case05", "stackMapFrame.cpp", true, "get_local_2",
|
|
110 |
"local not assignabled to expected [type2]",
|
|
111 |
"Bad local variable type"),
|
|
112 |
|
|
113 |
/* Unreachable: Can't split long/double on stack */
|
|
114 |
new Case("case06", "stackMapFrame.cpp", false, "get_local_2",
|
|
115 |
"local second-word not assignabled to expected",
|
|
116 |
"Bad local variable type"),
|
|
117 |
|
|
118 |
new Case("case07", "stackMapFrame.cpp", true, "set_local",
|
|
119 |
"local index out-of-bounds",
|
|
120 |
"Local variable table overflow"),
|
|
121 |
|
|
122 |
new Case("case08", "stackMapFrame.cpp", true, "set_local_2",
|
|
123 |
"local index out-of-bounds [type2]",
|
|
124 |
"Local variable table overflow"),
|
|
125 |
|
|
126 |
new Case("case09", "stackMapFrame.hpp", true, "push_stack",
|
|
127 |
"stack overflow",
|
|
128 |
"Operand stack overflow"),
|
|
129 |
|
|
130 |
new Case("case10", "stackMapFrame.hpp", true, "push_stack_2",
|
|
131 |
"stack overflow [type2]",
|
|
132 |
"Operand stack overflow"),
|
|
133 |
|
|
134 |
new Case("case11", "stackMapFrame.hpp", true, "pop_stack",
|
|
135 |
"stack underflow",
|
|
136 |
"Operand stack underflow"),
|
|
137 |
|
|
138 |
new Case("case12", "stackMapTable.cpp", true, "StackMapTable ctor",
|
|
139 |
"stackmap offset beyond code size",
|
|
140 |
"StackMapTable error: bad offset"),
|
|
141 |
|
|
142 |
new Case("case13", "stackMapTable.cpp", true, "match_stackmap",
|
|
143 |
"no stackmap frame at expected location",
|
|
144 |
"Expecting a stackmap frame at branch target "),
|
|
145 |
|
|
146 |
new Case("case14", "stackMapTable.cpp", true, "check_jump_target",
|
|
147 |
"no stackmap frame at jump location or bad jump",
|
|
148 |
"Inconsistent stackmap frames at branch target "),
|
|
149 |
|
|
150 |
new Case("case15", "stackMapTable.cpp", true, "check_new_object",
|
|
151 |
"backward jump with uninit",
|
|
152 |
"Uninitialized object exists on backward branch "),
|
|
153 |
|
|
154 |
/* Unreachable: wide instructions verified during bytecode analysis */
|
|
155 |
new Case("case16", "verifier.cpp", false, "loop header",
|
|
156 |
"bad op in wide instruction",
|
|
157 |
"Bad wide instruction"),
|
|
158 |
|
|
159 |
new Case("case17", "verifier.cpp", true, "case iaload",
|
|
160 |
"TOS not X array",
|
|
161 |
"Bad type on operand stack in iaload"),
|
|
162 |
|
|
163 |
new Case("case18", "verifier.cpp", true, "case baload",
|
|
164 |
"TOS not X array",
|
|
165 |
"Bad type on operand stack in baload"),
|
|
166 |
|
|
167 |
new Case("case19", "verifier.cpp", true, "case caload",
|
|
168 |
"TOS not X array",
|
|
169 |
"Bad type on operand stack in caload"),
|
|
170 |
|
|
171 |
new Case("case20", "verifier.cpp", true, "case saload",
|
|
172 |
"TOS not X array",
|
|
173 |
"Bad type on operand stack in saload"),
|
|
174 |
|
|
175 |
new Case("case21", "verifier.cpp", true, "case laload",
|
|
176 |
"TOS not X array",
|
|
177 |
"Bad type on operand stack in laload"),
|
|
178 |
|
|
179 |
new Case("case22", "verifier.cpp", true, "case faload",
|
|
180 |
"TOS not X array",
|
|
181 |
"Bad type on operand stack in faload"),
|
|
182 |
|
|
183 |
new Case("case23", "verifier.cpp", true, "case daload",
|
|
184 |
"TOS not X array",
|
|
185 |
"Bad type on operand stack in daload"),
|
|
186 |
|
|
187 |
new Case("case24", "verifier.cpp", true, "case aaload",
|
|
188 |
"TOS not X array",
|
|
189 |
"Bad type on operand stack in aaload"),
|
|
190 |
|
|
191 |
new Case("case25", "verifier.cpp", true, "case iastore",
|
|
192 |
"TOS not int array",
|
|
193 |
"Bad type on operand stack in iastore"),
|
|
194 |
|
|
195 |
new Case("case26", "verifier.cpp", true, "case bastore",
|
|
196 |
"TOS not byte array",
|
|
197 |
"Bad type on operand stack in bastore"),
|
|
198 |
|
|
199 |
new Case("case27", "verifier.cpp", true, "case castore",
|
|
200 |
"TOS not char array",
|
|
201 |
"Bad type on operand stack in castore"),
|
|
202 |
|
|
203 |
new Case("case28", "verifier.cpp", true, "case sastore",
|
|
204 |
"TOS not short array",
|
|
205 |
"Bad type on operand stack in sastore"),
|
|
206 |
|
|
207 |
new Case("case29", "verifier.cpp", true, "case lastore",
|
|
208 |
"TOS not long array",
|
|
209 |
"Bad type on operand stack in lastore"),
|
|
210 |
|
|
211 |
new Case("case30", "verifier.cpp", true, "case fastore",
|
|
212 |
"TOS not float array",
|
|
213 |
"Bad type on operand stack in fastore"),
|
|
214 |
|
|
215 |
new Case("case31", "verifier.cpp", true, "case dastore",
|
|
216 |
"TOS not double array",
|
|
217 |
"Bad type on operand stack in dastore"),
|
|
218 |
|
|
219 |
new Case("case32", "verifier.cpp", true, "case aastore",
|
|
220 |
"TOS not object array",
|
|
221 |
"Bad type on operand stack in aastore"),
|
|
222 |
|
|
223 |
/* Unreachable: In order to hit this case, we would need a
|
|
224 |
* category2_1st at TOS which is not possible. */
|
|
225 |
new Case("case33", "verifier.cpp", false, "case pop2",
|
|
226 |
"TOS is category2_1st (would split)",
|
|
227 |
"Bad type on operand stack in pop2"),
|
|
228 |
|
|
229 |
/* Unreachable: In order to hit this case, we would need a
|
|
230 |
* category2_1st at stack depth 2 with category_1 on TOS which is not
|
|
231 |
* possible. */
|
|
232 |
new Case("case34", "verifier.cpp", false, "case dup_x2",
|
|
233 |
"TOS-1 is category2_1st (would split)",
|
|
234 |
"Bad type on operand stack in dup_x2"),
|
|
235 |
|
|
236 |
/* Unreachable: In order to hit this case, we would need a
|
|
237 |
* category2_1st at TOS which is not possible. */
|
|
238 |
new Case("case35", "verifier.cpp", false, "case dup2",
|
|
239 |
"TOS-1 is category2_1st (would split)",
|
|
240 |
"Bad type on operand stack in dup2"),
|
|
241 |
|
|
242 |
/* Unreachable: In order to hit this case, we would need a
|
|
243 |
* category2_1st at TOS which is not possible. */
|
|
244 |
new Case("case36", "verifier.cpp", false, "case dup2_x1",
|
|
245 |
"TOS-1 is category2_1st (would split)",
|
|
246 |
"Bad type on operand stack in dup2_x1"),
|
|
247 |
|
|
248 |
/* Unreachable: In order to hit this case, we would need a
|
|
249 |
* category2_1st at TOS which is not possible. */
|
|
250 |
new Case("case37", "verifier.cpp", false, "case dup2_x2",
|
|
251 |
"TOS-1 is category2_1st (would split)",
|
|
252 |
"Bad type on operand stack in dup2_x2"),
|
|
253 |
|
|
254 |
/* Unreachable: In order to hit this case, we would need a
|
|
255 |
* category2_1st at stack depth 3 with either 2 category_1 or 1
|
|
256 |
* category_2 on TOS, which is not possible. */
|
|
257 |
new Case("case38", "verifier.cpp", false, "case dup2_x2",
|
|
258 |
"TOS-3 is category2_1st (would split)",
|
|
259 |
"Bad type on operand stack in dup2_x2"),
|
|
260 |
|
|
261 |
new Case("case39", "verifier.cpp", true, "case return",
|
|
262 |
"return type of method is not void",
|
|
263 |
"Method expects a return value"),
|
|
264 |
|
|
265 |
new Case("case40", "verifier.cpp", true, "case return",
|
|
266 |
"return with uninitialized this ",
|
|
267 |
"Constructor must call super() or this() before return"),
|
|
268 |
|
|
269 |
new Case("case41", "verifier.cpp", true, "case new",
|
|
270 |
"cp index not a class type",
|
|
271 |
"Illegal new instruction"),
|
|
272 |
|
|
273 |
new Case("case42", "verifier.cpp", true, "case arraylength",
|
|
274 |
"TOS is not an array",
|
|
275 |
"Bad type on operand stack in arraylength"),
|
|
276 |
|
|
277 |
new Case("case43", "verifier.cpp", true, "case multianewarray",
|
|
278 |
"CP index does not refer to array type",
|
|
279 |
"Illegal constant pool index in multianewarray instruction"),
|
|
280 |
|
|
281 |
new Case("case44", "verifier.cpp", true, "case multianewarray",
|
|
282 |
"Bad dimension (<1) or does not match CP signature",
|
|
283 |
"Illegal dimension in multianewarray instruction: "),
|
|
284 |
|
|
285 |
new Case("case45", "verifier.cpp", true, "case default",
|
|
286 |
"Unrecognized bytecode",
|
|
287 |
"Bad instruction: "),
|
|
288 |
|
|
289 |
new Case("case46", "verifier.cpp", true, "loop end",
|
|
290 |
"control flow falls off method",
|
|
291 |
"Control flow falls through code end"),
|
|
292 |
|
|
293 |
new Case("case47", "verifier.cpp", true, "generate_code_data",
|
|
294 |
"illegal bytecode via RawBytecodeStream (breakpoint)",
|
|
295 |
"Bad instruction"),
|
|
296 |
|
|
297 |
new Case("case48", "verifier.cpp", true, "generate_code_data",
|
|
298 |
"illegal bytecode via RawBytecodeStream (other illegal)",
|
|
299 |
"Bad instruction"),
|
|
300 |
|
|
301 |
new Case("case49", "verifier.cpp", true,
|
|
302 |
"verify_exception_handler_table",
|
|
303 |
"catch_type is not throwable",
|
|
304 |
"Catch type is not a subclass of Throwable in " +
|
|
305 |
"exception handler "),
|
|
306 |
|
|
307 |
new Case("case50", "verifier.cpp", true, "verify_stackmap_table",
|
|
308 |
"missing a stack map frame @ target location (mid table)",
|
|
309 |
"Expecting a stack map frame"),
|
|
310 |
|
|
311 |
new Case("case51", "verifier.cpp", true, "verify_stackmap_table",
|
|
312 |
"stack map does not match?",
|
|
313 |
"Instruction type does not match stack map"),
|
|
314 |
|
|
315 |
new Case("case52", "verifier.cpp", true, "verify_stackmap_table",
|
|
316 |
"missing a stack map frame @ target location (end of table)",
|
|
317 |
"Expecting a stack map frame"),
|
|
318 |
|
|
319 |
new Case("case53", "verifier.cpp", true,
|
|
320 |
"verify_exception_handler_targets",
|
|
321 |
"stackmap mismatch at exception handler",
|
|
322 |
"Stack map does not match the one at exception handler "),
|
|
323 |
|
|
324 |
new Case("case54", "verifier.cpp", true, "verify_cp_index",
|
|
325 |
"constant pool index is out-of-bounds",
|
|
326 |
"Illegal constant pool index "),
|
|
327 |
|
|
328 |
new Case("case55", "verifier.cpp", true, "verify_cp_type",
|
|
329 |
"constant pool entry is not expected type",
|
|
330 |
"Illegal type at constant pool entry "),
|
|
331 |
|
|
332 |
new Case("case56", "verifier.cpp", true, "verify_cp_class_type",
|
|
333 |
"constant pool entry is not an object type",
|
|
334 |
"Illegal type at constant pool entry "),
|
|
335 |
|
|
336 |
/* Unreachable: verify_cp_type gates this case */
|
|
337 |
new Case("case57", "verifier.cpp", false, "verify_ldc",
|
|
338 |
"invalid constant pool index in ldc",
|
|
339 |
"Invalid index in ldc"),
|
|
340 |
|
|
341 |
new Case("case58", "verifier.cpp", true, "verify_switch",
|
|
342 |
"bad switch padding",
|
|
343 |
"Nonzero padding byte in lookswitch or tableswitch"),
|
|
344 |
|
|
345 |
new Case("case59", "verifier.cpp", true, "verify_switch",
|
|
346 |
"tableswitch low is greater than high",
|
|
347 |
"low must be less than or equal to high in tableswitch"),
|
|
348 |
|
|
349 |
/* Unreachable on 64-bit? Only way to get here is to overflow
|
|
350 |
* the 'keys' variable which can't happen on 64-bit since we're dealing
|
|
351 |
* with 32-bit values. Perhaps reachable on 32-bit but the
|
|
352 |
* triggering class would be quite large */
|
|
353 |
new Case("case60", "verifier.cpp", false, "verify_switch",
|
|
354 |
"high - low + 1 < 0 (overflow?)",
|
|
355 |
"too many keys in tableswitch"),
|
|
356 |
|
|
357 |
/* Would have to create a 16G classfile to trip this. Possible but
|
|
358 |
* not reasonable to do in a test. */
|
|
359 |
new Case("case61", "verifier.cpp", false, "verify_switch",
|
|
360 |
"lookupswitch keys < 0",
|
|
361 |
"number of keys in lookupswitch less than 0"),
|
|
362 |
|
|
363 |
new Case("case62", "verifier.cpp", true, "verify_switch",
|
|
364 |
"lookupswitch keys out-of-order",
|
|
365 |
"Bad lookupswitch instruction"),
|
|
366 |
|
|
367 |
/* Unreachable: Class file parser verifies Fieldref contents */
|
|
368 |
new Case("case63", "verifier.cpp", false, "verify_field_instructions",
|
|
369 |
"referenced class is not an CP object",
|
|
370 |
"Expecting reference to class in class "),
|
|
371 |
|
|
372 |
new Case("case64", "verifier.cpp", true, "verify_field_instructions",
|
|
373 |
"TOS not assignable to field type in putfield",
|
|
374 |
"Bad type on operand stack in putfield"),
|
|
375 |
|
|
376 |
new Case("case65", "verifier.cpp", true, "verify_field_instructions",
|
|
377 |
"TOS not assignable to class when accessing protected field",
|
|
378 |
"Bad access to protected data in getfield"),
|
|
379 |
|
|
380 |
new Case("case66", "verifier.cpp", true, "verify_invoke_init",
|
|
381 |
"Uninit_this is not of the current type or it's supertype",
|
|
382 |
"Bad <init> method call"),
|
|
383 |
|
|
384 |
/* Unreachable: Stack map parsing ensures valid type and new
|
|
385 |
* instructions have a valid BCI. */
|
|
386 |
new Case("case67", "verifier.cpp", false, "verify_invoke_init",
|
|
387 |
"Uninit type with bad new instruction index",
|
|
388 |
"Expecting new instruction"),
|
|
389 |
|
|
390 |
new Case("case68", "verifier.cpp", true, "verify_invoke_init",
|
|
391 |
"calling other class's <init> method",
|
|
392 |
"Call to wrong <init> method"),
|
|
393 |
|
|
394 |
new Case("case69", "verifier.cpp", true, "verify_invoke_init",
|
|
395 |
"Calling protected <init> and type unassignable from current",
|
|
396 |
"Bad access to protected <init> method"),
|
|
397 |
|
|
398 |
new Case("case70", "verifier.cpp", true, "verify_invoke_init",
|
|
399 |
"TOS is not an uninitialized (or Uninit_this) type",
|
|
400 |
"Bad operand type when invoking <init>"),
|
|
401 |
|
|
402 |
new Case("case71", "verifier.cpp", true, "verify_invoke_instructions",
|
|
403 |
"Arg count in instruction doesn't match signature",
|
|
404 |
"Inconsistent args count operand in invokeinterface"),
|
|
405 |
|
|
406 |
new Case("case72", "verifier.cpp", true, "verify_invoke_instructions",
|
|
407 |
"Non-zero pad in invokeinterface",
|
|
408 |
"Fourth operand byte of invokeinterface must be zero"),
|
|
409 |
|
|
410 |
new Case("case73", "verifier.cpp", true, "verify_invoke_instructions",
|
|
411 |
"Non-zero pad in invokedynamic",
|
|
412 |
"Third and fourth operand bytes of " +
|
|
413 |
"invokedynamic must be zero"),
|
|
414 |
|
|
415 |
new Case("case74", "verifier.cpp", true, "verify_invoke_instructions",
|
|
416 |
"Non-invokespecial trying to invoke a '<' method",
|
|
417 |
"Illegal call to internal method"),
|
|
418 |
|
|
419 |
new Case("case75", "verifier.cpp", true, "verify_invoke_instructions",
|
|
420 |
"invokespecial and current unassignable from referenced type",
|
|
421 |
"Bad invokespecial instruction: current class isn't " +
|
|
422 |
"assignable to reference class."),
|
|
423 |
|
|
424 |
new Case("case76", "verifier.cpp", true, "verify_invoke_instructions",
|
|
425 |
"TOS not assignable to current when calling protected method",
|
|
426 |
"Bad access to protected data in invokevirtual"),
|
|
427 |
|
|
428 |
/* Unreachable: class file parser enforces void signature */
|
|
429 |
new Case("case77", "verifier.cpp", false, "verify_invoke_instructions",
|
|
430 |
"<init> method is not void return",
|
|
431 |
"Return type must be void in <init> method"),
|
|
432 |
|
|
433 |
new Case("case78", "verifier.cpp", true, "get_newarray_type",
|
|
434 |
"newarray type invalid",
|
|
435 |
"Illegal newarray instruction"),
|
|
436 |
|
|
437 |
new Case("case79", "verifier.cpp", true, "verify_return_value",
|
|
438 |
"void return from method which has a return value",
|
|
439 |
"Method expects a return value"),
|
|
440 |
|
|
441 |
new Case("case80", "verifier.cpp", true, "verify_return_value",
|
|
442 |
"TOS type does not match signature",
|
|
443 |
"Bad return type"),
|
|
444 |
|
|
445 |
new Case("case81", "verifier.cpp", true, "verify_stackmap_table",
|
|
446 |
"stack map does not match (flags)",
|
|
447 |
"Instruction type does not match stack map")
|
|
448 |
};
|
|
449 |
}
|
|
450 |
|
|
451 |
public class Test7116786 {
|
|
452 |
public static void main(String argv[]) throws Exception {
|
|
453 |
for (Case c : VerifyErrorCases.cases) {
|
|
454 |
System.out.println("******** " + c.getCaseName() + " ********");
|
|
455 |
if (c.isTestable()) {
|
|
456 |
try {
|
|
457 |
ClassLoader cl = Test7116786.class.getClassLoader();
|
|
458 |
Class<?> cls = Class.forName(c.getCaseName(), true, cl);
|
|
459 |
throw new RuntimeException(
|
|
460 |
"++ FAIL: No verify error encountered");
|
|
461 |
} catch (VerifyError ve) {
|
|
462 |
String message = c.getMessage();
|
|
463 |
String veMessage = ve.getMessage();
|
|
464 |
System.out.print(veMessage);
|
|
465 |
if (!veMessage.startsWith(message)) {
|
|
466 |
// We're not seeing the message we expect. Could be
|
|
467 |
// that we've gotten the wrong VerifyError case, or
|
|
468 |
// maybe the message changed.
|
|
469 |
System.out.println("++ FAIL? " +
|
|
470 |
"Message does not match what was expected: " +
|
|
471 |
message);
|
|
472 |
continue;
|
|
473 |
}
|
|
474 |
if (!veMessage.contains("Exception Details:") &&
|
|
475 |
!veMessage.contains("Reason:")) {
|
|
476 |
System.out.println("++ FAIL: No details found");
|
|
477 |
throw new RuntimeException("FAIL: No details found");
|
|
478 |
}
|
|
479 |
System.out.println("++ PASS");
|
|
480 |
}
|
|
481 |
} else {
|
|
482 |
System.out.println("++ SKIPPED");
|
|
483 |
}
|
|
484 |
}
|
|
485 |
}
|
|
486 |
}
|