/*

 * Copyright (c) 2009, 2012, 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.lang.invoke.MethodHandles

 * @compile MethodHandlesTest.java remote/RemoteExample.java

 * @run junit/othervm/timeout=2500 -XX:+IgnoreUnrecognizedVMOptions -XX:-VerifyDependencies -esa test.java.lang.invoke.MethodHandlesTest

 */

package test.java.lang.invoke;

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

import java.lang.invoke.*;

import java.lang.invoke.MethodHandles.Lookup;

import java.lang.reflect.*;

import java.util.*;

import org.junit.*;

import static org.junit.Assert.*;

/**

 *

 * @author jrose

 */

public class MethodHandlesTest {

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

    // How much output?

    static int verbosity = 0;

    static {

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

        if (vstr == null)

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

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

    }

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

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

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

    static final boolean CAN_SKIP_WORKING;

    static {

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

        if (vstr == null)

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

        CAN_SKIP_WORKING = Boolean.parseBoolean(vstr);

    }

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

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

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

    @Test

    public void testFirst() throws Throwable {

        verbosity += 9; try {

            // left blank for debugging

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

    }

    static final int MAX_ARG_INCREASE = 3;

    public MethodHandlesTest() {

    }

    String testName;

    static int allPosTests, allNegTests;

    int posTests, negTests;

    @After

    public void printCounts() {

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

            System.out.println();

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

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

            allPosTests += posTests;

            allNegTests += negTests;

            posTests = negTests = 0;

        }

    }

    void countTest(boolean positive) {

        if (positive) ++posTests;

        else          ++negTests;

    }

    void countTest() { countTest(true); }

    void startTest(String name) {

        if (testName != null)  printCounts();

        if (verbosity >= 1)

            System.out.println(name);

        posTests = negTests = 0;

        testName = name;

    }

    @BeforeClass

    public static void setUpClass() throws Exception {

        calledLog.clear();

        calledLog.add(null);

        nextArgVal = INITIAL_ARG_VAL;

    }

    @AfterClass

    public static void tearDownClass() throws Exception {

        int posTests = allPosTests, negTests = allNegTests;

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

            System.out.println();

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

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

        }

    }

    static List<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("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)

    }

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

        Object wrap = null;

        if (value instanceof Number)

            wrap = castToWrapperOrNull(((Number)value).longValue(), dst);

        if (value instanceof Character)

            wrap = castToWrapperOrNull((char)(Character)value, dst);

        if (wrap != null)  return wrap;

        return dst.cast(value);

    }

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

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

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

            return (int)(value);

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

            return (long)(value);

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

            return (char)(value);

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

            return (short)(value);

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

            return (float)(value);

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

            return (double)(value);

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

            return (byte)(value);

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

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

        return null;

    }

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

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

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

    static long nextArgVal;

    static long nextArg(boolean moreBits) {

        long val = nextArgVal++;

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

        val >>= 1;

        if (moreBits)

            // Guarantee some bits in the high word.

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

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

            // strings unnecessarily noisy.

            val += (val % ONE_MILLION) * TEN_BILLION;

        return val ^ sign;

    }

    static int nextArg() {

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

        // Example: 1_000_042.

        return (int) nextArg(false);

    }

    static long nextArg(Class<?> kind) {

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

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

            // produce a 64-bit result something like

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

            // Example: 10_000_420_001_000_042.

            return nextArg(true);

        return (long) nextArg();

    }

    static Object randomArg(Class<?> param) {

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

        if (wrap != null) {

            return wrap;

        }

//        import sun.invoke.util.Wrapper;

//        Wrapper wrap = Wrapper.forBasicType(dst);

//        if (wrap == Wrapper.OBJECT && Wrapper.isWrapperType(dst))

//            wrap = Wrapper.forWrapperType(dst);

//        if (wrap != Wrapper.OBJECT)

//            return wrap.wrap(nextArg++);

        if (param.isInterface()) {

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

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

                    { param = c; break; }

            }

        }

        if (param.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);