/*

 * Copyright (c) 2015, 2016, 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

 * @bug 8139885

 * @bug 8150635

 * @bug 8150956

 * @bug 8150957

 * @bug 8153637

 * @run testng/othervm -ea -esa test.java.lang.invoke.LoopCombinatorTest

 */

package test.java.lang.invoke;

import java.lang.invoke.MethodHandle;

import java.lang.invoke.MethodHandles;

import java.lang.invoke.MethodHandles.Lookup;

import java.lang.invoke.MethodType;

import java.util.*;

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

import static org.testng.AssertJUnit.*;

import org.testng.annotations.*;

/**

 * Tests for the loop combinators introduced in JEP 274.

 */

public class LoopCombinatorTest {

    static final Lookup LOOKUP = MethodHandles.lookup();

    @Test

    public static void testLoopFac() throws Throwable {

        MethodHandle[] counterClause = new MethodHandle[]{Fac.MH_zero, Fac.MH_inc};

        MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin};

        MethodHandle loop = MethodHandles.loop(counterClause, accumulatorClause);

        assertEquals(Fac.MT_fac, loop.type());

        assertEquals(120, loop.invoke(5));

    }

    @Test

    public static void testLoopFacNullInit() throws Throwable {

        // null initializer for counter, should initialize to 0

        MethodHandle[] counterClause = new MethodHandle[]{null, Fac.MH_inc};

        MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin};

        MethodHandle loop = MethodHandles.loop(counterClause, accumulatorClause);

        assertEquals(Fac.MT_fac, loop.type());

        assertEquals(120, loop.invoke(5));

    }

    @Test

    public static void testLoopNullInit() throws Throwable {

        // null initializer for counter, should initialize to 0, one-clause loop

        MethodHandle[] counterClause = new MethodHandle[]{null, Loop.MH_inc, Loop.MH_pred, Loop.MH_fin};

        MethodHandle loop = MethodHandles.loop(counterClause);

        assertEquals(Loop.MT_loop, loop.type());

        assertEquals(10, loop.invoke(10));

    }

    @Test

    public static void testLoopVoid1() throws Throwable {

        // construct a post-checked loop that only does one iteration and has a void body and void local state

        MethodHandle loop = MethodHandles.loop(new MethodHandle[]{Empty.MH_f, Empty.MH_f, Empty.MH_pred, null});

        assertEquals(MethodType.methodType(void.class), loop.type());

        loop.invoke();

    }

    @Test

    public static void testLoopVoid2() throws Throwable {

        // construct a post-checked loop that only does one iteration and has a void body and void local state,

        // initialized implicitly from the step type

        MethodHandle loop = MethodHandles.loop(new MethodHandle[]{null, Empty.MH_f, Empty.MH_pred, null});

        assertEquals(MethodType.methodType(void.class), loop.type());

        loop.invoke();

    }

    @Test

    public static void testLoopVoid3() throws Throwable {

        // construct a post-checked loop that only does one iteration and has a void body and void local state,

        // and that has a void finalizer

        MethodHandle loop = MethodHandles.loop(new MethodHandle[]{null, Empty.MH_f, Empty.MH_pred, Empty.MH_f});

        assertEquals(MethodType.methodType(void.class), loop.type());

        loop.invoke();

    }

    @Test

    public static void testLoopFacWithVoidState() throws Throwable {

        // like testLoopFac, but with additional void state that outputs a dot

        MethodHandle[] counterClause = new MethodHandle[]{Fac.MH_zero, Fac.MH_inc};

        MethodHandle[] accumulatorClause = new MethodHandle[]{Fac.MH_one, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin};

        MethodHandle[] dotClause = new MethodHandle[]{null, Fac.MH_dot};

        MethodHandle loop = MethodHandles.loop(counterClause, accumulatorClause, dotClause);

        assertEquals(Fac.MT_fac, loop.type());

        assertEquals(120, loop.invoke(5));

    }

    @Test

    public static void testLoopVoidInt() throws Throwable {

        // construct a post-checked loop that only does one iteration and has a void body and void local state,

        // and that returns a constant

        MethodHandle loop = MethodHandles.loop(new MethodHandle[]{null, Empty.MH_f, Empty.MH_pred, Empty.MH_c});

        assertEquals(MethodType.methodType(int.class), loop.type());

        assertEquals(23, loop.invoke());

    }

    @Test

    public static void testLoopWithVirtuals() throws Throwable {

        // construct a loop (to calculate factorial) that uses a mix of static and virtual methods

        MethodHandle[] counterClause = new MethodHandle[]{null, LoopWithVirtuals.permute(LoopWithVirtuals.MH_inc)};

        MethodHandle[] accumulatorClause = new MethodHandle[]{

                // init function must indicate the loop arguments (there is no other means to determine them)

                MethodHandles.dropArguments(LoopWithVirtuals.MH_one, 0, LoopWithVirtuals.class),

                LoopWithVirtuals.permute(LoopWithVirtuals.MH_mult),

                LoopWithVirtuals.permute(LoopWithVirtuals.MH_pred),

                LoopWithVirtuals.permute(LoopWithVirtuals.MH_fin)

        };

        MethodHandle loop = MethodHandles.loop(counterClause, accumulatorClause);

        assertEquals(LoopWithVirtuals.MT_loop, loop.type());

        assertEquals(120, loop.invoke(new LoopWithVirtuals(), 5));

    }

    @DataProvider

    static Object[][] negativeTestData() {

        MethodHandle i0 = MethodHandles.constant(int.class, 0);

        MethodHandle ii = MethodHandles.dropArguments(i0, 0, int.class, int.class);

        MethodHandle id = MethodHandles.dropArguments(i0, 0, int.class, double.class);

        MethodHandle i3 = MethodHandles.dropArguments(i0, 0, int.class, int.class, int.class);

        List<MethodHandle> inits = Arrays.asList(ii, id, i3);

        List<Class<?>> ints = Arrays.asList(int.class, int.class, int.class);

        List<MethodHandle> finis = Arrays.asList(Fac.MH_fin, Fac.MH_inc, Counted.MH_step);

        List<MethodHandle> preds1 = Arrays.asList(null, null, null);

        List<MethodHandle> preds2 = Arrays.asList(null, Fac.MH_fin, null);

        MethodHandle eek = MethodHandles.dropArguments(i0, 0, int.class, int.class, double.class);

        List<MethodHandle> nesteps = Arrays.asList(Fac.MH_inc, eek, Fac.MH_dot);

        List<MethodHandle> nepreds = Arrays.asList(null, Fac.MH_pred, null);

        List<MethodHandle> nefinis = Arrays.asList(null, Fac.MH_fin, null);

        List<MethodHandle> lvsteps = Arrays.asList(LoopWithVirtuals.MH_inc, LoopWithVirtuals.MH_mult);

        List<MethodHandle> lvpreds = Arrays.asList(null, LoopWithVirtuals.MH_pred);

        List<MethodHandle> lvfinis = Arrays.asList(null, LoopWithVirtuals.MH_fin);

        return new Object[][] {

                {null, "null or no clauses passed"},

                {new MethodHandle[][]{}, "null or no clauses passed"},

                {new MethodHandle[][]{{null, Fac.MH_inc}, {Fac.MH_one, null, Fac.MH_mult, Fac.MH_pred, Fac.MH_fin}},

                        "All loop clauses must be represented as MethodHandle arrays with at most 4 elements."},

                {new MethodHandle[][]{{null, Fac.MH_inc}, null}, "null clauses are not allowed"},

                {new MethodHandle[][]{{Fac.MH_zero, Fac.MH_dot}},

                        "clause 0: init and step return types must match: int != void"},

                {new MethodHandle[][]{{ii}, {id}, {i3}},

                        "found non-effectively identical init parameter type lists: " + inits +

                                " (common suffix: " + ints + ")"},

                {new MethodHandle[][]{{null, Fac.MH_inc, null, Fac.MH_fin}, {null, Fac.MH_inc, null, Fac.MH_inc},

                        {null, Counted.MH_start, null, Counted.MH_step}},

                        "found non-identical finalizer return types: " + finis + " (return type: int)"},

                {new MethodHandle[][]{{Fac.MH_zero, Fac.MH_inc}, {Fac.MH_one, Fac.MH_mult, null, Fac.MH_fin},

                        {null, Fac.MH_dot}}, "no predicate found: " + preds1},

                {new MethodHandle[][]{{Fac.MH_zero, Fac.MH_inc}, {Fac.MH_one, Fac.MH_mult, Fac.MH_fin, Fac.MH_fin},

                        {null, Fac.MH_dot}}, "predicates must have boolean return type: " + preds2},

                {new MethodHandle[][]{{Fac.MH_zero, Fac.MH_inc}, {Fac.MH_one, eek, Fac.MH_pred, Fac.MH_fin},

                        {null, Fac.MH_dot}},

                        "found non-effectively identical parameter type lists:\nstep: " + nesteps +

                                "\npred: " + nepreds + "\nfini: " + nefinis + " (common parameter sequence: " + ints + ")"},

                {new MethodHandle[][]{{null, LoopWithVirtuals.MH_inc},

                        {LoopWithVirtuals.MH_one, LoopWithVirtuals.MH_mult, LoopWithVirtuals.MH_pred, LoopWithVirtuals.MH_fin}},

                        "found non-effectively identical parameter type lists:\nstep: " + lvsteps +

                                "\npred: " + lvpreds + "\nfini: " + lvfinis + " (common parameter sequence: " + ints + ")"}

        };

    }

    static final MethodHandle MH_loop;

    static {

        try {

            MH_loop = LOOKUP.findStatic(MethodHandles.class, "loop", methodType(MethodHandle.class, MethodHandle[][].class));

        } catch (NoSuchMethodException | IllegalAccessException e) {

            throw new ExceptionInInitializerError(e);

        }

    }

    @Test(dataProvider = "negativeTestData")

    public static void testLoopNegative(MethodHandle[][] clauses, String expectedMessage) throws Throwable {

        boolean caught = false;

        try {

            MH_loop.invokeWithArguments(clauses);

        } catch (IllegalArgumentException iae) {

            assertEquals(expectedMessage, iae.getMessage());

            caught = true;

        }

        assertTrue(caught);

    }

    @Test

    public static void testWhileLoop() throws Throwable {

        // int i = 0; while (i < limit) { ++i; } return i; => limit

        MethodHandle loop = MethodHandles.whileLoop(While.MH_zero, While.MH_pred, While.MH_step);

        assertEquals(While.MT_while, loop.type());

        assertEquals(23, loop.invoke(23));

    }

    @Test

    public static void testWhileLoopNoIteration() throws Throwable {

        // a while loop that never executes its body because the predicate evaluates to false immediately

        MethodHandle loop = MethodHandles.whileLoop(While.MH_initString, While.MH_predString, While.MH_stepString);

        assertEquals(While.MT_string, loop.type());

        assertEquals("a", loop.invoke());

    }

    @Test

    public static void testDoWhileLoop() throws Throwable {

        // int i = 0; do { ++i; } while (i < limit); return i; => limit

        MethodHandle loop = MethodHandles.doWhileLoop(While.MH_zero, While.MH_step, While.MH_pred);

        assertEquals(While.MT_while, loop.type());

        assertEquals(23, loop.invoke(23));

    }

    @Test

    public static void testDoWhileNullInit() throws Throwable {

        While w = new While();

        int v = 5;

        MethodHandle loop = MethodHandles.doWhileLoop(null, While.MH_voidBody.bindTo(w), While.MH_voidPred.bindTo(w));

        assertEquals(While.MT_void, loop.type());

        loop.invoke(v);

        assertEquals(v, w.i);

    }

    @Test

    public static void testWhileZip() throws Throwable {

        MethodHandle loop = MethodHandles.doWhileLoop(While.MH_zipInitZip, While.MH_zipStep, While.MH_zipPred);

        assertEquals(While.MT_zip, loop.type());

        List<String> a = Arrays.asList("a", "b", "c", "d");

        List<String> b = Arrays.asList("e", "f", "g", "h");

        List<String> zipped = Arrays.asList("a", "e", "b", "f", "c", "g", "d", "h");

        assertEquals(zipped, (List<String>) loop.invoke(a.iterator(), b.iterator()));

    }

    @Test

    public static void testWhileNullInit() throws Throwable {

        While w = new While();

        int v = 5;

        MethodHandle loop = MethodHandles.whileLoop(null, While.MH_voidPred.bindTo(w), While.MH_voidBody.bindTo(w));

        assertEquals(While.MT_void, loop.type());

        loop.invoke(v);

        assertEquals(v, w.i);

    }

    @Test

    public static void testWhileVoidInit() throws Throwable {

        While w = new While();

        int v = 5;

        MethodHandle loop = MethodHandles.whileLoop(While.MH_voidInit.bindTo(w), While.MH_voidPred.bindTo(w),

                While.MH_voidBody.bindTo(w));

        assertEquals(While.MT_void, loop.type());

        loop.invoke(v);

        assertEquals(v, w.i);

    }

    @Test

    public static void testDoWhileVoidInit() throws Throwable {

        While w = new While();

        int v = 5;

        MethodHandle loop = MethodHandles.doWhileLoop(While.MH_voidInit.bindTo(w), While.MH_voidBody.bindTo(w),

                While.MH_voidPred.bindTo(w));

        assertEquals(While.MT_void, loop.type());

        loop.invoke(v);

        assertEquals(v, w.i);

    }

    @Test

    public static void testCountedLoop() throws Throwable {

        // String s = "Lambdaman!"; for (int i = 0; i < 13; ++i) { s = "na " + s; } return s; => a variation on a well known theme

        MethodHandle fit13 = MethodHandles.constant(int.class, 13);

        MethodHandle loop = MethodHandles.countedLoop(fit13, Counted.MH_start, Counted.MH_step);

        assertEquals(Counted.MT_counted, loop.type());

        assertEquals("na na na na na na na na na na na na na Lambdaman!", loop.invoke("Lambdaman!"));

    }

    @Test

    public static void testCountedLoopVoidInit() throws Throwable {

        MethodHandle fit5 = MethodHandles.constant(int.class, 5);

        MethodHandle loop = MethodHandles.countedLoop(fit5, MethodHandles.zero(void.class), Counted.MH_printHello);

        assertEquals(Counted.MT_countedPrinting, loop.type());

        loop.invoke();

    }

    @Test

    public static void testCountedArrayLoop() throws Throwable {

        // int[] a = new int[]{0}; for (int i = 0; i < 13; ++i) { ++a[0]; } => a[0] == 13

        MethodHandle fit13 = MethodHandles.dropArguments(MethodHandles.constant(int.class, 13), 0, int[].class);

        MethodHandle loop = MethodHandles.countedLoop(fit13, null, Counted.MH_stepUpdateArray);

        assertEquals(Counted.MT_arrayCounted, loop.type());

        int[] a = new int[]{0};

        loop.invoke(a);

        assertEquals(13, a[0]);

    }

    @Test

    public static void testCountedPrintingLoop() throws Throwable {

        MethodHandle fit5 = MethodHandles.constant(int.class, 5);

        MethodHandle loop = MethodHandles.countedLoop(fit5, null, Counted.MH_printHello);

        assertEquals(Counted.MT_countedPrinting, loop.type());

        loop.invoke();

    }

    @Test

    public static void testCountedRangeLoop() throws Throwable {

        // String s = "Lambdaman!"; for (int i = -5; i < 8; ++i) { s = "na " + s; } return s; => a well known theme

        MethodHandle fitm5 = MethodHandles.dropArguments(Counted.MH_m5, 0, String.class);

        MethodHandle fit8 = MethodHandles.dropArguments(Counted.MH_8, 0, String.class);

        MethodHandle loop = MethodHandles.countedLoop(fitm5, fit8, Counted.MH_start, Counted.MH_step);

        assertEquals(Counted.MT_counted, loop.type());

        assertEquals("na na na na na na na na na na na na na Lambdaman!", loop.invoke("Lambdaman!"));

    }

    @Test

    public static void testCountedLoopCounterInit() throws Throwable {

        // int x = 0; for (int i = 0; i < 5; ++i) { x += i; } return x; => 10

        // (only if counter's first value in body is 0)

        MethodHandle iter = MethodHandles.constant(int.class, 5);

        MethodHandle init = MethodHandles.constant(int.class, 0);

        MethodHandle body = Counted.MH_addCounter;

        MethodHandle loop = MethodHandles.countedLoop(iter, init, body);

        assertEquals(Counted.MT_counterInit, loop.type());

        assertEquals(10, loop.invoke());

    }

    @Test

    public static void testIterateSum() throws Throwable {

        // Integer[] a = new Integer[]{1,2,3,4,5,6}; int sum = 0; for (int e : a) { sum += e; } return sum; => 21

        MethodHandle loop = MethodHandles.iteratedLoop(Iterate.MH_sumIterator, Iterate.MH_sumInit, Iterate.MH_sumStep);

        assertEquals(Iterate.MT_sum, loop.type());

        assertEquals(21, loop.invoke(new Integer[]{1, 2, 3, 4, 5, 6}));

    }

    @Test

    public static void testIterateReverse() throws Throwable {

        MethodHandle loop = MethodHandles.iteratedLoop(null, Iterate.MH_reverseInit, Iterate.MH_reverseStep);

        assertEquals(Iterate.MT_reverse, loop.type());

        List<String> list = Arrays.asList("a", "b", "c", "d", "e");

        List<String> reversedList = Arrays.asList("e", "d", "c", "b", "a");

        assertEquals(reversedList, (List<String>) loop.invoke(list));

    }

    @Test

    public static void testIterateLength() throws Throwable {

        MethodHandle loop = MethodHandles.iteratedLoop(null, Iterate.MH_lengthInit, Iterate.MH_lengthStep);

        assertEquals(Iterate.MT_length, loop.type());

        List<Double> list = Arrays.asList(23.0, 148.0, 42.0);

        assertEquals(list.size(), (int) loop.invoke(list));

    }

    @Test

    public static void testIterateMap() throws Throwable {

        MethodHandle loop = MethodHandles.iteratedLoop(null, Iterate.MH_mapInit, Iterate.MH_mapStep);

        assertEquals(Iterate.MT_map, loop.type());

        List<String> list = Arrays.asList("Hello", "world", "!");

        List<String> upList = Arrays.asList("HELLO", "WORLD", "!");

        assertEquals(upList, (List<String>) loop.invoke(list));

    }

    @Test

    public static void testIteratePrint() throws Throwable {

        MethodHandle loop = MethodHandles.iteratedLoop(null, null, Iterate.MH_printStep);

        assertEquals(Iterate.MT_print, loop.type());

        loop.invoke(Arrays.asList("hello", "world"));

    }

    @Test

    public static void testIterateNullBody() {

        boolean caught = false;

        try {

            MethodHandles.iteratedLoop(MethodHandles.empty(methodType(Iterator.class, int.class)),

                    MethodHandles.identity(int.class), null);

        } catch (IllegalArgumentException iae) {

            assertEquals("iterated loop body must not be null", iae.getMessage());

            caught = true;

        }

        assertTrue(caught);

    }

        boolean caught = false;

        try {

            MethodHandles.iteratedLoop(MethodHandles.empty(v), null, MethodHandles.empty(v));

        } catch(IllegalArgumentException iae) {

            assertEquals("iteratedLoop first argument must have Iterator return type", iae.getMessage());

            caught = true;

        }

        assertTrue(caught);

    }

    @Test

    public static void testIterateVoidInit() throws Throwable {

        MethodHandle loop = MethodHandles.iteratedLoop(null, Iterate.MH_voidInit, Iterate.MH_printStep);

        assertEquals(Iterate.MT_print, loop.type());

        loop.invoke(Arrays.asList("hello", "world"));

    }

    static class Empty {

        static void f() { }

        static boolean pred() {

            return false;

        }

        static int c() {

            return 23;

        }

        static final Class<Empty> EMPTY = Empty.class;

        static final MethodType MT_f = methodType(void.class);

        static final MethodType MT_pred = methodType(boolean.class);

        static final MethodType MT_c = methodType(int.class);