1 /*
2 * Copyright (c) 2014, 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 package test.java.lang.invoke.MethodHandles;
24
25 import com.oracle.testlibrary.jsr292.Helper;
26 import jdk.testlibrary.Asserts;
27 import jdk.testlibrary.TimeLimitedRunner;
28 import jdk.testlibrary.Utils;
29
30 import java.lang.invoke.MethodHandle;
31 import java.lang.invoke.MethodHandles;
32 import java.lang.invoke.MethodType;
33 import java.lang.reflect.Array;
34 import java.util.*;
35 import java.util.function.BiFunction;
36 import java.util.function.Function;
37 import java.util.function.Supplier;
38 import java.util.concurrent.TimeUnit;
39
40 /* @test
41 * @library /lib/testlibrary/jsr292 /lib/testlibrary/
42 * @compile CatchExceptionTest.java
43 * @run main/othervm -esa test.java.lang.invoke.MethodHandles.CatchExceptionTest
44 * @key intermittent
45 */
46 public class CatchExceptionTest {
47 private static final List<Class<?>> ARGS_CLASSES;
48 protected static final int MAX_ARITY = Helper.MAX_ARITY - 1;
49
50 static {
51 Class<?> classes[] = {
52 Object.class,
53 long.class,
54 int.class,
55 byte.class,
56 Integer[].class,
57 double[].class,
58 String.class,
59 };
60 ARGS_CLASSES = Collections.unmodifiableList(
61 Helper.randomClasses(classes, MAX_ARITY));
62 }
63
64 private final TestCase testCase;
65 private final int nargs;
66 private final int argsCount;
67 private final MethodHandle catcher;
68 private int dropped;
69 private MethodHandle thrower;
70
71 public CatchExceptionTest(TestCase testCase, final boolean isVararg, final int argsCount,
72 final int catchDrops) {
73 this.testCase = testCase;
74 this.dropped = catchDrops;
75 if (Helper.IS_VERBOSE) {
76 System.out.printf("CatchException::CatchException(%s, isVararg=%b " +
77 "argsCount=%d catchDrops=%d)%n",
78 testCase, isVararg, argsCount, catchDrops
79 );
80 }
81 MethodHandle thrower = testCase.thrower;
82 int throwerLen = thrower.type().parameterCount();
83 List<Class<?>> classes;
84 int extra = Math.max(0, argsCount - throwerLen);
85 classes = getThrowerParams(isVararg, extra);
86 this.argsCount = throwerLen + classes.size();
87 thrower = Helper.addTrailingArgs(thrower, this.argsCount, classes);
88 if (isVararg && argsCount > throwerLen) {
89 MethodType mt = thrower.type();
90 Class<?> lastParam = mt.parameterType(mt.parameterCount() - 1);
91 thrower = thrower.asVarargsCollector(lastParam);
92 }
93 this.thrower = thrower;
94 this.dropped = Math.min(this.argsCount, catchDrops);
95 catcher = testCase.getCatcher(getCatcherParams());
96 nargs = Math.max(2, this.argsCount);
97 }
98
99 public static void main(String[] args) throws Throwable {
100 TestFactory factory = new TestFactory();
101 long timeout = Helper.IS_THOROUGH ? 0L : Utils.adjustTimeout(Utils.DEFAULT_TEST_TIMEOUT);
102 // substract vm init time and reserve time for vm exit
103 timeout *= 0.9;
104 TimeLimitedRunner runner = new TimeLimitedRunner(timeout, 2.0d,
105 () -> {
106 CatchExceptionTest test = factory.nextTest();
107 if (test != null) {
108 test.runTest();
109 return true;
110 }
111 return false;
112 });
113 for (CatchExceptionTest test : TestFactory.MANDATORY_TEST_CASES) {
114 test.runTest();
115 }
116 runner.call();
117 }
118
119 private List<Class<?>> getThrowerParams(boolean isVararg, int argsCount) {
120 return Helper.getParams(ARGS_CLASSES, isVararg, argsCount);
121 }
122
123
124 private List<Class<?>> getCatcherParams() {
125 int catchArgc = 1 + this.argsCount - dropped;
126 List<Class<?>> result = new ArrayList<>(
127 thrower.type().parameterList().subList(0, catchArgc - 1));
128 // prepend throwable
129 result.add(0, testCase.throwableClass);
130 return result;
131 }
132
133 private void runTest() {
134 Helper.clear();
135
136 Object[] args = Helper.randomArgs(
137 argsCount, thrower.type().parameterArray());
138 Object arg0 = Helper.MISSING_ARG;
139 Object arg1 = testCase.thrown;
140 if (argsCount > 0) {
141 arg0 = args[0];
142 }
143 if (argsCount > 1) {
144 args[1] = arg1;
145 }
146 Asserts.assertEQ(nargs, thrower.type().parameterCount());
147 if (argsCount < nargs) {
148 Object[] appendArgs = {arg0, arg1};
149 appendArgs = Arrays.copyOfRange(appendArgs, argsCount, nargs);
150 thrower = MethodHandles.insertArguments(
151 thrower, argsCount, appendArgs);
152 }
153 Asserts.assertEQ(argsCount, thrower.type().parameterCount());
154
155 MethodHandle target = MethodHandles.catchException(
156 testCase.filter(thrower), testCase.throwableClass,
157 testCase.filter(catcher));
158
159 Asserts.assertEQ(thrower.type(), target.type());
160 Asserts.assertEQ(argsCount, target.type().parameterCount());
161
162 Object returned;
163 try {
164 returned = target.invokeWithArguments(args);
165 } catch (Throwable ex) {
166 testCase.assertCatch(ex);
167 returned = ex;
168 }
169
170 testCase.assertReturn(returned, arg0, arg1, dropped, args);
171 }
172 }
173
174 class TestFactory {
175 public static final List<CatchExceptionTest> MANDATORY_TEST_CASES = new ArrayList<>();
176
177 private static final int MIN_TESTED_ARITY = 10;
178
179 static {
180 for (int[] args : new int[][]{
181 {0, 0},
182 {MIN_TESTED_ARITY, 0},
183 {MIN_TESTED_ARITY, MIN_TESTED_ARITY},
184 {CatchExceptionTest.MAX_ARITY, 0},
185 {CatchExceptionTest.MAX_ARITY, CatchExceptionTest.MAX_ARITY},
186 }) {
187 MANDATORY_TEST_CASES.addAll(createTests(args[0], args[1]));
188 }
189 }
190
191 private int count;
192 private int args;
193 private int dropArgs;
194 private int currentMaxDrops;
195 private int maxArgs;
196 private int maxDrops;
197 private int constructor;
198 private int constructorSize;
199 private boolean isVararg;
200
201 public TestFactory() {
202 if (Helper.IS_THOROUGH) {
203 maxArgs = maxDrops = CatchExceptionTest.MAX_ARITY;
204 } else {
205 maxArgs = MIN_TESTED_ARITY
206 + Helper.RNG.nextInt(CatchExceptionTest.MAX_ARITY
207 - MIN_TESTED_ARITY)
208 + 1;
209 maxDrops = MIN_TESTED_ARITY
210 + Helper.RNG.nextInt(maxArgs - MIN_TESTED_ARITY)
211 + 1;
212 args = 1;
213 }
214
215 if (Helper.IS_VERBOSE) {
216 System.out.printf("maxArgs = %d%nmaxDrops = %d%n",
217 maxArgs, maxDrops);
218 }
219 constructorSize = TestCase.CONSTRUCTORS.size();
220 }
221
222 private static List<CatchExceptionTest> createTests(int argsCount,
223 int catchDrops) {
224 if (catchDrops > argsCount || argsCount < 0 || catchDrops < 0) {
225 throw new IllegalArgumentException("argsCount = " + argsCount
226 + ", catchDrops = " + catchDrops
227 );
228 }
229 List<CatchExceptionTest> result = new ArrayList<>(
230 TestCase.CONSTRUCTORS.size());
231 for (Supplier<TestCase> constructor : TestCase.CONSTRUCTORS) {
232 result.add(new CatchExceptionTest(constructor.get(),
233 /* isVararg = */ true,
234 argsCount,
235 catchDrops));
236 result.add(new CatchExceptionTest(constructor.get(),
237 /* isVararg = */ false,
238 argsCount,
239 catchDrops));
240 }
241 return result;
242 }
243
244 /**
245 * @return next test from test matrix:
246 * {varArgs, noVarArgs} x TestCase.rtypes x TestCase.THROWABLES x {1, .., maxArgs } x {1, .., maxDrops}
247 */
248 public CatchExceptionTest nextTest() {
249 if (constructor < constructorSize) {
250 return createTest();
251 }
252 constructor = 0;
253 count++;
254 if (!Helper.IS_THOROUGH && count > Helper.TEST_LIMIT) {
255 System.out.println("test limit is exceeded");
256 return null;
257 }
258 if (dropArgs <= currentMaxDrops) {
259 if (dropArgs == 1) {
260 if (Helper.IS_THOROUGH || Helper.RNG.nextBoolean()) {
261 ++dropArgs;
262 return createTest();
263 } else if (Helper.IS_VERBOSE) {
264 System.out.printf(
265 "argsCount=%d : \"drop\" scenarios are skipped%n",
266 args);
267 }
268 } else {
269 ++dropArgs;
270 return createTest();
271 }
272 }
273
274 if (args <= maxArgs) {
275 dropArgs = 1;
276 currentMaxDrops = Math.min(args, maxDrops);
277 ++args;
278 return createTest();
279 }
280 return null;
281 }
282
283 private CatchExceptionTest createTest() {
284 if (!Helper.IS_THOROUGH) {
285 return new CatchExceptionTest(
286 TestCase.CONSTRUCTORS.get(constructor++).get(),
287 Helper.RNG.nextBoolean(), args, dropArgs);
288 } else {
289 if (isVararg) {
290 isVararg = false;
291 return new CatchExceptionTest(
292 TestCase.CONSTRUCTORS.get(constructor++).get(),
293 isVararg, args, dropArgs);
294 } else {
295 isVararg = true;
296 return new CatchExceptionTest(
297 TestCase.CONSTRUCTORS.get(constructor).get(),
298 isVararg, args, dropArgs);
299 }
300 }
301 }
302 }
303
304 class TestCase<T> {
305 private static enum ThrowMode {
306 NOTHING,
307 CAUGHT,
308 UNCAUGHT,
309 ADAPTER
310 }
311
312 @SuppressWarnings("unchecked")
313 public static final List<Supplier<TestCase>> CONSTRUCTORS;
314 private static final MethodHandle FAKE_IDENTITY;
315 private static final MethodHandle THROW_OR_RETURN;
316 private static final MethodHandle CATCHER;
317
318 static {
319 try {
320 MethodHandles.Lookup lookup = MethodHandles.lookup();
321 THROW_OR_RETURN = lookup.findStatic(
322 TestCase.class,
323 "throwOrReturn",
324 MethodType.methodType(Object.class, Object.class,
325 Throwable.class)
326 );
327 CATCHER = lookup.findStatic(
328 TestCase.class,
329 "catcher",
330 MethodType.methodType(Object.class, Object.class));
331 FAKE_IDENTITY = lookup.findVirtual(
332 TestCase.class, "fakeIdentity",
333 MethodType.methodType(Object.class, Object.class));
334
335 } catch (NoSuchMethodException | IllegalAccessException e) {
336 throw new Error(e);
337 }
338 PartialConstructor[] constructors = {
339 create(Object.class, Object.class::cast),
340 create(String.class, Objects::toString),
341 create(int[].class, x -> new int[]{Objects.hashCode(x)}),
342 create(long.class,
343 x -> Objects.hashCode(x) & (-1L >>> 32)),
344 create(void.class, TestCase::noop)};
345 Throwable[] throwables = {
346 new ClassCastException("testing"),
347 new java.io.IOException("testing"),
348 new LinkageError("testing")};
349 List<Supplier<TestCase>> list = new ArrayList<>(constructors.length *
350 throwables.length * ThrowMode.values().length);
351 //noinspection unchecked
352 for (PartialConstructor f : constructors) {
353 for (ThrowMode mode : ThrowMode.values()) {
354 for (Throwable t : throwables) {
355 list.add(f.apply(mode, t));
356 }
357 }
358 }
359 CONSTRUCTORS = Collections.unmodifiableList(list);
360 }
361
362 public final Class<T> rtype;
363 public final ThrowMode throwMode;
364 public final Throwable thrown;
365 public final Class<? extends Throwable> throwableClass;
366 /**
367 * MH which takes 2 args (Object,Throwable), 1st is the return value,
368 * 2nd is the exception which will be thrown, if it's supposed in current
369 * {@link #throwMode}.
370 */
371 public final MethodHandle thrower;
372 private final Function<Object, T> cast;
373 protected MethodHandle filter;
374 private int fakeIdentityCount;
375
376 private TestCase(Class<T> rtype, Function<Object, T> cast,
377 ThrowMode throwMode, Throwable thrown)
378 throws NoSuchMethodException, IllegalAccessException {
379 this.cast = cast;
380 filter = MethodHandles.lookup().findVirtual(
381 Function.class,
382 "apply",
383 MethodType.methodType(Object.class, Object.class))
384 .bindTo(cast);
385 this.rtype = rtype;
386 this.throwMode = throwMode;
387 this.throwableClass = thrown.getClass();
388 switch (throwMode) {
389 case NOTHING:
390 this.thrown = null;
391 break;
392 case ADAPTER:
393 case UNCAUGHT:
394 this.thrown = new Error("do not catch this");
395 break;
396 default:
397 this.thrown = thrown;
398 }
399
400 MethodHandle throwOrReturn = THROW_OR_RETURN;
401 if (throwMode == ThrowMode.ADAPTER) {
402 MethodHandle fakeIdentity = FAKE_IDENTITY.bindTo(this);
403 for (int i = 0; i < 10; ++i) {
404 throwOrReturn = MethodHandles.filterReturnValue(
405 throwOrReturn, fakeIdentity);
406 }
407 }
408 thrower = throwOrReturn.asType(MethodType.genericMethodType(2));
409 }
410
411 private static Void noop(Object x) {
412 return null;
413 }
414
415 private static <T2> PartialConstructor create(
416 Class<T2> rtype, Function<Object, T2> cast) {
417 return (t, u) -> () -> {
418 try {
419 return new TestCase<>(rtype, cast, t, u);
420 } catch (NoSuchMethodException | IllegalAccessException e) {
421 throw new Error(e);
422 }
423 };
424 }
425
426 private static <T extends Throwable>
427 Object throwOrReturn(Object normal, T exception) throws T {
428 if (exception != null) {
429 Helper.called("throwOrReturn/throw", normal, exception);
430 throw exception;
431 }
432 Helper.called("throwOrReturn/normal", normal, exception);
433 return normal;
434 }
435
436 private static <T extends Throwable>
437 Object catcher(Object o) {
438 Helper.called("catcher", o);
439 return o;
440 }
441
442 public MethodHandle filter(MethodHandle target) {
443 return MethodHandles.filterReturnValue(target, filter);
444 }
445
446 public MethodHandle getCatcher(List<Class<?>> classes) {
447 return MethodHandles.filterReturnValue(Helper.AS_LIST.asType(
448 MethodType.methodType(Object.class, classes)),
449 CATCHER
450 );
451 }
452
453 @Override
454 public String toString() {
455 return "TestCase{" +
456 "rtype=" + rtype +
457 ", throwMode=" + throwMode +
458 ", throwableClass=" + throwableClass +
459 '}';
460 }
461
462 public String callName() {
463 return "throwOrReturn/" +
464 (throwMode == ThrowMode.NOTHING
465 ? "normal"
466 : "throw");
467 }
468
469 public void assertReturn(Object returned, Object arg0, Object arg1,
470 int catchDrops, Object... args) {
471 int lag = 0;
472 if (throwMode == ThrowMode.CAUGHT) {
473 lag = 1;
474 }
475 Helper.assertCalled(lag, callName(), arg0, arg1);
476
477 if (throwMode == ThrowMode.NOTHING) {
478 assertEQ(cast.apply(arg0), returned);
479 } else if (throwMode == ThrowMode.CAUGHT) {
480 List<Object> catchArgs = new ArrayList<>(Arrays.asList(args));
481 // catcher receives an initial subsequence of target arguments:
482 catchArgs.subList(args.length - catchDrops, args.length).clear();
483 // catcher also receives the exception, prepended:
484 catchArgs.add(0, thrown);
485 Helper.assertCalled("catcher", catchArgs);
486 assertEQ(cast.apply(catchArgs), returned);
487 }
488 Asserts.assertEQ(0, fakeIdentityCount);
489 }
490
491 private void assertEQ(T t, Object returned) {
492 if (rtype.isArray()) {
493 Asserts.assertEQ(t.getClass(), returned.getClass());
494 int n = Array.getLength(t);
495 Asserts.assertEQ(n, Array.getLength(returned));
496 for (int i = 0; i < n; ++i) {
497 Asserts.assertEQ(Array.get(t, i), Array.get(returned, i));
498 }
499 } else {
500 Asserts.assertEQ(t, returned);
501 }
502 }
503
504 private Object fakeIdentity(Object x) {
505 System.out.println("should throw through this!");
506 ++fakeIdentityCount;
507 return x;
508 }
509
510 public void assertCatch(Throwable ex) {
511 try {
512 Asserts.assertSame(thrown, ex,
513 "must get the out-of-band exception");
514 } catch (Throwable t) {
515 ex.printStackTrace();
516 }
517 }
518
519 public interface PartialConstructor
520 extends BiFunction<ThrowMode, Throwable, Supplier<TestCase>> {
521 }
522 }