rev 11029 : 8039953: [TESTBUG] Timeout java/lang/invoke/MethodHandles/CatchExceptionTest.java
Reviewed-by:

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