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 }