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