/* * Copyright (c) 2009, 2017, 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. * * 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 java.lang.invoke.MethodHandles * @library /lib/testlibrary /java/lang/invoke/common * @compile MethodHandlesTest.java remote/RemoteExample.java * @run junit/othervm/timeout=2500 -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies -esa test.java.lang.invoke.MethodHandlesTest */ package test.java.lang.invoke; import test.java.lang.invoke.remote.RemoteExample; import test.java.lang.invoke.lib.CodeCacheOverflowProcessor; import java.lang.invoke.*; import static java.lang.invoke.MethodType.methodType; import java.lang.invoke.MethodHandles.Lookup; import java.lang.reflect.*; import java.util.*; import org.junit.*; import static org.junit.Assert.*; /** * * @author jrose */ public class MethodHandlesTest { static final Class THIS_CLASS = MethodHandlesTest.class; // How much output? static int verbosity = 0; static { String vstr = System.getProperty(THIS_CLASS.getSimpleName()+".verbosity"); if (vstr == null) vstr = System.getProperty(THIS_CLASS.getName()+".verbosity"); if (vstr != null) verbosity = Integer.parseInt(vstr); } // Set this true during development if you want to fast-forward to // a particular new, non-working test. Tests which are known to // work (or have recently worked) test this flag and return on true. static final boolean CAN_SKIP_WORKING; static { String vstr = System.getProperty(THIS_CLASS.getSimpleName()+".CAN_SKIP_WORKING"); if (vstr == null) vstr = System.getProperty(THIS_CLASS.getName()+".CAN_SKIP_WORKING"); CAN_SKIP_WORKING = Boolean.parseBoolean(vstr); } // Set 'true' to do about 15x fewer tests, especially those redundant with RicochetTest. // This might be useful with -Xcomp stress tests that compile all method handles. static boolean CAN_TEST_LIGHTLY = Boolean.getBoolean(THIS_CLASS.getName()+".CAN_TEST_LIGHTLY"); @Test public void testFirst() throws Throwable { verbosity += 9; try { // left blank for debugging } finally { printCounts(); verbosity -= 9; } } static final int MAX_ARG_INCREASE = 3; public MethodHandlesTest() { } String testName; static int allPosTests, allNegTests; int posTests, negTests; @After public void printCounts() { if (verbosity >= 2 && (posTests | negTests) != 0) { System.out.println(); if (posTests != 0) System.out.println("=== "+testName+": "+posTests+" positive test cases run"); if (negTests != 0) System.out.println("=== "+testName+": "+negTests+" negative test cases run"); allPosTests += posTests; allNegTests += negTests; posTests = negTests = 0; } } void countTest(boolean positive) { if (positive) ++posTests; else ++negTests; } void countTest() { countTest(true); } void startTest(String name) { if (testName != null) printCounts(); if (verbosity >= 1) System.out.println(name); posTests = negTests = 0; testName = name; } @BeforeClass public static void setUpClass() throws Exception { calledLog.clear(); calledLog.add(null); nextArgVal = INITIAL_ARG_VAL; } @AfterClass public static void tearDownClass() throws Exception { int posTests = allPosTests, negTests = allNegTests; if (verbosity >= 0 && (posTests | negTests) != 0) { System.out.println(); if (posTests != 0) System.out.println("=== "+posTests+" total positive test cases"); if (negTests != 0) System.out.println("=== "+negTests+" total negative test cases"); } } static List calledLog = new ArrayList<>(); static Object logEntry(String name, Object... args) { return Arrays.asList(name, Arrays.asList(args)); } public static Object called(String name, Object... args) { Object entry = logEntry(name, args); calledLog.add(entry); return entry; } static void assertCalled(String name, Object... args) { Object expected = logEntry(name, args); Object actual = calledLog.get(calledLog.size() - 1); if (expected.equals(actual) && verbosity < 9) return; System.out.println("assertCalled "+name+":"); System.out.println("expected: "+deepToString(expected)); System.out.println("actual: "+actual); System.out.println("ex. types: "+getClasses(expected)); System.out.println("act. types: "+getClasses(actual)); assertEquals("previous method call", expected, actual); } static void printCalled(MethodHandle target, String name, Object... args) { if (verbosity >= 3) System.out.println("calling MH="+target+" to "+name+deepToString(args)); } static String deepToString(Object x) { if (x == null) return "null"; if (x instanceof Collection) x = ((Collection)x).toArray(); if (x instanceof Object[]) { Object[] ax = (Object[]) x; ax = Arrays.copyOf(ax, ax.length, Object[].class); for (int i = 0; i < ax.length; i++) ax[i] = deepToString(ax[i]); x = Arrays.deepToString(ax); } if (x.getClass().isArray()) try { x = Arrays.class.getMethod("toString", x.getClass()).invoke(null, x); } catch (ReflectiveOperationException ex) { throw new Error(ex); } assert(!(x instanceof Object[])); return x.toString(); } static Object castToWrapper(Object value, Class dst) { Object wrap = null; if (value instanceof Number) wrap = castToWrapperOrNull(((Number)value).longValue(), dst); if (value instanceof Character) wrap = castToWrapperOrNull((char)(Character)value, dst); if (wrap != null) return wrap; return dst.cast(value); } @SuppressWarnings("cast") // primitive cast to (long) is part of the pattern static Object castToWrapperOrNull(long value, Class dst) { if (dst == int.class || dst == Integer.class) return (int)(value); if (dst == long.class || dst == Long.class) return (long)(value); if (dst == char.class || dst == Character.class) return (char)(value); if (dst == short.class || dst == Short.class) return (short)(value); if (dst == float.class || dst == Float.class) return (float)(value); if (dst == double.class || dst == Double.class) return (double)(value); if (dst == byte.class || dst == Byte.class) return (byte)(value); if (dst == boolean.class || dst == boolean.class) return ((value % 29) & 1) == 0; return null; } static final int ONE_MILLION = (1000*1000), // first int value TEN_BILLION = (10*1000*1000*1000), // scale factor to reach upper 32 bits INITIAL_ARG_VAL = ONE_MILLION << 1; // <<1 makes space for sign bit; static long nextArgVal; static long nextArg(boolean moreBits) { long val = nextArgVal++; long sign = -(val & 1); // alternate signs val >>= 1; if (moreBits) // Guarantee some bits in the high word. // In any case keep the decimal representation simple-looking, // with lots of zeroes, so as not to make the printed decimal // strings unnecessarily noisy. val += (val % ONE_MILLION) * TEN_BILLION; return val ^ sign; } static int nextArg() { // Produce a 32-bit result something like ONE_MILLION+(smallint). // Example: 1_000_042. return (int) nextArg(false); } static long nextArg(Class kind) { if (kind == long.class || kind == Long.class || kind == double.class || kind == Double.class) // produce a 64-bit result something like // ((TEN_BILLION+1) * (ONE_MILLION+(smallint))) // Example: 10_000_420_001_000_042. return nextArg(true); return (long) nextArg(); } static Object randomArg(Class param) { Object wrap = castToWrapperOrNull(nextArg(param), param); if (wrap != null) { return wrap; } // import sun.invoke.util.Wrapper; // Wrapper wrap = Wrapper.forBasicType(dst); // if (wrap == Wrapper.OBJECT && Wrapper.isWrapperType(dst)) // wrap = Wrapper.forWrapperType(dst); // if (wrap != Wrapper.OBJECT) // return wrap.wrap(nextArg++); if (param.isInterface()) { for (Class c : param.getClasses()) { if (param.isAssignableFrom(c) && !c.isInterface()) { param = c; break; } } } if (param.isArray()) { Class ctype = param.getComponentType(); Object arg = Array.newInstance(ctype, 2); Array.set(arg, 0, randomArg(ctype)); return arg; } if (param.isInterface() && param.isAssignableFrom(List.class)) return Arrays.asList("#"+nextArg()); if (param.isInterface() || param.isAssignableFrom(String.class)) return "#"+nextArg(); else try { return param.newInstance(); } catch (InstantiationException | IllegalAccessException ex) { } return null; // random class not Object, String, Integer, etc. } static Object[] randomArgs(Class... params) { Object[] args = new Object[params.length]; for (int i = 0; i < args.length; i++) args[i] = randomArg(params[i]); return args; } static Object[] randomArgs(int nargs, Class param) { Object[] args = new Object[nargs]; for (int i = 0; i < args.length; i++) args[i] = randomArg(param); return args; } static Object[] randomArgs(List> params) { return randomArgs(params.toArray(new Class[params.size()])); } @SafeVarargs @SuppressWarnings("varargs") static T[] array(Class atype, E... a) { return Arrays.copyOf(a, a.length, atype); } @SafeVarargs @SuppressWarnings("varargs") static T[] cat(T[] a, T... b) { int alen = a.length, blen = b.length; if (blen == 0) return a; T[] c = Arrays.copyOf(a, alen + blen); System.arraycopy(b, 0, c, alen, blen); return c; } static Integer[] boxAll(int... vx) { Integer[] res = new Integer[vx.length]; for (int i = 0; i < res.length; i++) { res[i] = vx[i]; } return res; } static Object getClasses(Object x) { if (x == null) return x; if (x instanceof String) return x; // keep the name if (x instanceof List) { // recursively report classes of the list elements Object[] xa = ((List)x).toArray(); for (int i = 0; i < xa.length; i++) xa[i] = getClasses(xa[i]); return Arrays.asList(xa); } return x.getClass().getSimpleName(); } /** Return lambda(arg...[arity]) { new Object[]{ arg... } } */ static MethodHandle varargsList(int arity) { return ValueConversions.varargsList(arity); } /** Return lambda(arg...[arity]) { Arrays.asList(arg...) } */ static MethodHandle varargsArray(int arity) { return ValueConversions.varargsArray(arity); } static MethodHandle varargsArray(Class arrayType, int arity) { return ValueConversions.varargsArray(arrayType, arity); } /** Variation of varargsList, but with the given rtype. */ static MethodHandle varargsList(int arity, Class rtype) { MethodHandle list = varargsList(arity); MethodType listType = list.type().changeReturnType(rtype); if (List.class.isAssignableFrom(rtype) || rtype == void.class || rtype == Object.class) { // OK } else if (rtype.isAssignableFrom(String.class)) { if (LIST_TO_STRING == null) try { LIST_TO_STRING = PRIVATE.findStatic(PRIVATE.lookupClass(), "listToString", MethodType.methodType(String.class, List.class)); } catch (NoSuchMethodException | IllegalAccessException ex) { throw new RuntimeException(ex); } list = MethodHandles.filterReturnValue(list, LIST_TO_STRING); } else if (rtype.isPrimitive()) { if (LIST_TO_INT == null) try { LIST_TO_INT = PRIVATE.findStatic(PRIVATE.lookupClass(), "listToInt", MethodType.methodType(int.class, List.class)); } catch (NoSuchMethodException | IllegalAccessException ex) { throw new RuntimeException(ex); } list = MethodHandles.filterReturnValue(list, LIST_TO_INT); list = MethodHandles.explicitCastArguments(list, listType); } else { throw new RuntimeException("varargsList: "+rtype); } return list.asType(listType); } /** Variation of varargsList, but with the given ptypes and rtype. */ static MethodHandle varargsList(List> ptypes, Class rtype) { MethodHandle list = varargsList(ptypes.size(), rtype); return list.asType(MethodType.methodType(rtype, ptypes)); } private static MethodHandle LIST_TO_STRING, LIST_TO_INT; private static String listToString(List x) { return x.toString(); } private static int listToInt(List x) { return x.toString().hashCode(); } static MethodHandle changeArgTypes(MethodHandle target, Class argType) { return changeArgTypes(target, 0, 999, argType); } static MethodHandle changeArgTypes(MethodHandle target, int beg, int end, Class argType) { MethodType targetType = target.type(); end = Math.min(end, targetType.parameterCount()); ArrayList> argTypes = new ArrayList<>(targetType.parameterList()); Collections.fill(argTypes.subList(beg, end), argType); MethodType ttype2 = MethodType.methodType(targetType.returnType(), argTypes); return target.asType(ttype2); } static MethodHandle addTrailingArgs(MethodHandle target, int nargs, Class argClass) { int targetLen = target.type().parameterCount(); int extra = (nargs - targetLen); if (extra <= 0) return target; List> fakeArgs = Collections.>nCopies(extra, argClass); return MethodHandles.dropArguments(target, targetLen, fakeArgs); } // This lookup is good for all members in and under MethodHandlesTest. static final Lookup PRIVATE = MethodHandles.lookup(); // This lookup is good for package-private members but not private ones. static final Lookup PACKAGE = PackageSibling.lookup(); // This lookup is good for public members and protected members of PubExample static final Lookup SUBCLASS = RemoteExample.lookup(); // This lookup is good only for public members in exported packages. static final Lookup PUBLIC = MethodHandles.publicLookup(); // Subject methods... static class Example implements IntExample { final String name; public Example() { name = "Example#"+nextArg(); } protected Example(String name) { this.name = name; } @SuppressWarnings("LeakingThisInConstructor") protected Example(int x) { this(); called("protected ", this, x); } //Example(Void x) { does not exist; lookup elicts NoSuchMethodException } @Override public String toString() { return name; } public void v0() { called("v0", this); } protected void pro_v0() { called("pro_v0", this); } void pkg_v0() { called("pkg_v0", this); } private void pri_v0() { called("pri_v0", this); } public static void s0() { called("s0"); } protected static void pro_s0() { called("pro_s0"); } static void pkg_s0() { called("pkg_s0"); } private static void pri_s0() { called("pri_s0"); } public Object v1(Object x) { return called("v1", this, x); } public Object v2(Object x, Object y) { return called("v2", this, x, y); } public Object v2(Object x, int y) { return called("v2", this, x, y); } public Object v2(int x, Object y) { return called("v2", this, x, y); } public Object v2(int x, int y) { return called("v2", this, x, y); } public static Object s1(Object x) { return called("s1", x); } public static Object s2(int x) { return called("s2", x); } public static Object s3(long x) { return called("s3", x); } public static Object s4(int x, int y) { return called("s4", x, y); } public static Object s5(long x, int y) { return called("s5", x, y); } public static Object s6(int x, long y) { return called("s6", x, y); } public static Object s7(float x, double y) { return called("s7", x, y); } // for testing findConstructor: public Example(String x, int y) { this.name = x+y; called("Example.", x, y); } public Example(int x, String y) { this.name = x+y; called("Example.", x, y); } public Example(int x, int y) { this.name = x+""+y; called("Example.", x, y); } public Example(int x, long y) { this.name = x+""+y; called("Example.", x, y); } public Example(int x, float y) { this.name = x+""+y; called("Example.", x, y); } public Example(int x, double y) { this.name = x+""+y; called("Example.", x, y); } public Example(int x, int y, int z) { this.name = x+""+y+""+z; called("Example.", x, y, z); } public Example(int x, int y, int z, int a) { this.name = x+""+y+""+z+""+a; called("Example.", x, y, z, a); } static final Lookup EXAMPLE = MethodHandles.lookup(); // for testing findSpecial } static final Lookup EXAMPLE = Example.EXAMPLE; public static class PubExample extends Example { public PubExample() { this("PubExample"); } protected PubExample(String prefix) { super(prefix+"#"+nextArg()); } protected void pro_v0() { called("Pub/pro_v0", this); } protected static void pro_s0() { called("Pub/pro_s0"); } } static class SubExample extends Example { @Override public void v0() { called("Sub/v0", this); } @Override void pkg_v0() { called("Sub/pkg_v0", this); } @SuppressWarnings("LeakingThisInConstructor") private SubExample(int x) { called("", this, x); } public SubExample() { super("SubExample#"+nextArg()); } } public static interface IntExample { public void v0(); public default void vd() { called("vd", this); } public static class Impl implements IntExample { public void v0() { called("Int/v0", this); } final String name; public Impl() { name = "Impl#"+nextArg(); } @Override public String toString() { return name; } } } static interface SubIntExample extends IntExample { } static final Object[][][] ACCESS_CASES = { { { false, PUBLIC }, { false, SUBCLASS }, { false, PACKAGE }, { false, PRIVATE }, { false, EXAMPLE } }, //[0]: all false { { false, PUBLIC }, { false, SUBCLASS }, { false, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[1]: only PRIVATE { { false, PUBLIC }, { false, SUBCLASS }, { true, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[2]: PUBLIC false { { false, PUBLIC }, { true, SUBCLASS }, { true, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[3]: subclass OK { { true, PUBLIC }, { true, SUBCLASS }, { true, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[4]: all true }; static Object[][] accessCases(Class defc, String name, boolean isSpecial) { Object[][] cases; if (name.contains("pri_") || isSpecial) { cases = ACCESS_CASES[1]; // PRIVATE only } else if (name.contains("pkg_") || !Modifier.isPublic(defc.getModifiers())) { cases = ACCESS_CASES[2]; // not PUBLIC } else if (name.contains("pro_")) { cases = ACCESS_CASES[3]; // PUBLIC class, protected member } else { assertTrue(name.indexOf('_') < 0 || name.contains("fin_")); boolean pubc = Modifier.isPublic(defc.getModifiers()); if (pubc) cases = ACCESS_CASES[4]; // all access levels else cases = ACCESS_CASES[2]; // PACKAGE but not PUBLIC } if (defc != Example.class && cases[cases.length-1][1] == EXAMPLE) cases = Arrays.copyOfRange(cases, 0, cases.length-1); return cases; } static Object[][] accessCases(Class defc, String name) { return accessCases(defc, name, false); } static Lookup maybeMoveIn(Lookup lookup, Class defc) { if (lookup == PUBLIC || lookup == SUBCLASS || lookup == PACKAGE) // external views stay external return lookup; return lookup.in(defc); } /** Is findVirtual (etc.) of "<init<" supposed to elicit a NoSuchMethodException? */ static final boolean INIT_REF_CAUSES_NSME = true; @Test public void testFindStatic() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFindStatic0); } public void testFindStatic0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("findStatic"); testFindStatic(PubExample.class, void.class, "s0"); testFindStatic(Example.class, void.class, "s0"); testFindStatic(Example.class, void.class, "pkg_s0"); testFindStatic(Example.class, void.class, "pri_s0"); testFindStatic(Example.class, void.class, "pro_s0"); testFindStatic(PubExample.class, void.class, "Pub/pro_s0"); testFindStatic(Example.class, Object.class, "s1", Object.class); testFindStatic(Example.class, Object.class, "s2", int.class); testFindStatic(Example.class, Object.class, "s3", long.class); testFindStatic(Example.class, Object.class, "s4", int.class, int.class); testFindStatic(Example.class, Object.class, "s5", long.class, int.class); testFindStatic(Example.class, Object.class, "s6", int.class, long.class); testFindStatic(Example.class, Object.class, "s7", float.class, double.class); testFindStatic(false, PRIVATE, Example.class, void.class, "bogus"); testFindStatic(false, PRIVATE, Example.class, void.class, "", int.class); testFindStatic(false, PRIVATE, Example.class, void.class, "", Void.class); testFindStatic(false, PRIVATE, Example.class, void.class, "v0"); } void testFindStatic(Class defc, Class ret, String name, Class... params) throws Throwable { for (Object[] ac : accessCases(defc, name)) { testFindStatic((Boolean)ac[0], (Lookup)ac[1], defc, ret, name, params); } } void testFindStatic(Lookup lookup, Class defc, Class ret, String name, Class... params) throws Throwable { testFindStatic(true, lookup, defc, ret, name, params); } void testFindStatic(boolean positive, Lookup lookup, Class defc, Class ret, String name, Class... params) throws Throwable { countTest(positive); String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo MethodType type = MethodType.methodType(ret, params); MethodHandle target = null; Exception noAccess = null; try { if (verbosity >= 4) System.out.println("lookup via "+lookup+" of "+defc+" "+name+type); target = maybeMoveIn(lookup, defc).findStatic(defc, methodName, type); } catch (ReflectiveOperationException ex) { noAccess = ex; assertExceptionClass( (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("")) ? NoSuchMethodException.class : IllegalAccessException.class, noAccess); if (verbosity >= 5) ex.printStackTrace(System.out); } if (verbosity >= 3) System.out.println("findStatic "+lookup+": "+defc.getName()+"."+name+"/"+type+" => "+target +(noAccess == null ? "" : " !! "+noAccess)); if (positive && noAccess != null) throw noAccess; assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null); if (!positive) return; // negative test failed as expected assertEquals(type, target.type()); assertNameStringContains(target, methodName); Object[] args = randomArgs(params); printCalled(target, name, args); target.invokeWithArguments(args); assertCalled(name, args); if (verbosity >= 1) System.out.print(':'); } static void assertExceptionClass(Class expected, Throwable actual) { if (expected.isInstance(actual)) return; actual.printStackTrace(); assertEquals(expected, actual.getClass()); } static final boolean DEBUG_METHOD_HANDLE_NAMES = Boolean.getBoolean("java.lang.invoke.MethodHandle.DEBUG_NAMES"); // rough check of name string static void assertNameStringContains(MethodHandle x, String s) { if (!DEBUG_METHOD_HANDLE_NAMES) { // ignore s assertEquals("MethodHandle"+x.type(), x.toString()); return; } if (x.toString().contains(s)) return; assertEquals(s, x); } @Test public void testFindVirtual() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFindVirtual0); } public void testFindVirtual0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("findVirtual"); testFindVirtual(Example.class, void.class, "v0"); testFindVirtual(Example.class, void.class, "pkg_v0"); testFindVirtual(Example.class, void.class, "pri_v0"); testFindVirtual(Example.class, Object.class, "v1", Object.class); testFindVirtual(Example.class, Object.class, "v2", Object.class, Object.class); testFindVirtual(Example.class, Object.class, "v2", Object.class, int.class); testFindVirtual(Example.class, Object.class, "v2", int.class, Object.class); testFindVirtual(Example.class, Object.class, "v2", int.class, int.class); testFindVirtual(Example.class, void.class, "pro_v0"); testFindVirtual(PubExample.class, void.class, "Pub/pro_v0"); testFindVirtual(false, PRIVATE, Example.class, Example.class, void.class, "bogus"); testFindVirtual(false, PRIVATE, Example.class, Example.class, void.class, "", int.class); testFindVirtual(false, PRIVATE, Example.class, Example.class, void.class, "", Void.class); testFindVirtual(false, PRIVATE, Example.class, Example.class, void.class, "s0"); // test dispatch testFindVirtual(SubExample.class, SubExample.class, void.class, "Sub/v0"); testFindVirtual(SubExample.class, Example.class, void.class, "Sub/v0"); testFindVirtual(SubExample.class, IntExample.class, void.class, "Sub/v0"); testFindVirtual(SubExample.class, SubExample.class, void.class, "Sub/pkg_v0"); testFindVirtual(SubExample.class, Example.class, void.class, "Sub/pkg_v0"); testFindVirtual(Example.class, IntExample.class, void.class, "v0"); testFindVirtual(IntExample.Impl.class, IntExample.class, void.class, "Int/v0"); } @Test public void testFindVirtualClone() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFindVirtualClone0); } public void testFindVirtualClone0() throws Throwable { if (CAN_SKIP_WORKING) return; // test some ad hoc system methods testFindVirtual(false, PUBLIC, Object.class, Object.class, "clone"); // ##### FIXME - disable tests for clone until we figure out how they should work with modules /* testFindVirtual(true, PUBLIC, Object[].class, Object.class, "clone"); testFindVirtual(true, PUBLIC, int[].class, Object.class, "clone"); for (Class cls : new Class[]{ boolean[].class, long[].class, float[].class, char[].class }) testFindVirtual(true, PUBLIC, cls, Object.class, "clone"); */ } void testFindVirtual(Class defc, Class ret, String name, Class... params) throws Throwable { Class rcvc = defc; testFindVirtual(rcvc, defc, ret, name, params); } void testFindVirtual(Class rcvc, Class defc, Class ret, String name, Class... params) throws Throwable { for (Object[] ac : accessCases(defc, name)) { testFindVirtual((Boolean)ac[0], (Lookup)ac[1], rcvc, defc, ret, name, params); } } void testFindVirtual(Lookup lookup, Class rcvc, Class defc, Class ret, String name, Class... params) throws Throwable { testFindVirtual(true, lookup, rcvc, defc, ret, name, params); } void testFindVirtual(boolean positive, Lookup lookup, Class defc, Class ret, String name, Class... params) throws Throwable { testFindVirtual(positive, lookup, defc, defc, ret, name, params); } void testFindVirtual(boolean positive, Lookup lookup, Class rcvc, Class defc, Class ret, String name, Class... params) throws Throwable { countTest(positive); String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo MethodType type = MethodType.methodType(ret, params); MethodHandle target = null; Exception noAccess = null; try { if (verbosity >= 4) System.out.println("lookup via "+lookup+" of "+defc+" "+name+type); target = maybeMoveIn(lookup, defc).findVirtual(defc, methodName, type); } catch (ReflectiveOperationException ex) { noAccess = ex; assertExceptionClass( (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("")) ? NoSuchMethodException.class : IllegalAccessException.class, noAccess); if (verbosity >= 5) ex.printStackTrace(System.out); } if (verbosity >= 3) System.out.println("findVirtual "+lookup+": "+defc.getName()+"."+name+"/"+type+" => "+target +(noAccess == null ? "" : " !! "+noAccess)); if (positive && noAccess != null) throw noAccess; assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null); if (!positive) return; // negative test failed as expected Class selfc = defc; // predict receiver type narrowing: if (lookup == SUBCLASS && name.contains("pro_") && selfc.isAssignableFrom(lookup.lookupClass())) { selfc = lookup.lookupClass(); if (name.startsWith("Pub/")) name = "Rem/"+name.substring(4); } Class[] paramsWithSelf = cat(array(Class[].class, (Class)selfc), params); MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf); assertEquals(typeWithSelf, target.type()); assertNameStringContains(target, methodName); Object[] argsWithSelf = randomArgs(paramsWithSelf); if (selfc.isAssignableFrom(rcvc) && rcvc != selfc) argsWithSelf[0] = randomArg(rcvc); printCalled(target, name, argsWithSelf); Object res = target.invokeWithArguments(argsWithSelf); if (Example.class.isAssignableFrom(defc) || IntExample.class.isAssignableFrom(defc)) { assertCalled(name, argsWithSelf); } else if (name.equals("clone")) { // Ad hoc method call outside Example. For Object[].clone. printCalled(target, name, argsWithSelf); assertEquals(MethodType.methodType(Object.class, rcvc), target.type()); Object orig = argsWithSelf[0]; assertEquals(orig.getClass(), res.getClass()); if (res instanceof Object[]) assertArrayEquals((Object[])res, (Object[])argsWithSelf[0]); assert(Arrays.deepEquals(new Object[]{res}, new Object[]{argsWithSelf[0]})); } else { assert(false) : Arrays.asList(positive, lookup, rcvc, defc, ret, name, deepToString(params)); } if (verbosity >= 1) System.out.print(':'); } @Test public void testFindSpecial() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFindSpecial0); } public void testFindSpecial0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("findSpecial"); testFindSpecial(SubExample.class, Example.class, void.class, false, "v0"); testFindSpecial(SubExample.class, Example.class, void.class, false, "pkg_v0"); testFindSpecial(RemoteExample.class, PubExample.class, void.class, false, "Pub/pro_v0"); testFindSpecial(Example.class, IntExample.class, void.class, true, "vd"); // Do some negative testing: for (Lookup lookup : new Lookup[]{ PRIVATE, EXAMPLE, PACKAGE, PUBLIC }) { testFindSpecial(false, lookup, Object.class, Example.class, void.class, "v0"); testFindSpecial(false, lookup, SubExample.class, Example.class, void.class, "bogus"); testFindSpecial(false, lookup, SubExample.class, Example.class, void.class, "", int.class); testFindSpecial(false, lookup, SubExample.class, Example.class, void.class, "", Void.class); testFindSpecial(false, lookup, SubExample.class, Example.class, void.class, "s0"); testFindSpecial(false, lookup, Example.class, IntExample.class, void.class, "v0"); } } void testFindSpecial(Class specialCaller, Class defc, Class ret, boolean dflt, String name, Class... params) throws Throwable { if (specialCaller == RemoteExample.class) { testFindSpecial(false, EXAMPLE, specialCaller, defc, ret, name, params); testFindSpecial(false, PRIVATE, specialCaller, defc, ret, name, params); testFindSpecial(false, PACKAGE, specialCaller, defc, ret, name, params); testFindSpecial(true, SUBCLASS, specialCaller, defc, ret, name, params); testFindSpecial(false, PUBLIC, specialCaller, defc, ret, name, params); return; } testFindSpecial(true, EXAMPLE, specialCaller, defc, ret, name, params); testFindSpecial(true, PRIVATE, specialCaller, defc, ret, name, params); testFindSpecial(false || dflt, PACKAGE, specialCaller, defc, ret, name, params); testFindSpecial(false, SUBCLASS, specialCaller, defc, ret, name, params); testFindSpecial(false, PUBLIC, specialCaller, defc, ret, name, params); } void testFindSpecial(boolean positive, Lookup lookup, Class specialCaller, Class defc, Class ret, String name, Class... params) throws Throwable { countTest(positive); String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo MethodType type = MethodType.methodType(ret, params); Lookup specialLookup = maybeMoveIn(lookup, specialCaller); boolean specialAccessOK = (specialLookup.lookupClass() == specialCaller && (specialLookup.lookupModes() & Lookup.PRIVATE) != 0); MethodHandle target = null; Exception noAccess = null; try { if (verbosity >= 4) System.out.println("lookup via "+lookup+" of "+defc+" "+name+type); if (verbosity >= 5) System.out.println(" lookup => "+specialLookup); target = specialLookup.findSpecial(defc, methodName, type, specialCaller); } catch (ReflectiveOperationException ex) { noAccess = ex; assertExceptionClass( (!specialAccessOK) // this check should happen first ? IllegalAccessException.class : (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("")) ? NoSuchMethodException.class : IllegalAccessException.class, noAccess); if (verbosity >= 5) ex.printStackTrace(System.out); } if (verbosity >= 3) System.out.println("findSpecial from "+specialCaller.getName()+" to "+defc.getName()+"."+name+"/"+type+" => "+target +(target == null ? "" : target.type()) +(noAccess == null ? "" : " !! "+noAccess)); if (positive && noAccess != null) throw noAccess; assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null); if (!positive) return; // negative test failed as expected assertEquals(specialCaller, target.type().parameterType(0)); assertEquals(type, target.type().dropParameterTypes(0,1)); Class[] paramsWithSelf = cat(array(Class[].class, (Class)specialCaller), params); MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf); assertNameStringContains(target, methodName); Object[] args = randomArgs(paramsWithSelf); printCalled(target, name, args); target.invokeWithArguments(args); assertCalled(name, args); } @Test public void testFindConstructor() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFindConstructor0); } public void testFindConstructor0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("findConstructor"); testFindConstructor(true, EXAMPLE, Example.class); testFindConstructor(true, EXAMPLE, Example.class, int.class); testFindConstructor(true, EXAMPLE, Example.class, int.class, int.class); testFindConstructor(true, EXAMPLE, Example.class, int.class, long.class); testFindConstructor(true, EXAMPLE, Example.class, int.class, float.class); testFindConstructor(true, EXAMPLE, Example.class, int.class, double.class); testFindConstructor(true, EXAMPLE, Example.class, String.class); testFindConstructor(true, EXAMPLE, Example.class, int.class, int.class, int.class); testFindConstructor(true, EXAMPLE, Example.class, int.class, int.class, int.class, int.class); } void testFindConstructor(boolean positive, Lookup lookup, Class defc, Class... params) throws Throwable { countTest(positive); MethodType type = MethodType.methodType(void.class, params); MethodHandle target = null; Exception noAccess = null; try { if (verbosity >= 4) System.out.println("lookup via "+lookup+" of "+defc+" "+type); target = lookup.findConstructor(defc, type); } catch (ReflectiveOperationException ex) { noAccess = ex; assertTrue(noAccess.getClass().getName(), noAccess instanceof IllegalAccessException); } if (verbosity >= 3) System.out.println("findConstructor "+defc.getName()+"./"+type+" => "+target +(target == null ? "" : target.type()) +(noAccess == null ? "" : " !! "+noAccess)); if (positive && noAccess != null) throw noAccess; assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null); if (!positive) return; // negative test failed as expected assertEquals(type.changeReturnType(defc), target.type()); Object[] args = randomArgs(params); printCalled(target, defc.getSimpleName(), args); Object obj = target.invokeWithArguments(args); if (!(defc == Example.class && params.length < 2)) assertCalled(defc.getSimpleName()+".", args); assertTrue("instance of "+defc.getName(), defc.isInstance(obj)); } @Test public void testBind() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testBind0); } public void testBind0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("bind"); testBind(Example.class, void.class, "v0"); testBind(Example.class, void.class, "pkg_v0"); testBind(Example.class, void.class, "pri_v0"); testBind(Example.class, Object.class, "v1", Object.class); testBind(Example.class, Object.class, "v2", Object.class, Object.class); testBind(Example.class, Object.class, "v2", Object.class, int.class); testBind(Example.class, Object.class, "v2", int.class, Object.class); testBind(Example.class, Object.class, "v2", int.class, int.class); testBind(false, PRIVATE, Example.class, void.class, "bogus"); testBind(false, PRIVATE, Example.class, void.class, "", int.class); testBind(false, PRIVATE, Example.class, void.class, "", Void.class); testBind(SubExample.class, void.class, "Sub/v0"); testBind(SubExample.class, void.class, "Sub/pkg_v0"); testBind(IntExample.Impl.class, void.class, "Int/v0"); } void testBind(Class defc, Class ret, String name, Class... params) throws Throwable { for (Object[] ac : accessCases(defc, name)) { testBind((Boolean)ac[0], (Lookup)ac[1], defc, ret, name, params); } } void testBind(boolean positive, Lookup lookup, Class defc, Class ret, String name, Class... params) throws Throwable { countTest(positive); String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo MethodType type = MethodType.methodType(ret, params); Object receiver = randomArg(defc); MethodHandle target = null; Exception noAccess = null; try { if (verbosity >= 4) System.out.println("lookup via "+lookup+" of "+defc+" "+name+type); target = maybeMoveIn(lookup, defc).bind(receiver, methodName, type); } catch (ReflectiveOperationException ex) { noAccess = ex; assertExceptionClass( (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("")) ? NoSuchMethodException.class : IllegalAccessException.class, noAccess); if (verbosity >= 5) ex.printStackTrace(System.out); } if (verbosity >= 3) System.out.println("bind "+receiver+"."+name+"/"+type+" => "+target +(noAccess == null ? "" : " !! "+noAccess)); if (positive && noAccess != null) throw noAccess; assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null); if (!positive) return; // negative test failed as expected assertEquals(type, target.type()); Object[] args = randomArgs(params); printCalled(target, name, args); target.invokeWithArguments(args); Object[] argsWithReceiver = cat(array(Object[].class, receiver), args); assertCalled(name, argsWithReceiver); if (verbosity >= 1) System.out.print(':'); } @Test public void testUnreflect() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testUnreflect0); } public void testUnreflect0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("unreflect"); testUnreflect(Example.class, true, void.class, "s0"); testUnreflect(Example.class, true, void.class, "pro_s0"); testUnreflect(Example.class, true, void.class, "pkg_s0"); testUnreflect(Example.class, true, void.class, "pri_s0"); testUnreflect(Example.class, true, Object.class, "s1", Object.class); testUnreflect(Example.class, true, Object.class, "s2", int.class); testUnreflect(Example.class, true, Object.class, "s3", long.class); testUnreflect(Example.class, true, Object.class, "s4", int.class, int.class); testUnreflect(Example.class, true, Object.class, "s5", long.class, int.class); testUnreflect(Example.class, true, Object.class, "s6", int.class, long.class); testUnreflect(Example.class, false, void.class, "v0"); testUnreflect(Example.class, false, void.class, "pkg_v0"); testUnreflect(Example.class, false, void.class, "pri_v0"); testUnreflect(Example.class, false, Object.class, "v1", Object.class); testUnreflect(Example.class, false, Object.class, "v2", Object.class, Object.class); testUnreflect(Example.class, false, Object.class, "v2", Object.class, int.class); testUnreflect(Example.class, false, Object.class, "v2", int.class, Object.class); testUnreflect(Example.class, false, Object.class, "v2", int.class, int.class); // Test a public final member in another package: testUnreflect(RemoteExample.class, false, void.class, "Rem/fin_v0"); } void testUnreflect(Class defc, boolean isStatic, Class ret, String name, Class... params) throws Throwable { for (Object[] ac : accessCases(defc, name)) { testUnreflectMaybeSpecial(null, (Boolean)ac[0], (Lookup)ac[1], defc, (isStatic ? null : defc), ret, name, params); } } void testUnreflect(Class defc, Class rcvc, Class ret, String name, Class... params) throws Throwable { for (Object[] ac : accessCases(defc, name)) { testUnreflectMaybeSpecial(null, (Boolean)ac[0], (Lookup)ac[1], defc, rcvc, ret, name, params); } } void testUnreflectMaybeSpecial(Class specialCaller, boolean positive, Lookup lookup, Class defc, Class rcvc, Class ret, String name, Class... params) throws Throwable { countTest(positive); String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo MethodType type = MethodType.methodType(ret, params); Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null); boolean specialAccessOK = (specialCaller != null && specialLookup.lookupClass() == specialCaller && (specialLookup.lookupModes() & Lookup.PRIVATE) != 0); Method rmethod = defc.getDeclaredMethod(methodName, params); MethodHandle target = null; Exception noAccess = null; boolean isStatic = (rcvc == null); boolean isSpecial = (specialCaller != null); try { if (verbosity >= 4) System.out.println("lookup via "+lookup+" of "+defc+" "+name+type); if (isSpecial) target = specialLookup.unreflectSpecial(rmethod, specialCaller); else target = maybeMoveIn(lookup, defc).unreflect(rmethod); } catch (ReflectiveOperationException ex) { noAccess = ex; assertExceptionClass( IllegalAccessException.class, // NSME is impossible, since it was already reflected noAccess); if (verbosity >= 5) ex.printStackTrace(System.out); } if (verbosity >= 3) System.out.println("unreflect"+(isSpecial?"Special":"")+" "+defc.getName()+"."+name+"/"+type +(!isSpecial ? "" : " specialCaller="+specialCaller) +( isStatic ? "" : " receiver="+rcvc) +" => "+target +(noAccess == null ? "" : " !! "+noAccess)); if (positive && noAccess != null) throw noAccess; assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null); if (!positive) return; // negative test failed as expected assertEquals(isStatic, Modifier.isStatic(rmethod.getModifiers())); Class[] paramsMaybeWithSelf = params; if (!isStatic) { paramsMaybeWithSelf = cat(array(Class[].class, (Class)rcvc), params); } MethodType typeMaybeWithSelf = MethodType.methodType(ret, paramsMaybeWithSelf); if (isStatic) { assertEquals(typeMaybeWithSelf, target.type()); } else { if (isSpecial) assertEquals(specialCaller, target.type().parameterType(0)); else assertEquals(defc, target.type().parameterType(0)); assertEquals(typeMaybeWithSelf, target.type().changeParameterType(0, rcvc)); } Object[] argsMaybeWithSelf = randomArgs(paramsMaybeWithSelf); printCalled(target, name, argsMaybeWithSelf); target.invokeWithArguments(argsMaybeWithSelf); assertCalled(name, argsMaybeWithSelf); if (verbosity >= 1) System.out.print(':'); } void testUnreflectSpecial(Class defc, Class rcvc, Class ret, String name, Class... params) throws Throwable { for (Object[] ac : accessCases(defc, name, true)) { Class specialCaller = rcvc; testUnreflectMaybeSpecial(specialCaller, (Boolean)ac[0], (Lookup)ac[1], defc, rcvc, ret, name, params); } } @Test public void testUnreflectSpecial() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testUnreflectSpecial0); } public void testUnreflectSpecial0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("unreflectSpecial"); testUnreflectSpecial(Example.class, Example.class, void.class, "v0"); testUnreflectSpecial(Example.class, SubExample.class, void.class, "v0"); testUnreflectSpecial(Example.class, Example.class, void.class, "pkg_v0"); testUnreflectSpecial(Example.class, SubExample.class, void.class, "pkg_v0"); testUnreflectSpecial(Example.class, Example.class, Object.class, "v2", int.class, int.class); testUnreflectSpecial(Example.class, SubExample.class, Object.class, "v2", int.class, int.class); testUnreflectMaybeSpecial(Example.class, false, PRIVATE, Example.class, Example.class, void.class, "s0"); } public static class HasFields { boolean fZ = false; byte fB = (byte)'B'; short fS = (short)'S'; char fC = 'C'; int fI = 'I'; long fJ = 'J'; float fF = 'F'; double fD = 'D'; static boolean sZ = true; static byte sB = 1+(byte)'B'; static short sS = 1+(short)'S'; static char sC = 1+'C'; static int sI = 1+'I'; static long sJ = 1+'J'; static float sF = 1+'F'; static double sD = 1+'D'; Object fL = 'L'; String fR = "R"; static Object sL = 'M'; static String sR = "S"; static final Object[][] CASES; static { ArrayList cases = new ArrayList<>(); Object types[][] = { {'L',Object.class}, {'R',String.class}, {'I',int.class}, {'J',long.class}, {'F',float.class}, {'D',double.class}, {'Z',boolean.class}, {'B',byte.class}, {'S',short.class}, {'C',char.class}, }; HasFields fields = new HasFields(); for (Object[] t : types) { for (int kind = 0; kind <= 1; kind++) { boolean isStatic = (kind != 0); char btc = (Character)t[0]; String name = (isStatic ? "s" : "f") + btc; Class type = (Class) t[1]; Object value; Field field; try { field = HasFields.class.getDeclaredField(name); } catch (NoSuchFieldException | SecurityException ex) { throw new InternalError("no field HasFields."+name); } try { value = field.get(fields); } catch (IllegalArgumentException | IllegalAccessException ex) { throw new InternalError("cannot fetch field HasFields."+name); } if (type == float.class) { float v = 'F'; if (isStatic) v++; assertTrue(value.equals(v)); } assertTrue(name.equals(field.getName())); assertTrue(type.equals(field.getType())); assertTrue(isStatic == (Modifier.isStatic(field.getModifiers()))); cases.add(new Object[]{ field, value }); } } cases.add(new Object[]{ new Object[]{ false, HasFields.class, "bogus_fD", double.class }, Error.class }); cases.add(new Object[]{ new Object[]{ true, HasFields.class, "bogus_sL", Object.class }, Error.class }); CASES = cases.toArray(new Object[0][]); } } static final int TEST_UNREFLECT = 1, TEST_FIND_FIELD = 2, TEST_FIND_STATIC = 3, TEST_SETTER = 0x10, TEST_BOUND = 0x20, TEST_NPE = 0x40; static boolean testModeMatches(int testMode, boolean isStatic) { switch (testMode) { case TEST_FIND_STATIC: return isStatic; case TEST_FIND_FIELD: return !isStatic; case TEST_UNREFLECT: return true; // unreflect matches both } throw new InternalError("testMode="+testMode); } @Test public void testUnreflectGetter() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testUnreflectGetter0); } public void testUnreflectGetter0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("unreflectGetter"); testGetter(TEST_UNREFLECT); } @Test public void testFindGetter() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFindGetter0); } public void testFindGetter0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("findGetter"); testGetter(TEST_FIND_FIELD); testGetter(TEST_FIND_FIELD | TEST_BOUND); } @Test public void testFindStaticGetter() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFindStaticGetter0); } public void testFindStaticGetter0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("findStaticGetter"); testGetter(TEST_FIND_STATIC); } public void testGetter(int testMode) throws Throwable { Lookup lookup = PRIVATE; // FIXME: test more lookups than this one for (Object[] c : HasFields.CASES) { boolean positive = (c[1] != Error.class); testGetter(positive, lookup, c[0], c[1], testMode); if (positive) testGetter(positive, lookup, c[0], c[1], testMode | TEST_NPE); } testGetter(true, lookup, new Object[]{ true, System.class, "out", java.io.PrintStream.class }, System.out, testMode); for (int isStaticN = 0; isStaticN <= 1; isStaticN++) { testGetter(false, lookup, new Object[]{ (isStaticN != 0), System.class, "bogus", char.class }, null, testMode); } } public void testGetter(boolean positive, MethodHandles.Lookup lookup, Object fieldRef, Object value, int testMode) throws Throwable { testAccessor(positive, lookup, fieldRef, value, testMode); } public void testAccessor(boolean positive0, MethodHandles.Lookup lookup, Object fieldRef, Object value, int testMode0) throws Throwable { if (verbosity >= 4) System.out.println("testAccessor"+Arrays.deepToString(new Object[]{positive0, lookup, fieldRef, value, testMode0})); boolean isGetter = ((testMode0 & TEST_SETTER) == 0); boolean doBound = ((testMode0 & TEST_BOUND) != 0); boolean testNPE = ((testMode0 & TEST_NPE) != 0); int testMode = testMode0 & ~(TEST_SETTER | TEST_BOUND | TEST_NPE); boolean positive = positive0 && !testNPE; boolean isStatic; Class fclass; String fname; Class ftype; Field f = (fieldRef instanceof Field ? (Field)fieldRef : null); if (f != null) { isStatic = Modifier.isStatic(f.getModifiers()); fclass = f.getDeclaringClass(); fname = f.getName(); ftype = f.getType(); } else { Object[] scnt = (Object[]) fieldRef; isStatic = (Boolean) scnt[0]; fclass = (Class) scnt[1]; fname = (String) scnt[2]; ftype = (Class) scnt[3]; try { f = fclass.getDeclaredField(fname); } catch (ReflectiveOperationException ex) { f = null; } } if (!testModeMatches(testMode, isStatic)) return; if (f == null && testMode == TEST_UNREFLECT) return; if (testNPE && isStatic) return; countTest(positive); MethodType expType; if (isGetter) expType = MethodType.methodType(ftype, HasFields.class); else expType = MethodType.methodType(void.class, HasFields.class, ftype); if (isStatic) expType = expType.dropParameterTypes(0, 1); Exception noAccess = null; MethodHandle mh; try { switch (testMode0 & ~(TEST_BOUND | TEST_NPE)) { case TEST_UNREFLECT: mh = lookup.unreflectGetter(f); break; case TEST_FIND_FIELD: mh = lookup.findGetter(fclass, fname, ftype); break; case TEST_FIND_STATIC: mh = lookup.findStaticGetter(fclass, fname, ftype); break; case TEST_SETTER| TEST_UNREFLECT: mh = lookup.unreflectSetter(f); break; case TEST_SETTER| TEST_FIND_FIELD: mh = lookup.findSetter(fclass, fname, ftype); break; case TEST_SETTER| TEST_FIND_STATIC: mh = lookup.findStaticSetter(fclass, fname, ftype); break; default: throw new InternalError("testMode="+testMode); } } catch (ReflectiveOperationException ex) { mh = null; noAccess = ex; assertExceptionClass( (fname.contains("bogus")) ? NoSuchFieldException.class : IllegalAccessException.class, noAccess); if (verbosity >= 5) ex.printStackTrace(System.out); } if (verbosity >= 3) System.out.println("find"+(isStatic?"Static":"")+(isGetter?"Getter":"Setter")+" "+fclass.getName()+"."+fname+"/"+ftype +" => "+mh +(noAccess == null ? "" : " !! "+noAccess)); if (positive && !testNPE && noAccess != null) throw new RuntimeException(noAccess); assertEquals(positive0 ? "positive test" : "negative test erroneously passed", positive0, mh != null); if (!positive && !testNPE) return; // negative access test failed as expected assertEquals((isStatic ? 0 : 1)+(isGetter ? 0 : 1), mh.type().parameterCount()); assertSame(mh.type(), expType); //assertNameStringContains(mh, fname); // This does not hold anymore with LFs HasFields fields = new HasFields(); HasFields fieldsForMH = fields; if (testNPE) fieldsForMH = null; // perturb MH argument to elicit expected error if (doBound) mh = mh.bindTo(fieldsForMH); Object sawValue; Class vtype = ftype; if (ftype != int.class) vtype = Object.class; if (isGetter) { mh = mh.asType(mh.type().generic() .changeReturnType(vtype)); } else { int last = mh.type().parameterCount() - 1; mh = mh.asType(mh.type().generic() .changeReturnType(void.class) .changeParameterType(last, vtype)); } if (f != null && f.getDeclaringClass() == HasFields.class) { assertEquals(f.get(fields), value); // clean to start with } Throwable caughtEx = null; if (isGetter) { Object expValue = value; for (int i = 0; i <= 1; i++) { sawValue = null; // make DA rules happy under try/catch try { if (isStatic || doBound) { if (ftype == int.class) sawValue = (int) mh.invokeExact(); // do these exactly else sawValue = mh.invokeExact(); } else { if (ftype == int.class) sawValue = (int) mh.invokeExact((Object) fieldsForMH); else sawValue = mh.invokeExact((Object) fieldsForMH); } } catch (RuntimeException ex) { if (ex instanceof NullPointerException && testNPE) { caughtEx = ex; break; } } assertEquals(sawValue, expValue); if (f != null && f.getDeclaringClass() == HasFields.class && !Modifier.isFinal(f.getModifiers())) { Object random = randomArg(ftype); f.set(fields, random); expValue = random; } else { break; } } } else { for (int i = 0; i <= 1; i++) { Object putValue = randomArg(ftype); try { if (isStatic || doBound) { if (ftype == int.class) mh.invokeExact((int)putValue); // do these exactly else mh.invokeExact(putValue); } else { if (ftype == int.class) mh.invokeExact((Object) fieldsForMH, (int)putValue); else mh.invokeExact((Object) fieldsForMH, putValue); } } catch (RuntimeException ex) { if (ex instanceof NullPointerException && testNPE) { caughtEx = ex; break; } } if (f != null && f.getDeclaringClass() == HasFields.class) { assertEquals(f.get(fields), putValue); } } } if (f != null && f.getDeclaringClass() == HasFields.class) { f.set(fields, value); // put it back } if (testNPE) { if (caughtEx == null || !(caughtEx instanceof NullPointerException)) throw new RuntimeException("failed to catch NPE exception"+(caughtEx == null ? " (caughtEx=null)" : ""), caughtEx); caughtEx = null; // nullify expected exception } if (caughtEx != null) { throw new RuntimeException("unexpected exception", caughtEx); } } @Test public void testUnreflectSetter() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testUnreflectSetter0); } public void testUnreflectSetter0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("unreflectSetter"); testSetter(TEST_UNREFLECT); } @Test public void testFindSetter() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFindSetter0); } public void testFindSetter0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("findSetter"); testSetter(TEST_FIND_FIELD); testSetter(TEST_FIND_FIELD | TEST_BOUND); } @Test public void testFindStaticSetter() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFindStaticSetter0); } public void testFindStaticSetter0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("findStaticSetter"); testSetter(TEST_FIND_STATIC); } public void testSetter(int testMode) throws Throwable { Lookup lookup = PRIVATE; // FIXME: test more lookups than this one startTest("unreflectSetter"); for (Object[] c : HasFields.CASES) { boolean positive = (c[1] != Error.class); testSetter(positive, lookup, c[0], c[1], testMode); if (positive) testSetter(positive, lookup, c[0], c[1], testMode | TEST_NPE); } for (int isStaticN = 0; isStaticN <= 1; isStaticN++) { testSetter(false, lookup, new Object[]{ (isStaticN != 0), System.class, "bogus", char.class }, null, testMode); } } public void testSetter(boolean positive, MethodHandles.Lookup lookup, Object fieldRef, Object value, int testMode) throws Throwable { testAccessor(positive, lookup, fieldRef, value, testMode | TEST_SETTER); } @Test public void testArrayElementGetter() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testArrayElementGetter0); } public void testArrayElementGetter0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("arrayElementGetter"); testArrayElementGetterSetter(false); } @Test public void testArrayElementSetter() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testArrayElementSetter0); } public void testArrayElementSetter0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("arrayElementSetter"); testArrayElementGetterSetter(true); } private static final int TEST_ARRAY_NONE = 0, TEST_ARRAY_NPE = 1, TEST_ARRAY_OOB = 2, TEST_ARRAY_ASE = 3; public void testArrayElementGetterSetter(boolean testSetter) throws Throwable { testArrayElementGetterSetter(testSetter, TEST_ARRAY_NONE); } @Test public void testArrayElementErrors() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testArrayElementErrors0); } public void testArrayElementErrors0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("arrayElementErrors"); testArrayElementGetterSetter(false, TEST_ARRAY_NPE); testArrayElementGetterSetter(true, TEST_ARRAY_NPE); testArrayElementGetterSetter(false, TEST_ARRAY_OOB); testArrayElementGetterSetter(true, TEST_ARRAY_OOB); testArrayElementGetterSetter(new Object[10], true, TEST_ARRAY_ASE); testArrayElementGetterSetter(new Example[10], true, TEST_ARRAY_ASE); testArrayElementGetterSetter(new IntExample[10], true, TEST_ARRAY_ASE); } public void testArrayElementGetterSetter(boolean testSetter, int negTest) throws Throwable { testArrayElementGetterSetter(new String[10], testSetter, negTest); testArrayElementGetterSetter(new Iterable[10], testSetter, negTest); testArrayElementGetterSetter(new Example[10], testSetter, negTest); testArrayElementGetterSetter(new IntExample[10], testSetter, negTest); testArrayElementGetterSetter(new Object[10], testSetter, negTest); testArrayElementGetterSetter(new boolean[10], testSetter, negTest); testArrayElementGetterSetter(new byte[10], testSetter, negTest); testArrayElementGetterSetter(new char[10], testSetter, negTest); testArrayElementGetterSetter(new short[10], testSetter, negTest); testArrayElementGetterSetter(new int[10], testSetter, negTest); testArrayElementGetterSetter(new float[10], testSetter, negTest); testArrayElementGetterSetter(new long[10], testSetter, negTest); testArrayElementGetterSetter(new double[10], testSetter, negTest); } public void testArrayElementGetterSetter(Object array, boolean testSetter, int negTest) throws Throwable { boolean positive = (negTest == TEST_ARRAY_NONE); int length = java.lang.reflect.Array.getLength(array); Class arrayType = array.getClass(); Class elemType = arrayType.getComponentType(); Object arrayToMH = array; // this stanza allows negative tests to make argument perturbations: switch (negTest) { case TEST_ARRAY_NPE: arrayToMH = null; break; case TEST_ARRAY_OOB: assert(length > 0); arrayToMH = java.lang.reflect.Array.newInstance(elemType, 0); break; case TEST_ARRAY_ASE: assert(testSetter && !elemType.isPrimitive()); if (elemType == Object.class) arrayToMH = new StringBuffer[length]; // very random subclass of Object! else if (elemType == Example.class) arrayToMH = new SubExample[length]; else if (elemType == IntExample.class) arrayToMH = new SubIntExample[length]; else return; // can't make an ArrayStoreException test assert(arrayType.isInstance(arrayToMH)) : Arrays.asList(arrayType, arrayToMH.getClass(), testSetter, negTest); break; } countTest(positive); if (verbosity > 2) System.out.println("array type = "+array.getClass().getComponentType().getName()+"["+length+"]"+(positive ? "" : " negative test #"+negTest+" using "+Arrays.deepToString(new Object[]{arrayToMH}))); MethodType expType = !testSetter ? MethodType.methodType(elemType, arrayType, int.class) : MethodType.methodType(void.class, arrayType, int.class, elemType); MethodHandle mh = !testSetter ? MethodHandles.arrayElementGetter(arrayType) : MethodHandles.arrayElementSetter(arrayType); assertSame(mh.type(), expType); if (elemType != int.class && elemType != boolean.class) { MethodType gtype = mh.type().generic().changeParameterType(1, int.class); if (testSetter) gtype = gtype.changeReturnType(void.class); mh = mh.asType(gtype); } Object sawValue, expValue; List model = array2list(array); Throwable caughtEx = null; for (int i = 0; i < length; i++) { // update array element Object random = randomArg(elemType); model.set(i, random); if (testSetter) { try { if (elemType == int.class) mh.invokeExact((int[]) arrayToMH, i, (int)random); else if (elemType == boolean.class) mh.invokeExact((boolean[]) arrayToMH, i, (boolean)random); else mh.invokeExact(arrayToMH, i, random); } catch (RuntimeException ex) { caughtEx = ex; break; } assertEquals(model, array2list(array)); } else { Array.set(array, i, random); } if (verbosity >= 5) { List array2list = array2list(array); System.out.println("a["+i+"]="+random+" => "+array2list); if (!array2list.equals(model)) System.out.println("*** != "+model); } // observe array element sawValue = Array.get(array, i); if (!testSetter) { expValue = sawValue; try { if (elemType == int.class) sawValue = (int) mh.invokeExact((int[]) arrayToMH, i); else if (elemType == boolean.class) sawValue = (boolean) mh.invokeExact((boolean[]) arrayToMH, i); else sawValue = mh.invokeExact(arrayToMH, i); } catch (RuntimeException ex) { caughtEx = ex; break; } assertEquals(sawValue, expValue); assertEquals(model, array2list(array)); } } if (!positive) { if (caughtEx == null) throw new RuntimeException("failed to catch exception for negTest="+negTest); // test the kind of exception Class reqType = null; switch (negTest) { case TEST_ARRAY_ASE: reqType = ArrayStoreException.class; break; case TEST_ARRAY_OOB: reqType = ArrayIndexOutOfBoundsException.class; break; case TEST_ARRAY_NPE: reqType = NullPointerException.class; break; default: assert(false); } if (reqType.isInstance(caughtEx)) { caughtEx = null; // nullify expected exception } } if (caughtEx != null) { throw new RuntimeException("unexpected exception", caughtEx); } } List array2list(Object array) { int length = Array.getLength(array); ArrayList model = new ArrayList<>(length); for (int i = 0; i < length; i++) model.add(Array.get(array, i)); return model; } static class Callee { static Object id() { return called("id"); } static Object id(Object x) { return called("id", x); } static Object id(Object x, Object y) { return called("id", x, y); } static Object id(Object x, Object y, Object z) { return called("id", x, y, z); } static Object id(Object... vx) { return called("id", vx); } static MethodHandle ofType(int n) { return ofType(Object.class, n); } static MethodHandle ofType(Class rtype, int n) { if (n == -1) return ofType(MethodType.methodType(rtype, Object[].class)); return ofType(MethodType.genericMethodType(n).changeReturnType(rtype)); } static MethodHandle ofType(Class rtype, Class... ptypes) { return ofType(MethodType.methodType(rtype, ptypes)); } static MethodHandle ofType(MethodType type) { Class rtype = type.returnType(); String pfx = ""; if (rtype != Object.class) pfx = rtype.getSimpleName().substring(0, 1).toLowerCase(); String name = pfx+"id"; try { return PRIVATE.findStatic(Callee.class, name, type); } catch (NoSuchMethodException | IllegalAccessException ex) { throw new RuntimeException(ex); } } } @Test public void testConvertArguments() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testConvertArguments0); } public void testConvertArguments0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("convertArguments"); testConvert(Callee.ofType(1), null, "id", int.class); testConvert(Callee.ofType(1), null, "id", String.class); testConvert(Callee.ofType(1), null, "id", Integer.class); testConvert(Callee.ofType(1), null, "id", short.class); testConvert(Callee.ofType(1), null, "id", char.class); testConvert(Callee.ofType(1), null, "id", byte.class); } void testConvert(MethodHandle id, Class rtype, String name, Class... params) throws Throwable { testConvert(true, id, rtype, name, params); } void testConvert(boolean positive, MethodHandle id, Class rtype, String name, Class... params) throws Throwable { countTest(positive); MethodType idType = id.type(); if (rtype == null) rtype = idType.returnType(); for (int i = 0; i < params.length; i++) { if (params[i] == null) params[i] = idType.parameterType(i); } // simulate the pairwise conversion MethodType newType = MethodType.methodType(rtype, params); Object[] args = randomArgs(newType.parameterArray()); Object[] convArgs = args.clone(); for (int i = 0; i < args.length; i++) { Class src = newType.parameterType(i); Class dst = idType.parameterType(i); if (src != dst) convArgs[i] = castToWrapper(convArgs[i], dst); } Object convResult = id.invokeWithArguments(convArgs); { Class dst = newType.returnType(); Class src = idType.returnType(); if (src != dst) convResult = castToWrapper(convResult, dst); } MethodHandle target = null; RuntimeException error = null; try { target = id.asType(newType); } catch (WrongMethodTypeException ex) { error = ex; } if (verbosity >= 3) System.out.println("convert "+id+ " to "+newType+" => "+target +(error == null ? "" : " !! "+error)); if (positive && error != null) throw error; assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null); if (!positive) return; // negative test failed as expected assertEquals(newType, target.type()); printCalled(target, id.toString(), args); Object result = target.invokeWithArguments(args); assertCalled(name, convArgs); assertEquals(convResult, result); if (verbosity >= 1) System.out.print(':'); } @Test public void testVarargsCollector() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testVarargsCollector0); } public void testVarargsCollector0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("varargsCollector"); MethodHandle vac0 = PRIVATE.findStatic(MethodHandlesTest.class, "called", MethodType.methodType(Object.class, String.class, Object[].class)); vac0 = vac0.bindTo("vac"); MethodHandle vac = vac0.asVarargsCollector(Object[].class); testConvert(true, vac.asType(MethodType.genericMethodType(0)), null, "vac"); testConvert(true, vac.asType(MethodType.genericMethodType(0)), null, "vac"); for (Class at : new Class[] { Object.class, String.class, Integer.class }) { testConvert(true, vac.asType(MethodType.genericMethodType(1)), null, "vac", at); testConvert(true, vac.asType(MethodType.genericMethodType(2)), null, "vac", at, at); } } @Test // SLOW public void testPermuteArguments() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testPermuteArguments0); } public void testPermuteArguments0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("permuteArguments"); testPermuteArguments(4, Integer.class, 2, long.class, 6); if (CAN_TEST_LIGHTLY) return; testPermuteArguments(4, Integer.class, 2, String.class, 0); testPermuteArguments(6, Integer.class, 0, null, 30); } public void testPermuteArguments(int max, Class type1, int t2c, Class type2, int dilution) throws Throwable { if (verbosity >= 2) System.out.println("permuteArguments "+max+"*"+type1.getName() +(t2c==0?"":"/"+t2c+"*"+type2.getName()) +(dilution > 0 ? " with dilution "+dilution : "")); int t2pos = t2c == 0 ? 0 : 1; for (int inargs = t2pos+1; inargs <= max; inargs++) { Class[] types = new Class[inargs]; Arrays.fill(types, type1); if (t2c != 0) { // Fill in a middle range with type2: Arrays.fill(types, t2pos, Math.min(t2pos+t2c, inargs), type2); } Object[] args = randomArgs(types); int numcases = 1; for (int outargs = 0; outargs <= max; outargs++) { if (outargs - inargs >= MAX_ARG_INCREASE) continue; int casStep = dilution + 1; // Avoid some common factors: while ((casStep > 2 && casStep % 2 == 0 && inargs % 2 == 0) || (casStep > 3 && casStep % 3 == 0 && inargs % 3 == 0)) casStep++; testPermuteArguments(args, types, outargs, numcases, casStep); numcases *= inargs; if (CAN_TEST_LIGHTLY && outargs < max-2) continue; if (dilution > 10 && outargs >= 4) { if (CAN_TEST_LIGHTLY) continue; int[] reorder = new int[outargs]; // Do some special patterns, which we probably missed. // Replication of a single argument or argument pair. for (int i = 0; i < inargs; i++) { Arrays.fill(reorder, i); testPermuteArguments(args, types, reorder); for (int d = 1; d <= 2; d++) { if (i + d >= inargs) continue; for (int j = 1; j < outargs; j += 2) reorder[j] += 1; testPermuteArguments(args, types, reorder); testPermuteArguments(args, types, reverse(reorder)); } } // Repetition of a sequence of 3 or more arguments. for (int i = 1; i < inargs; i++) { for (int len = 3; len <= inargs; len++) { for (int j = 0; j < outargs; j++) reorder[j] = (i + (j % len)) % inargs; testPermuteArguments(args, types, reorder); testPermuteArguments(args, types, reverse(reorder)); } } } } } } public void testPermuteArguments(Object[] args, Class[] types, int outargs, int numcases, int casStep) throws Throwable { int inargs = args.length; int[] reorder = new int[outargs]; for (int cas = 0; cas < numcases; cas += casStep) { for (int i = 0, c = cas; i < outargs; i++) { reorder[i] = c % inargs; c /= inargs; } if (CAN_TEST_LIGHTLY && outargs >= 3 && (reorder[0] == reorder[1] || reorder[1] == reorder[2])) continue; testPermuteArguments(args, types, reorder); } } static int[] reverse(int[] reorder) { reorder = reorder.clone(); for (int i = 0, imax = reorder.length / 2; i < imax; i++) { int j = reorder.length - 1 - i; int tem = reorder[i]; reorder[i] = reorder[j]; reorder[j] = tem; } return reorder; } void testPermuteArguments(Object[] args, Class[] types, int[] reorder) throws Throwable { countTest(); if (args == null && types == null) { int max = 0; for (int j : reorder) { if (max < j) max = j; } args = randomArgs(max+1, Integer.class); } if (args == null) { args = randomArgs(types); } if (types == null) { types = new Class[args.length]; for (int i = 0; i < args.length; i++) types[i] = args[i].getClass(); } int inargs = args.length, outargs = reorder.length; assertTrue(inargs == types.length); if (verbosity >= 3) System.out.println("permuteArguments "+Arrays.toString(reorder)); Object[] permArgs = new Object[outargs]; Class[] permTypes = new Class[outargs]; for (int i = 0; i < outargs; i++) { permArgs[i] = args[reorder[i]]; permTypes[i] = types[reorder[i]]; } if (verbosity >= 4) { System.out.println("in args: "+Arrays.asList(args)); System.out.println("out args: "+Arrays.asList(permArgs)); System.out.println("in types: "+Arrays.asList(types)); System.out.println("out types: "+Arrays.asList(permTypes)); } MethodType inType = MethodType.methodType(Object.class, types); MethodType outType = MethodType.methodType(Object.class, permTypes); MethodHandle target = varargsList(outargs).asType(outType); MethodHandle newTarget = MethodHandles.permuteArguments(target, inType, reorder); if (verbosity >= 5) System.out.println("newTarget = "+newTarget); Object result = newTarget.invokeWithArguments(args); Object expected = Arrays.asList(permArgs); if (!expected.equals(result)) { System.out.println("*** failed permuteArguments "+Arrays.toString(reorder)+" types="+Arrays.asList(types)); System.out.println("in args: "+Arrays.asList(args)); System.out.println("out args: "+expected); System.out.println("bad args: "+result); } assertEquals(expected, result); } @Test // SLOW public void testSpreadArguments() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testSpreadArguments0); CodeCacheOverflowProcessor.runMHTest(this::testSpreadArguments1); } public void testSpreadArguments0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("spreadArguments"); for (Class argType : new Class[]{Object.class, Integer.class, int.class}) { if (verbosity >= 3) System.out.println("spreadArguments "+argType); Class arrayType = java.lang.reflect.Array.newInstance(argType, 0).getClass(); for (int nargs = 0; nargs < 50; nargs++) { if (CAN_TEST_LIGHTLY && nargs > 11) break; for (int pos = 0; pos <= nargs; pos++) { if (CAN_TEST_LIGHTLY && pos > 2 && pos < nargs-2) continue; if (nargs > 10 && pos > 4 && pos < nargs-4 && pos % 10 != 3) continue; testSpreadArguments(argType, arrayType, pos, nargs); } } } } public void testSpreadArguments(Class argType, Class arrayType, int pos, int nargs) throws Throwable { countTest(); MethodHandle target2 = varargsArray(arrayType, nargs); MethodHandle target = target2.asType(target2.type().generic()); if (verbosity >= 3) System.out.println("spread into "+target2+" ["+pos+".."+nargs+"]"); Object[] args = randomArgs(target2.type().parameterArray()); // make sure the target does what we think it does: checkTarget(argType, pos, nargs, target, args); List> newParams = new ArrayList<>(target2.type().parameterList()); { // modify newParams in place List> spreadParams = newParams.subList(pos, nargs); spreadParams.clear(); spreadParams.add(arrayType); } MethodType newType = MethodType.methodType(arrayType, newParams); MethodHandle result = target2.asSpreader(arrayType, nargs-pos); assert(result.type() == newType) : Arrays.asList(result, newType); result = result.asType(newType.generic()); Object returnValue; if (pos == 0) { Object args2 = ValueConversions.changeArrayType(arrayType, Arrays.copyOfRange(args, pos, args.length)); returnValue = result.invokeExact(args2); } else { Object[] args1 = Arrays.copyOfRange(args, 0, pos+1); args1[pos] = ValueConversions.changeArrayType(arrayType, Arrays.copyOfRange(args, pos, args.length)); returnValue = result.invokeWithArguments(args1); } checkReturnValue(argType, args, result, returnValue); } public void testSpreadArguments1() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("spreadArguments/pos"); for (Class argType : new Class[]{Object.class, Integer.class, int.class}) { if (verbosity >= 3) System.out.println("spreadArguments "+argType); Class arrayType = java.lang.reflect.Array.newInstance(argType, 0).getClass(); for (int nargs = 0; nargs < 50; nargs++) { if (CAN_TEST_LIGHTLY && nargs > 11) break; for (int pos = 0; pos <= nargs; pos++) { if (CAN_TEST_LIGHTLY && pos > 2 && pos < nargs-2) continue; if (nargs > 10 && pos > 4 && pos < nargs-4 && pos % 10 != 3) continue; for (int spr = 1; spr < nargs - pos; ++spr) { if (spr > 4 && spr != 7 && spr != 11 && spr != 20 && spr < nargs - pos - 4) continue; testSpreadArguments(argType, arrayType, pos, spr, nargs); } } } } } public void testSpreadArguments(Class argType, Class arrayType, int pos, int spread, int nargs) throws Throwable { countTest(); MethodHandle target2 = varargsArray(arrayType, nargs); MethodHandle target = target2.asType(target2.type().generic()); if (verbosity >= 3) System.out.println("spread into " + target2 + " [" + pos + ".." + (pos + spread) + "["); Object[] args = randomArgs(target2.type().parameterArray()); // make sure the target does what we think it does: checkTarget(argType, pos, nargs, target, args); List> newParams = new ArrayList<>(target2.type().parameterList()); { // modify newParams in place List> spreadParams = newParams.subList(pos, pos + spread); spreadParams.clear(); spreadParams.add(arrayType); } MethodType newType = MethodType.methodType(arrayType, newParams); MethodHandle result = target2.asSpreader(pos, arrayType, spread); assert (result.type() == newType) : Arrays.asList(result, newType); result = result.asType(newType.generic()); // args1 has nargs-spread entries, plus one for the to-be-spread array int args1Length = nargs - (spread - 1); Object[] args1 = new Object[args1Length]; System.arraycopy(args, 0, args1, 0, pos); args1[pos] = ValueConversions.changeArrayType(arrayType, Arrays.copyOfRange(args, pos, pos + spread)); System.arraycopy(args, pos + spread, args1, pos + 1, nargs - spread - pos); Object returnValue = result.invokeWithArguments(args1); checkReturnValue(argType, args, result, returnValue); } private static void checkTarget(Class argType, int pos, int nargs, MethodHandle target, Object[] args) throws Throwable { if (pos == 0 && nargs < 5 && !argType.isPrimitive()) { Object[] check = (Object[]) target.invokeWithArguments(args); assertArrayEquals(args, check); switch (nargs) { case 0: check = (Object[]) (Object) target.invokeExact(); assertArrayEquals(args, check); break; case 1: check = (Object[]) (Object) target.invokeExact(args[0]); assertArrayEquals(args, check); break; case 2: check = (Object[]) (Object) target.invokeExact(args[0], args[1]); assertArrayEquals(args, check); break; } } } private static void checkReturnValue(Class argType, Object[] args, MethodHandle result, Object returnValue) { String argstr = Arrays.toString(args); if (!argType.isPrimitive()) { Object[] rv = (Object[]) returnValue; String rvs = Arrays.toString(rv); if (!Arrays.equals(args, rv)) { System.out.println("method: "+result); System.out.println("expected: "+argstr); System.out.println("returned: "+rvs); assertArrayEquals(args, rv); } } else if (argType == int.class) { String rvs = Arrays.toString((int[]) returnValue); if (!argstr.equals(rvs)) { System.out.println("method: "+result); System.out.println("expected: "+argstr); System.out.println("returned: "+rvs); assertEquals(argstr, rvs); } } else if (argType == long.class) { String rvs = Arrays.toString((long[]) returnValue); if (!argstr.equals(rvs)) { System.out.println("method: "+result); System.out.println("expected: "+argstr); System.out.println("returned: "+rvs); assertEquals(argstr, rvs); } } else { // cannot test... } } @Test // SLOW public void testAsCollector() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testAsCollector0); CodeCacheOverflowProcessor.runMHTest(this::testAsCollector1); } public void testAsCollector0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("asCollector"); for (Class argType : new Class[]{Object.class, Integer.class, int.class}) { if (verbosity >= 3) System.out.println("asCollector "+argType); for (int nargs = 0; nargs < 50; nargs++) { if (CAN_TEST_LIGHTLY && nargs > 11) break; for (int pos = 0; pos <= nargs; pos++) { if (CAN_TEST_LIGHTLY && pos > 2 && pos < nargs-2) continue; if (nargs > 10 && pos > 4 && pos < nargs-4 && pos % 10 != 3) continue; testAsCollector(argType, pos, nargs); } } } } public void testAsCollector(Class argType, int pos, int nargs) throws Throwable { countTest(); // fake up a MH with the same type as the desired adapter: MethodHandle fake = varargsArray(nargs); fake = changeArgTypes(fake, argType); MethodType newType = fake.type(); Object[] args = randomArgs(newType.parameterArray()); // here is what should happen: Object[] collectedArgs = Arrays.copyOfRange(args, 0, pos+1); collectedArgs[pos] = Arrays.copyOfRange(args, pos, args.length); // here is the MH which will witness the collected argument tail: MethodHandle target = varargsArray(pos+1); target = changeArgTypes(target, 0, pos, argType); target = changeArgTypes(target, pos, pos+1, Object[].class); if (verbosity >= 3) System.out.println("collect from "+Arrays.asList(args)+" ["+pos+".."+nargs+"]"); MethodHandle result = target.asCollector(Object[].class, nargs-pos).asType(newType); Object[] returnValue = (Object[]) result.invokeWithArguments(args); // assertTrue(returnValue.length == pos+1 && returnValue[pos] instanceof Object[]); // returnValue[pos] = Arrays.asList((Object[]) returnValue[pos]); // collectedArgs[pos] = Arrays.asList((Object[]) collectedArgs[pos]); assertArrayEquals(collectedArgs, returnValue); } public void testAsCollector1() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("asCollector/pos"); for (Class argType : new Class[]{Object.class, Integer.class, int.class}) { if (verbosity >= 3) System.out.println("asCollector/pos "+argType); for (int nargs = 0; nargs < 50; nargs++) { if (CAN_TEST_LIGHTLY && nargs > 11) break; for (int pos = 0; pos <= nargs; pos++) { if (CAN_TEST_LIGHTLY && pos > 2 && pos < nargs-2) continue; if (nargs > 10 && pos > 4 && pos < nargs-4 && pos % 10 != 3) continue; for (int coll = 1; coll < nargs - pos; ++coll) { if (coll > 4 && coll != 7 && coll != 11 && coll != 20 && coll < nargs - pos - 4) continue; testAsCollector(argType, pos, coll, nargs); } } } } } public void testAsCollector(Class argType, int pos, int collect, int nargs) throws Throwable { countTest(); // fake up a MH with the same type as the desired adapter: MethodHandle fake = varargsArray(nargs); fake = changeArgTypes(fake, argType); MethodType newType = fake.type(); Object[] args = randomArgs(newType.parameterArray()); // here is what should happen: // new arg list has "collect" less arguments, but one extra for collected arguments array int collectedLength = nargs-(collect-1); Object[] collectedArgs = new Object[collectedLength]; System.arraycopy(args, 0, collectedArgs, 0, pos); collectedArgs[pos] = Arrays.copyOfRange(args, pos, pos+collect); System.arraycopy(args, pos+collect, collectedArgs, pos+1, args.length-(pos+collect)); // here is the MH which will witness the collected argument part (not tail!): MethodHandle target = varargsArray(collectedLength); target = changeArgTypes(target, 0, pos, argType); target = changeArgTypes(target, pos, pos+1, Object[].class); target = changeArgTypes(target, pos+1, collectedLength, argType); if (verbosity >= 3) System.out.println("collect "+collect+" from "+Arrays.asList(args)+" ["+pos+".."+(pos+collect)+"["); MethodHandle result = target.asCollector(pos, Object[].class, collect).asType(newType); Object[] returnValue = (Object[]) result.invokeWithArguments(args); assertArrayEquals(collectedArgs, returnValue); } @Test // SLOW public void testInsertArguments() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testInsertArguments0); } public void testInsertArguments0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("insertArguments"); for (int nargs = 0; nargs < 50; nargs++) { if (CAN_TEST_LIGHTLY && nargs > 11) break; for (int ins = 0; ins <= nargs; ins++) { if (nargs > 10 && ins > 4 && ins < nargs-4 && ins % 10 != 3) continue; for (int pos = 0; pos <= nargs; pos++) { if (nargs > 10 && pos > 4 && pos < nargs-4 && pos % 10 != 3) continue; if (CAN_TEST_LIGHTLY && pos > 2 && pos < nargs-2) continue; testInsertArguments(nargs, pos, ins); } } } } void testInsertArguments(int nargs, int pos, int ins) throws Throwable { countTest(); MethodHandle target = varargsArray(nargs + ins); Object[] args = randomArgs(target.type().parameterArray()); List resList = Arrays.asList(args); List argsToPass = new ArrayList<>(resList); List argsToInsert = argsToPass.subList(pos, pos + ins); if (verbosity >= 3) System.out.println("insert: "+argsToInsert+" @"+pos+" into "+target); @SuppressWarnings("cast") // cast to spread Object... is helpful MethodHandle target2 = MethodHandles.insertArguments(target, pos, (Object[]/*...*/) argsToInsert.toArray()); argsToInsert.clear(); // remove from argsToInsert Object res2 = target2.invokeWithArguments(argsToPass); Object res2List = Arrays.asList((Object[])res2); if (verbosity >= 3) System.out.println("result: "+res2List); //if (!resList.equals(res2List)) // System.out.println("*** fail at n/p/i = "+nargs+"/"+pos+"/"+ins+": "+resList+" => "+res2List); assertEquals(resList, res2List); } @Test public void testFilterReturnValue() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFilterReturnValue0); } public void testFilterReturnValue0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("filterReturnValue"); Class classOfVCList = varargsList(1).invokeWithArguments(0).getClass(); assertTrue(List.class.isAssignableFrom(classOfVCList)); for (int nargs = 0; nargs <= 3; nargs++) { for (Class rtype : new Class[] { Object.class, List.class, int.class, byte.class, long.class, CharSequence.class, String.class }) { testFilterReturnValue(nargs, rtype); } } } void testFilterReturnValue(int nargs, Class rtype) throws Throwable { countTest(); MethodHandle target = varargsList(nargs, rtype); MethodHandle filter; if (List.class.isAssignableFrom(rtype) || rtype.isAssignableFrom(List.class)) filter = varargsList(1); // add another layer of list-ness else filter = MethodHandles.identity(rtype); filter = filter.asType(MethodType.methodType(target.type().returnType(), rtype)); Object[] argsToPass = randomArgs(nargs, Object.class); if (verbosity >= 3) System.out.println("filter "+target+" to "+rtype.getSimpleName()+" with "+filter); MethodHandle target2 = MethodHandles.filterReturnValue(target, filter); if (verbosity >= 4) System.out.println("filtered target: "+target2); // Simulate expected effect of filter on return value: Object unfiltered = target.invokeWithArguments(argsToPass); Object expected = filter.invokeWithArguments(unfiltered); if (verbosity >= 4) System.out.println("unfiltered: "+unfiltered+" : "+unfiltered.getClass().getSimpleName()); if (verbosity >= 4) System.out.println("expected: "+expected+" : "+expected.getClass().getSimpleName()); Object result = target2.invokeWithArguments(argsToPass); if (verbosity >= 3) System.out.println("result: "+result+" : "+result.getClass().getSimpleName()); if (!expected.equals(result)) System.out.println("*** fail at n/rt = "+nargs+"/"+rtype.getSimpleName()+": "+Arrays.asList(argsToPass)+" => "+result+" != "+expected); assertEquals(expected, result); } @Test public void testFilterArguments() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFilterArguments0); } public void testFilterArguments0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("filterArguments"); for (int nargs = 1; nargs <= 6; nargs++) { for (int pos = 0; pos < nargs; pos++) { testFilterArguments(nargs, pos); } } } void testFilterArguments(int nargs, int pos) throws Throwable { countTest(); MethodHandle target = varargsList(nargs); MethodHandle filter = varargsList(1); filter = filter.asType(filter.type().generic()); Object[] argsToPass = randomArgs(nargs, Object.class); if (verbosity >= 3) System.out.println("filter "+target+" at "+pos+" with "+filter); MethodHandle target2 = MethodHandles.filterArguments(target, pos, filter); // Simulate expected effect of filter on arglist: Object[] filteredArgs = argsToPass.clone(); filteredArgs[pos] = filter.invokeExact(filteredArgs[pos]); List expected = Arrays.asList(filteredArgs); Object result = target2.invokeWithArguments(argsToPass); if (verbosity >= 3) System.out.println("result: "+result); if (!expected.equals(result)) System.out.println("*** fail at n/p = "+nargs+"/"+pos+": "+Arrays.asList(argsToPass)+" => "+result+" != "+expected); assertEquals(expected, result); } @Test public void testCollectArguments() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testCollectArguments0); } public void testCollectArguments0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("collectArguments"); testFoldOrCollectArguments(true, false); } @Test public void testFoldArguments() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testFoldArguments0); CodeCacheOverflowProcessor.runMHTest(this::testFoldArguments1); } public void testFoldArguments0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("foldArguments"); testFoldOrCollectArguments(false, false); } public void testFoldArguments1() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("foldArguments/pos"); testFoldOrCollectArguments(false, true); } void testFoldOrCollectArguments(boolean isCollect, boolean withFoldPos) throws Throwable { assert !(isCollect && withFoldPos); // exclude illegal argument combination for (Class lastType : new Class[]{ Object.class, String.class, int.class }) { for (Class collectType : new Class[]{ Object.class, String.class, int.class, void.class }) { int maxArity = 10; if (collectType != String.class) maxArity = 5; if (lastType != Object.class) maxArity = 4; for (int nargs = 0; nargs <= maxArity; nargs++) { ArrayList> argTypes = new ArrayList<>(Collections.nCopies(nargs, Object.class)); int maxMix = 20; if (collectType != Object.class) maxMix = 0; Map argTypesSeen = new HashMap<>(); for (int mix = 0; mix <= maxMix; mix++) { if (!mixArgs(argTypes, mix, argTypesSeen)) continue; for (int collect = 0; collect <= nargs; collect++) { for (int pos = 0; pos <= nargs - collect; pos++) { testFoldOrCollectArguments(argTypes, pos, collect, collectType, lastType, isCollect, withFoldPos); } } } } } } } boolean mixArgs(List> argTypes, int mix, Map argTypesSeen) { assert(mix >= 0); if (mix == 0) return true; // no change if ((mix >>> argTypes.size()) != 0) return false; for (int i = 0; i < argTypes.size(); i++) { if (i >= 31) break; boolean bit = (mix & (1 << i)) != 0; if (bit) { Class type = argTypes.get(i); if (type == Object.class) type = String.class; else if (type == String.class) type = int.class; else type = Object.class; argTypes.set(i, type); } } Integer prev = argTypesSeen.put(new ArrayList<>(argTypes), mix); if (prev != null) { if (verbosity >= 4) System.out.println("mix "+prev+" repeated "+mix+": "+argTypes); return false; } if (verbosity >= 3) System.out.println("mix "+mix+" = "+argTypes); return true; } void testFoldOrCollectArguments(List> argTypes, // argument types minus the inserted combineType int pos, int fold, // position and length of the folded arguments Class combineType, // type returned from the combiner Class lastType, // type returned from the target boolean isCollect, boolean withFoldPos) throws Throwable { int nargs = argTypes.size(); if (pos != 0 && !isCollect && !withFoldPos) return; // test MethodHandles.foldArguments(MH,MH) only for pos=0 countTest(); List> combineArgTypes = argTypes.subList(pos, pos + fold); List> targetArgTypes = new ArrayList<>(argTypes); if (isCollect) // does target see arg[pos..pos+cc-1]? targetArgTypes.subList(pos, pos + fold).clear(); if (combineType != void.class) targetArgTypes.add(pos, combineType); MethodHandle target = varargsList(targetArgTypes, lastType); MethodHandle combine = varargsList(combineArgTypes, combineType); List argsToPass = Arrays.asList(randomArgs(argTypes)); if (verbosity >= 3) System.out.println((isCollect ? "collect" : "fold")+" "+target+" with "+combine); MethodHandle target2; if (isCollect) target2 = MethodHandles.collectArguments(target, pos, combine); else target2 = withFoldPos ? MethodHandles.foldArguments(target, pos, combine) : MethodHandles.foldArguments(target, combine); // Simulate expected effect of combiner on arglist: List expectedList = new ArrayList<>(argsToPass); List argsToFold = expectedList.subList(pos, pos + fold); if (verbosity >= 3) System.out.println((isCollect ? "collect" : "fold")+": "+argsToFold+" into "+target2); Object foldedArgs = combine.invokeWithArguments(argsToFold); if (isCollect) argsToFold.clear(); if (combineType != void.class) argsToFold.add(0, foldedArgs); Object result = target2.invokeWithArguments(argsToPass); if (verbosity >= 3) System.out.println("result: "+result); Object expected = target.invokeWithArguments(expectedList); if (!expected.equals(result)) System.out.println("*** fail at n/p/f = "+nargs+"/"+pos+"/"+fold+": "+argsToPass+" => "+result+" != "+expected); assertEquals(expected, result); } @Test public void testDropArguments() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testDropArguments0); } public void testDropArguments0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("dropArguments"); for (int nargs = 0; nargs <= 4; nargs++) { for (int drop = 1; drop <= 4; drop++) { for (int pos = 0; pos <= nargs; pos++) { testDropArguments(nargs, pos, drop); } } } } void testDropArguments(int nargs, int pos, int drop) throws Throwable { countTest(); MethodHandle target = varargsArray(nargs); Object[] args = randomArgs(target.type().parameterArray()); MethodHandle target2 = MethodHandles.dropArguments(target, pos, Collections.nCopies(drop, Object.class).toArray(new Class[0])); List resList = Arrays.asList(args); List argsToDrop = new ArrayList<>(resList); for (int i = drop; i > 0; i--) { argsToDrop.add(pos, "blort#"+i); } Object res2 = target2.invokeWithArguments(argsToDrop); Object res2List = Arrays.asList((Object[])res2); //if (!resList.equals(res2List)) // System.out.println("*** fail at n/p/d = "+nargs+"/"+pos+"/"+drop+": "+argsToDrop+" => "+res2List); assertEquals(resList, res2List); } @Test // SLOW public void testInvokers() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testInvokers0); } public void testInvokers0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("exactInvoker, genericInvoker, varargsInvoker, dynamicInvoker"); // exactInvoker, genericInvoker, varargsInvoker[0..N], dynamicInvoker Set done = new HashSet<>(); for (int i = 0; i <= 6; i++) { if (CAN_TEST_LIGHTLY && i > 3) break; MethodType gtype = MethodType.genericMethodType(i); for (Class argType : new Class[]{Object.class, Integer.class, int.class}) { for (int j = -1; j < i; j++) { MethodType type = gtype; if (j < 0) type = type.changeReturnType(argType); else if (argType == void.class) continue; else type = type.changeParameterType(j, argType); if (done.add(type)) testInvokersWithCatch(type); MethodType vtype = type.changeReturnType(void.class); if (done.add(vtype)) testInvokersWithCatch(vtype); } } } } public void testInvokersWithCatch(MethodType type) throws Throwable { try { testInvokers(type); } catch (Throwable ex) { System.out.println("*** testInvokers on "+type+" => "); ex.printStackTrace(System.out); } } public void testInvokers(MethodType type) throws Throwable { if (verbosity >= 3) System.out.println("test invokers for "+type); int nargs = type.parameterCount(); boolean testRetCode = type.returnType() != void.class; MethodHandle target = PRIVATE.findStatic(MethodHandlesTest.class, "invokee", MethodType.genericMethodType(0, true)); assertTrue(target.isVarargsCollector()); target = target.asType(type); Object[] args = randomArgs(type.parameterArray()); List targetPlusArgs = new ArrayList<>(Arrays.asList(args)); targetPlusArgs.add(0, target); int code = (Integer) invokee(args); Object log = logEntry("invokee", args); assertEquals(log.hashCode(), code); assertCalled("invokee", args); MethodHandle inv; Object result; // exact invoker countTest(); calledLog.clear(); inv = MethodHandles.exactInvoker(type); result = inv.invokeWithArguments(targetPlusArgs); if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); // generic invoker countTest(); inv = MethodHandles.invoker(type); if (nargs <= 3 && type == type.generic()) { calledLog.clear(); switch (nargs) { case 0: result = inv.invokeExact(target); break; case 1: result = inv.invokeExact(target, args[0]); break; case 2: result = inv.invokeExact(target, args[0], args[1]); break; case 3: result = inv.invokeExact(target, args[0], args[1], args[2]); break; } if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); } calledLog.clear(); result = inv.invokeWithArguments(targetPlusArgs); if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); // varargs invoker #0 calledLog.clear(); inv = MethodHandles.spreadInvoker(type, 0); if (type.returnType() == Object.class) { result = inv.invokeExact(target, args); } else if (type.returnType() == void.class) { result = null; inv.invokeExact(target, args); } else { result = inv.invokeWithArguments(target, (Object) args); } if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); if (nargs >= 1 && type == type.generic()) { // varargs invoker #1 calledLog.clear(); inv = MethodHandles.spreadInvoker(type, 1); result = inv.invokeExact(target, args[0], Arrays.copyOfRange(args, 1, nargs)); if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); } if (nargs >= 2 && type == type.generic()) { // varargs invoker #2 calledLog.clear(); inv = MethodHandles.spreadInvoker(type, 2); result = inv.invokeExact(target, args[0], args[1], Arrays.copyOfRange(args, 2, nargs)); if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); } if (nargs >= 3 && type == type.generic()) { // varargs invoker #3 calledLog.clear(); inv = MethodHandles.spreadInvoker(type, 3); result = inv.invokeExact(target, args[0], args[1], args[2], Arrays.copyOfRange(args, 3, nargs)); if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); } for (int k = 0; k <= nargs; k++) { // varargs invoker #0..N if (CAN_TEST_LIGHTLY && (k > 1 || k < nargs - 1)) continue; countTest(); calledLog.clear(); inv = MethodHandles.spreadInvoker(type, k); MethodType expType = (type.dropParameterTypes(k, nargs) .appendParameterTypes(Object[].class) .insertParameterTypes(0, MethodHandle.class)); assertEquals(expType, inv.type()); List targetPlusVarArgs = new ArrayList<>(targetPlusArgs); List tailList = targetPlusVarArgs.subList(1+k, 1+nargs); Object[] tail = tailList.toArray(); tailList.clear(); tailList.add(tail); result = inv.invokeWithArguments(targetPlusVarArgs); if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); } // dynamic invoker countTest(); CallSite site = new MutableCallSite(type); inv = site.dynamicInvoker(); // see if we get the result of the original target: try { result = inv.invokeWithArguments(args); assertTrue("should not reach here", false); } catch (IllegalStateException ex) { String msg = ex.getMessage(); assertTrue(msg, msg.contains("site")); } // set new target after invoker is created, to make sure we track target site.setTarget(target); calledLog.clear(); result = inv.invokeWithArguments(args); if (testRetCode) assertEquals(code, result); assertCalled("invokee", args); } static Object invokee(Object... args) { return called("invokee", args).hashCode(); } private static final String MISSING_ARG = "missingArg"; private static final String MISSING_ARG_2 = "missingArg#2"; static Object targetIfEquals() { return called("targetIfEquals"); } static Object fallbackIfNotEquals() { return called("fallbackIfNotEquals"); } static Object targetIfEquals(Object x) { assertEquals(x, MISSING_ARG); return called("targetIfEquals", x); } static Object fallbackIfNotEquals(Object x) { assertFalse(x.toString(), x.equals(MISSING_ARG)); return called("fallbackIfNotEquals", x); } static Object targetIfEquals(Object x, Object y) { assertEquals(x, y); return called("targetIfEquals", x, y); } static Object fallbackIfNotEquals(Object x, Object y) { assertFalse(x.toString(), x.equals(y)); return called("fallbackIfNotEquals", x, y); } static Object targetIfEquals(Object x, Object y, Object z) { assertEquals(x, y); return called("targetIfEquals", x, y, z); } static Object fallbackIfNotEquals(Object x, Object y, Object z) { assertFalse(x.toString(), x.equals(y)); return called("fallbackIfNotEquals", x, y, z); } @Test public void testGuardWithTest() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testGuardWithTest0); } public void testGuardWithTest0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("guardWithTest"); for (int nargs = 0; nargs <= 50; nargs++) { if (CAN_TEST_LIGHTLY && nargs > 7) break; testGuardWithTest(nargs, Object.class); testGuardWithTest(nargs, String.class); } } void testGuardWithTest(int nargs, Class argClass) throws Throwable { testGuardWithTest(nargs, 0, argClass); if (nargs <= 5 || nargs % 10 == 3) { for (int testDrops = 1; testDrops <= nargs; testDrops++) testGuardWithTest(nargs, testDrops, argClass); } } void testGuardWithTest(int nargs, int testDrops, Class argClass) throws Throwable { countTest(); int nargs1 = Math.min(3, nargs); MethodHandle test = PRIVATE.findVirtual(Object.class, "equals", MethodType.methodType(boolean.class, Object.class)); MethodHandle target = PRIVATE.findStatic(MethodHandlesTest.class, "targetIfEquals", MethodType.genericMethodType(nargs1)); MethodHandle fallback = PRIVATE.findStatic(MethodHandlesTest.class, "fallbackIfNotEquals", MethodType.genericMethodType(nargs1)); while (test.type().parameterCount() > nargs) // 0: test = constant(MISSING_ARG.equals(MISSING_ARG)) // 1: test = lambda (_) MISSING_ARG.equals(_) test = MethodHandles.insertArguments(test, 0, MISSING_ARG); if (argClass != Object.class) { test = changeArgTypes(test, argClass); target = changeArgTypes(target, argClass); fallback = changeArgTypes(fallback, argClass); } int testArgs = nargs - testDrops; assert(testArgs >= 0); test = addTrailingArgs(test, Math.min(testArgs, nargs), argClass); target = addTrailingArgs(target, nargs, argClass); fallback = addTrailingArgs(fallback, nargs, argClass); Object[][] argLists = { { }, { "foo" }, { MISSING_ARG }, { "foo", "foo" }, { "foo", "bar" }, { "foo", "foo", "baz" }, { "foo", "bar", "baz" } }; for (Object[] argList : argLists) { Object[] argList1 = argList; if (argList.length != nargs) { if (argList.length != nargs1) continue; argList1 = Arrays.copyOf(argList, nargs); Arrays.fill(argList1, nargs1, nargs, MISSING_ARG_2); } MethodHandle test1 = test; if (test1.type().parameterCount() > testArgs) { int pc = test1.type().parameterCount(); test1 = MethodHandles.insertArguments(test, testArgs, Arrays.copyOfRange(argList1, testArgs, pc)); } MethodHandle mh = MethodHandles.guardWithTest(test1, target, fallback); assertEquals(target.type(), mh.type()); boolean equals; switch (nargs) { case 0: equals = true; break; case 1: equals = MISSING_ARG.equals(argList[0]); break; default: equals = argList[0].equals(argList[1]); break; } String willCall = (equals ? "targetIfEquals" : "fallbackIfNotEquals"); if (verbosity >= 3) System.out.println(logEntry(willCall, argList)); Object result = mh.invokeWithArguments(argList1); assertCalled(willCall, argList); } } @Test public void testGenericLoopCombinator() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testGenericLoopCombinator0); } public void testGenericLoopCombinator0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("loop"); // Test as follows: // * Have an increasing number of loop-local state. Local state type diversity grows with the number. // * Initializers set the starting value of loop-local state from the corresponding loop argument. // * For each local state element, there is a predicate - for all state combinations, exercise all predicates. // * Steps modify each local state element in each iteration. // * Finalizers group all local state elements into a resulting array. Verify end values. // * Exercise both pre- and post-checked loops. // Local state types, start values, predicates, and steps: // * int a, 0, a < 7, a = a + 1 // * double b, 7.0, b > 0.5, b = b / 2.0 // * String c, "start", c.length <= 9, c = c + a final Class[] argTypes = new Class[] {int.class, double.class, String.class}; final Object[][] args = new Object[][] { new Object[]{0 }, new Object[]{0, 7.0 }, new Object[]{0, 7.0, "start"} }; // These are the expected final state tuples for argument type tuple / predicate combinations, for pre- and // post-checked loops: final Object[][] preCheckedResults = new Object[][] { new Object[]{7 }, // (int) / int new Object[]{7, 0.0546875 }, // (int,double) / int new Object[]{5, 0.4375 }, // (int,double) / double new Object[]{7, 0.0546875, "start1234567"}, // (int,double,String) / int new Object[]{5, 0.4375, "start1234" }, // (int,double,String) / double new Object[]{6, 0.109375, "start12345" } // (int,double,String) / String }; final Object[][] postCheckedResults = new Object[][] { new Object[]{7 }, // (int) / int new Object[]{7, 0.109375 }, // (int,double) / int new Object[]{4, 0.4375 }, // (int,double) / double new Object[]{7, 0.109375, "start123456"}, // (int,double,String) / int new Object[]{4, 0.4375, "start123" }, // (int,double,String) / double new Object[]{5, 0.21875, "start12345" } // (int,double,String) / String }; final Lookup l = MethodHandles.lookup(); final Class MHT = MethodHandlesTest.class; final Class B = boolean.class; final Class I = int.class; final Class D = double.class; final Class S = String.class; final MethodHandle hip = l.findStatic(MHT, "loopIntPred", methodType(B, I)); final MethodHandle hdp = l.findStatic(MHT, "loopDoublePred", methodType(B, I, D)); final MethodHandle hsp = l.findStatic(MHT, "loopStringPred", methodType(B, I, D, S)); final MethodHandle his = l.findStatic(MHT, "loopIntStep", methodType(I, I)); final MethodHandle hds = l.findStatic(MHT, "loopDoubleStep", methodType(D, I, D)); final MethodHandle hss = l.findStatic(MHT, "loopStringStep", methodType(S, I, D, S)); final MethodHandle[] preds = new MethodHandle[] {hip, hdp, hsp}; final MethodHandle[] steps = new MethodHandle[] {his, hds, hss}; for (int nargs = 1, useResultsStart = 0; nargs <= argTypes.length; useResultsStart += nargs++) { Class[] useArgTypes = Arrays.copyOf(argTypes, nargs, Class[].class); MethodHandle[] usePreds = Arrays.copyOf(preds, nargs, MethodHandle[].class); MethodHandle[] useSteps = Arrays.copyOf(steps, nargs, MethodHandle[].class); Object[] useArgs = args[nargs - 1]; Object[][] usePreCheckedResults = new Object[nargs][]; Object[][] usePostCheckedResults = new Object[nargs][]; System.arraycopy(preCheckedResults, useResultsStart, usePreCheckedResults, 0, nargs); System.arraycopy(postCheckedResults, useResultsStart, usePostCheckedResults, 0, nargs); testGenericLoopCombinator(nargs, useArgTypes, usePreds, useSteps, useArgs, usePreCheckedResults, usePostCheckedResults); } } void testGenericLoopCombinator(int nargs, Class[] argTypes, MethodHandle[] preds, MethodHandle[] steps, Object[] args, Object[][] preCheckedResults, Object[][] postCheckedResults) throws Throwable { List> lArgTypes = Arrays.asList(argTypes); // Predicate and step handles are passed in as arguments, initializer and finalizer handles are constructed here // from the available information. MethodHandle[] inits = new MethodHandle[nargs]; for (int i = 0; i < nargs; ++i) { MethodHandle h; // Initializers are meant to return whatever they are passed at a given argument position. This means that // additional arguments may have to be appended and prepended. h = MethodHandles.identity(argTypes[i]); if (i < nargs - 1) { h = MethodHandles.dropArguments(h, 1, lArgTypes.subList(i + 1, nargs)); } if (i > 0) { h = MethodHandles.dropArguments(h, 0, lArgTypes.subList(0, i)); } inits[i] = h; } // Finalizers are all meant to collect all of the loop-local state in a single array and return that. Local // state is passed before the loop args. Construct such a finalizer by first taking a varargsArray collector for // the number of local state arguments, and then appending the loop args as to-be-dropped arguments. MethodHandle[] finis = new MethodHandle[nargs]; MethodHandle genericFini = MethodHandles.dropArguments( varargsArray(nargs).asType(methodType(Object[].class, lArgTypes)), nargs, lArgTypes); Arrays.fill(finis, genericFini); // The predicate and step handles' signatures need to be extended. They currently just accept local state args; // append possibly missing local state args and loop args using dropArguments. for (int i = 0; i < nargs; ++i) { List> additionalLocalStateArgTypes = lArgTypes.subList(i + 1, nargs); preds[i] = MethodHandles.dropArguments( MethodHandles.dropArguments(preds[i], i + 1, additionalLocalStateArgTypes), nargs, lArgTypes); steps[i] = MethodHandles.dropArguments( MethodHandles.dropArguments(steps[i], i + 1, additionalLocalStateArgTypes), nargs, lArgTypes); } // Iterate over all of the predicates, using only one of them at a time. for (int i = 0; i < nargs; ++i) { MethodHandle[] usePreds; if (nargs == 1) { usePreds = preds; } else { // Create an all-null preds array, and only use one predicate in this iteration. The null entries will // be substituted with true predicates by the loop combinator. usePreds = new MethodHandle[nargs]; usePreds[i] = preds[i]; } // Go for it. if (verbosity >= 3) { System.out.println("calling loop for argument types " + lArgTypes + " with predicate at index " + i); if (verbosity >= 5) { System.out.println("predicates: " + Arrays.asList(usePreds)); } } MethodHandle[] preInits = new MethodHandle[nargs + 1]; MethodHandle[] prePreds = new MethodHandle[nargs + 1]; MethodHandle[] preSteps = new MethodHandle[nargs + 1]; MethodHandle[] preFinis = new MethodHandle[nargs + 1]; System.arraycopy(inits, 0, preInits, 1, nargs); System.arraycopy(usePreds, 0, prePreds, 0, nargs); // preds are offset by 1 for pre-checked loops System.arraycopy(steps, 0, preSteps, 1, nargs); System.arraycopy(finis, 0, preFinis, 0, nargs); // finis are also offset by 1 for pre-checked loops // Convert to clause-major form. MethodHandle[][] preClauses = new MethodHandle[nargs + 1][4]; MethodHandle[][] postClauses = new MethodHandle[nargs][4]; toClauseMajor(preClauses, preInits, preSteps, prePreds, preFinis); toClauseMajor(postClauses, inits, steps, usePreds, finis); MethodHandle pre = MethodHandles.loop(preClauses); MethodHandle post = MethodHandles.loop(postClauses); if (verbosity >= 6) { System.out.println("pre-handle: " + pre); } Object[] preResults = (Object[]) pre.invokeWithArguments(args); if (verbosity >= 4) { System.out.println("pre-checked: expected " + Arrays.asList(preCheckedResults[i]) + ", actual " + Arrays.asList(preResults)); } if (verbosity >= 6) { System.out.println("post-handle: " + post); } Object[] postResults = (Object[]) post.invokeWithArguments(args); if (verbosity >= 4) { System.out.println("post-checked: expected " + Arrays.asList(postCheckedResults[i]) + ", actual " + Arrays.asList(postResults)); } assertArrayEquals(preCheckedResults[i], preResults); assertArrayEquals(postCheckedResults[i], postResults); } } static void toClauseMajor(MethodHandle[][] clauses, MethodHandle[] init, MethodHandle[] step, MethodHandle[] pred, MethodHandle[] fini) { for (int i = 0; i < clauses.length; ++i) { clauses[i][0] = init[i]; clauses[i][1] = step[i]; clauses[i][2] = pred[i]; clauses[i][3] = fini[i]; } } static boolean loopIntPred(int a) { if (verbosity >= 5) { System.out.println("int pred " + a + " -> " + (a < 7)); } return a < 7; } static boolean loopDoublePred(int a, double b) { if (verbosity >= 5) { System.out.println("double pred (a=" + a + ") " + b + " -> " + (b > 0.5)); } return b > 0.5; } static boolean loopStringPred(int a, double b, String c) { if (verbosity >= 5) { System.out.println("String pred (a=" + a + ",b=" + b + ") " + c + " -> " + (c.length() <= 9)); } return c.length() <= 9; } static int loopIntStep(int a) { if (verbosity >= 5) { System.out.println("int step " + a + " -> " + (a + 1)); } return a + 1; } static double loopDoubleStep(int a, double b) { if (verbosity >= 5) { System.out.println("double step (a=" + a + ") " + b + " -> " + (b / 2.0)); } return b / 2.0; } static String loopStringStep(int a, double b, String c) { if (verbosity >= 5) { System.out.println("String step (a=" + a + ",b=" + b + ") " + c + " -> " + (c + a)); } return c + a; } @Test public void testThrowException() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testThrowException0); } public void testThrowException0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("throwException"); testThrowException(int.class, new ClassCastException("testing")); testThrowException(void.class, new java.io.IOException("testing")); testThrowException(String.class, new LinkageError("testing")); } void testThrowException(Class returnType, Throwable thrown) throws Throwable { countTest(); Class exType = thrown.getClass(); MethodHandle target = MethodHandles.throwException(returnType, exType); //System.out.println("throwing with "+target+" : "+thrown); MethodType expectedType = MethodType.methodType(returnType, exType); assertEquals(expectedType, target.type()); target = target.asType(target.type().generic()); Throwable caught = null; try { Object res = target.invokeExact((Object) thrown); fail("got "+res+" instead of throwing "+thrown); } catch (Throwable ex) { if (ex != thrown) { if (ex instanceof Error) throw (Error)ex; if (ex instanceof RuntimeException) throw (RuntimeException)ex; } caught = ex; } assertSame(thrown, caught); } @Test public void testTryFinally() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testTryFinally0); } public void testTryFinally0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("tryFinally"); String inputMessage = "returned"; String augmentedMessage = "augmented"; String thrownMessage = "thrown"; String rethrownMessage = "rethrown"; // Test these cases: // * target returns, cleanup passes through // * target returns, cleanup augments // * target throws, cleanup augments and returns // * target throws, cleanup augments and rethrows MethodHandle target = MethodHandles.identity(String.class); MethodHandle targetThrow = MethodHandles.dropArguments( MethodHandles.throwException(String.class, Exception.class).bindTo(new Exception(thrownMessage)), 0, String.class); MethodHandle cleanupPassThrough = MethodHandles.dropArguments(MethodHandles.identity(String.class), 0, Throwable.class, String.class); MethodHandle cleanupAugment = MethodHandles.dropArguments(MethodHandles.constant(String.class, augmentedMessage), 0, Throwable.class, String.class, String.class); MethodHandle cleanupCatch = MethodHandles.dropArguments(MethodHandles.constant(String.class, thrownMessage), 0, Throwable.class, String.class, String.class); MethodHandle cleanupThrow = MethodHandles.dropArguments(MethodHandles.throwException(String.class, Exception.class). bindTo(new Exception(rethrownMessage)), 0, Throwable.class, String.class, String.class); testTryFinally(target, cleanupPassThrough, inputMessage, inputMessage, false); testTryFinally(target, cleanupAugment, inputMessage, augmentedMessage, false); testTryFinally(targetThrow, cleanupCatch, inputMessage, thrownMessage, true); testTryFinally(targetThrow, cleanupThrow, inputMessage, rethrownMessage, true); // Test the same cases as above for void targets and cleanups. MethodHandles.Lookup lookup = MethodHandles.lookup(); Class C = this.getClass(); MethodType targetType = methodType(void.class, String[].class); MethodType cleanupType = methodType(void.class, Throwable.class, String[].class); MethodHandle vtarget = lookup.findStatic(C, "vtarget", targetType); MethodHandle vtargetThrow = lookup.findStatic(C, "vtargetThrow", targetType); MethodHandle vcleanupPassThrough = lookup.findStatic(C, "vcleanupPassThrough", cleanupType); MethodHandle vcleanupAugment = lookup.findStatic(C, "vcleanupAugment", cleanupType); MethodHandle vcleanupCatch = lookup.findStatic(C, "vcleanupCatch", cleanupType); MethodHandle vcleanupThrow = lookup.findStatic(C, "vcleanupThrow", cleanupType); testTryFinally(vtarget, vcleanupPassThrough, inputMessage, inputMessage, false); testTryFinally(vtarget, vcleanupAugment, inputMessage, augmentedMessage, false); testTryFinally(vtargetThrow, vcleanupCatch, inputMessage, thrownMessage, true); testTryFinally(vtargetThrow, vcleanupThrow, inputMessage, rethrownMessage, true); } void testTryFinally(MethodHandle target, MethodHandle cleanup, String input, String msg, boolean mustCatch) throws Throwable { countTest(); MethodHandle tf = MethodHandles.tryFinally(target, cleanup); String result = null; boolean isVoid = target.type().returnType() == void.class; String[] argArray = new String[]{input}; try { if (isVoid) { tf.invoke(argArray); } else { result = (String) tf.invoke(input); } } catch (Throwable t) { assertTrue(mustCatch); assertEquals(msg, t.getMessage()); return; } assertFalse(mustCatch); if (isVoid) { assertEquals(msg, argArray[0]); } else { assertEquals(msg, result); } } static void vtarget(String[] a) { // naught, akin to identity } static void vtargetThrow(String[] a) throws Exception { throw new Exception("thrown"); } static void vcleanupPassThrough(Throwable t, String[] a) { assertNull(t); // naught, akin to identity } static void vcleanupAugment(Throwable t, String[] a) { assertNull(t); a[0] = "augmented"; } static void vcleanupCatch(Throwable t, String[] a) { assertNotNull(t); a[0] = "caught"; } static void vcleanupThrow(Throwable t, String[] a) throws Exception { assertNotNull(t); throw new Exception("rethrown"); } @Test public void testInterfaceCast() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testInterfaceCast0); } public void testInterfaceCast0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("interfaceCast"); assert( (((Object)"foo") instanceof CharSequence)); assert(!(((Object)"foo") instanceof Iterable)); for (MethodHandle mh : new MethodHandle[]{ MethodHandles.identity(String.class), MethodHandles.identity(CharSequence.class), MethodHandles.identity(Iterable.class) }) { if (verbosity > 0) System.out.println("-- mh = "+mh); for (Class ctype : new Class[]{ Object.class, String.class, CharSequence.class, Number.class, Iterable.class }) { if (verbosity > 0) System.out.println("---- ctype = "+ctype.getName()); // doret docast testInterfaceCast(mh, ctype, false, false); testInterfaceCast(mh, ctype, true, false); testInterfaceCast(mh, ctype, false, true); testInterfaceCast(mh, ctype, true, true); } } } private static Class i2o(Class c) { return (c.isInterface() ? Object.class : c); } public void testInterfaceCast(MethodHandle mh, Class ctype, boolean doret, boolean docast) throws Throwable { MethodHandle mh0 = mh; if (verbosity > 1) System.out.println("mh="+mh+", ctype="+ctype.getName()+", doret="+doret+", docast="+docast); String normalRetVal = "normal return value"; MethodType mt = mh.type(); MethodType mt0 = mt; if (doret) mt = mt.changeReturnType(ctype); else mt = mt.changeParameterType(0, ctype); if (docast) mh = MethodHandles.explicitCastArguments(mh, mt); else mh = mh.asType(mt); assertEquals(mt, mh.type()); MethodType mt1 = mt; // this bit is needed to make the interface types disappear for invokeWithArguments: mh = MethodHandles.explicitCastArguments(mh, mt.generic()); Class[] step = { mt1.parameterType(0), // param as passed to mh at first mt0.parameterType(0), // param after incoming cast mt0.returnType(), // return value before cast mt1.returnType(), // return value after outgoing cast }; // where might a checkCast occur? boolean[] checkCast = new boolean[step.length]; // the string value must pass each step without causing an exception if (!docast) { if (!doret) { if (step[0] != step[1]) checkCast[1] = true; // incoming value is cast } else { if (step[2] != step[3]) checkCast[3] = true; // outgoing value is cast } } boolean expectFail = false; for (int i = 0; i < step.length; i++) { Class c = step[i]; if (!checkCast[i]) c = i2o(c); if (!c.isInstance(normalRetVal)) { if (verbosity > 3) System.out.println("expect failure at step "+i+" in "+Arrays.toString(step)+Arrays.toString(checkCast)); expectFail = true; break; } } countTest(!expectFail); if (verbosity > 2) System.out.println("expectFail="+expectFail+", mt="+mt); Object res; try { res = mh.invokeWithArguments(normalRetVal); } catch (Exception ex) { res = ex; } boolean sawFail = !(res instanceof String); if (sawFail != expectFail) { System.out.println("*** testInterfaceCast: mh0 = "+mh0); System.out.println(" retype using "+(docast ? "explicitCastArguments" : "asType")+" to "+mt+" => "+mh); System.out.println(" call returned "+res); System.out.println(" expected "+(expectFail ? "an exception" : normalRetVal)); } if (!expectFail) { assertFalse(res.toString(), sawFail); assertEquals(normalRetVal, res); } else { assertTrue(res.toString(), sawFail); } } @Test // SLOW public void testCastFailure() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testCastFailure0); } public void testCastFailure0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("testCastFailure"); testCastFailure("cast/argument", 11000); if (CAN_TEST_LIGHTLY) return; testCastFailure("unbox/argument", 11000); testCastFailure("cast/return", 11000); testCastFailure("unbox/return", 11000); } static class Surprise { public MethodHandle asMethodHandle() { return VALUE.bindTo(this); } Object value(Object x) { trace("value", x); if (boo != null) return boo; return x; } Object boo; void boo(Object x) { boo = x; } static void trace(String x, Object y) { if (verbosity > 8) System.out.println(x+"="+y); } static Object refIdentity(Object x) { trace("ref.x", x); return x; } static Integer boxIdentity(Integer x) { trace("box.x", x); return x; } static int intIdentity(int x) { trace("int.x", x); return x; } static MethodHandle VALUE, REF_IDENTITY, BOX_IDENTITY, INT_IDENTITY; static { try { VALUE = PRIVATE.findVirtual( Surprise.class, "value", MethodType.methodType(Object.class, Object.class)); REF_IDENTITY = PRIVATE.findStatic( Surprise.class, "refIdentity", MethodType.methodType(Object.class, Object.class)); BOX_IDENTITY = PRIVATE.findStatic( Surprise.class, "boxIdentity", MethodType.methodType(Integer.class, Integer.class)); INT_IDENTITY = PRIVATE.findStatic( Surprise.class, "intIdentity", MethodType.methodType(int.class, int.class)); } catch (NoSuchMethodException | IllegalAccessException ex) { throw new RuntimeException(ex); } } } @SuppressWarnings("ConvertToStringSwitch") void testCastFailure(String mode, int okCount) throws Throwable { countTest(false); if (verbosity > 2) System.out.println("mode="+mode); Surprise boo = new Surprise(); MethodHandle identity = Surprise.REF_IDENTITY, surprise0 = boo.asMethodHandle(), surprise = surprise0; if (mode.endsWith("/return")) { if (mode.equals("unbox/return")) { // fail on return to ((Integer)surprise).intValue surprise = surprise.asType(MethodType.methodType(int.class, Object.class)); identity = identity.asType(MethodType.methodType(int.class, Object.class)); } else if (mode.equals("cast/return")) { // fail on return to (Integer)surprise surprise = surprise.asType(MethodType.methodType(Integer.class, Object.class)); identity = identity.asType(MethodType.methodType(Integer.class, Object.class)); } } else if (mode.endsWith("/argument")) { MethodHandle callee = null; if (mode.equals("unbox/argument")) { // fail on handing surprise to int argument callee = Surprise.INT_IDENTITY; } else if (mode.equals("cast/argument")) { // fail on handing surprise to Integer argument callee = Surprise.BOX_IDENTITY; } if (callee != null) { callee = callee.asType(MethodType.genericMethodType(1)); surprise = MethodHandles.filterArguments(callee, 0, surprise); identity = MethodHandles.filterArguments(callee, 0, identity); } } assertNotSame(mode, surprise, surprise0); identity = identity.asType(MethodType.genericMethodType(1)); surprise = surprise.asType(MethodType.genericMethodType(1)); Object x = 42; for (int i = 0; i < okCount; i++) { Object y = identity.invokeExact(x); assertEquals(x, y); Object z = surprise.invokeExact(x); assertEquals(x, z); } boo.boo("Boo!"); Object y = identity.invokeExact(x); assertEquals(x, y); try { Object z = surprise.invokeExact(x); System.out.println("Failed to throw; got z="+z); assertTrue(false); } catch (ClassCastException ex) { if (verbosity > 2) System.out.println("caught "+ex); if (verbosity > 3) ex.printStackTrace(System.out); assertTrue(true); // all is well } } static Example userMethod(Object o, String s, int i) { called("userMethod", o, s, i); return null; } @Test public void testUserClassInSignature() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testUserClassInSignature0); } public void testUserClassInSignature0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("testUserClassInSignature"); Lookup lookup = MethodHandles.lookup(); String name; MethodType mt; MethodHandle mh; Object[] args; // Try a static method. name = "userMethod"; mt = MethodType.methodType(Example.class, Object.class, String.class, int.class); mh = lookup.findStatic(lookup.lookupClass(), name, mt); assertEquals(mt, mh.type()); assertEquals(Example.class, mh.type().returnType()); args = randomArgs(mh.type().parameterArray()); mh.invokeWithArguments(args); assertCalled(name, args); // Try a virtual method. name = "v2"; mt = MethodType.methodType(Object.class, Object.class, int.class); mh = lookup.findVirtual(Example.class, name, mt); assertEquals(mt, mh.type().dropParameterTypes(0,1)); assertTrue(mh.type().parameterList().contains(Example.class)); args = randomArgs(mh.type().parameterArray()); mh.invokeWithArguments(args); assertCalled(name, args); } static void runForRunnable() { called("runForRunnable"); } public interface Fooable { // overloads: Object foo(Object x, String y); List foo(String x, int y); Object foo(String x); } static Object fooForFooable(String x, Object... y) { return called("fooForFooable/"+x, y); } @SuppressWarnings("serial") // not really a public API, just a test case public static class MyCheckedException extends Exception { } public interface WillThrow { void willThrow() throws MyCheckedException; } /*non-public*/ interface PrivateRunnable { public void run(); } @Test public void testAsInterfaceInstance() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testAsInterfaceInstance0); } public void testAsInterfaceInstance0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("asInterfaceInstance"); Lookup lookup = MethodHandles.lookup(); // test typical case: Runnable.run { countTest(); if (verbosity >= 2) System.out.println("Runnable"); MethodType mt = MethodType.methodType(void.class); MethodHandle mh = lookup.findStatic(MethodHandlesTest.class, "runForRunnable", mt); Runnable proxy = MethodHandleProxies.asInterfaceInstance(Runnable.class, mh); proxy.run(); assertCalled("runForRunnable"); } // well known single-name overloaded interface: Appendable.append { countTest(); if (verbosity >= 2) System.out.println("Appendable"); ArrayList> appendResults = new ArrayList<>(); MethodHandle append = lookup.bind(appendResults, "add", MethodType.methodType(boolean.class, Object.class)); append = append.asType(MethodType.methodType(void.class, List.class)); // specialize the type MethodHandle asList = lookup.findStatic(Arrays.class, "asList", MethodType.methodType(List.class, Object[].class)); MethodHandle mh = MethodHandles.filterReturnValue(asList, append).asVarargsCollector(Object[].class); Appendable proxy = MethodHandleProxies.asInterfaceInstance(Appendable.class, mh); proxy.append("one"); proxy.append("two", 3, 4); proxy.append('5'); assertEquals(Arrays.asList(Arrays.asList("one"), Arrays.asList("two", 3, 4), Arrays.asList('5')), appendResults); if (verbosity >= 3) System.out.println("appendResults="+appendResults); appendResults.clear(); Formatter formatter = new Formatter(proxy); String fmt = "foo str=%s char='%c' num=%d"; Object[] fmtArgs = { "str!", 'C', 42 }; String expect = String.format(fmt, fmtArgs); formatter.format(fmt, fmtArgs); String actual = ""; if (verbosity >= 3) System.out.println("appendResults="+appendResults); for (List l : appendResults) { Object x = l.get(0); switch (l.size()) { case 1: actual += x; continue; case 3: actual += ((String)x).substring((int)(Object)l.get(1), (int)(Object)l.get(2)); continue; } actual += l; } if (verbosity >= 3) System.out.println("expect="+expect); if (verbosity >= 3) System.out.println("actual="+actual); assertEquals(expect, actual); } // test case of an single name which is overloaded: Fooable.foo(...) { if (verbosity >= 2) System.out.println("Fooable"); MethodHandle mh = lookup.findStatic(MethodHandlesTest.class, "fooForFooable", MethodType.methodType(Object.class, String.class, Object[].class)); Fooable proxy = MethodHandleProxies.asInterfaceInstance(Fooable.class, mh); for (Method m : Fooable.class.getDeclaredMethods()) { countTest(); assertSame("foo", m.getName()); if (verbosity > 3) System.out.println("calling "+m); MethodHandle invoker = lookup.unreflect(m); MethodType mt = invoker.type(); Class[] types = mt.parameterArray(); types[0] = int.class; // placeholder Object[] args = randomArgs(types); args[0] = proxy; if (verbosity > 3) System.out.println("calling "+m+" on "+Arrays.asList(args)); Object result = invoker.invokeWithArguments(args); if (verbosity > 4) System.out.println("result = "+result); String name = "fooForFooable/"+args[1]; Object[] argTail = Arrays.copyOfRange(args, 2, args.length); assertCalled(name, argTail); assertEquals(result, logEntry(name, argTail)); } } // test processing of thrown exceptions: for (Throwable ex : new Throwable[] { new NullPointerException("ok"), new InternalError("ok"), new Throwable("fail"), new Exception("fail"), new MyCheckedException() }) { MethodHandle mh = MethodHandles.throwException(void.class, Throwable.class); mh = MethodHandles.insertArguments(mh, 0, ex); WillThrow proxy = MethodHandleProxies.asInterfaceInstance(WillThrow.class, mh); try { countTest(); proxy.willThrow(); System.out.println("Failed to throw: "+ex); assertTrue(false); } catch (Throwable ex1) { if (verbosity > 3) { System.out.println("throw "+ex); System.out.println("catch "+(ex == ex1 ? "UNWRAPPED" : ex1)); } if (ex instanceof RuntimeException || ex instanceof Error) { assertSame("must pass unchecked exception out without wrapping", ex, ex1); } else if (ex instanceof MyCheckedException) { assertSame("must pass declared exception out without wrapping", ex, ex1); } else { assertNotSame("must pass undeclared checked exception with wrapping", ex, ex1); if (!(ex1 instanceof UndeclaredThrowableException) || ex1.getCause() != ex) { ex1.printStackTrace(System.out); } assertSame(ex, ex1.getCause()); UndeclaredThrowableException utex = (UndeclaredThrowableException) ex1; } } } // Test error checking on bad interfaces: for (Class nonSMI : new Class[] { Object.class, String.class, CharSequence.class, java.io.Serializable.class, PrivateRunnable.class, Example.class }) { if (verbosity > 2) System.out.println(nonSMI.getName()); try { countTest(false); MethodHandleProxies.asInterfaceInstance(nonSMI, varargsArray(0)); assertTrue("Failed to throw on "+nonSMI.getName(), false); } catch (IllegalArgumentException ex) { if (verbosity > 2) System.out.println(nonSMI.getSimpleName()+": "+ex); // Object: java.lang.IllegalArgumentException: // not a public interface: java.lang.Object // String: java.lang.IllegalArgumentException: // not a public interface: java.lang.String // CharSequence: java.lang.IllegalArgumentException: // not a single-method interface: java.lang.CharSequence // Serializable: java.lang.IllegalArgumentException: // not a single-method interface: java.io.Serializable // PrivateRunnable: java.lang.IllegalArgumentException: // not a public interface: test.java.lang.invoke.MethodHandlesTest$PrivateRunnable // Example: java.lang.IllegalArgumentException: // not a public interface: test.java.lang.invoke.MethodHandlesTest$Example } } // Test error checking on interfaces with the wrong method type: for (Class intfc : new Class[] { Runnable.class /*arity 0*/, Fooable.class /*arity 1 & 2*/ }) { int badArity = 1; // known to be incompatible if (verbosity > 2) System.out.println(intfc.getName()); try { countTest(false); MethodHandleProxies.asInterfaceInstance(intfc, varargsArray(badArity)); assertTrue("Failed to throw on "+intfc.getName(), false); } catch (WrongMethodTypeException ex) { if (verbosity > 2) System.out.println(intfc.getSimpleName()+": "+ex); // Runnable: java.lang.invoke.WrongMethodTypeException: // cannot convert MethodHandle(Object)Object[] to ()void // Fooable: java.lang.invoke.WrongMethodTypeException: // cannot convert MethodHandle(Object)Object[] to (Object,String)Object } } } @Test public void testRunnableProxy() throws Throwable { CodeCacheOverflowProcessor.runMHTest(this::testRunnableProxy0); } public void testRunnableProxy0() throws Throwable { if (CAN_SKIP_WORKING) return; startTest("testRunnableProxy"); MethodHandles.Lookup lookup = MethodHandles.lookup(); MethodHandle run = lookup.findStatic(lookup.lookupClass(), "runForRunnable", MethodType.methodType(void.class)); Runnable r = MethodHandleProxies.asInterfaceInstance(Runnable.class, run); testRunnableProxy(r); assertCalled("runForRunnable"); } private static void testRunnableProxy(Runnable r) { //7058630: JSR 292 method handle proxy violates contract for Object methods r.run(); Object o = r; r = null; boolean eq = (o == o); int hc = System.identityHashCode(o); String st = o.getClass().getName() + "@" + Integer.toHexString(hc); Object expect = Arrays.asList(st, eq, hc); if (verbosity >= 2) System.out.println("expect st/eq/hc = "+expect); Object actual = Arrays.asList(o.toString(), o.equals(o), o.hashCode()); if (verbosity >= 2) System.out.println("actual st/eq/hc = "+actual); assertEquals(expect, actual); } } // Local abbreviated copy of sun.invoke.util.ValueConversions // This guy tests access from outside the same package member, but inside // the package itself. class ValueConversions { private static final Lookup IMPL_LOOKUP = MethodHandles.lookup(); private static final Object[] NO_ARGS_ARRAY = {}; private static Object[] makeArray(Object... args) { return args; } private static Object[] array() { return NO_ARGS_ARRAY; } private static Object[] array(Object a0) { return makeArray(a0); } private static Object[] array(Object a0, Object a1) { return makeArray(a0, a1); } private static Object[] array(Object a0, Object a1, Object a2) { return makeArray(a0, a1, a2); } private static Object[] array(Object a0, Object a1, Object a2, Object a3) { return makeArray(a0, a1, a2, a3); } private static Object[] array(Object a0, Object a1, Object a2, Object a3, Object a4) { return makeArray(a0, a1, a2, a3, a4); } private static Object[] array(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return makeArray(a0, a1, a2, a3, a4, a5); } private static Object[] array(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return makeArray(a0, a1, a2, a3, a4, a5, a6); } private static Object[] array(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7); } private static Object[] array(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7, a8); } private static Object[] array(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return makeArray(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } static MethodHandle[] makeArrays() { ArrayList arrays = new ArrayList<>(); MethodHandles.Lookup lookup = IMPL_LOOKUP; for (;;) { int nargs = arrays.size(); MethodType type = MethodType.genericMethodType(nargs).changeReturnType(Object[].class); String name = "array"; MethodHandle array = null; try { array = lookup.findStatic(ValueConversions.class, name, type); } catch (ReflectiveOperationException ex) { // break from loop! } if (array == null) break; arrays.add(array); } assertTrue(arrays.size() == 11); // current number of methods return arrays.toArray(new MethodHandle[0]); } static final MethodHandle[] ARRAYS = makeArrays(); /** Return a method handle that takes the indicated number of Object * arguments and returns an Object array of them, as if for varargs. */ public static MethodHandle varargsArray(int nargs) { if (nargs < ARRAYS.length) return ARRAYS[nargs]; return MethodHandles.identity(Object[].class).asCollector(Object[].class, nargs); } public static MethodHandle varargsArray(Class arrayType, int nargs) { Class elemType = arrayType.getComponentType(); MethodType vaType = MethodType.methodType(arrayType, Collections.>nCopies(nargs, elemType)); MethodHandle mh = varargsArray(nargs); if (arrayType != Object[].class) mh = MethodHandles.filterReturnValue(mh, CHANGE_ARRAY_TYPE.bindTo(arrayType)); return mh.asType(vaType); } static Object changeArrayType(Class arrayType, Object[] a) { Class elemType = arrayType.getComponentType(); if (!elemType.isPrimitive()) return Arrays.copyOf(a, a.length, arrayType.asSubclass(Object[].class)); Object b = java.lang.reflect.Array.newInstance(elemType, a.length); for (int i = 0; i < a.length; i++) java.lang.reflect.Array.set(b, i, a[i]); return b; } private static final MethodHandle CHANGE_ARRAY_TYPE; static { try { CHANGE_ARRAY_TYPE = IMPL_LOOKUP.findStatic(ValueConversions.class, "changeArrayType", MethodType.methodType(Object.class, Class.class, Object[].class)); } catch (NoSuchMethodException | IllegalAccessException ex) { Error err = new InternalError("uncaught exception"); err.initCause(ex); throw err; } } private static final List NO_ARGS_LIST = Arrays.asList(NO_ARGS_ARRAY); private static List makeList(Object... args) { return Arrays.asList(args); } private static List list() { return NO_ARGS_LIST; } private static List list(Object a0) { return makeList(a0); } private static List list(Object a0, Object a1) { return makeList(a0, a1); } private static List list(Object a0, Object a1, Object a2) { return makeList(a0, a1, a2); } private static List list(Object a0, Object a1, Object a2, Object a3) { return makeList(a0, a1, a2, a3); } private static List list(Object a0, Object a1, Object a2, Object a3, Object a4) { return makeList(a0, a1, a2, a3, a4); } private static List list(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5) { return makeList(a0, a1, a2, a3, a4, a5); } private static List list(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6) { return makeList(a0, a1, a2, a3, a4, a5, a6); } private static List list(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7) { return makeList(a0, a1, a2, a3, a4, a5, a6, a7); } private static List list(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8) { return makeList(a0, a1, a2, a3, a4, a5, a6, a7, a8); } private static List list(Object a0, Object a1, Object a2, Object a3, Object a4, Object a5, Object a6, Object a7, Object a8, Object a9) { return makeList(a0, a1, a2, a3, a4, a5, a6, a7, a8, a9); } static MethodHandle[] makeLists() { ArrayList lists = new ArrayList<>(); MethodHandles.Lookup lookup = IMPL_LOOKUP; for (;;) { int nargs = lists.size(); MethodType type = MethodType.genericMethodType(nargs).changeReturnType(List.class); String name = "list"; MethodHandle list = null; try { list = lookup.findStatic(ValueConversions.class, name, type); } catch (ReflectiveOperationException ex) { // break from loop! } if (list == null) break; lists.add(list); } assertTrue(lists.size() == 11); // current number of methods return lists.toArray(new MethodHandle[0]); } static final MethodHandle[] LISTS = makeLists(); static final MethodHandle AS_LIST; static { try { AS_LIST = IMPL_LOOKUP.findStatic(Arrays.class, "asList", MethodType.methodType(List.class, Object[].class)); } catch (NoSuchMethodException | IllegalAccessException ex) { throw new RuntimeException(ex); } } /** Return a method handle that takes the indicated number of Object * arguments and returns List. */ public static MethodHandle varargsList(int nargs) { if (nargs < LISTS.length) return LISTS[nargs]; return AS_LIST.asCollector(Object[].class, nargs); } } // This guy tests access from outside the same package member, but inside // the package itself. class PackageSibling { static Lookup lookup() { return MethodHandles.lookup(); } }