package test.java.lang.invoke;

import test.java.lang.invoke.remote.RemoteExample;

import java.lang.invoke.*;

import java.lang.invoke.MethodHandles.Lookup;

import java.lang.reflect.*;

import java.util.*;

import org.junit.*;

import static org.junit.Assert.*;

public class MethodHandlesTest {

static final Class<?> THIS_CLASS = MethodHandlesTest.class;

// How much output?

static int verbosity = 0;

static {

String vstr = System.getProperty(THIS_CLASS.getSimpleName()+".verbosity");

if (vstr == null)

vstr = System.getProperty(THIS_CLASS.getName()+".verbosity");

if (vstr != null) verbosity = Integer.parseInt(vstr);

}

// Set this true during development if you want to fast-forward to

// a particular new, non-working test. Tests which are known to

// work (or have recently worked) test this flag and return on true.

static final boolean CAN_SKIP_WORKING;

static {

String vstr = System.getProperty(THIS_CLASS.getSimpleName()+".CAN_SKIP_WORKING");

if (vstr == null)

vstr = System.getProperty(THIS_CLASS.getName()+".CAN_SKIP_WORKING");

CAN_SKIP_WORKING = Boolean.parseBoolean(vstr);

}

// Set 'true' to do about 15x fewer tests, especially those redundant with RicochetTest.

// This might be useful with -Xcomp stress tests that compile all method handles.

static boolean CAN_TEST_LIGHTLY = Boolean.getBoolean(THIS_CLASS.getName()+".CAN_TEST_LIGHTLY");

@Test

public void testFirst() throws Throwable {

verbosity += 9; try {

// left blank for debugging

} finally { printCounts(); verbosity -= 9; }

}

static final int MAX_ARG_INCREASE = 3;

public MethodHandlesTest() {

}

String testName;

static int allPosTests, allNegTests;

int posTests, negTests;

@After

public void printCounts() {

if (verbosity >= 2 && (posTests | negTests) != 0) {

System.out.println();

if (posTests != 0) System.out.println("=== "+testName+": "+posTests+" positive test cases run");

if (negTests != 0) System.out.println("=== "+testName+": "+negTests+" negative test cases run");

allPosTests += posTests;

allNegTests += negTests;

posTests = negTests = 0;

}

}

void countTest(boolean positive) {

if (positive) ++posTests;

else ++negTests;

}

void countTest() { countTest(true); }

void startTest(String name) {

if (testName != null) printCounts();

if (verbosity >= 1)

System.out.println(name);

posTests = negTests = 0;

testName = name;

}

@BeforeClass

public static void setUpClass() throws Exception {

calledLog.clear();

calledLog.add(null);

nextArgVal = INITIAL_ARG_VAL;

}

@AfterClass

public static void tearDownClass() throws Exception {

int posTests = allPosTests, negTests = allNegTests;

if (verbosity >= 0 && (posTests | negTests) != 0) {

System.out.println();

if (posTests != 0) System.out.println("=== "+posTests+" total positive test cases");

if (negTests != 0) System.out.println("=== "+negTests+" total negative test cases");

}

}

static List<Object> calledLog = new ArrayList<>();

static Object logEntry(String name, Object... args) {

return Arrays.asList(name, Arrays.asList(args));

}

public static Object called(String name, Object... args) {

Object entry = logEntry(name, args);

calledLog.add(entry);

return entry;

}

static void assertCalled(String name, Object... args) {

Object expected = logEntry(name, args);

Object actual = calledLog.get(calledLog.size() - 1);

if (expected.equals(actual) && verbosity < 9) return;

System.out.println("assertCalled "+name+":");

System.out.println("expected: "+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);

}

@SuppressWarnings("cast") // primitive cast to (long) is part of the pattern

static Object castToWrapperOrNull(long value, Class<?> dst) {

if (dst == int.class || dst == Integer.class)

return (int)(value);

if (dst == long.class || dst == Long.class)

return (long)(value);

if (dst == char.class || dst == Character.class)

return (char)(value);

if (dst == short.class || dst == Short.class)

return (short)(value);

if (dst == float.class || dst == Float.class)

return (float)(value);

if (dst == double.class || dst == Double.class)

return (double)(value);

if (dst == byte.class || dst == Byte.class)

return (byte)(value);

if (dst == boolean.class || dst == boolean.class)

return ((value % 29) & 1) == 0;

return null;

}

static final int ONE_MILLION = (1000*1000), // first int value

TEN_BILLION = (10*1000*1000*1000), // scale factor to reach upper 32 bits

INITIAL_ARG_VAL = ONE_MILLION << 1; // <<1 makes space for sign bit;

static long nextArgVal;

static long nextArg(boolean moreBits) {

long val = nextArgVal++;

long sign = -(val & 1); // alternate signs

val >>= 1;

if (moreBits)

// Guarantee some bits in the high word.

// In any case keep the decimal representation simple-looking,

// with lots of zeroes, so as not to make the printed decimal

// strings unnecessarily noisy.

val += (val % ONE_MILLION) * TEN_BILLION;

return val ^ sign;

}

static int nextArg() {

// Produce a 32-bit result something like ONE_MILLION+(smallint).

// Example: 1_000_042.

return (int) nextArg(false);

}

static long nextArg(Class<?> kind) {

if (kind == long.class || kind == Long.class ||

kind == double.class || kind == Double.class)

// produce a 64-bit result something like

// ((TEN_BILLION+1) * (ONE_MILLION+(smallint)))

// Example: 10_000_420_001_000_042.

return nextArg(true);

return (long) nextArg();

}

static Object randomArg(Class<?> param) {

Object wrap = castToWrapperOrNull(nextArg(param), param);

if (wrap != null) {

return wrap;

}

if (param.isInterface()) {

for (Class<?> c : param.getClasses()) {

if (param.isAssignableFrom(c) && !c.isInterface())

{ param = c; break; }

}

}

if (param.isInterface() && param.isAssignableFrom(List.class))

return Arrays.asList("#"+nextArg());

if (param.isInterface() || param.isAssignableFrom(String.class))

return "#"+nextArg();

else

try {

return param.newInstance();

} catch (InstantiationException | IllegalAccessException ex) {

}

return null; // random class not Object, String, Integer, etc.

}

static Object[] randomArgs(Class<?>... params) {

Object[] args = new Object[params.length];

for (int i = 0; i < args.length; i++)

args[i] = randomArg(params[i]);

return args;

}

static Object[] randomArgs(int nargs, Class<?> param) {

Object[] args = new Object[nargs];

for (int i = 0; i < args.length; i++)

args[i] = randomArg(param);

return args;

}

@SafeVarargs @SuppressWarnings("varargs")

static <T, E extends T> T[] array(Class<T[]> atype, E... a) {

return Arrays.copyOf(a, a.length, atype);

}

@SafeVarargs @SuppressWarnings("varargs")

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);

}

static MethodHandle varargsArray(Class<?> arrayType, int arity) {

return ValueConversions.varargsArray(arrayType, arity);

}

/** Variation of varargsList, but with the given rtype. */

static MethodHandle varargsList(int arity, Class<?> rtype) {

MethodHandle list = varargsList(arity);

MethodType listType = list.type().changeReturnType(rtype);

if (List.class.isAssignableFrom(rtype) || rtype == void.class || rtype == Object.class) {

// OK

} else if (rtype.isAssignableFrom(String.class)) {

if (LIST_TO_STRING == null)

try {

LIST_TO_STRING = PRIVATE.findStatic(PRIVATE.lookupClass(), "listToString",

MethodType.methodType(String.class, List.class));

} catch (NoSuchMethodException | IllegalAccessException ex) { throw new RuntimeException(ex); }

list = MethodHandles.filterReturnValue(list, LIST_TO_STRING);

} else if (rtype.isPrimitive()) {

if (LIST_TO_INT == null)

try {

LIST_TO_INT = PRIVATE.findStatic(PRIVATE.lookupClass(), "listToInt",

MethodType.methodType(int.class, List.class));

} catch (NoSuchMethodException | IllegalAccessException ex) { throw new RuntimeException(ex); }

list = MethodHandles.filterReturnValue(list, LIST_TO_INT);

list = MethodHandles.explicitCastArguments(list, listType);

} else {

throw new RuntimeException("varargsList: "+rtype);

}

return list.asType(listType);

}

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<>(targetType.parameterList());

Collections.fill(argTypes.subList(beg, end), argType);

MethodType ttype2 = MethodType.methodType(targetType.returnType(), argTypes);

return target.asType(ttype2);

}

static MethodHandle addTrailingArgs(MethodHandle target, int nargs, Class<?> argClass) {

int targetLen = target.type().parameterCount();

int extra = (nargs - targetLen);

if (extra <= 0) return target;

List<Class<?>> fakeArgs = Collections.<Class<?>>nCopies(extra, argClass);

return MethodHandles.dropArguments(target, targetLen, fakeArgs);

}

// This lookup is good for all members in and under MethodHandlesTest.

static final Lookup PRIVATE = MethodHandles.lookup();

// This lookup is good for package-private members but not private ones.

static final Lookup PACKAGE = PackageSibling.lookup();

// This lookup is good for public members and protected members of PubExample

static final Lookup SUBCLASS = RemoteExample.lookup();

// This lookup is good only for public members.

static final Lookup PUBLIC = MethodHandles.publicLookup();

// Subject methods...

static class Example implements IntExample {

final String name;

public Example() { name = "Example#"+nextArg(); }

protected Example(String name) { this.name = name; }

@SuppressWarnings("LeakingThisInConstructor")

protected Example(int x) { this(); called("protected <init>", this, x); }

@Override public String toString() { return name; }

public void v0() { called("v0", this); }

protected void pro_v0() { called("pro_v0", this); }

void pkg_v0() { called("pkg_v0", this); }

private void pri_v0() { called("pri_v0", this); }

public static void s0() { called("s0"); }

protected static void pro_s0() { called("pro_s0"); }

static void pkg_s0() { called("pkg_s0"); }

private static void pri_s0() { called("pri_s0"); }

public Object v1(Object x) { return called("v1", this, x); }

public Object v2(Object x, Object y) { return called("v2", this, x, y); }

public Object v2(Object x, int y) { return called("v2", this, x, y); }

public Object v2(int x, Object y) { return called("v2", this, x, y); }

public Object v2(int x, int y) { return called("v2", this, x, y); }

public static Object s1(Object x) { return called("s1", x); }

public static Object s2(int x) { return called("s2", x); }

public static Object s3(long x) { return called("s3", x); }

public static Object s4(int x, int y) { return called("s4", x, y); }

public static Object s5(long x, int y) { return called("s5", x, y); }

public static Object s6(int x, long y) { return called("s6", x, y); }

public static Object s7(float x, double y) { return called("s7", x, y); }

// for testing findConstructor:

public Example(String x, int y) { this.name = x+y; called("Example.<init>", x, y); }

public Example(int x, String y) { this.name = x+y; called("Example.<init>", x, y); }

public Example(int x, int y) { this.name = x+""+y; called("Example.<init>", x, y); }

public Example(int x, long y) { this.name = x+""+y; called("Example.<init>", x, y); }

public Example(int x, float y) { this.name = x+""+y; called("Example.<init>", x, y); }

public Example(int x, double y) { this.name = x+""+y; called("Example.<init>", x, y); }

public Example(int x, int y, int z) { this.name = x+""+y+""+z; called("Example.<init>", x, y, z); }

public Example(int x, int y, int z, int a) { this.name = x+""+y+""+z+""+a; called("Example.<init>", x, y, z, a); }

static final Lookup EXAMPLE = MethodHandles.lookup(); // for testing findSpecial

}

static final Lookup EXAMPLE = Example.EXAMPLE;

public static class PubExample extends Example {

public PubExample() { this("PubExample"); }

protected PubExample(String prefix) { super(prefix+"#"+nextArg()); }

protected void pro_v0() { called("Pub/pro_v0", this); }

protected static void pro_s0() { called("Pub/pro_s0"); }

}

static class SubExample extends Example {

@Override public void v0() { called("Sub/v0", this); }

@Override void pkg_v0() { called("Sub/pkg_v0", this); }

@SuppressWarnings("LeakingThisInConstructor")

private SubExample(int x) { called("<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 interface SubIntExample extends IntExample { }

static final Object[][][] ACCESS_CASES = {

{ { false, PUBLIC }, { false, SUBCLASS }, { false, PACKAGE }, { false, PRIVATE }, { false, EXAMPLE } }, //[0]: all false

{ { false, PUBLIC }, { false, SUBCLASS }, { false, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[1]: only PRIVATE

{ { false, PUBLIC }, { false, SUBCLASS }, { true, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[2]: PUBLIC false

{ { false, PUBLIC }, { true, SUBCLASS }, { true, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[3]: subclass OK

{ { true, PUBLIC }, { true, SUBCLASS }, { true, PACKAGE }, { true, PRIVATE }, { true, EXAMPLE } }, //[4]: all true

};

static Object[][] accessCases(Class<?> defc, String name, boolean isSpecial) {

Object[][] cases;

if (name.contains("pri_") || isSpecial) {

cases = ACCESS_CASES[1]; // PRIVATE only

} else if (name.contains("pkg_") || !Modifier.isPublic(defc.getModifiers())) {

cases = ACCESS_CASES[2]; // not PUBLIC

} else if (name.contains("pro_")) {

cases = ACCESS_CASES[3]; // PUBLIC class, protected member

} else {

assertTrue(name.indexOf('_') < 0 || name.contains("fin_"));

boolean pubc = Modifier.isPublic(defc.getModifiers());

if (pubc)

cases = ACCESS_CASES[4]; // all access levels

else

cases = ACCESS_CASES[2]; // PACKAGE but not PUBLIC

}

if (defc != Example.class && cases[cases.length-1][1] == EXAMPLE)

cases = Arrays.copyOfRange(cases, 0, cases.length-1);

return cases;

}

static Object[][] accessCases(Class<?> defc, String name) {

return accessCases(defc, name, false);

}

static Lookup maybeMoveIn(Lookup lookup, Class<?> defc) {

if (lookup == PUBLIC || lookup == SUBCLASS || lookup == PACKAGE)

// external views stay external

return lookup;

return lookup.in(defc);

}

@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, void.class, "pro_s0");

testFindStatic(PubExample.class, void.class, "Pub/pro_s0");

testFindStatic(Example.class, Object.class, "s1", Object.class);

testFindStatic(Example.class, Object.class, "s2", int.class);

testFindStatic(Example.class, Object.class, "s3", long.class);

testFindStatic(Example.class, Object.class, "s4", int.class, int.class);

testFindStatic(Example.class, Object.class, "s5", long.class, int.class);

testFindStatic(Example.class, Object.class, "s6", int.class, long.class);

testFindStatic(Example.class, Object.class, "s7", float.class, double.class);

testFindStatic(false, PRIVATE, Example.class, void.class, "bogus");

testFindStatic(false, PRIVATE, Example.class, void.class, "v0");

}

void testFindStatic(Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {

for (Object[] ac : accessCases(defc, name)) {

testFindStatic((Boolean)ac[0], (Lookup)ac[1], defc, ret, name, params);

}

}

void testFindStatic(Lookup lookup, Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {

testFindStatic(true, lookup, defc, ret, name, params);

}

void testFindStatic(boolean positive, Lookup lookup, Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {

countTest(positive);

String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo

MethodType type = MethodType.methodType(ret, params);

MethodHandle target = null;

Exception noAccess = null;

try {

if (verbosity >= 4) System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);

target = maybeMoveIn(lookup, defc).findStatic(defc, methodName, type);

} catch (ReflectiveOperationException ex) {

noAccess = ex;

if (verbosity >= 5) ex.printStackTrace(System.out);

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, methodName);

Object[] args = randomArgs(params);

printCalled(target, name, args);

target.invokeWithArguments(args);

assertCalled(name, args);

if (verbosity >= 1)

System.out.print(':');

}

static final boolean DEBUG_METHOD_HANDLE_NAMES = Boolean.getBoolean("java.lang.invoke.MethodHandle.DEBUG_NAMES");

// rough check of name string

static void assertNameStringContains(MethodHandle x, String s) {

if (!DEBUG_METHOD_HANDLE_NAMES) {

// ignore s

assertEquals("MethodHandle"+x.type(), x.toString());

return;

}

if (x.toString().contains(s)) return;

assertEquals(s, x);

}

@Test

public void testFindVirtual() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("findVirtual");

testFindVirtual(Example.class, void.class, "v0");

testFindVirtual(Example.class, void.class, "pkg_v0");

testFindVirtual(Example.class, void.class, "pri_v0");

testFindVirtual(Example.class, Object.class, "v1", Object.class);

testFindVirtual(Example.class, Object.class, "v2", Object.class, Object.class);

testFindVirtual(Example.class, Object.class, "v2", Object.class, int.class);

testFindVirtual(Example.class, Object.class, "v2", int.class, Object.class);

testFindVirtual(Example.class, Object.class, "v2", int.class, int.class);

testFindVirtual(Example.class, void.class, "pro_v0");

testFindVirtual(PubExample.class, void.class, "Pub/pro_v0");

testFindVirtual(false, PRIVATE, Example.class, Example.class, void.class, "bogus");

testFindVirtual(false, PRIVATE, Example.class, Example.class, void.class, "s0");

// test dispatch

testFindVirtual(SubExample.class, SubExample.class, void.class, "Sub/v0");

testFindVirtual(SubExample.class, Example.class, void.class, "Sub/v0");

testFindVirtual(SubExample.class, IntExample.class, void.class, "Sub/v0");

testFindVirtual(SubExample.class, SubExample.class, void.class, "Sub/pkg_v0");

testFindVirtual(SubExample.class, Example.class, void.class, "Sub/pkg_v0");

testFindVirtual(Example.class, IntExample.class, void.class, "v0");

testFindVirtual(IntExample.Impl.class, IntExample.class, void.class, "Int/v0");

}

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 = maybeMoveIn(lookup, defc).findVirtual(defc, methodName, type);

} catch (ReflectiveOperationException ex) {

noAccess = ex;

if (verbosity >= 5) ex.printStackTrace(System.out);

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<?> selfc = defc;

// predict receiver type narrowing:

if (lookup == SUBCLASS &&

name.contains("pro_") &&

selfc.isAssignableFrom(lookup.lookupClass())) {

selfc = lookup.lookupClass();

if (name.startsWith("Pub/")) name = "Rem/"+name.substring(4);

}

Class<?>[] paramsWithSelf = cat(array(Class[].class, (Class)selfc), params);

MethodType typeWithSelf = MethodType.methodType(ret, paramsWithSelf);

assertEquals(typeWithSelf, target.type());

assertNameStringContains(target, methodName);

Object[] argsWithSelf = randomArgs(paramsWithSelf);

if (selfc.isAssignableFrom(rcvc) && rcvc != selfc) argsWithSelf[0] = randomArg(rcvc);

printCalled(target, name, argsWithSelf);

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");

testFindSpecial(RemoteExample.class, PubExample.class, void.class, "Pub/pro_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 {

if (specialCaller == RemoteExample.class) {

testFindSpecial(false, EXAMPLE, specialCaller, defc, ret, name, params);

testFindSpecial(false, PRIVATE, specialCaller, defc, ret, name, params);

testFindSpecial(false, PACKAGE, specialCaller, defc, ret, name, params);

testFindSpecial(true, SUBCLASS, specialCaller, defc, ret, name, params);

testFindSpecial(false, PUBLIC, specialCaller, defc, ret, name, params);

return;

}

testFindSpecial(true, EXAMPLE, specialCaller, defc, ret, name, params);

testFindSpecial(true, PRIVATE, specialCaller, defc, ret, name, params);

testFindSpecial(false, PACKAGE, specialCaller, defc, ret, name, params);

testFindSpecial(false, SUBCLASS, specialCaller, defc, ret, name, params);

testFindSpecial(false, PUBLIC, specialCaller, defc, ret, name, params);

}

void testFindSpecial(boolean positive, Lookup lookup, Class<?> specialCaller,

Class<?> defc, Class<?> ret, String name, Class<?>... params) throws Throwable {

countTest(positive);

String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo

MethodType type = MethodType.methodType(ret, params);

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 => "+maybeMoveIn(lookup, specialCaller));

target = maybeMoveIn(lookup, specialCaller).findSpecial(defc, methodName, type, specialCaller);

} catch (ReflectiveOperationException ex) {

noAccess = ex;

if (verbosity >= 5) ex.printStackTrace(System.out);

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, methodName);

Object[] args = randomArgs(paramsWithSelf);

printCalled(target, name, args);

target.invokeWithArguments(args);

assertCalled(name, args);

}

@Test

public void testFindConstructor() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("findConstructor");

testFindConstructor(true, EXAMPLE, Example.class);

testFindConstructor(true, EXAMPLE, Example.class, int.class);

testFindConstructor(true, EXAMPLE, Example.class, int.class, int.class);

testFindConstructor(true, EXAMPLE, Example.class, int.class, long.class);

testFindConstructor(true, EXAMPLE, Example.class, int.class, float.class);

testFindConstructor(true, EXAMPLE, Example.class, int.class, double.class);

testFindConstructor(true, EXAMPLE, Example.class, String.class);

testFindConstructor(true, EXAMPLE, Example.class, int.class, int.class, int.class);

testFindConstructor(true, EXAMPLE, Example.class, int.class, int.class, int.class, int.class);

}

void testFindConstructor(boolean positive, Lookup lookup,

Class<?> defc, Class<?>... params) throws Throwable {

countTest(positive);

MethodType type = MethodType.methodType(void.class, params);

MethodHandle target = null;

Exception noAccess = null;

try {

if (verbosity >= 4) System.out.println("lookup via "+lookup+" of "+defc+" <init>"+type);

target = lookup.findConstructor(defc, type);

} catch (ReflectiveOperationException ex) {

noAccess = ex;

assertTrue(noAccess instanceof IllegalAccessException);

}

if (verbosity >= 3)

System.out.println("findConstructor "+defc.getName()+".<init>/"+type+" => "+target

+(target == null ? "" : target.type())

+(noAccess == null ? "" : " !! "+noAccess));

if (positive && noAccess != null) throw noAccess;

assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

if (!positive) return; // negative test failed as expected

assertEquals(type.changeReturnType(defc), target.type());

Object[] args = randomArgs(params);

printCalled(target, defc.getSimpleName(), args);

Object obj = target.invokeWithArguments(args);

if (!(defc == Example.class && params.length < 2))

assertCalled(defc.getSimpleName()+".<init>", args);

assertTrue("instance of "+defc.getName(), defc.isInstance(obj));

}

@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 = maybeMoveIn(lookup, defc).bind(receiver, methodName, type);

} catch (ReflectiveOperationException ex) {

noAccess = ex;

if (verbosity >= 5) ex.printStackTrace(System.out);

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, "pro_s0");

testUnreflect(Example.class, true, void.class, "pkg_s0");

testUnreflect(Example.class, true, void.class, "pri_s0");

testUnreflect(Example.class, true, Object.class, "s1", Object.class);

testUnreflect(Example.class, true, Object.class, "s2", int.class);

testUnreflect(Example.class, true, Object.class, "s3", long.class);

testUnreflect(Example.class, true, Object.class, "s4", int.class, int.class);

testUnreflect(Example.class, true, Object.class, "s5", long.class, int.class);

testUnreflect(Example.class, true, Object.class, "s6", int.class, long.class);

testUnreflect(Example.class, false, void.class, "v0");

testUnreflect(Example.class, false, void.class, "pkg_v0");

testUnreflect(Example.class, false, void.class, "pri_v0");

testUnreflect(Example.class, false, Object.class, "v1", Object.class);

testUnreflect(Example.class, false, Object.class, "v2", Object.class, Object.class);

testUnreflect(Example.class, false, Object.class, "v2", Object.class, int.class);

testUnreflect(Example.class, false, Object.class, "v2", int.class, Object.class);

testUnreflect(Example.class, false, Object.class, "v2", int.class, int.class);

// Test a public final member in another package:

testUnreflect(RemoteExample.class, false, void.class, "Rem/fin_v0");

}

void testUnreflect(Class<?> defc, boolean isStatic, Class<?> ret, String name, Class<?>... params) throws Throwable {

for (Object[] ac : accessCases(defc, name)) {

testUnreflectMaybeSpecial(null, (Boolean)ac[0], (Lookup)ac[1], defc, (isStatic ? null : defc), ret, name, params);

}

}

void testUnreflect(Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {

for (Object[] ac : accessCases(defc, name)) {

testUnreflectMaybeSpecial(null, (Boolean)ac[0], (Lookup)ac[1], defc, rcvc, ret, name, params);

}

}

void testUnreflectMaybeSpecial(Class<?> specialCaller,

boolean positive, Lookup lookup,

Class<?> defc, Class<?> rcvc, Class<?> ret, String name, Class<?>... params) throws Throwable {

countTest(positive);

String methodName = name.substring(1 + name.indexOf('/')); // foo/bar => foo

MethodType type = MethodType.methodType(ret, params);

Method rmethod = defc.getDeclaredMethod(methodName, params);

MethodHandle target = null;

Exception noAccess = null;

boolean isStatic = (rcvc == null);

boolean isSpecial = (specialCaller != null);

try {

if (verbosity >= 4) System.out.println("lookup via "+lookup+" of "+defc+" "+name+type);

if (isSpecial)

target = maybeMoveIn(lookup, specialCaller).unreflectSpecial(rmethod, specialCaller);

else

target = maybeMoveIn(lookup, defc).unreflect(rmethod);

} catch (ReflectiveOperationException ex) {

noAccess = ex;

if (verbosity >= 5) ex.printStackTrace(System.out);

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 types[][] = {

{'L',Object.class}, {'R',String.class},

{'I',int.class}, {'J',long.class},

{'F',float.class}, {'D',double.class},

{'Z',boolean.class}, {'B',byte.class},

{'S',short.class}, {'C',char.class},

};

HasFields fields = new HasFields();

for (Object[] t : types) {

for (int kind = 0; kind <= 1; kind++) {

boolean isStatic = (kind != 0);

char btc = (Character)t[0];

String name = (isStatic ? "s" : "f") + btc;

Class<?> type = (Class<?>) t[1];

Object value;

Field field;

try {

field = HasFields.class.getDeclaredField(name);

} catch (NoSuchFieldException | SecurityException ex) {

throw new InternalError("no field HasFields."+name);

}

try {

value = field.get(fields);

} catch (IllegalArgumentException | IllegalAccessException ex) {

throw new InternalError("cannot fetch field HasFields."+name);

}

if (type == float.class) {

float v = 'F';

if (isStatic) v++;

assertTrue(value.equals(v));

}

assertTrue(name.equals(field.getName()));

assertTrue(type.equals(field.getType()));

assertTrue(isStatic == (Modifier.isStatic(field.getModifiers())));

cases.add(new Object[]{ field, value });

}

}

cases.add(new Object[]{ new Object[]{ false, HasFields.class, "bogus_fD", double.class }, Error.class });

cases.add(new Object[]{ new Object[]{ true, HasFields.class, "bogus_sL", Object.class }, Error.class });

CASES = cases.toArray(new Object[0][]);

}

}

static final int TEST_UNREFLECT = 1, TEST_FIND_FIELD = 2, TEST_FIND_STATIC = 3, TEST_SETTER = 0x10, TEST_BOUND = 0x20, TEST_NPE = 0x40;

static boolean testModeMatches(int testMode, boolean isStatic) {

switch (testMode) {

case TEST_FIND_STATIC: return isStatic;

case TEST_FIND_FIELD: return !isStatic;

case TEST_UNREFLECT: return true; // unreflect matches both

}

throw new InternalError("testMode="+testMode);

}

@Test

public void testUnreflectGetter() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("unreflectGetter");

testGetter(TEST_UNREFLECT);

}

@Test

public void testFindGetter() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("findGetter");

testGetter(TEST_FIND_FIELD);

testGetter(TEST_FIND_FIELD | TEST_BOUND);

}

@Test

public void testFindStaticGetter() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("findStaticGetter");

testGetter(TEST_FIND_STATIC);

}

public void testGetter(int testMode) throws Throwable {

Lookup lookup = PRIVATE; // FIXME: test more lookups than this one

for (Object[] c : HasFields.CASES) {

boolean positive = (c[1] != Error.class);

testGetter(positive, lookup, c[0], c[1], testMode);

if (positive)

testGetter(positive, lookup, c[0], c[1], testMode | TEST_NPE);

}

testGetter(true, lookup,

new Object[]{ true, System.class, "out", java.io.PrintStream.class },

System.out, testMode);

for (int isStaticN = 0; isStaticN <= 1; isStaticN++) {

testGetter(false, lookup,

new Object[]{ (isStaticN != 0), System.class, "bogus", char.class },

null, testMode);

}

}

public void testGetter(boolean positive, MethodHandles.Lookup lookup,

Object fieldRef, Object value, int testMode) throws Throwable {

testAccessor(positive, lookup, fieldRef, value, testMode);

}

public void testAccessor(boolean positive0, MethodHandles.Lookup lookup,

Object fieldRef, Object value, int testMode0) throws Throwable {

if (verbosity >= 4)

System.out.println("testAccessor"+Arrays.deepToString(new Object[]{positive0, lookup, fieldRef, value, testMode0}));

boolean isGetter = ((testMode0 & TEST_SETTER) == 0);

boolean doBound = ((testMode0 & TEST_BOUND) != 0);

boolean testNPE = ((testMode0 & TEST_NPE) != 0);

int testMode = testMode0 & ~(TEST_SETTER | TEST_BOUND | TEST_NPE);

boolean positive = positive0 && !testNPE;

boolean isStatic;

Class<?> fclass;

String fname;

Class<?> ftype;

Field f = (fieldRef instanceof Field ? (Field)fieldRef : null);

if (f != null) {

isStatic = Modifier.isStatic(f.getModifiers());

fclass = f.getDeclaringClass();

fname = f.getName();

ftype = f.getType();

} else {

Object[] scnt = (Object[]) fieldRef;

isStatic = (Boolean) scnt[0];

fclass = (Class<?>) scnt[1];

fname = (String) scnt[2];

ftype = (Class<?>) scnt[3];

try {

f = fclass.getDeclaredField(fname);

} catch (ReflectiveOperationException ex) {

f = null;

}

}

if (!testModeMatches(testMode, isStatic)) return;

if (f == null && testMode == TEST_UNREFLECT) return;

if (testNPE && isStatic) return;

countTest(positive);

MethodType expType;

if (isGetter)

expType = MethodType.methodType(ftype, HasFields.class);

else

expType = MethodType.methodType(void.class, HasFields.class, ftype);

if (isStatic) expType = expType.dropParameterTypes(0, 1);

Exception noAccess = null;

MethodHandle mh;

try {

switch (testMode0 & ~(TEST_BOUND | TEST_NPE)) {

case TEST_UNREFLECT: mh = lookup.unreflectGetter(f); break;

case TEST_FIND_FIELD: mh = lookup.findGetter(fclass, fname, ftype); break;

case TEST_FIND_STATIC: mh = lookup.findStaticGetter(fclass, fname, ftype); break;

case TEST_SETTER|

TEST_UNREFLECT: mh = lookup.unreflectSetter(f); break;

case TEST_SETTER|

TEST_FIND_FIELD: mh = lookup.findSetter(fclass, fname, ftype); break;

case TEST_SETTER|

TEST_FIND_STATIC: mh = lookup.findStaticSetter(fclass, fname, ftype); break;

default:

throw new InternalError("testMode="+testMode);

}

} catch (ReflectiveOperationException ex) {

mh = null;

noAccess = ex;

if (verbosity >= 5) ex.printStackTrace(System.out);

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 && !testNPE && noAccess != null) throw new RuntimeException(noAccess);

assertEquals(positive0 ? "positive test" : "negative test erroneously passed", positive0, mh != null);

if (!positive && !testNPE) return; // negative access test failed as expected

assertEquals((isStatic ? 0 : 1)+(isGetter ? 0 : 1), mh.type().parameterCount());

assertSame(mh.type(), expType);

//assertNameStringContains(mh, fname); // This does not hold anymore with LFs

HasFields fields = new HasFields();

HasFields fieldsForMH = fields;

if (testNPE) fieldsForMH = null; // perturb MH argument to elicit expected error

if (doBound)

mh = mh.bindTo(fieldsForMH);

Object sawValue;

Class<?> vtype = ftype;

if (ftype != int.class) vtype = Object.class;

if (isGetter) {

mh = mh.asType(mh.type().generic()

.changeReturnType(vtype));

} else {

int last = mh.type().parameterCount() - 1;

mh = mh.asType(mh.type().generic()

.changeReturnType(void.class)

.changeParameterType(last, vtype));

}

if (f != null && f.getDeclaringClass() == HasFields.class) {

assertEquals(f.get(fields), value); // clean to start with

}

Throwable caughtEx = null;

if (isGetter) {

Object expValue = value;

for (int i = 0; i <= 1; i++) {

sawValue = null; // make DA rules happy under try/catch

try {

if (isStatic || doBound) {

if (ftype == int.class)

sawValue = (int) mh.invokeExact(); // do these exactly

else

sawValue = mh.invokeExact();

} else {

if (ftype == int.class)

sawValue = (int) mh.invokeExact((Object) fieldsForMH);

else

sawValue = mh.invokeExact((Object) fieldsForMH);

}

} catch (RuntimeException ex) {

if (ex instanceof NullPointerException && testNPE) {

caughtEx = ex;

break;

}

}

assertEquals(sawValue, expValue);

if (f != null && f.getDeclaringClass() == HasFields.class

&& !Modifier.isFinal(f.getModifiers())) {

Object random = randomArg(ftype);

f.set(fields, random);

expValue = random;

} else {

break;

}

}

} else {

for (int i = 0; i <= 1; i++) {

Object putValue = randomArg(ftype);

try {

if (isStatic || doBound) {

if (ftype == int.class)

mh.invokeExact((int)putValue); // do these exactly

else

mh.invokeExact(putValue);

} else {

if (ftype == int.class)

mh.invokeExact((Object) fieldsForMH, (int)putValue);

else

mh.invokeExact((Object) fieldsForMH, putValue);

}

} catch (RuntimeException ex) {

if (ex instanceof NullPointerException && testNPE) {

caughtEx = ex;

break;

}

}

if (f != null && f.getDeclaringClass() == HasFields.class) {

assertEquals(f.get(fields), putValue);

}

}

}

if (f != null && f.getDeclaringClass() == HasFields.class) {

f.set(fields, value); // put it back

}

if (testNPE) {

if (caughtEx == null || !(caughtEx instanceof NullPointerException))

throw new RuntimeException("failed to catch NPE exception"+(caughtEx == null ? " (caughtEx=null)" : ""), caughtEx);

caughtEx = null; // nullify expected exception

}

if (caughtEx != null) {

throw new RuntimeException("unexpected exception", caughtEx);

}

}

@Test

public void testUnreflectSetter() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("unreflectSetter");

testSetter(TEST_UNREFLECT);

}

@Test

public void testFindSetter() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("findSetter");

testSetter(TEST_FIND_FIELD);

testSetter(TEST_FIND_FIELD | TEST_BOUND);

}

@Test

public void testFindStaticSetter() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("findStaticSetter");

testSetter(TEST_FIND_STATIC);

}

public void testSetter(int testMode) throws Throwable {

Lookup lookup = PRIVATE; // FIXME: test more lookups than this one

startTest("unreflectSetter");

for (Object[] c : HasFields.CASES) {

boolean positive = (c[1] != Error.class);

testSetter(positive, lookup, c[0], c[1], testMode);

if (positive)

testSetter(positive, lookup, c[0], c[1], testMode | TEST_NPE);

}

for (int isStaticN = 0; isStaticN <= 1; isStaticN++) {

testSetter(false, lookup,

new Object[]{ (isStaticN != 0), System.class, "bogus", char.class },

null, testMode);

}

}

public void testSetter(boolean positive, MethodHandles.Lookup lookup,

Object fieldRef, Object value, int testMode) throws Throwable {

testAccessor(positive, lookup, fieldRef, value, testMode | TEST_SETTER);

}

@Test

public void testArrayElementGetter() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("arrayElementGetter");

testArrayElementGetterSetter(false);

}

@Test

public void testArrayElementSetter() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("arrayElementSetter");

testArrayElementGetterSetter(true);

}

private static final int TEST_ARRAY_NONE = 0, TEST_ARRAY_NPE = 1, TEST_ARRAY_OOB = 2, TEST_ARRAY_ASE = 3;

public void testArrayElementGetterSetter(boolean testSetter) throws Throwable {

testArrayElementGetterSetter(testSetter, TEST_ARRAY_NONE);

}

@Test

public void testArrayElementErrors() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("arrayElementErrors");

testArrayElementGetterSetter(false, TEST_ARRAY_NPE);

testArrayElementGetterSetter(true, TEST_ARRAY_NPE);

testArrayElementGetterSetter(false, TEST_ARRAY_OOB);

testArrayElementGetterSetter(true, TEST_ARRAY_OOB);

testArrayElementGetterSetter(new Object[10], true, TEST_ARRAY_ASE);

testArrayElementGetterSetter(new Example[10], true, TEST_ARRAY_ASE);

testArrayElementGetterSetter(new IntExample[10], true, TEST_ARRAY_ASE);

}

public void testArrayElementGetterSetter(boolean testSetter, int negTest) throws Throwable {

testArrayElementGetterSetter(new String[10], testSetter, negTest);

testArrayElementGetterSetter(new Iterable<?>[10], testSetter, negTest);

testArrayElementGetterSetter(new Example[10], testSetter, negTest);

testArrayElementGetterSetter(new IntExample[10], testSetter, negTest);

testArrayElementGetterSetter(new Object[10], testSetter, negTest);

testArrayElementGetterSetter(new boolean[10], testSetter, negTest);

testArrayElementGetterSetter(new byte[10], testSetter, negTest);

testArrayElementGetterSetter(new char[10], testSetter, negTest);

testArrayElementGetterSetter(new short[10], testSetter, negTest);

testArrayElementGetterSetter(new int[10], testSetter, negTest);

testArrayElementGetterSetter(new float[10], testSetter, negTest);

testArrayElementGetterSetter(new long[10], testSetter, negTest);

testArrayElementGetterSetter(new double[10], testSetter, negTest);

}

public void testArrayElementGetterSetter(Object array, boolean testSetter, int negTest) throws Throwable {

boolean positive = (negTest == TEST_ARRAY_NONE);

int length = java.lang.reflect.Array.getLength(array);

Class<?> arrayType = array.getClass();

Class<?> elemType = arrayType.getComponentType();

Object arrayToMH = array;

// this stanza allows negative tests to make argument perturbations:

switch (negTest) {

case TEST_ARRAY_NPE:

arrayToMH = null;

break;

case TEST_ARRAY_OOB:

assert(length > 0);

arrayToMH = java.lang.reflect.Array.newInstance(elemType, 0);

break;

case TEST_ARRAY_ASE:

assert(testSetter && !elemType.isPrimitive());

if (elemType == Object.class)

arrayToMH = new StringBuffer[length]; // very random subclass of Object!

else if (elemType == Example.class)

arrayToMH = new SubExample[length];

else if (elemType == IntExample.class)

arrayToMH = new SubIntExample[length];

else

return; // can't make an ArrayStoreException test

assert(arrayType.isInstance(arrayToMH))

: Arrays.asList(arrayType, arrayToMH.getClass(), testSetter, negTest);

break;

}

countTest(positive);

if (verbosity > 2) System.out.println("array type = "+array.getClass().getComponentType().getName()+"["+length+"]"+(positive ? "" : " negative test #"+negTest+" using "+Arrays.deepToString(new Object[]{arrayToMH})));

MethodType expType = !testSetter

? MethodType.methodType(elemType, arrayType, int.class)

: MethodType.methodType(void.class, arrayType, int.class, elemType);

MethodHandle mh = !testSetter

? MethodHandles.arrayElementGetter(arrayType)

: MethodHandles.arrayElementSetter(arrayType);

assertSame(mh.type(), expType);

if (elemType != int.class && elemType != boolean.class) {

MethodType gtype = mh.type().generic().changeParameterType(1, int.class);

if (testSetter) gtype = gtype.changeReturnType(void.class);

mh = mh.asType(gtype);

}

Object sawValue, expValue;

List<Object> model = array2list(array);

Throwable caughtEx = null;

for (int i = 0; i < length; i++) {

// update array element

Object random = randomArg(elemType);

model.set(i, random);

if (testSetter) {

try {

if (elemType == int.class)

mh.invokeExact((int[]) arrayToMH, i, (int)random);

else if (elemType == boolean.class)

mh.invokeExact((boolean[]) arrayToMH, i, (boolean)random);

else

mh.invokeExact(arrayToMH, i, random);

} catch (RuntimeException ex) {

caughtEx = ex;

break;

}

assertEquals(model, array2list(array));

} else {

Array.set(array, i, random);

}

if (verbosity >= 5) {

List<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;

try {

if (elemType == int.class)

sawValue = (int) mh.invokeExact((int[]) arrayToMH, i);

else if (elemType == boolean.class)

sawValue = (boolean) mh.invokeExact((boolean[]) arrayToMH, i);

else

sawValue = mh.invokeExact(arrayToMH, i);

} catch (RuntimeException ex) {

caughtEx = ex;

break;

}

assertEquals(sawValue, expValue);

assertEquals(model, array2list(array));

}

}

if (!positive) {

if (caughtEx == null)

throw new RuntimeException("failed to catch exception for negTest="+negTest);

// test the kind of exception

Class<?> reqType = null;

switch (negTest) {

case TEST_ARRAY_ASE: reqType = ArrayStoreException.class; break;

case TEST_ARRAY_OOB: reqType = ArrayIndexOutOfBoundsException.class; break;

case TEST_ARRAY_NPE: reqType = NullPointerException.class; break;

default: assert(false);

}

if (reqType.isInstance(caughtEx)) {

caughtEx = null; // nullify expected exception

}

}

if (caughtEx != null) {

throw new RuntimeException("unexpected exception", caughtEx);

}

}

List<Object> array2list(Object array) {

int length = Array.getLength(array);

ArrayList<Object> model = new ArrayList<>(length);

for (int i = 0; i < length; i++)

model.add(Array.get(array, i));

return model;

}

static class Callee {

static Object id() { return called("id"); }

static Object id(Object x) { return called("id", x); }

static Object id(Object x, Object y) { return called("id", x, y); }

static Object id(Object x, Object y, Object z) { return called("id", x, y, z); }

static Object id(Object... vx) { return called("id", vx); }

static MethodHandle ofType(int n) {

return ofType(Object.class, n);

}

static MethodHandle ofType(Class<?> rtype, int n) {

if (n == -1)

return ofType(MethodType.methodType(rtype, Object[].class));

return ofType(MethodType.genericMethodType(n).changeReturnType(rtype));

}

static MethodHandle ofType(Class<?> rtype, Class<?>... ptypes) {

return ofType(MethodType.methodType(rtype, ptypes));

}

static MethodHandle ofType(MethodType type) {

Class<?> rtype = type.returnType();

String pfx = "";

if (rtype != Object.class)

pfx = rtype.getSimpleName().substring(0, 1).toLowerCase();

String name = pfx+"id";

try {

return PRIVATE.findStatic(Callee.class, name, type);

} catch (NoSuchMethodException | IllegalAccessException ex) {

throw new RuntimeException(ex);

}

}

}

@Test

public void testConvertArguments() throws Throwable {

if (CAN_SKIP_WORKING) return;

startTest("convertArguments");

testConvert(Callee.ofType(1), null, "id", int.class);

testConvert(Callee.ofType(1), null, "id", String.class);

testConvert(Callee.ofType(1), null, "id", Integer.class);

testConvert(Callee.ofType(1), null, "id", short.class);

testConvert(Callee.ofType(1), null, "id", char.class);

testConvert(Callee.ofType(1), null, "id", byte.class);

}

void testConvert(MethodHandle id, Class<?> rtype, String name, Class<?>... params) throws Throwable {

testConvert(true, id, rtype, name, params);

}

void testConvert(boolean positive,

MethodHandle id, Class<?> rtype, String name, Class<?>... params) throws Throwable {

countTest(positive);

MethodType idType = id.type();

if (rtype == null) rtype = idType.returnType();

for (int i = 0; i < params.length; i++) {

if (params[i] == null) params[i] = idType.parameterType(i);

}

// simulate the pairwise conversion

MethodType newType = MethodType.methodType(rtype, params);

Object[] args = randomArgs(newType.parameterArray());

Object[] convArgs = args.clone();

for (int i = 0; i < args.length; i++) {

Class<?> src = newType.parameterType(i);

Class<?> dst = idType.parameterType(i);

if (src != dst)

convArgs[i] = castToWrapper(convArgs[i], dst);

}

Object convResult = id.invokeWithArguments(convArgs);

{

Class<?> dst = newType.returnType();

Class<?> src = idType.returnType();

if (src != dst)

convResult = castToWrapper(convResult, dst);

}

MethodHandle target = null;

RuntimeException error = null;

try {

target = id.asType(newType);

} catch (WrongMethodTypeException ex) {

error = ex;

}

if (verbosity >= 3)

System.out.println("convert "+id+ " to "+newType+" => "+target

+(error == null ? "" : " !! "+error));

if (positive && error != null) throw error;

assertEquals(positive ? "positive test" : "negative test erroneously passed", positive, target != null);

if (!positive) return; // negative test failed as expected