/**

 * Back 2 Browser Bytecode Translator

 * Copyright (C) 2012 Jaroslav Tulach <jaroslav.tulach@apidesign.org>

 *

 * This program is free software: you can redistribute it and/or modify

 * it under the terms of the GNU General Public License as published by

 * the Free Software Foundation, version 2 of the License.

 *

 * This program 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 for more details.

 *

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

 * along with this program. Look for COPYING file in the top folder.

 * If not, see http://opensource.org/licenses/GPL-2.0.

 */

package org.apidesign.bck2brwsr.vm8;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import java.util.concurrent.Callable;

import org.apidesign.bck2brwsr.vmtest.Compare;

import org.apidesign.bck2brwsr.vmtest.VMTest;

import org.testng.annotations.Factory;

/**

 *

 * @author Jaroslav Tulach <jtulach@netbeans.org>

 */

public class LambdasTest extends LambdasSuper {

    @Compare public String StringverifyJSTime() throws Exception {

        return Lambdas.compound();

    }

    @Compare

    public int canCallLambda() {

        int[] arr = {0};

        Runnable incr = () -> {

            arr[0]++;

        };

        incr.run();

        return arr[0];

    }

    @Compare

    public String lambdaReturnsString() throws Exception {

        Callable<String> lambda = () -> "Hello World!";

        return lambda.call();

    }

    private interface Convertor<P, R> {

        public R convert(P value);

    }

    @Compare

    public int convertToLength() {

        Convertor<String, Integer> lambda = (String s) -> s.getBytes().length;

        return lambda.convert("buu");

    }

    private int meaningOfWorld = 0;

    @Compare

    public int accessToInstanceVar() {

        Runnable lambda = () -> {

            meaningOfWorld = 42;

        };

        lambda.run();

        return meaningOfWorld;

    }

    @Compare

    public int localMeaningOfWorld() {

        int[] meansOfWorld = new int[1];

        Runnable lambda = () -> {

            meansOfWorld[0] = 42;

        };

        lambda.run();

        return meansOfWorld[0];

    }

    @Compare

    public int useLocalVars() throws Exception {

        boolean bool = true;

        byte b = 2;

        short s = 3;

        int i = 4;

        long l = 5;

        float f = 6;

        double d = 7;

        char c = 8;

        Callable<Integer> lambda = () -> (int) ((bool ? 1 : 0) + b + s + i + l + f + d + c);

        return lambda.call();

    }

    @Compare

    public String callVirtualMethod() throws Exception {

        String foo = "foo";

        Callable<String> ref = foo::toUpperCase;

        return ref.call();

    }

    @Compare

    public int callInterfaceMethod() throws Exception {

        List<String> foos = Arrays.asList("foo");

        Callable<Integer> ref = foos::size;

        return ref.call();

    }

    @Compare

    public long callStaticMethod() throws Exception {

        long expected = System.currentTimeMillis();

        Callable<Long> ref = System::currentTimeMillis;

        return ref.call() & ~0xffff;

    }

    @Compare

    public String callConstructor() throws Exception {

        Callable<List<String>> ref = ArrayList<String>::new;

        return ref.call().toString();

    }

    @Compare

    public String superMethodOverridenByThis() throws Exception {

        Callable<String> ref = super::inheritedMethod;

        return ref.call();

    }

    @Override

    String inheritedMethod() {

        return "overridden version";

    }

    @Compare

    public String referencePrivateClassMethod() throws Exception {

        StringBuilder sb = new StringBuilder();

        Callable<String> ref1 = LambdasTest::privateClassMethod;

        sb.append(ref1.call());

        Callable<String> ref2 = this::privateInstanceMethod;

        sb.append("\n").append(ref2.call());

        // Normal method calls should still work after our magic

        // of making them them accessible from the lambda classes.

        sb.append("\n").append(privateClassMethod());

        sb.append("\n").append(privateInstanceMethod());

        return sb.toString();

    }

    private String privateInstanceMethod() {

        return "foo";

    }

    private static String privateClassMethod() {

        return "foo";

    }

    private String unrelatedPrivateMethod() {

        return "foo";

    }

    @Factory public static Object[] create() {

        return VMTest.create(LambdasTest.class);

    }

}