/*
 * Copyright (c) 2012, 2013, 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.
 */
package org.openjdk.tests.java.lang.invoke;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.NotSerializableException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.lang.invoke.CallSite;
import java.lang.invoke.LambdaMetafactory;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.invoke.MethodType;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.LongConsumer;
import java.util.function.Predicate;
import java.util.function.Supplier;

import org.testng.annotations.Test;

import static org.testng.Assert.assertFalse;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.fail;

/**
 * SerializedLambdaTest
 *
 * @author Brian Goetz
 */
@Test
public class SerializedLambdaTest {
    public static final int REPS = 50;

    @SuppressWarnings("unchecked")
    private<T> void assertSerial(T p, Consumer<T> asserter) throws IOException, ClassNotFoundException {
        asserter.accept(p);

        for (int i=0; i<REPS; i++) {
            byte[] bytes = serialize(p);
            assertTrue(bytes.length > 0);

            asserter.accept((T) deserialize(bytes));
        }
    }

    private void assertNotSerial(Predicate<String> p, Consumer<Predicate<String>> asserter)
            throws IOException, ClassNotFoundException {
        asserter.accept(p);
        try {
            byte[] bytes = serialize(p);
            fail("Expected serialization failure");
        }
        catch (NotSerializableException e) {
            // success
        }
    }

    private byte[] serialize(Object o) throws IOException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(o);
        oos.close();
        return bos.toByteArray();
    }

    private Object deserialize(byte[] bytes) throws IOException, ClassNotFoundException {
        try(ObjectInputStream ois = new ObjectInputStream(new ByteArrayInputStream(bytes))) {
            return ois.readObject();
        }
    }

    // Test instantiating against intersection type
    public void testSimpleSerializedInstantiation() throws IOException, ClassNotFoundException {
        @SuppressWarnings("unchecked")
        Predicate<String> pred = (Predicate<String> & Serializable) s -> true;
        assertSerial(pred,
                     p -> {
                         assertTrue(p instanceof Predicate);
                         assertTrue(p instanceof Serializable);
                         assertTrue(p.test(""));
                     });
    }

    interface SerPredicate<T> extends Predicate<T>, Serializable { }

    // Test instantiating against derived type
    public void testSimpleSerializedInstantiation2() throws IOException, ClassNotFoundException {
        SerPredicate<String> serPred = (SerPredicate<String>) s -> true;
        assertSerial(serPred,
                     p -> {
                         assertTrue(p instanceof Predicate);
                         assertTrue(p instanceof Serializable);
                         assertTrue(p instanceof SerPredicate);
                         assertTrue(p.test(""));
                     });
    }

    // Negative test: non-serializable lambdas are in fact not serializable
    public void testNonserializableInstantiation() throws IOException, ClassNotFoundException {
        @SuppressWarnings("unchecked")
        Predicate<String> pred = (Predicate<String>) s -> true;
        assertNotSerial(pred,
                        p -> {
                            assertTrue(p instanceof Predicate);
                            assertFalse(p instanceof Serializable);
                            assertTrue(p.test(""));
                        });
    }

    // Test lambda capturing int
    public void testSerializeCapturingInt() throws IOException, ClassNotFoundException {
        class Moo {
            @SuppressWarnings("unchecked")
            Predicate<String> foo(int x) {
                return (Predicate<String> & Serializable) s -> s.length() >= x;
            }
        }
        Predicate<String> pred = new Moo().foo(3);
        assertSerial(pred, p -> {
            assertTrue(p.test("yada"));
            assertFalse(p.test("no"));
        });
    }

    // Test lambda capturing String
    public void testSerializeCapturingString() throws IOException, ClassNotFoundException {
        class Moo {
            @SuppressWarnings("unchecked")
            Predicate<String> foo(String t) {
                return (Predicate<String> & Serializable) s -> s.equals(t);
            }
        }
        Predicate<String> pred = new Moo().foo("goo");
        assertSerial(pred, p -> {
            assertTrue(p.test("goo"));
            assertFalse(p.test("foo"));
        });
    }

    // Negative test: lambdas that capture a non-serializable var
    public void testSerializeCapturingNonSerializable() throws IOException, ClassNotFoundException {
        class Box {
            String s;

            Box(String s) { this.s = s; }
        }
        class Moo {
            @SuppressWarnings("unchecked")
            Predicate<String> foo(Box b) {
                return (Predicate<String> & Serializable) s -> s.equals(b.s);
            }
        }
        Predicate<String> pred = new Moo().foo(new Box("goo"));
        assertNotSerial(pred, p -> {
            assertTrue(p.test("goo"));
            assertFalse(p.test("foo"));
        });
    }

    static boolean startsWithA(String s) {
        return s.startsWith("a");
    }

    // Test static method ref
    public void testStaticMR() throws IOException, ClassNotFoundException {
        @SuppressWarnings("unchecked")
        Predicate<String> mh1 = (Predicate<String> & Serializable) SerializedLambdaTest::startsWithA;
        @SuppressWarnings("unchecked")
        Predicate<String> mh2 = (SerPredicate<String>) SerializedLambdaTest::startsWithA;
        Consumer<Predicate<String>> b = p -> {
            assertTrue(p instanceof Serializable);
            assertTrue(p.test("arf"));
            assertFalse(p.test("barf"));
        };
        assertSerial(mh1, b);
        assertSerial(mh2, b);
    }

    // Test unbound method ref of nonserializable class -- should still succeed
    public void testUnboundMR() throws IOException, ClassNotFoundException {
        class Moo {
            public boolean startsWithB(String s) {
                return s.startsWith("b");
            }
        }
        @SuppressWarnings("unchecked")
        BiPredicate<Moo, String> mh1 = (BiPredicate<Moo, String> & Serializable) Moo::startsWithB;
        Consumer<BiPredicate<Moo, String>> b = p -> {
            assertTrue(p instanceof Serializable);
            assertTrue(p.test(new Moo(), "barf"));
            assertFalse(p.test(new Moo(), "arf"));
        };
        assertSerial(mh1, b);
    }

    // Negative test: test bound MR of nonserializable class
    public void testBoundMRNotSerReceiver() throws IOException, ClassNotFoundException {
        class Moo {
            public boolean startsWithB(String s) {
                return s.startsWith("b");
            }
        }
        Moo moo = new Moo();
        @SuppressWarnings("unchecked")
        Predicate<String> mh1 = (Predicate<String> & Serializable) moo::startsWithB;
        @SuppressWarnings("unchecked")
        Predicate<String> mh2 = (SerPredicate<String>) moo::startsWithB;
        Consumer<Predicate<String>> b = p -> {
            assertTrue(p instanceof Serializable);
            assertTrue(p.test("barf"));
            assertFalse(p.test("arf"));
        };
        assertNotSerial(mh1, b);
        assertNotSerial(mh2, b);
    }

    // Test bound MR of serializable class
    @SuppressWarnings("serial")
    static class ForBoundMRef implements Serializable {
        public boolean startsWithB(String s) {
            return s.startsWith("b");
        }
    }

    public void testBoundMR() throws IOException, ClassNotFoundException {
        ForBoundMRef moo = new ForBoundMRef();
        @SuppressWarnings("unchecked")
        Predicate<String> mh1 = (Predicate<String> & Serializable) moo::startsWithB;
        @SuppressWarnings("unchecked")
        Predicate<String> mh2 = (SerPredicate<String>) moo::startsWithB;
        Consumer<Predicate<String>> b = p -> {
            assertTrue(p instanceof Serializable);
            assertTrue(p.test("barf"));
            assertFalse(p.test("arf"));
        };
        assertSerial(mh1, b);
        assertSerial(mh2, b);
    }

    static class ForCtorRef {
        public boolean startsWithB(String s) {
            return s.startsWith("b");
        }
    }
    // Test ctor ref of nonserializable class
    public void testCtorRef() throws IOException, ClassNotFoundException {
        @SuppressWarnings("unchecked")
        Supplier<ForCtorRef> ctor = (Supplier<ForCtorRef> & Serializable) ForCtorRef::new;
        Consumer<Supplier<ForCtorRef>> b = s -> {
            assertTrue(s instanceof Serializable);
            ForCtorRef m = s.get();
            assertTrue(m.startsWithB("barf"));
            assertFalse(m.startsWithB("arf"));
        };
        assertSerial(ctor, b);
    }

    //Test throwing away return type
    public void testDiscardReturnBound() throws IOException, ClassNotFoundException {
        List<String> list = new ArrayList<>();
        Consumer<String> c = (Consumer<String> & Serializable) list::add;
        assertSerial(c, cc -> { assertTrue(cc instanceof Consumer); });

        AtomicLong a = new AtomicLong();
        LongConsumer lc = (LongConsumer & Serializable) a::addAndGet;
        assertSerial(lc, plc -> { plc.accept(3); });
    }

    // Tests of direct use of metafactories

    private static boolean foo(Object s) { return s != null && ((String) s).length() > 0; }
    private static final MethodType predicateMT = MethodType.methodType(boolean.class, Object.class);
    private static final MethodType stringPredicateMT = MethodType.methodType(boolean.class, String.class);
    private static final Consumer<Predicate<String>> fooAsserter = x -> {
        assertTrue(x.test("foo"));
        assertFalse(x.test(""));
        assertFalse(x.test(null));
    };

    // standard MF: nonserializable supertype
    public void testDirectStdNonser() throws Throwable {
        MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

        // Standard metafactory, non-serializable target: not serializable
        CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
                                                    "test", MethodType.methodType(Predicate.class),
                                                    predicateMT, fooMH, stringPredicateMT);
        Predicate<String> p = (Predicate<String>) cs.getTarget().invokeExact();
        assertNotSerial(p, fooAsserter);
    }

    // standard MF: serializable supertype
    public void testDirectStdSer() throws Throwable {
        MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

        // Standard metafactory, serializable target: not serializable
        CallSite cs = LambdaMetafactory.metafactory(MethodHandles.lookup(),
                                                    "test", MethodType.methodType(SerPredicate.class),
                                                    predicateMT, fooMH, stringPredicateMT);
        assertNotSerial((SerPredicate<String>) cs.getTarget().invokeExact(), fooAsserter);
    }

    // alt MF: nonserializable supertype
    public void testAltStdNonser() throws Throwable {
        MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

        // Alt metafactory, non-serializable target: not serializable
        CallSite cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
                                                       "test", MethodType.methodType(Predicate.class),
                                                       predicateMT, fooMH, stringPredicateMT, 0);
        assertNotSerial((Predicate<String>) cs.getTarget().invokeExact(), fooAsserter);
    }

    // alt MF: serializable supertype
    public void testAltStdSer() throws Throwable {
        MethodHandle fooMH = MethodHandles.lookup().findStatic(SerializedLambdaTest.class, "foo", predicateMT);

        // Alt metafactory, serializable target, no FLAG_SERIALIZABLE: not serializable
        CallSite cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
                                                       "test", MethodType.methodType(SerPredicate.class),
                                                       predicateMT, fooMH, stringPredicateMT, 0);
        assertNotSerial((SerPredicate<String>) cs.getTarget().invokeExact(), fooAsserter);

        // Alt metafactory, serializable marker, no FLAG_SERIALIZABLE: not serializable
        cs = LambdaMetafactory.altMetafactory(MethodHandles.lookup(),
                                              "test", MethodType.methodType(Predicate.class),
                                              predicateMT, fooMH, stringPredicateMT, LambdaMetafactory.FLAG_MARKERS, 1, Serializable.class);
        assertNotSerial((Predicate<String>) cs.getTarget().invokeExact(), fooAsserter);
    }
}