/*

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

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

 *

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

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

 * published by the Free Software Foundation.

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

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

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

 * questions.

 */

/* @test

 * @summary High arity invocations

 * @compile BigArityTest.java

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

 */

package test.java.lang.invoke;

import org.junit.Test;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodType;

import java.lang.invoke.WrongMethodTypeException;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Objects;

import static org.junit.Assert.assertEquals;

public class BigArityTest {

    static MethodHandles.Lookup LOOKUP = MethodHandles.lookup();

    static final int MAX_JVM_ARITY = 255;

    static final int ITERATION_COUNT = getProperty("ITERATION_COUNT", 40000);

    static final int MIN_ARITY = getProperty("MIN_ARITY", 250);

    static final int SLOW_ARITY = getProperty("SLOW_ARITY", MAX_JVM_ARITY-3);

    static final int MAX_ARITY = getProperty("MAX_ARITY", MAX_JVM_ARITY-1);  // always -1 for the MH reciever itself

    private static int getProperty(String name, int dflt) {

        return Integer.parseInt(getProperty(name, ""+dflt));

    }

    private static String getProperty(String name, String dflt) {

        String x = System.getProperty(BigArityTest.class.getSimpleName() + "." + name);

        if (x == null)  x = System.getProperty(BigArityTest.class.getName() + "." + name);

        return x == null ? dflt : x;

    }

    static final MethodType MT_A = MethodType.methodType(Object.class, Object.class, Object[].class, Object.class);

    static Object hashArguments(Object... args) {

        return Objects.hash(args);

    }

    static Object hashArguments(int... args) {

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

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

            wrappedArgs[i] = args[i];

        }

        return hashArguments(wrappedArgs);

    }

    static Object hashArguments(long... args) {

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

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

            wrappedArgs[i] = (int) args[i];

        }

        return hashArguments(wrappedArgs);

    }

    static Object hashArguments1(Object o, Object... args) {

        Object[] arr = new Object[args.length + 1];

        arr[0] = 0;

        System.arraycopy(args, 0, arr, 1, args.length);

        return Objects.hash(arr);

    }

    static Object hashArguments1(int i0, int... args) {

        Object[] wrappedArgs = new Object[args.length + 1];

        wrappedArgs[0] = i0;

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

            wrappedArgs[i + 1] = args[i];

        }

        return hashArguments(wrappedArgs);

    }

    static Object hashArguments1(long l0, long... args) {

        Object[] wrappedArgs = new Object[args.length + 1];

        wrappedArgs[0] = l0;

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

            wrappedArgs[i + 1] = (int) args[i];

        }

        return hashArguments(wrappedArgs);

    }

    static final MethodHandle MH_hashArguments_VA;

    static final MethodHandle MH_hashArguments_IVA;

    static final MethodHandle MH_hashArguments_JVA;

    static final MethodHandle MH_hashArguments1_VA;

    static final MethodHandle MH_hashArguments1_IVA;

    static final MethodHandle MH_hashArguments1_JVA;

    static {

        try {

            MH_hashArguments_VA =

                MethodHandles.lookup().unreflect(

                    BigArityTest.class.getDeclaredMethod("hashArguments", Object[].class));

            MH_hashArguments_IVA =

                MethodHandles.lookup().unreflect(

                    BigArityTest.class.getDeclaredMethod("hashArguments", int[].class));

            MH_hashArguments_JVA =

                MethodHandles.lookup().unreflect(

                    BigArityTest.class.getDeclaredMethod("hashArguments", long[].class));

            MH_hashArguments1_VA =

                MethodHandles.lookup().unreflect(

                    BigArityTest.class.getDeclaredMethod("hashArguments1", Object.class, Object[].class));

            MH_hashArguments1_IVA =

                MethodHandles.lookup().unreflect(

                    BigArityTest.class.getDeclaredMethod("hashArguments1", int.class, int[].class));

            MH_hashArguments1_JVA =

                MethodHandles.lookup().unreflect(

                    BigArityTest.class.getDeclaredMethod("hashArguments1", long.class, long[].class));

        } catch (ReflectiveOperationException ex) {

            throw new Error(ex);

        }

    }

    static MethodHandle MH_hashArguments(int arity) {

        MethodType mt = MethodType.genericMethodType(arity);

        return MH_hashArguments_VA.asType(mt);

    }

    static MethodHandle MH_hashArguments(Class<? extends Object[]> arrayClass, int arity) {

        if (arrayClass == Object[].class)

            return MH_hashArguments(arity);

        ArrayList<Class<?>> ptypes = new ArrayList<>(Collections.<Class<?>>nCopies(arity, arrayClass.getComponentType()));

        MethodType mt = MethodType.methodType(Object.class, ptypes);

        return MH_hashArguments_VA.asType(mt);

    }

    static Object[] testArgs(int arity) {

        Object args[] = new Object[arity];

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

            args[i] = i * (i + 1) / 2;

        return args;

    }

    @Test

    public void asCollectorIAE01() throws ReflectiveOperationException {

        final int [] INVALID_ARRAY_LENGTHS = {

            Integer.MIN_VALUE, Integer.MIN_VALUE + 1, -2, -1, 255, 256, Integer.MAX_VALUE - 1, Integer.MAX_VALUE

        };

        MethodHandle target = MethodHandles.publicLookup().findStatic(Arrays.class,

                "deepToString", MethodType.methodType(String.class, Object[].class));

        int minbig = Integer.MAX_VALUE;

        for (int invalidLength : INVALID_ARRAY_LENGTHS) {

            if (minbig > invalidLength && invalidLength > 100)  minbig = invalidLength;

            try {

                target.asCollector(Object[].class, invalidLength);

                assert(false) : invalidLength;

            } catch (IllegalArgumentException ex) {

                System.out.println("OK: "+ex);

            }

        }

        // Sizes not in the above array are good:

        target.asCollector(Object[].class, minbig - 1);

        for (int i = 2; i <= 10; i++)

            target.asCollector(Object[].class, minbig - i);

    }

    static void asciae02target(Object[] a, Object b) {

        // naught

    }

    @Test

    public void asCollectorIAE02() throws ReflectiveOperationException {

        final int[] INVALID_ARRAY_LENGTHS = {

            Integer.MIN_VALUE, Integer.MIN_VALUE + 1, -2, -1, 254, 255, Integer.MAX_VALUE - 1, Integer.MAX_VALUE

        };

        MethodHandle target = MethodHandles.lookup().findStatic(BigArityTest.class, "asciae02target",

                MethodType.methodType(void.class, Object[].class, Object.class));

        int minbig = Integer.MAX_VALUE;

        for (int invalidLength : INVALID_ARRAY_LENGTHS) {

            if (minbig > invalidLength && invalidLength > 100) minbig = invalidLength;

            try {

                target.asCollector(0, Object[].class, invalidLength);

                assert(false) : invalidLength;

            } catch (IllegalArgumentException ex) {

                System.out.println("OK: "+ex);

            }

        }

        // Sizes not in the above array are good:

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

            target.asCollector(0, Object[].class, minbig - i);

        }

    }

    @Test

    public void invoker02() {

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

            MethodType mt = MethodType.genericMethodType(i);

            MethodType expMT = mt.insertParameterTypes(0, MethodHandle.class);

            if (i < 254) {

                assertEquals(expMT, MethodHandles.invoker(mt).type());

            } else {

                try {

                    MethodHandles.invoker(mt);

                    assert(false) : i;

                } catch (IllegalArgumentException ex) {

                    System.out.println("OK: "+ex);

                }

            }

        }

    }

    @Test

    public void exactInvoker02() {

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

            MethodType mt = MethodType.genericMethodType(i);

            MethodType expMT = mt.insertParameterTypes(0, MethodHandle.class);

            if (i < 254) {

                assertEquals(expMT, MethodHandles.exactInvoker(mt).type());

            } else {

                try {

                    MethodHandles.exactInvoker(mt);

                    assert(false) : i;

                } catch (IllegalArgumentException ex) {

                    System.out.println("OK: "+ex);

                }

            }

        }

    }

    @Test

    public void testBoundaryValues() throws Throwable {

        for (int badArity : new int[]{ -1, MAX_JVM_ARITY+1, MAX_JVM_ARITY }) {

            try {

                MethodHandle badmh = MH_hashArguments(badArity);

                throw new AssertionError("should not be able to build a 255-arity MH: "+badmh);

            } catch (IllegalArgumentException | WrongMethodTypeException ex) {

                System.out.println("OK: "+ex);

            }

        }

        final int MAX_MH_ARITY      = MAX_JVM_ARITY - 1;  // mh.invoke(arg*[N])

        final int MAX_INVOKER_ARITY = MAX_MH_ARITY - 1;   // inv.invoke(mh, arg*[N])

        for (int arity : new int[]{ 0, 1, MAX_MH_ARITY-2, MAX_MH_ARITY-1, MAX_MH_ARITY }) {

            MethodHandle mh = MH_hashArguments(arity);

            if (arity < MAX_INVOKER_ARITY) {

                MethodHandle ximh = MethodHandles.exactInvoker(mh.type());

                MethodHandle gimh = MethodHandles.invoker(mh.type());

                MethodHandle simh = MethodHandles.spreadInvoker(mh.type(), 0);

                if (arity != 0) {

                    simh = MethodHandles.spreadInvoker(mh.type(), 1);

                } else {

                    try {

                        simh = MethodHandles.spreadInvoker(mh.type(), 1);

                        assert(false) : arity;

                    } catch (IllegalArgumentException ex) {

                        System.out.println("OK: "+ex);

                    }

                }

                if (arity != 0) {

                    simh = MethodHandles.spreadInvoker(mh.type(), arity-1);

                } else {

                    try {

                        simh = MethodHandles.spreadInvoker(mh.type(), arity-1);

                        assert(false) : arity;

                    } catch (IllegalArgumentException ex) {

                        System.out.println("OK: "+ex);

                    }

                }

                simh = MethodHandles.spreadInvoker(mh.type(), arity);

            }

        }

    }

    // Make sure the basic argument spreading and varargs mechanisms are working.

    // Exercise arity 3 thoroughly.

    @Test

    public void testSpreads() throws Throwable {

        System.out.println("testing asSpreader on arity=3");

        Object[] args = testArgs(3);

        int r0 = Objects.hash(args);

        MethodHandle mh = MH_hashArguments(3);

        Object r;

        r = mh.invokeExact(args[0], args[1], args[2]);

        assertEquals(r0, r);

        r = mh.invoke(args[0], args[1], args[2]);

        assertEquals(r0, r);

        r = mh.invoke((Comparable) args[0], (Integer) args[1], (Number) args[2]);

        assertEquals(r0, r);

        r = mh.invokeWithArguments(args);

        assertEquals(r0, r);

        for (Class<?> cls0 : new Class<?>[] {

            Object[].class, Number[].class, Integer[].class, Comparable[].class

        }) {

            @SuppressWarnings("unchecked")

            Class<? extends Object[]> cls = (Class<? extends Object[]>) cls0;

            //Class<? extends Object[]> cls = Object[].class.asSubclass(cls0);

            int nargs = args.length, skip;

            Object hr;

            MethodHandle smh = mh.asSpreader(cls, nargs - (skip = 0));

            MethodHandle hsmh = mh.asSpreader(0, cls, nargs - skip);

            Object[] tail = Arrays.copyOfRange(args, skip, nargs, cls);

            Object[] head = Arrays.copyOfRange(args, 0, nargs - skip, cls);

            if (cls == Object[].class) {

                r = smh.invokeExact(tail);

                hr = hsmh.invokeExact(head);

            } else if (cls == Integer[].class) {

                r = smh.invokeExact((Integer[]) tail); //warning OK, see 8019340

                hr = hsmh.invokeExact((Integer[]) head);

            } else {

                r = smh.invoke(tail);

                hr = hsmh.invoke(head);

            }

            assertEquals(r0, r);

            assertEquals(r0, hr);

            smh = mh.asSpreader(cls, nargs - (skip = 1));

            hsmh = mh.asSpreader(0, cls, nargs - skip);

            tail = Arrays.copyOfRange(args, skip, nargs, cls);

            head = Arrays.copyOfRange(args, 0, nargs - skip, cls);

            if (cls == Object[].class) {

                r = smh.invokeExact(args[0], tail);

                hr = hsmh.invokeExact(head, args[2]);

            } else if (cls == Integer[].class) {

                r = smh.invokeExact(args[0], (Integer[]) tail);

                hr = hsmh.invokeExact((Integer[]) head, args[2]);

            } else {

                r = smh.invoke(args[0], tail);

                hr = hsmh.invoke(head, args[2]);

            }

            assertEquals(r0, r);

            assertEquals(r0, hr);

            smh = mh.asSpreader(cls, nargs - (skip = 2));

            hsmh = mh.asSpreader(0, cls, nargs - skip);

            tail = Arrays.copyOfRange(args, skip, nargs, cls);

            head = Arrays.copyOfRange(args, 0, nargs - skip, cls);

            if (cls == Object[].class) {

                r = smh.invokeExact(args[0], args[1], tail);

                hr = hsmh.invokeExact(head, args[1], args[2]);

            } else if (cls == Integer[].class) {

                r = smh.invokeExact(args[0], args[1], (Integer[]) tail);

                hr = hsmh.invokeExact((Integer[]) head, args[1], args[2]);

            } else {

                r = smh.invoke(args[0], args[1], tail);

                hr = hsmh.invoke(head, args[1], args[2]);

            }

            assertEquals(r0, r);

            assertEquals(r0, hr);

            smh = mh.asSpreader(cls, nargs - (skip = 3));

            hsmh = mh.asSpreader(0, cls, nargs - skip);

            tail = Arrays.copyOfRange(args, skip, nargs, cls);

            head = Arrays.copyOfRange(args, 0, nargs - skip, cls);

            if (cls == Object[].class) {

                r = smh.invokeExact(args[0], args[1], args[2], tail);

                hr = hsmh.invokeExact(head, args[0], args[1], args[2]);

            } else if (cls == Integer[].class) {

                r = smh.invokeExact(args[0], args[1], args[2], (Integer[]) tail);

                hr = hsmh.invokeExact((Integer[]) head, args[0], args[1], args[2]);

            } else {

                r = smh.invoke(args[0], args[1], args[2], tail);

                hr = hsmh.invoke(head, args[0], args[1], args[2]);

            }

            assertEquals(r0, r);

            assertEquals(r0, hr);

            // Try null array in addition to zero-length array:

            tail = null;

            head = null;

            if (cls == Object[].class) {

                r = smh.invokeExact(args[0], args[1], args[2], tail);

                hr = hsmh.invokeExact(head, args[0], args[1], args[2]);

            } else if (cls == Integer[].class) {

                r = smh.invokeExact(args[0], args[1], args[2], (Integer[]) tail);

                hr = hsmh.invokeExact((Integer[]) head, args[0], args[1], args[2]);

            } else {

                r = smh.invoke(args[0], args[1], args[2], tail);

                hr = hsmh.invoke(head, args[0], args[1], args[2]);

            }

            assertEquals(r0, r);

            assertEquals(r0, hr);

        }

    }

    @Test

    public void testInvokeWithArguments() throws Throwable {

        System.out.println("testing invokeWithArguments on all arities");

        for (int arity = 0; arity < MAX_ARITY; arity++) {

            Object[] args = testArgs(arity);

            Object r0 = Objects.hash(args);

            Object r = MH_hashArguments(arity).invokeWithArguments(args);

            assertEquals("arity="+arity, r0, r);

        }

        // The next one is the most likely to fail:

        int arity = MAX_ARITY;

        Object[] args = testArgs(arity);

        Object r0 = Objects.hash(args);

        Object r = MH_hashArguments(arity).invokeWithArguments(args);

        assertEquals("arity=MAX_ARITY", r0, r);

    }

    @Test

    public void testInvokeWithArgumentsJumbo() throws Throwable {

        System.out.println("testing invokeWithArguments on jumbo arities");

        ArrayList<Integer> arities = new ArrayList<>();

        for (int arity = 125; arity < 1000; arity += (arity < MAX_ARITY+10 ? 1 : arity/7)) {

            arities.add(arity);

            Object[] args = testArgs(arity);

            Object r0 = Objects.hash(args);

            assertEquals("jumbo arity="+arity, r0, MH_hashArguments_VA.invokeWithArguments(args));

            assertEquals("jumbo arity="+arity, r0, MH_hashArguments1_VA.invokeWithArguments(args));

            // use primitive typed argument lists also:

            assertEquals("jumbo int arity="+arity, r0, MH_hashArguments_IVA.invokeWithArguments(args));

            assertEquals("jumbo int arity="+arity, r0, MH_hashArguments1_IVA.invokeWithArguments(args));

            assertEquals("jumbo long arity="+arity, r0, MH_hashArguments_JVA.invokeWithArguments(args));

            assertEquals("jumbo long arity="+arity, r0, MH_hashArguments1_JVA.invokeWithArguments(args));

        }

        System.out.println("  jumbo arities = "+arities);

    }

    static Object[] cat(Object a, Object[] b) {

        int alen = 1, blen = b.length;

        Object[] c = new Object[alen + blen];

        c[0] = a;

        System.arraycopy(b, 0, c, alen, blen);

        return c;

    }

    @Test

    public void testArities() throws Throwable {

        System.out.println("testing spreaders and collectors on high arities...");

        int iterations = ITERATION_COUNT;

        testArities(Object[].class, MIN_ARITY-10, MIN_ARITY-1, iterations / 1000);

        testArities(Object[].class, MIN_ARITY, SLOW_ARITY-1, iterations);

        testArities(Object[].class, SLOW_ARITY, MAX_ARITY, iterations / 1000);

    }

    @Test

    public void testAritiesOnTypedArrays() throws Throwable {

        for (Class<?> cls0 : new Class<?>[] {

            Number[].class, Integer[].class, Comparable[].class

        }) {

            @SuppressWarnings("unchecked")

            Class<? extends Object[]> cls = (Class<? extends Object[]>) cls0;

            System.out.println("array class: "+cls.getSimpleName());

            int iterations = ITERATION_COUNT / 1000;

            try {

                testArities(cls, MIN_ARITY, SLOW_ARITY - 1, iterations);

                testArities(cls, SLOW_ARITY, MAX_ARITY, iterations / 100);

            } catch (Throwable t) {

                t.printStackTrace();

                throw t;

            }

        }

    }

    private void testArities(Class<? extends Object[]> cls,

                             int minArity,

                             int maxArity,

                             int iterations) throws Throwable {

        boolean verbose = (cls == Object[].class);

        for (int arity = minArity; arity <= maxArity; arity++) {

            if (verbose)  System.out.println("arity="+arity);

            MethodHandle mh = MH_hashArguments(cls, arity);

            MethodHandle mh_VA = mh.asSpreader(cls, arity);

            MethodHandle mh_VA_h = mh.asSpreader(0, cls, arity-1);

            assert(mh_VA.type().parameterType(0) == cls);

            assert(mh_VA_h.type().parameterType(0) == cls);

            testArities(cls, arity, iterations, verbose, mh, mh_VA, mh_VA_h);

            // mh_CA will collect arguments of a particular type and pass them to mh_VA

            MethodHandle mh_CA = mh_VA.asCollector(cls, arity);

            MethodHandle mh_VA2 = mh_CA.asSpreader(cls, arity);

            MethodHandle mh_VA2_h = mh_CA.asSpreader(0, cls, arity-1);

            assert(mh_CA.type().equals(mh.type()));

            assert(mh_VA2.type().equals(mh_VA.type()));

            if (cls != Object[].class) {

                try {

                    mh_VA2.invokeWithArguments(new Object[arity]);

                    throw new AssertionError("should not reach");

                } catch (ClassCastException | WrongMethodTypeException ex) {

                }

            }

            int iterations_VA = iterations / 100;

            testArities(cls, arity, iterations_VA, false, mh_CA, mh_VA2, mh_VA2_h);

        }

    }

   /**

     * Tests calls to {@link BigArityTest#hashArguments hashArguments} as related to a single given arity N.

     * Applies the given {@code mh} to a set of N integer arguments, checking the answer.

     * Also applies the varargs variation {@code mh_VA} to an array of type C[] (given by {@code cls}).

     * Test steps:

     * <ul>

     * <li>mh_VA.invokeExact(new C[]{ arg, ... })</li>