/*

 * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.

 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

 *

 * This code is free software; you can redistribute it and/or modify it

 * under the terms of the GNU General Public License version 2 only, as

 * published by the Free Software Foundation.

 *

 * This code is distributed in the hope that it will be useful, but WITHOUT

 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

 * version 2 for more details (a copy is included in the LICENSE file that

 * accompanied this code).

 *

 * You should have received a copy of the GNU General Public License version

 * 2 along with this work; if not, write to the Free Software Foundation,

 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 */

/* @test

 * @summary unit tests for java.lang.invoke.MethodHandles

 * @library /test/lib /java/lang/invoke/common

 * @compile MethodHandlesTest.java MethodHandlesGeneralTest.java remote/RemoteExample.java

 * @run junit/othervm/timeout=2500 -XX:+IgnoreUnrecognizedVMOptions

 *                                 -XX:-VerifyDependencies

 *                                 -esa

 *                                 test.java.lang.invoke.MethodHandlesGeneralTest

 */

package test.java.lang.invoke;

import org.junit.*;

import test.java.lang.invoke.lib.CodeCacheOverflowProcessor;

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

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandleProxies;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.lang.invoke.WrongMethodTypeException;

import java.lang.invoke.MethodHandles.Lookup;

import java.lang.reflect.Array;

import java.lang.reflect.Field;

import java.lang.reflect.Method;

import java.lang.reflect.Modifier;

import java.lang.reflect.UndeclaredThrowableException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Formatter;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import static java.lang.invoke.MethodType.methodType;

import static org.junit.Assert.*;

public class MethodHandlesGeneralTest extends MethodHandlesTest {

    @Test

    public void testFirst() throws Throwable {

        verbosity += 9;

        try {

            // left blank for debugging

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

    }

    @Test

    public void testFindStatic() throws Throwable {

        CodeCacheOverflowProcessor.runMHTest(this::testFindStatic0);

    }

    public void testFindStatic0() throws Throwable {

        if (CAN_SKIP_WORKING)  return;

        startTest("findStatic");

        testFindStatic(PubExample.class, void.class, "s0");

        testFindStatic(Example.class, void.class, "s0");

        testFindStatic(Example.class, void.class, "pkg_s0");

        testFindStatic(Example.class, void.class, "pri_s0");

        testFindStatic(Example.class, void.class, "pro_s0");

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

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

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

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

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

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

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

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

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

        testFindStatic(false, PRIVATE, Example.class, void.class, "<init>", int.class);

        testFindStatic(false, PRIVATE, Example.class, void.class, "<init>", Void.class);

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

    }

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

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

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

        }

    }

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

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

    }

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

        countTest(positive);

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

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

        MethodHandle target = null;

        Exception noAccess = null;

        try {

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

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

        } catch (ReflectiveOperationException ex) {

            noAccess = ex;

            assertExceptionClass(

                (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("<init>"))

                ?   NoSuchMethodException.class

                :   IllegalAccessException.class,

                noAccess);

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

        }

        if (verbosity >= 3)

            System.out.println("findStatic "+lookup+": "+defc.getName()+"."+name+"/"+type+" => "+target

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

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

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

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

        assertEquals(type, target.type());

        assertNameStringContains(target, methodName);

        Object[] args = randomArgs(params);

        printCalled(target, name, args);

        target.invokeWithArguments(args);

        assertCalled(name, args);

        if (verbosity >= 1)

            System.out.print(':');

    }

    @Test

    public void testFindVirtual() throws Throwable {

        CodeCacheOverflowProcessor.runMHTest(this::testFindVirtual0);

    }

    public void testFindVirtual0() throws Throwable {

        if (CAN_SKIP_WORKING)  return;

        startTest("findVirtual");

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

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

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

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

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

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

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

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

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

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

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

        testFindVirtual(false, PRIVATE, Example.class, Example.class, void.class, "<init>", int.class);

        testFindVirtual(false, PRIVATE, Example.class, Example.class, void.class, "<init>", Void.class);

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

        // test dispatch

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

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

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

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

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

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

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

    }

    @Test

    public void testFindVirtualClone() throws Throwable {

        CodeCacheOverflowProcessor.runMHTest(this::testFindVirtualClone0);

    }

    public void testFindVirtualClone0() throws Throwable {

        if (CAN_SKIP_WORKING)  return;

        // test some ad hoc system methods

        testFindVirtual(false, PUBLIC, Object.class, Object.class, "clone");

        // ##### FIXME - disable tests for clone until we figure out how they should work with modules

        /*

        testFindVirtual(true, PUBLIC, Object[].class, Object.class, "clone");

        testFindVirtual(true, PUBLIC, int[].class, Object.class, "clone");

        for (Class<?> cls : new Class<?>[]{ boolean[].class, long[].class, float[].class, char[].class })

            testFindVirtual(true, PUBLIC, cls, Object.class, "clone");

         */

    }

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

        Class<?> rcvc = defc;

        testFindVirtual(rcvc, defc, ret, name, params);

    }

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

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

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

        }

    }

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

        testFindVirtual(true, lookup, rcvc, defc, ret, name, params);

    }

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

        testFindVirtual(positive, lookup, defc, defc, ret, name, params);

    }

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

        countTest(positive);

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

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

        MethodHandle target = null;

        Exception noAccess = null;

        try {

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

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

        } catch (ReflectiveOperationException ex) {

            noAccess = ex;

            assertExceptionClass(

                (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("<init>"))

                ? NoSuchMethodException.class

                : IllegalAccessException.class,

                noAccess);

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

        }

        if (verbosity >= 3)

            System.out.println("findVirtual "+lookup+": "+defc.getName()+"."+name+"/"+type+" => "+target

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

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

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

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

        Class<?> selfc = defc;

        // predict receiver type narrowing:

        if (lookup == SUBCLASS &&

                name.contains("pro_") &&

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

            selfc = lookup.lookupClass();

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

        }

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

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

        assertEquals(typeWithSelf, target.type());

        assertNameStringContains(target, methodName);

        Object[] argsWithSelf = randomArgs(paramsWithSelf);

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

        printCalled(target, name, argsWithSelf);

        Object res = target.invokeWithArguments(argsWithSelf);

        if (Example.class.isAssignableFrom(defc) || IntExample.class.isAssignableFrom(defc)) {

            assertCalled(name, argsWithSelf);

        } else if (name.equals("clone")) {

            // Ad hoc method call outside Example.  For Object[].clone.

            printCalled(target, name, argsWithSelf);

            assertEquals(MethodType.methodType(Object.class, rcvc), target.type());

            Object orig = argsWithSelf[0];

            assertEquals(orig.getClass(), res.getClass());

            if (res instanceof Object[])

                assertArrayEquals((Object[])res, (Object[])argsWithSelf[0]);

            assert(Arrays.deepEquals(new Object[]{res}, new Object[]{argsWithSelf[0]}));

        } else {

            assert(false) : Arrays.asList(positive, lookup, rcvc, defc, ret, name, deepToString(params));

        }

        if (verbosity >= 1)

            System.out.print(':');

    }

    @Test

    public void testFindSpecial() throws Throwable {

        CodeCacheOverflowProcessor.runMHTest(this::testFindSpecial0);

    }

    public void testFindSpecial0() throws Throwable {

        if (CAN_SKIP_WORKING)  return;

        startTest("findSpecial");

        testFindSpecial(SubExample.class, Example.class, void.class, false, "v0");

        testFindSpecial(SubExample.class, Example.class, void.class, false, "pkg_v0");

        testFindSpecial(RemoteExample.class, PubExample.class, void.class, false, "Pub/pro_v0");

        testFindSpecial(Example.class, IntExample.class, void.class, true, "vd");

        // Do some negative testing:

        for (Lookup lookup : new Lookup[]{ PRIVATE, EXAMPLE, PACKAGE, PUBLIC }) {

            testFindSpecial(false, lookup, Object.class, Example.class, void.class, "v0");

            testFindSpecial(false, lookup, SubExample.class, Example.class, void.class, "bogus");

            testFindSpecial(false, lookup, SubExample.class, Example.class, void.class, "<init>", int.class);

            testFindSpecial(false, lookup, SubExample.class, Example.class, void.class, "<init>", Void.class);

            testFindSpecial(false, lookup, SubExample.class, Example.class, void.class, "s0");

            testFindSpecial(false, lookup, Example.class, IntExample.class, void.class, "v0");

        }

    }

    void testFindSpecial(Class<?> specialCaller,

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

        if (specialCaller == RemoteExample.class) {

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

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

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

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

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

            return;

        }

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

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

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

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

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

    }

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

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

        countTest(positive);

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

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

        Lookup specialLookup = maybeMoveIn(lookup, specialCaller);

        boolean specialAccessOK = (specialLookup.lookupClass() == specialCaller &&

                                  (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);

        MethodHandle target = null;

        Exception noAccess = null;

        try {

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

            if (verbosity >= 5)  System.out.println("  lookup => "+specialLookup);

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

        } catch (ReflectiveOperationException ex) {

            noAccess = ex;

            assertExceptionClass(

                (!specialAccessOK)  // this check should happen first

                ? IllegalAccessException.class

                : (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("<init>"))

                ? NoSuchMethodException.class

                : IllegalAccessException.class,

                noAccess);

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

        }

        if (verbosity >= 3)

            System.out.println("findSpecial from "+specialCaller.getName()+" to "+defc.getName()+"."+name+"/"+type+" => "+target

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

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

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

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

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

        assertEquals(specialCaller, target.type().parameterType(0));

        assertEquals(type, target.type().dropParameterTypes(0,1));

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

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

        assertNameStringContains(target, methodName);

        Object[] args = randomArgs(paramsWithSelf);

        printCalled(target, name, args);

        target.invokeWithArguments(args);

        assertCalled(name, args);

    }

    @Test

    public void testFindConstructor() throws Throwable {

        CodeCacheOverflowProcessor.runMHTest(this::testFindConstructor0);

    }

    public void testFindConstructor0() throws Throwable {

        if (CAN_SKIP_WORKING)  return;

        startTest("findConstructor");

        testFindConstructor(true, EXAMPLE, Example.class);

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

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

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

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

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

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

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

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

    }

    void testFindConstructor(boolean positive, Lookup lookup,

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

        countTest(positive);

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

        MethodHandle target = null;

        Exception noAccess = null;

        try {

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

            target = lookup.findConstructor(defc, type);

        } catch (ReflectiveOperationException ex) {

            noAccess = ex;

            assertTrue(noAccess.getClass().getName(), noAccess instanceof IllegalAccessException);

        }

        if (verbosity >= 3)

            System.out.println("findConstructor "+defc.getName()+".<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 {

        CodeCacheOverflowProcessor.runMHTest(this::testBind0);

    }

    public void testBind0() throws Throwable {

        if (CAN_SKIP_WORKING)  return;

        startTest("bind");

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

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

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

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

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

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

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

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

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

        testBind(false, PRIVATE, Example.class, void.class, "<init>", int.class);

        testBind(false, PRIVATE, Example.class, void.class, "<init>", Void.class);

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

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

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

    }

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

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

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

        }

    }

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

        countTest(positive);

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

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

        Object receiver = randomArg(defc);

        MethodHandle target = null;

        Exception noAccess = null;

        try {

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

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

        } catch (ReflectiveOperationException ex) {

            noAccess = ex;

            assertExceptionClass(

                (name.contains("bogus") || INIT_REF_CAUSES_NSME && name.contains("<init>"))

                ? NoSuchMethodException.class

                : IllegalAccessException.class,

                noAccess);

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

        }

        if (verbosity >= 3)

            System.out.println("bind "+receiver+"."+name+"/"+type+" => "+target

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

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

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

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

        assertEquals(type, target.type());

        Object[] args = randomArgs(params);

        printCalled(target, name, args);

        target.invokeWithArguments(args);

        Object[] argsWithReceiver = cat(array(Object[].class, receiver), args);

        assertCalled(name, argsWithReceiver);

        if (verbosity >= 1)

            System.out.print(':');

    }

    @Test

    public void testUnreflect() throws Throwable {

        CodeCacheOverflowProcessor.runMHTest(this::testUnreflect0);

    }

    public void testUnreflect0() throws Throwable {

        if (CAN_SKIP_WORKING)  return;

        startTest("unreflect");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        // Test a public final member in another package:

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

    }

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

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

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

        }

    }

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

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

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

        }

    }

    void testUnreflectMaybeSpecial(Class<?> specialCaller,

                                   boolean positive, Lookup lookup,

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

        countTest(positive);

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

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

        Lookup specialLookup = (specialCaller != null ? maybeMoveIn(lookup, specialCaller) : null);

        boolean specialAccessOK = (specialCaller != null &&

                                  specialLookup.lookupClass() == specialCaller &&

                                  (specialLookup.lookupModes() & Lookup.PRIVATE) != 0);

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