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 }
--- EOF ---