--- a/jdk/test/java/dyn/MethodHandlesTest.java Thu Mar 31 19:09:02 2011 -0700
+++ /dev/null Thu Jan 01 00:00:00 1970 +0000
@@ -1,2400 +0,0 @@
-/*
- * Copyright (c) 2009, 2011, Oracle and/or its affiliates. All rights reserved.
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- *
- * This code is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 only, as
- * published by the Free Software Foundation. Oracle designates this
- * particular file as subject to the "Classpath" exception as provided
- * by Oracle in the LICENSE file that accompanied this code.
- *
- * This code is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- * version 2 for more details (a copy is included in the LICENSE file that
- * accompanied this code).
- *
- * You should have received a copy of the GNU General Public License version
- * 2 along with this work; if not, write to the Free Software Foundation,
- * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- *
- * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
- * or visit www.oracle.com if you need additional information or have any
- * questions.
- */
-
-/* @test
- * @summary unit tests for java.dyn.MethodHandles
- * @compile -source 7 -target 7 -XDallowTransitionalJSR292=no MethodHandlesTest.java
- * @run junit/othervm -XX:+UnlockExperimentalVMOptions -XX:+EnableMethodHandles test.java.dyn.MethodHandlesTest
- */
-
-package test.java.dyn;
-
-import java.dyn.*;
-import java.dyn.MethodHandles.Lookup;
-import java.lang.reflect.*;
-import java.util.*;
-import org.junit.*;
-import static org.junit.Assert.*;
-import static org.junit.Assume.*;
-
-
-/**
- *
- * @author jrose
- */
-public class MethodHandlesTest {
- // How much output?
- static int verbosity = 0;
- static {
- String vstr = System.getProperty("test.java.dyn.MethodHandlesTest.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 boolean CAN_SKIP_WORKING = false;
- //static { CAN_SKIP_WORKING = true; }
-
- // Set true to test more calls. If false, some tests are just
- // lookups, without exercising the actual method handle.
- static boolean DO_MORE_CALLS = true;
-
- @Test
- public void testFirst() throws Throwable {
- verbosity += 9; try {
- // left blank for debugging
- } finally { printCounts(); verbosity -= 9; }
- }
-
- // current failures
- @Test @Ignore("failure in call to makeRawRetypeOnly in ToGeneric")
- public void testFail_1() throws Throwable {
- // AMH.<init>: IllegalArgumentException: bad adapter (conversion=0xfffab300): adapter pushes too many parameters
- testSpreadArguments(int.class, 0, 6);
- }
- @Test @Ignore("failure in JVM when expanding the stack using asm stub for _adapter_spread_args")
- public void testFail_2() throws Throwable {
- // if CONV_OP_IMPLEMENTED_MASK includes OP_SPREAD_ARGS, this crashes:
- testSpreadArguments(Object.class, 0, 2);
- }
- @Test @Ignore("IllArgEx failure in call to ToGeneric.make")
- public void testFail_3() throws Throwable {
- // ToGeneric.<init>: UnsupportedOperationException: NYI: primitive parameters must follow references; entryType = (int,java.lang.Object)java.lang.Object
- testSpreadArguments(int.class, 1, 2);
- }
- @Test @Ignore("IllArgEx failure in call to ToGeneric.make")
- public void testFail_4() throws Throwable {
- // ToGeneric.<init>: UnsupportedOperationException: NYI: primitive parameters must follow references; entryType = (int,java.lang.Object)java.lang.Object
- testCollectArguments(int.class, 1, 2);
- }
- @Test @Ignore("cannot collect leading primitive types")
- public void testFail_5() throws Throwable {
- // ToGeneric.<init>: UnsupportedOperationException: NYI: primitive parameters must follow references; entryType = (int,java.lang.Object)java.lang.Object
- testInvokers(MethodType.genericMethodType(2).changeParameterType(0, int.class));
- }
- @Test @Ignore("should not insert arguments beyond MethodHandlePushLimit")
- public void testFail_6() throws Throwable {
- // ValueConversions.varargsArray: UnsupportedOperationException: NYI: cannot form a varargs array of length 13
- testInsertArguments(0, 0, MAX_ARG_INCREASE+10);
- }
- static final int MAX_ARG_INCREASE = 3;
-
- public MethodHandlesTest() {
- }
-
- @Before
- public void checkImplementedPlatform() {
- boolean platformOK = false;
- Properties properties = System.getProperties();
- String vers = properties.getProperty("java.vm.version");
- String name = properties.getProperty("java.vm.name");
- String arch = properties.getProperty("os.arch");
- if ((arch.equals("amd64") || arch.equals("i386") || arch.equals("x86") ||
- arch.equals("sparc") || arch.equals("sparcv9")) &&
- (name.contains("Client") || name.contains("Server"))
- ) {
- platformOK = true;
- } else {
- System.err.println("Skipping tests for unsupported platform: "+Arrays.asList(vers, name, arch));
- }
- assumeTrue(platformOK);
- }
-
- 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 >= 2 && (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<Object> calledLog = new ArrayList<Object>();
- static Object logEntry(String name, Object... args) {
- return Arrays.asList(name, Arrays.asList(args));
- }
- 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: "+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+Arrays.toString(args));
- }
-
- 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);
- }
-
- 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.dyn.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.isInterface() || param.isAssignableFrom(String.class))
- return "#"+nextArg();
- else
- try {
- return param.newInstance();
- } catch (InstantiationException ex) {
- } catch (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 <T, E extends T> T[] array(Class<T[]> atype, E... a) {
- return Arrays.copyOf(a, a.length, atype);
- }
- static <T> 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);
- }
- /** 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 (Exception 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 (Exception 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);
- }
- 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<Class<?>> argTypes = new ArrayList<Class<?>>(targetType.parameterList());
- Collections.fill(argTypes.subList(beg, end), argType);
- MethodType ttype2 = MethodType.methodType(targetType.returnType(), argTypes);
- return MethodHandles.convertArguments(target, ttype2);
- }
-
- // 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 only for public members.
- 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; }
- protected Example(int x) { this(); called("protected <init>", this, x); }
- @Override public String toString() { return name; }
-
- public void v0() { called("v0", this); }
- void pkg_v0() { called("pkg_v0", this); }
- private void pri_v0() { called("pri_v0", this); }
- public static void s0() { called("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); }
-
- static final Lookup EXAMPLE = MethodHandles.lookup(); // for testing findSpecial
- }
- static final Lookup EXAMPLE = Example.EXAMPLE;
- public static class PubExample extends Example {
- public PubExample() { super("PubExample#"+nextArg()); }
- }
- static class SubExample extends Example {
- @Override public void v0() { called("Sub/v0", this); }
- @Override void pkg_v0() { called("Sub/pkg_v0", this); }
- private SubExample(int x) { called("<init>", this, x); }
- public SubExample() { super("SubExample#"+nextArg()); }
- }
- public static interface IntExample {
- public void v0();
- 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 final Object[][][] ACCESS_CASES = {
- { { false, PUBLIC }, { false, PACKAGE }, { false, PRIVATE }, { false, EXAMPLE } }, //[0]: all false
- { { false, PUBLIC }, { false, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[1]: only PRIVATE
- { { false, PUBLIC }, { true, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[2]: PUBLIC false
- { { true, PUBLIC }, { true, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[3]: 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 {
- assertTrue(name.indexOf('_') < 0);
- boolean pubc = Modifier.isPublic(defc.getModifiers());
- if (pubc)
- cases = ACCESS_CASES[3]; // 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);
- }
-
- @Test
- public void testFindStatic() 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, 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");
- }
-
- 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);
- 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 = lookup.in(defc).findStatic(defc, name, type);
- } catch (ReflectiveOperationException ex) {
- noAccess = ex;
- if (name.contains("bogus"))
- assertTrue(noAccess instanceof NoSuchMethodException);
- else
- assertTrue(noAccess instanceof IllegalAccessException);
- }
- 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, name);
- if (!DO_MORE_CALLS && lookup != PRIVATE) return;
- Object[] args = randomArgs(params);
- printCalled(target, name, args);
- target.invokeWithArguments(args);
- assertCalled(name, args);
- if (verbosity >= 1)
- System.out.print(':');
- }
-
- // rough check of name string
- static void assertNameStringContains(Object x, String s) {
- if (x.toString().contains(s)) return;
- assertEquals(s, x);
- }
-
- @Test
- public void testFindVirtual() 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(false, PRIVATE, Example.class, Example.class, void.class, "bogus");
- // 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");
- }
-
- 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<?> 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 = lookup.in(defc).findVirtual(defc, methodName, type);
- } catch (ReflectiveOperationException ex) {
- noAccess = ex;
- if (name.contains("bogus"))
- assertTrue(noAccess instanceof NoSuchMethodException);
- else
- assertTrue(noAccess instanceof IllegalAccessException);
- }
- 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<?>[] paramsWithSelf = cat(array(Class[].class, (Class)defc), params);
- MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);
- assertEquals(typeWithSelf, target.type());
- assertNameStringContains(target, methodName);
- if (!DO_MORE_CALLS && lookup != PRIVATE) return;
- Object[] argsWithSelf = randomArgs(paramsWithSelf);
- if (rcvc != defc) argsWithSelf[0] = randomArg(rcvc);
- printCalled(target, name, argsWithSelf);
- target.invokeWithArguments(argsWithSelf);
- assertCalled(name, argsWithSelf);
- if (verbosity >= 1)
- System.out.print(':');
- }
-
- @Test
- public void testFindSpecial() throws Throwable {
- if (CAN_SKIP_WORKING) return;
- startTest("findSpecial");
- testFindSpecial(SubExample.class, Example.class, void.class, "v0");
- testFindSpecial(SubExample.class, Example.class, void.class, "pkg_v0");
- // Do some negative testing:
- testFindSpecial(false, EXAMPLE, SubExample.class, Example.class, void.class, "bogus");
- testFindSpecial(false, PRIVATE, SubExample.class, Example.class, void.class, "bogus");
- 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, "<init>", int.class);
- testFindSpecial(false, lookup, SubExample.class, Example.class, void.class, "s0");
- }
- }
-
- void testFindSpecial(Class<?> specialCaller,
- Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {
- testFindSpecial(true, EXAMPLE, specialCaller, defc, ret, name, params);
- testFindSpecial(true, PRIVATE, specialCaller, defc, ret, name, params);
- testFindSpecial(false, PACKAGE, 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);
- 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);
- if (verbosity >= 5) System.out.println(" lookup => "+lookup.in(specialCaller));
- target = lookup.in(specialCaller).findSpecial(defc, name, type, specialCaller);
- } catch (ReflectiveOperationException ex) {
- noAccess = ex;
- if (name.contains("bogus"))
- assertTrue(noAccess instanceof NoSuchMethodException);
- else
- assertTrue(noAccess instanceof IllegalAccessException);
- }
- 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, name);
- if (!DO_MORE_CALLS && lookup != PRIVATE && lookup != EXAMPLE) return;
- Object[] args = randomArgs(paramsWithSelf);
- printCalled(target, name, args);
- target.invokeWithArguments(args);
- assertCalled(name, args);
- }
-
- @Test
- public void testBind() 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(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 = lookup.in(defc).bind(receiver, methodName, type);
- } catch (ReflectiveOperationException ex) {
- noAccess = ex;
- if (name.contains("bogus"))
- assertTrue(noAccess instanceof NoSuchMethodException);
- else
- assertTrue(noAccess instanceof IllegalAccessException);
- }
- 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 {
- if (CAN_SKIP_WORKING) return;
- startTest("unreflect");
- testUnreflect(Example.class, true, void.class, "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);
- }
-
- 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);
- MethodType type = MethodType.methodType(ret, params);
- Method rmethod = defc.getDeclaredMethod(name, 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 = lookup.in(specialCaller).unreflectSpecial(rmethod, specialCaller);
- else
- target = lookup.in(defc).unreflect(rmethod);
- } catch (ReflectiveOperationException ex) {
- noAccess = ex;
- if (name.contains("bogus"))
- assertTrue(noAccess instanceof NoSuchMethodException);
- else
- assertTrue(noAccess instanceof IllegalAccessException);
- }
- 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 {
- 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<Object[]> cases = new ArrayList<Object[]>();
- 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 (Exception ex) {
- throw new InternalError("no field HasFields."+name);
- }
- try {
- value = field.get(fields);
- } catch (Exception 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;
- 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 {
- startTest("unreflectGetter");
- testGetter(TEST_UNREFLECT);
- }
- @Test
- public void testFindGetter() throws Throwable {
- startTest("findGetter");
- testGetter(TEST_FIND_FIELD);
- }
- @Test
- public void testFindStaticGetter() throws Throwable {
- 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);
- }
- 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 positive, MethodHandles.Lookup lookup,
- Object fieldRef, Object value, int testMode0) throws Throwable {
- boolean isGetter = ((testMode0 & TEST_SETTER) == 0);
- int testMode = testMode0 & ~TEST_SETTER;
- 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;
- 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) {
- 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;
- if (fname.contains("bogus"))
- assertTrue(noAccess instanceof NoSuchFieldException);
- else
- assertTrue(noAccess instanceof IllegalAccessException);
- }
- if (verbosity >= 3)
- System.out.println("find"+(isStatic?"Static":"")+(isGetter?"Getter":"Setter")+" "+fclass.getName()+"."+fname+"/"+ftype
- +" => "+mh
- +(noAccess == null ? "" : " !! "+noAccess));
- if (positive && noAccess != null) throw new RuntimeException(noAccess);
- assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, mh != null);
- if (!positive) return; // negative test failed as expected
- assertEquals((isStatic ? 0 : 1)+(isGetter ? 0 : 1), mh.type().parameterCount());
-
-
- assertSame(mh.type(), expType);
- assertNameStringContains(mh, fname);
- HasFields fields = new HasFields();
- Object sawValue;
- Class<?> vtype = ftype;
- if (ftype != int.class) vtype = Object.class;
- if (isGetter) {
- mh = MethodHandles.convertArguments(mh, mh.type().generic()
- .changeReturnType(vtype));
- } else {
- int last = mh.type().parameterCount() - 1;
- mh = MethodHandles.convertArguments(mh, 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
- }
- if (isGetter) {
- Object expValue = value;
- for (int i = 0; i <= 1; i++) {
- if (isStatic) {
- 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) fields);
- else
- sawValue = mh.invokeExact((Object) fields);
- }
- 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);
- if (isStatic) {
- if (ftype == int.class)
- mh.invokeExact((int)putValue); // do these exactly
- else
- mh.invokeExact(putValue);
- } else {
- if (ftype == int.class)
- mh.invokeExact((Object) fields, (int)putValue);
- else
- mh.invokeExact((Object) fields, putValue);
- }
- 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
- }
- }
-
-
- @Test
- public void testUnreflectSetter() throws Throwable {
- startTest("unreflectSetter");
- testSetter(TEST_UNREFLECT);
- }
- @Test
- public void testFindSetter() throws Throwable {
- startTest("findSetter");
- testSetter(TEST_FIND_FIELD);
- }
- @Test
- public void testFindStaticSetter() throws Throwable {
- 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);
- }
- 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 {
- startTest("arrayElementGetter");
- testArrayElementGetterSetter(false);
- }
-
- @Test
- public void testArrayElementSetter() throws Throwable {
- startTest("arrayElementSetter");
- testArrayElementGetterSetter(true);
- }
-
- public void testArrayElementGetterSetter(boolean testSetter) throws Throwable {
- testArrayElementGetterSetter(new Object[10], testSetter);
- testArrayElementGetterSetter(new String[10], testSetter);
- testArrayElementGetterSetter(new boolean[10], testSetter);
- testArrayElementGetterSetter(new byte[10], testSetter);
- testArrayElementGetterSetter(new char[10], testSetter);
- testArrayElementGetterSetter(new short[10], testSetter);
- testArrayElementGetterSetter(new int[10], testSetter);
- testArrayElementGetterSetter(new float[10], testSetter);
- testArrayElementGetterSetter(new long[10], testSetter);
- testArrayElementGetterSetter(new double[10], testSetter);
- }
-
- public void testArrayElementGetterSetter(Object array, boolean testSetter) throws Throwable {
- countTest(true);
- if (verbosity >= 2) System.out.println("array type = "+array.getClass().getComponentType().getName()+"["+Array.getLength(array)+"]");
- Class<?> arrayType = array.getClass();
- Class<?> elemType = arrayType.getComponentType();
- 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;
- if (true) { // FIXME: remove this path (and remove <void> below in the mh.invokes)
- gtype = mh.type().changeParameterType(0, Object.class);
- if (testSetter)
- gtype = gtype.changeParameterType(2, Object.class);
- else
- gtype = gtype.changeReturnType(Object.class);
- } else
- // FIXME: This simpler path hits a bug in convertArguments => ToGeneric
- gtype = mh.type().generic().changeParameterType(1, int.class);
- mh = MethodHandles.convertArguments(mh, gtype);
- }
- Object sawValue, expValue;
- List<Object> model = array2list(array);
- int length = Array.getLength(array);
- for (int i = 0; i < length; i++) {
- // update array element
- Object random = randomArg(elemType);
- model.set(i, random);
- if (testSetter) {
- if (elemType == int.class)
- mh.invokeExact((int[]) array, i, (int)random);
- else if (elemType == boolean.class)
- mh.invokeExact((boolean[]) array, i, (boolean)random);
- else
- mh.invokeExact(array, i, random);
- assertEquals(model, array2list(array));
- } else {
- Array.set(array, i, random);
- }
- if (verbosity >= 5) {
- List<Object> 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;
- if (elemType == int.class)
- sawValue = (int) mh.invokeExact((int[]) array, i);
- else if (elemType == boolean.class)
- sawValue = (boolean) mh.invokeExact((boolean[]) array, i);
- else
- sawValue = mh.invokeExact(array, i);
- assertEquals(sawValue, expValue);
- assertEquals(model, array2list(array));
- }
- }
- }
-
- List<Object> array2list(Object array) {
- int length = Array.getLength(array);
- ArrayList<Object> model = new ArrayList<Object>(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 (Exception ex) {
- throw new RuntimeException(ex);
- }
- }
- }
-
- @Test
- public void testConvertArguments() 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, false, id, rtype, name, params);
- testConvert(true, true, id, rtype, name, params);
- }
-
- void testConvert(boolean positive, boolean useAsType,
- 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 {
- if (useAsType)
- target = id.asType(newType);
- else
- target = MethodHandles.convertArguments(id, newType);
- } catch (RuntimeException 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 {
- 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, true, vac.asType(MethodType.genericMethodType(0)), null, "vac");
- testConvert(true, true, vac.asType(MethodType.genericMethodType(0)), null, "vac");
- for (Class<?> at : new Class[] { Object.class, String.class, Integer.class }) {
- testConvert(true, true, vac.asType(MethodType.genericMethodType(1)), null, "vac", at);
- testConvert(true, true, vac.asType(MethodType.genericMethodType(2)), null, "vac", at, at);
- }
- }
-
- @Test
- public void testPermuteArguments() throws Throwable {
- if (CAN_SKIP_WORKING) return;
- startTest("permuteArguments");
- testPermuteArguments(4, Integer.class, 2, String.class, 0);
- //testPermuteArguments(6, Integer.class, 0, null, 30);
- //testPermuteArguments(4, Integer.class, 1, int.class, 6);
- }
- 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[] reorder = new int[outargs];
- 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++;
- for (int cas = 0; cas < numcases; cas += casStep) {
- for (int i = 0, c = cas; i < outargs; i++) {
- reorder[i] = c % inargs;
- c /= inargs;
- }
- testPermuteArguments(args, types, reorder);
- }
- numcases *= inargs;
- if (dilution > 10 && outargs >= 4) {
- // 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));
- }
- }
- }
- }
- }
- }
-
- 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 = MethodHandles.convertArguments(varargsList(outargs), outType);
- MethodHandle newTarget = MethodHandles.permuteArguments(target, inType, reorder);
- Object result = newTarget.invokeWithArguments(args);
- Object expected = Arrays.asList(permArgs);
- assertEquals(expected, result);
- }
-
-
- @Test
- public void testSpreadArguments() 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);
- // FIXME: enable _adapter_spread_args and fix Fail_2
- for (int nargs = 0; nargs < 10; nargs++) {
- if (argType == int.class && nargs >= 6) continue; // FIXME Fail_1
- for (int pos = 0; pos < nargs; pos++) {
- if (argType == int.class && pos > 0) continue; // FIXME Fail_3
- testSpreadArguments(argType, pos, nargs);
- }
- }
- }
- }
- public void testSpreadArguments(Class<?> argType, int pos, int nargs) throws Throwable {
- countTest();
- MethodHandle target = varargsArray(nargs);
- MethodHandle target2 = changeArgTypes(target, argType);
- 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:
- if (pos == 0 && nargs < 5) {
- Object[] check = (Object[]) target.invokeWithArguments(args);
- assertArrayEquals(args, check);
- switch (nargs) {
- case 0:
- check = (Object[]) target.invokeExact();
- assertArrayEquals(args, check);
- break;
- case 1:
- check = (Object[]) target.invokeExact(args[0]);
- assertArrayEquals(args, check);
- break;
- case 2:
- check = (Object[]) target.invokeExact(args[0], args[1]);
- assertArrayEquals(args, check);
- break;
- }
- }
- List<Class<?>> newParams = new ArrayList<Class<?>>(target2.type().parameterList());
- { // modify newParams in place
- List<Class<?>> spreadParams = newParams.subList(pos, nargs);
- spreadParams.clear(); spreadParams.add(Object[].class);
- }
- MethodType newType = MethodType.methodType(Object.class, newParams);
- MethodHandle result = target2.asSpreader(Object[].class, nargs-pos).asType(newType);
- Object[] returnValue;
- if (pos == 0) {
- // In the following line, the first cast implies
- // normal Object return value for the MH call (Object[])->Object,
- // while the second cast dynamically converts to an Object array.
- // Such a double cast is typical of MH.invokeExact.
- returnValue = (Object[]) (Object) result.invokeExact(args);
- } else {
- Object[] args1 = Arrays.copyOfRange(args, 0, pos+1);
- args1[pos] = Arrays.copyOfRange(args, pos, args.length);
- returnValue = (Object[]) result.invokeWithArguments(args1);
- }
- assertArrayEquals(args, returnValue);
- }
-
- @Test
- public void testCollectArguments() throws Throwable {
- if (CAN_SKIP_WORKING) return;
- startTest("collectArguments");
- for (Class<?> argType : new Class[]{Object.class, Integer.class, int.class}) {
- if (verbosity >= 3)
- System.out.println("collectArguments "+argType);
- for (int nargs = 0; nargs < 10; nargs++) {
- for (int pos = 0; pos < nargs; pos++) {
- if (argType == int.class) continue; // FIXME Fail_4
- testCollectArguments(argType, pos, nargs);
- }
- }
- }
- }
- public void testCollectArguments(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);
- }
-
- @Test
- public void testInsertArguments() throws Throwable {
- if (CAN_SKIP_WORKING) return;
- startTest("insertArguments");
- for (int nargs = 0; nargs <= 4; nargs++) {
- for (int ins = 0; ins <= 4; ins++) {
- if (ins > MAX_ARG_INCREASE) continue; // FIXME Fail_6
- for (int pos = 0; pos <= nargs; pos++) {
- 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<Object> resList = Arrays.asList(args);
- List<Object> argsToPass = new ArrayList<Object>(resList);
- List<Object> argsToInsert = argsToPass.subList(pos, pos + ins);
- if (verbosity >= 3)
- System.out.println("insert: "+argsToInsert+" into "+target);
- 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 {
- 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, //FIXME: add this
- //long.class, //FIXME: add this
- 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 {
- 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 = MethodHandles.convertArguments(filter, 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<Object> 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 testFoldArguments() throws Throwable {
- if (CAN_SKIP_WORKING) return;
- startTest("foldArguments");
- for (int nargs = 0; nargs <= 4; nargs++) {
- for (int fold = 0; fold <= nargs; fold++) {
- for (int pos = 0; pos <= nargs; pos++) {
- testFoldArguments(nargs, pos, fold);
- }
- }
- }
- }
-
- void testFoldArguments(int nargs, int pos, int fold) throws Throwable {
- if (pos != 0) return; // can fold only at pos=0 for now
- countTest();
- MethodHandle target = varargsList(1 + nargs);
- MethodHandle combine = varargsList(fold).asType(MethodType.genericMethodType(fold));
- List<Object> argsToPass = Arrays.asList(randomArgs(nargs, Object.class));
- if (verbosity >= 3)
- System.out.println("fold "+target+" with "+combine);
- MethodHandle target2 = MethodHandles.foldArguments(target, combine);
- // Simulate expected effect of combiner on arglist:
- List<Object> expected = new ArrayList<Object>(argsToPass);
- List<Object> argsToFold = expected.subList(pos, pos + fold);
- if (verbosity >= 3)
- System.out.println("fold: "+argsToFold+" into "+target2);
- Object foldedArgs = combine.invokeWithArguments(argsToFold);
- argsToFold.add(0, foldedArgs);
- Object result = target2.invokeWithArguments(argsToPass);
- if (verbosity >= 3)
- System.out.println("result: "+result);
- 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 {
- 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<Object> resList = Arrays.asList(args);
- List<Object> argsToDrop = new ArrayList<Object>(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
- public void testInvokers() throws Throwable {
- if (CAN_SKIP_WORKING) return;
- startTest("exactInvoker, genericInvoker, varargsInvoker, dynamicInvoker");
- // exactInvoker, genericInvoker, varargsInvoker[0..N], dynamicInvoker
- Set<MethodType> done = new HashSet<MethodType>();
- for (int i = 0; i <= 6; i++) {
- 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 (argType.isPrimitive() && j != i-1) continue; // FIXME Fail_5
- if (done.add(type))
- testInvokers(type);
- MethodType vtype = type.changeReturnType(void.class);
- if (done.add(vtype))
- testInvokers(vtype);
- }
- }
- }
- }
-
- 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<Object> targetPlusArgs = new ArrayList<Object>(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.genericInvoker(type);
- if (nargs <= 3) {
- 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);
- result = inv.invokeExact(target, args);
- if (testRetCode) assertEquals(code, result);
- assertCalled("invokee", args);
- if (nargs >= 1) {
- // 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) {
- // 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) {
- // 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
- countTest();
- calledLog.clear();
- inv = MethodHandles.spreadInvoker(type, k);
- List<Object> targetPlusVarArgs = new ArrayList<Object>(targetPlusArgs);
- List<Object> 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";
- 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 {
- if (CAN_SKIP_WORKING) return;
- startTest("guardWithTest");
- for (int nargs = 0; nargs <= 3; nargs++) {
- if (nargs != 2) continue; // FIXME: test more later
- testGuardWithTest(nargs, Object.class);
- testGuardWithTest(nargs, String.class);
- }
- }
- void testGuardWithTest(int nargs, Class<?> argClass) throws Throwable {
- countTest();
- MethodHandle test = PRIVATE.findVirtual(Object.class, "equals", MethodType.methodType(boolean.class, Object.class));
- MethodHandle target = PRIVATE.findStatic(MethodHandlesTest.class, "targetIfEquals", MethodType.genericMethodType(nargs));
- MethodHandle fallback = PRIVATE.findStatic(MethodHandlesTest.class, "fallbackIfNotEquals", MethodType.genericMethodType(nargs));
- while (test.type().parameterCount() < nargs)
- test = MethodHandles.dropArguments(test, test.type().parameterCount()-1, Object.class);
- while (test.type().parameterCount() > nargs)
- test = MethodHandles.insertArguments(test, 0, MISSING_ARG);
- if (argClass != Object.class) {
- test = changeArgTypes(test, argClass);
- target = changeArgTypes(target, argClass);
- fallback = changeArgTypes(fallback, argClass);
- }
- MethodHandle mh = MethodHandles.guardWithTest(test, target, fallback);
- assertEquals(target.type(), mh.type());
- Object[][] argLists = {
- { },
- { "foo" }, { MISSING_ARG },
- { "foo", "foo" }, { "foo", "bar" },
- { "foo", "foo", "baz" }, { "foo", "bar", "baz" }
- };
- for (Object[] argList : argLists) {
- if (argList.length != nargs) continue;
- 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(argList);
- assertCalled(willCall, argList);
- }
- }
-
- @Test
- public void testCatchException() throws Throwable {
- if (CAN_SKIP_WORKING) return;
- startTest("catchException");
- for (int nargs = 2; nargs <= 6; nargs++) {
- for (int ti = 0; ti <= 1; ti++) {
- boolean throwIt = (ti != 0);
- testCatchException(int.class, new ClassCastException("testing"), throwIt, nargs);
- testCatchException(void.class, new java.io.IOException("testing"), throwIt, nargs);
- testCatchException(String.class, new LinkageError("testing"), throwIt, nargs);
- }
- }
- }
-
- private static <T extends Throwable>
- Object throwOrReturn(Object normal, T exception) throws T {
- if (exception != null) throw exception;
- return normal;
- }
-
- void testCatchException(Class<?> returnType, Throwable thrown, boolean throwIt, int nargs) throws Throwable {
- countTest();
- if (verbosity >= 3)
- System.out.println("catchException rt="+returnType+" throw="+throwIt+" nargs="+nargs);
- Class<? extends Throwable> exType = thrown.getClass();
- MethodHandle throwOrReturn
- = PRIVATE.findStatic(MethodHandlesTest.class, "throwOrReturn",
- MethodType.methodType(Object.class, Object.class, Throwable.class));
- MethodHandle thrower = throwOrReturn.asType(MethodType.genericMethodType(2));
- while (thrower.type().parameterCount() < nargs)
- thrower = MethodHandles.dropArguments(thrower, thrower.type().parameterCount(), Object.class);
- MethodHandle catcher = varargsList(1+nargs).asType(MethodType.genericMethodType(1+nargs));
- MethodHandle target = MethodHandles.catchException(thrower,
- thrown.getClass(), catcher);
- assertEquals(thrower.type(), target.type());
- //System.out.println("catching with "+target+" : "+throwOrReturn);
- Object[] args = randomArgs(nargs, Object.class);
- args[1] = (throwIt ? thrown : null);
- Object returned = target.invokeWithArguments(args);
- //System.out.println("return from "+target+" : "+returned);
- if (!throwIt) {
- assertSame(args[0], returned);
- } else {
- List<Object> catchArgs = new ArrayList<Object>(Arrays.asList(args));
- catchArgs.add(0, thrown);
- assertEquals(catchArgs, returned);
- }
- }
-
- @Test
- public void testThrowException() 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<? extends Throwable> 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 = MethodHandles.convertArguments(target, 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 testCastFailure() throws Throwable {
- if (CAN_SKIP_WORKING) return;
- startTest("testCastFailure");
- testCastFailure("cast/argument", 11000);
- 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 (Exception ex) {
- throw new RuntimeException(ex);
- }
- }
- }
-
- 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 = MethodHandles.convertArguments(surprise, MethodType.methodType(int.class, Object.class));
- identity = MethodHandles.convertArguments(identity, MethodType.methodType(int.class, Object.class));
- } else if (mode.equals("cast/return")) {
- // fail on return to (Integer)surprise
- surprise = MethodHandles.convertArguments(surprise, MethodType.methodType(Integer.class, Object.class));
- identity = MethodHandles.convertArguments(identity, 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 = MethodHandles.convertArguments(callee, MethodType.genericMethodType(1));
- surprise = MethodHandles.filterArguments(callee, 0, surprise);
- identity = MethodHandles.filterArguments(callee, 0, identity);
- }
- }
- assertNotSame(mode, surprise, surprise0);
- identity = MethodHandles.convertArguments(identity, MethodType.genericMethodType(1));
- surprise = MethodHandles.convertArguments(surprise, 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 (Exception ex) {
- if (verbosity > 2)
- System.out.println("caught "+ex);
- if (verbosity > 3)
- ex.printStackTrace();
- assertTrue(ex instanceof ClassCastException
- // FIXME: accept only one of the two for any given unit test
- || ex instanceof WrongMethodTypeException
- );
- }
- }
-
- static Example userMethod(Object o, String s, int i) {
- called("userMethod", o, s, i);
- return null;
- }
-
- @Test
- public void testUserClassInSignature() 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");
- }
- private interface Fooable {
- Object foo(Fooable x, Object y);
- // this is for randomArg:
- public class Impl implements Fooable {
- public Object foo(Fooable x, Object y) {
- throw new RuntimeException("do not call");
- }
- final String name;
- public Impl() { name = "Fooable#"+nextArg(); }
- @Override public String toString() { return name; }
- }
- }
- static Object fooForFooable(Fooable x, Object y) {
- return called("fooForFooable", x, y);
- }
- private static class MyCheckedException extends Exception {
- }
- private interface WillThrow {
- void willThrow() throws MyCheckedException;
- }
-
- @Test
- public void testAsInstance() throws Throwable {
- if (CAN_SKIP_WORKING) return;
- Lookup lookup = MethodHandles.lookup();
- {
- MethodType mt = MethodType.methodType(void.class);
- MethodHandle mh = lookup.findStatic(MethodHandlesTest.class, "runForRunnable", mt);
- Runnable proxy = MethodHandles.asInstance(mh, Runnable.class);
- proxy.run();
- assertCalled("runForRunnable");
- }
- {
- MethodType mt = MethodType.methodType(Object.class, Fooable.class, Object.class);
- MethodHandle mh = lookup.findStatic(MethodHandlesTest.class, "fooForFooable", mt);
- Fooable proxy = MethodHandles.asInstance(mh, Fooable.class);
- Object[] args = randomArgs(mt.parameterArray());
- Object result = proxy.foo((Fooable) args[0], args[1]);
- assertCalled("fooForFooable", args);
- assertEquals(result, logEntry("fooForFooable", args));
- }
- 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 = MethodHandles.asInstance(mh, WillThrow.class);
- try {
- proxy.willThrow();
- System.out.println("Failed to throw: "+ex);
- assertTrue(false);
- } catch (Throwable ex1) {
- if (verbosity > 2) {
- 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);
- UndeclaredThrowableException utex = (UndeclaredThrowableException) ex1;
- assertSame(ex, utex.getCause());
- }
- }
- }
- // Test error checking:
- for (Class<?> nonSAM : new Class[] { Object.class,
- String.class,
- CharSequence.class,
- Example.class }) {
- try {
- MethodHandles.asInstance(varargsArray(0), nonSAM);
- System.out.println("Failed to throw");
- assertTrue(false);
- } catch (IllegalArgumentException ex) {
- }
- }
- }
-}
-// Local abbreviated copy of sun.dyn.util.ValueConversions
-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<MethodHandle> arrays = new ArrayList<MethodHandle>();
- 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];
- // else need to spin bytecode or do something else fancy
- throw new UnsupportedOperationException("NYI: cannot form a varargs array of length "+nargs);
- }
-
- private static final List<Object> NO_ARGS_LIST = Arrays.asList(NO_ARGS_ARRAY);
- private static List<Object> makeList(Object... args) { return Arrays.asList(args); }
- private static List<Object> list() { return NO_ARGS_LIST; }
- private static List<Object> list(Object a0)
- { return makeList(a0); }
- private static List<Object> list(Object a0, Object a1)
- { return makeList(a0, a1); }
- private static List<Object> list(Object a0, Object a1, Object a2)
- { return makeList(a0, a1, a2); }
- private static List<Object> list(Object a0, Object a1, Object a2, Object a3)
- { return makeList(a0, a1, a2, a3); }
- private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
- Object a4)
- { return makeList(a0, a1, a2, a3, a4); }
- private static List<Object> list(Object a0, Object a1, Object a2, Object a3,
- Object a4, Object a5)
- { return makeList(a0, a1, a2, a3, a4, a5); }
- private static List<Object> 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<Object> 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<Object> 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<Object> 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<MethodHandle> lists = new ArrayList<MethodHandle>();
- 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();
-
- /** 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];
- // else need to spin bytecode or do something else fancy
- throw new UnsupportedOperationException("NYI");
- }
-}
-// This guy tests access from outside the same package member, but inside
-// the package itself.
-class PackageSibling {
- static Lookup lookup() {
- return MethodHandles.lookup();
- }
-}