--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/java/lang/invoke/ThrowExceptionsTest.java Sat Jul 16 15:44:33 2011 -0700
@@ -0,0 +1,229 @@
+/*
+ * Copyright (c) 2011, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/* @test
+ * @summary unit tests for method handles which permute their arguments
+ * @run junit test.java.lang.invoke.ThrowExceptionsTest
+ */
+
+package test.java.lang.invoke;
+
+import org.junit.*;
+
+import java.util.*;
+import java.lang.reflect.*;
+
+import java.lang.invoke.*;
+import static java.lang.invoke.MethodHandles.*;
+import static java.lang.invoke.MethodType.*;
+
+public class ThrowExceptionsTest {
+ private static final Class CLASS = ThrowExceptionsTest.class;
+ private static final Lookup LOOKUP = lookup();
+
+ public static void main(String argv[]) throws Throwable {
+ new ThrowExceptionsTest().testAll((argv.length == 0 ? null : Arrays.asList(argv).toString()));
+ }
+
+ @Test
+ public void testWMT() throws Throwable {
+ // mostly call testWMTCallee, but sometimes call its void-returning variant
+ MethodHandle mh = testWMTCallee();
+ MethodHandle mh1 = mh.asType(mh.type().changeReturnType(void.class));
+ assert(mh1 != mh);
+ testWMT(mh, mh1, 1000);
+ }
+
+ @Test
+ public void testBoundWMT() throws Throwable {
+ // mostly call exactInvoker.bindTo(testWMTCallee), but sometimes call its void-returning variant
+ MethodHandle callee = testWMTCallee();
+ MethodHandle callee1 = callee.asType(callee.type().changeReturnType(void.class));
+ MethodHandle invoker = exactInvoker(callee.type());
+ MethodHandle mh = invoker.bindTo(callee);
+ MethodHandle mh1 = invoker.bindTo(callee1);
+ testWMT(mh, mh1, 1000);
+ }
+
+ @Test
+ public void testFoldWMT() throws Throwable {
+ // mostly call exactInvoker.fold(constant(testWMTCallee)), but sometimes call its void-returning variant
+ MethodHandle callee = testWMTCallee();
+ MethodHandle callee1 = callee.asType(callee.type().changeReturnType(void.class));
+ MethodHandle invoker = exactInvoker(callee.type());
+ MethodHandle mh = foldArguments(invoker, constant(MethodHandle.class, callee));
+ MethodHandle mh1 = foldArguments(invoker, constant(MethodHandle.class, callee1));
+ testWMT(mh, mh1, 1000);
+ }
+
+ @Test
+ public void testFoldCCE() throws Throwable {
+ MethodHandle callee = testWMTCallee();
+ MethodHandle callee1 = callee.asType(callee.type().changeParameterType(1, Number.class)).asType(callee.type());
+ MethodHandle invoker = exactInvoker(callee.type());
+ MethodHandle mh = foldArguments(invoker, constant(MethodHandle.class, callee));
+ MethodHandle mh1 = foldArguments(invoker, constant(MethodHandle.class, callee1));
+ testWMT(mh, mh1, 1000);
+ }
+
+ @Test
+ public void testStackOverflow() throws Throwable {
+ MethodHandle callee = testWMTCallee();
+ MethodHandle callee1 = makeStackOverflow().asType(callee.type());
+ MethodHandle invoker = exactInvoker(callee.type());
+ MethodHandle mh = foldArguments(invoker, constant(MethodHandle.class, callee));
+ MethodHandle mh1 = foldArguments(invoker, constant(MethodHandle.class, callee1));
+ for (int i = 0; i < REPEAT; i++) {
+ try {
+ testWMT(mh, mh1, 1000);
+ } catch (StackOverflowError ex) {
+ // OK, try again
+ }
+ }
+ }
+
+ private static MethodHandle makeStackOverflow() {
+ MethodType cellType = methodType(void.class);
+ MethodHandle[] cell = { null }; // recursion point
+ MethodHandle getCell = insertArguments(arrayElementGetter(cell.getClass()), 0, cell, 0);
+ MethodHandle invokeCell = foldArguments(exactInvoker(cellType), getCell);
+ assert(invokeCell.type() == cellType);
+ cell[0] = invokeCell;
+ // make it conformable to any type:
+ invokeCell = dropArguments(invokeCell, 0, Object[].class).asVarargsCollector(Object[].class);
+ return invokeCell;
+ }
+
+ static int testCases;
+
+ private void testAll(String match) throws Throwable {
+ testCases = 0;
+ Lookup lookup = lookup();
+ for (Method m : CLASS.getDeclaredMethods()) {
+ String name = m.getName();
+ if (name.startsWith("test") &&
+ (match == null || match.contains(name.substring("test".length()))) &&
+ m.getParameterTypes().length == 0 &&
+ Modifier.isPublic(m.getModifiers()) &&
+ !Modifier.isStatic(m.getModifiers())) {
+ System.out.println("["+name+"]");
+ int tc = testCases;
+ try {
+ m.invoke(this);
+ } catch (Throwable ex) {
+ System.out.println("*** "+ex);
+ ex.printStackTrace();
+ }
+ if (testCases == tc) testCases++;
+ }
+ }
+ if (testCases == 0) throw new RuntimeException("no test cases found");
+ System.out.println("ran a total of "+testCases+" test cases");
+ }
+
+ private static MethodHandle findStatic(String name) {
+ return findMethod(name, true);
+ }
+ private static MethodHandle findVirtual(String name) {
+ return findMethod(name, false);
+ }
+ private static MethodHandle findMethod(String name, boolean isStatic) {
+ MethodHandle mh = null;
+ for (Method m : CLASS.getDeclaredMethods()) {
+ if (m.getName().equals(name) &&
+ Modifier.isStatic(m.getModifiers()) == isStatic) {
+ if (mh != null)
+ throw new RuntimeException("duplicate methods: "+name);
+ try {
+ mh = LOOKUP.unreflect(m);
+ } catch (ReflectiveOperationException ex) {
+ throw new RuntimeException(ex);
+ }
+ }
+ }
+ if (mh == null)
+ throw new RuntimeException("no method: "+name);
+ return mh;
+ }
+
+ int testWMTCallee;
+ private int testWMTCallee(String x) {
+ return testWMTCallee++;
+ }
+ private static MethodHandle testWMTCallee() {
+ MethodHandle callee = findVirtual("testWMTCallee");
+ // FIXME: should not have to retype callee
+ callee = callee.asType(callee.type().changeParameterType(0, Object.class));
+ return callee;
+ }
+
+ private Exception testWMT(MethodHandle[] mhs, int reps) throws Throwable {
+ testCases += 1;
+ testWMTCallee = 0;
+ int catches = 0;
+ Exception savedEx = null;
+ for (int i = 0; i < reps; i++) {
+ MethodHandle mh = mhs[i % mhs.length];
+ int n;
+ try {
+ // FIXME: should not have to retype this
+ n = (int) mh.invokeExact((Object)this, "x");
+ assertEquals(n, i - catches);
+ // Using the exact type for this causes endless deopt due to
+ // 'non_cached_result' in SystemDictionary::find_method_handle_invoke.
+ // The problem is that the compiler thread needs to access a cached
+ // invoke method, but invoke methods are not cached if one of the
+ // component types is not on the BCP.
+ } catch (Exception ex) {
+ savedEx = ex;
+ catches++;
+ }
+ }
+ //VERBOSE: System.out.println("reps="+reps+" catches="+catches);
+ return savedEx;
+ }
+
+ private static final int REPEAT = Integer.getInteger(CLASS.getSimpleName()+".REPEAT", 10);
+
+ private Exception testWMT(MethodHandle mh, MethodHandle mh1, int reps) throws Throwable {
+ //VERBOSE: System.out.println("mh="+mh+" mh1="+mh1);
+ MethodHandle[] mhs = new MethodHandle[100];
+ Arrays.fill(mhs, mh);
+ int patch = mhs.length-1;
+ Exception savedEx = null;
+ for (int i = 0; i < REPEAT; i++) {
+ mhs[patch] = mh;
+ testWMT(mhs, 10000);
+ mhs[patch] = mh1;
+ savedEx = testWMT(mhs, reps);
+ }
+ return savedEx;
+ }
+
+ private static void assertEquals(Object x, Object y) {
+ if (x == y || x != null && x.equals(y)) return;
+ throw new RuntimeException(x+" != "+y);
+ }
+}