/*
 *  Licensed to the Apache Software Foundation (ASF) under one
 *  or more contributor license agreements.  See the NOTICE file
 *  distributed with this work for additional information
 *  regarding copyright ownership.  The ASF licenses this file
 *  to you under the Apache License, Version 2.0 (the
 *  "License"); you may not use this file except in compliance
 *  with the License.  You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 *  Unless required by applicable law or agreed to in writing,
 *  software distributed under the License is distributed on an
 *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 *  KIND, either express or implied.  See the License for the
 *  specific language governing permissions and limitations
 *  under the License.
 */

package groovy.transform.stc

import groovy.test.GroovyTestCase

class LambdaTest extends GroovyTestCase {
    void testFunction() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                assert [2, 3, 4] == [1, 2, 3].stream().map(e -> e.plus 1).collect(Collectors.toList());
            }
        }
        '''
    }

    void testFunction2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            @CompileStatic
            public static void p() {
                assert [2, 3, 4] == [1, 2, 3].stream().map(e -> e.plus 1).collect(Collectors.toList());
            }
        }
        '''
    }


    void testFunctionScript() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        void p() {
            assert [2, 3, 4] == [1, 2, 3].stream().map(e -> e + 1).collect(Collectors.toList());
        }
        
        p()
        '''
    }

    void testFunctionScript2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        void p() {
            assert [2, 3, 4] == [1, 2, 3].stream().map(e -> e.plus 1).collect(Collectors.toList());
        }
        
        p()
        '''
    }

    void testBinaryOperator() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                assert 13 == [1, 2, 3].stream().reduce(7, (Integer r, Integer e) -> r + e);
            }
        }
        '''
    }

    // GROOVY-8917: Failed to infer parameter type of some SAM, e.g. BinaryOperator
    void testBinaryOperatorWithoutExplicitTypeDef() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                assert 13 == [1, 2, 3].stream().reduce(7, (r, e) -> r + e);
            }
        }
        '''
    }

    void testBinaryOperatorWithoutExplicitTypeDef2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.BinaryOperator
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                BinaryOperator<Integer> accumulator = (r, e) -> r + e
                assert 13 == [1, 2, 3].stream().reduce(7, accumulator);
            }
        }
        '''
    }

    void testConsumer() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                [1, 2, 3].stream().forEach(e -> { System.out.println(e + 1); });
            }
            
        }
        '''
    }

    void testPredicate() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                def list = ['ab', 'bc', 'de']
                list.removeIf(e -> e.startsWith("a"))
                assert ['bc', 'de'] == list
            }
        }
        '''
    }

    void testPredicateWithoutExplicitTypeDef() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        import java.util.function.Predicate
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p()
            }
        
            public static void p() {
                List<String> myList = Arrays.asList("a1", "a2", "b2", "b1", "c2", "c1")
                Predicate<String> predicate = s -> s.startsWith("b")
                Function<String, String> mapper = s -> s.toUpperCase()
                
                List<String> result =
                        myList
                            .stream()
                            .filter(predicate)
                            .map(mapper)
                            .sorted()
                            .collect(Collectors.toList())
                
                assert ['B1', 'B2'] == result
            }
        }
        '''
    }

    void testUnaryOperator() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                def list = [1, 2, 3]
                list.replaceAll(e -> e + 10)
                assert [11, 12, 13] == list
            }
        }
        '''
    }

    void testBiConsumer() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                def map = [a: 1, b: 2, c: 3]
                map.forEach((k, v) -> System.out.println(k + ":" + v));
            }
        }
        '''
    }

    void testFunctionWithLocalVariables() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                String x = "#"
                assert ['#1', '#2', '#3'] == [1, 2, 3].stream().map(e -> x + e).collect(Collectors.toList());
            }
        }
        '''
    }


    void testFunctionWithLocalVariables2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                new Test1().p();
            }
        
            public void p() {
                String x = "#"
                Integer y = 23
                assert ['23#1', '23#2', '23#3'] == [1, 2, 3].stream().map(e -> '' + y + x + e).collect(Collectors.toList())
            }
        }
        '''
    }

    void testFunctionWithLocalVariables4() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test4 {
            public static void main(String[] args) {
                new Test4().p();
            }
        
            public void p() {
                String x = "x";
                StringBuilder y = new StringBuilder("y");
                assert ['yx1', 'yx2', 'yx3'] == [1, 2, 3].stream().map(e -> y + x + e).collect(Collectors.toList());
            }
        }
        '''
    }

    void testFunctionWithLocalVariables5() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                Function<Integer, String> f = p();
                assert '#1' == f(1)
            }
        
            static Function<Integer, String> p() {
                String x = "#"
                Function<Integer, String> f = (Integer e) -> x + e
                return f
            }
        }
        '''
    }

    void testFunctionWithLocalVariables6() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                Function<Integer, String> f = new Test1().p();
                assert '#1' == f(1)
            }
        
            Function<Integer, String> p() {
                String x = "#"
                Function<Integer, String> f = (Integer e) -> x + e
                return f
            }
        }
        '''
    }

    void testFunctionWithStaticMethodCall() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test4 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                String x = "x";
                StringBuilder y = new StringBuilder("y");
                assert ['Hello yx1', 'Hello yx2', 'Hello yx3'] == [1, 2, 3].stream().map(e -> hello() + y + x + e).collect(Collectors.toList());
            }
        
            public static String hello() {
                return "Hello ";
            }
        }
        '''
    }

    void testFunctionWithStaticMethodCall2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test4 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                String x = "x";
                StringBuilder y = new StringBuilder("y");
                assert ['Hello yx1', 'Hello yx2', 'Hello yx3'] == [1, 2, 3].stream().map(e -> Test4.hello() + y + x + e).collect(Collectors.toList());
            }
        
            public static String hello() {
                return "Hello ";
            }
        }
        '''
    }

    void testFunctionWithInstanceMethodCall() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test4 {
            public static void main(String[] args) {
                new Test4().p();
            }
        
            public void p() {
                assert ['Hello Jochen', 'Hello Daniel'] == ["Jochen", "Daniel"].stream().map(e -> hello() + e).collect(Collectors.toList());
            }
        
            public String hello() {
                return "Hello ";
            }
        }
        '''
    }

    void testFunctionInConstructor() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test4 {
            public static void main(String[] args) {
                new Test4();
            }
            
            public Test4() {
                assert ['Hello Jochen', 'Hello Daniel'] == ["Jochen", "Daniel"].stream().map(e -> hello() + e).collect(Collectors.toList());
            }
        
            public String hello() {
                return "Hello ";
            }
        }
        '''
    }

    void testFunctionWithInstanceMethodCall2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test4 {
            public static void main(String[] args) {
                new Test4().p();
            }
        
            public void p() {
                assert ['Hello Jochen', 'Hello Daniel'] == ["Jochen", "Daniel"].stream().map(e -> this.hello() + e).collect(Collectors.toList());
            }
        
            public String hello() {
                return "Hello ";
            }
        }
        '''
    }

    void testFunctionWithInstanceMethodCall3() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test4 {
            public static void main(String[] args) {
                new Test4().p();
            }
        
            public void p() {
                assert ['Hello Jochen', 'Hello Daniel'] == ["Jochen", "Daniel"].stream().map(e -> hello(e)).collect(Collectors.toList());
            }
        
            public String hello(String name) {
                return "Hello $name";
            }
        }
        '''
    }

    void testFunctionCall() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                Function<Integer, Integer> f = (Integer e) -> (Integer) (e + 1)
                assert 2 == f(1)
            }
        }
        '''
    }

    void testFunctionCallWithoutExplicitTypeDef() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                Function<Integer, Integer> f = e -> e + 1
                assert 2 == f(1)
            }
        }
        '''
    }

    void testFunctionCall2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                new Test1().p();
            }
        
            public void p() {
                Function<Integer, Integer> f = (Integer e) -> (Integer) (e + 1)
                assert 2 == f(1)
            }
        }
        '''
    }

    void testFunctionCall3() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                Function<Integer, Integer> f = (Integer e) -> (Integer) (e + 1)
                assert 2 == f.apply(1)
            }
        }
        '''
    }

    void testConsumerCall() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Consumer
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                int r = 1
                Consumer<Integer> c = (Integer e) -> { r += e }
                c(2)
                assert 3 == r
            }
        }
        '''
    }

    void testConsumerCallWithoutExplicitTypeDef() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Consumer
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                int r = 1
                Consumer<Integer> c = e -> { r += e }
                c(2)
                assert 3 == r
            }
        }
        '''
    }

    void testConsumerCall2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Consumer
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                new Test1().p();
            }
        
            public void p() {
                int r = 1
                Consumer<Integer> c = (Integer e) -> { r += e }
                c(2)
                assert 3 == r
            }
        }
        '''
    }

    void testConsumerCall3() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Consumer
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                int r = 1
                Consumer<Integer> c = (Integer e) -> { r += e }
                c.accept(2)
                assert 3 == r
            }
        }
        '''
    }

    void testSamCall() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                SamCallable c = (int e) -> e
                assert 1 == c(1)
            }
        }
        
        @CompileStatic
        interface SamCallable {
            int call(int p);
        }
        '''
    }


    void testSamCallWithoutExplicitTypeDef() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                SamCallable c = e -> e
                assert 1 == c(1)
            }
        }
        
        @CompileStatic
        interface SamCallable {
            int call(int p);
        }
        '''
    }

    void testSamCall2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
            
            public static void p() {
                SamCallable c = (int e) -> e // This is actually a closure(not a native lambda), because "Functional interface SamCallable is not an interface"
                assert 1 == c(1)
            }
        }
        
        @CompileStatic
        abstract class SamCallable {
            abstract int call(int p);
        }
        '''
    }

    void testFunctionWithUpdatingLocalVariable() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p();
            }
        
            public static void p() {
                int i = 1
                assert [2, 4, 7] == [1, 2, 3].stream().map(e -> i += e).collect(Collectors.toList())
                assert 7 == i
            }
        }
        '''
    }

    void testFunctionWithUpdatingLocalVariable2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                new Test1().p();
            }
        
            public void p() {
                int i = 1
                assert [2, 4, 7] == [1, 2, 3].stream().map(e -> i += e).collect(Collectors.toList())
                assert 7 == i
            }
        }
        '''
    }

    void testFunctionWithVariableDeclaration() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p()
            }
        
            public static void p() {
                Function<Integer, String> f = (Integer e) -> 'a' + e
                assert ['a1', 'a2', 'a3'] == [1, 2, 3].stream().map(f).collect(Collectors.toList())
            }
        }
        
        '''
    }

    void testFunctionWithMixingVariableDeclarationAndMethodInvocation() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p()
            }
        
            public static void p() {
                String x = "#"
                Integer y = 23
                assert ['23#1', '23#2', '23#3'] == [1, 2, 3].stream().map(e -> '' + y + x + e).collect(Collectors.toList())
            
                Function<Integer, String> f = (Integer e) -> 'a' + e
                assert ['a1', 'a2', 'a3'] == [1, 2, 3].stream().map(f).collect(Collectors.toList())
                
                assert [2, 3, 4] == [1, 2, 3].stream().map(e -> e.plus 1).collect(Collectors.toList());
            }
        }
        
        '''
    }

    void testFunctionWithNestedLambda() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p()
            }
        
            public static void p() {
                [1, 2].stream().forEach(e -> {
                    def list = ['a', 'b'].stream().map(f -> f + e).toList()
                    if (1 == e) {
                        assert ['a1', 'b1'] == list
                    } else if (2 == e) {
                        assert ['a2', 'b2'] == list
                    }
                })
                
            }
        }
        '''
    }

    void testFunctionWithNestedLambda2() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p()
            }
        
            public static void p() {
                def list = ['a', 'b'].stream()
                .map(e -> {
                    [1, 2].stream().map(f -> e + f).toList()
                }).toList()
                
                assert ['a1', 'a2'] == list[0]
                assert ['b1', 'b2'] == list[1]
            }
        }
        '''
    }

    void testFunctionWithNestedLambda3() {
        assertScript '''
        import groovy.transform.CompileStatic
        import java.util.stream.Collectors
        import java.util.stream.Stream
        import java.util.function.Function
        
        @CompileStatic
        public class Test1 {
            public static void main(String[] args) {
                p()
            }
        
            public static void p() {
                def list = ['a', 'b'].stream()
                .map(e -> {
                    Function<Integer, String> x = (Integer f) -> e + f
                    [1, 2].stream().map(x).toList()
                }).toList()
                
                assert ['a1', 'a2'] == list[0]
                assert ['b1', 'b2'] == list[1]
            }
        }
        '''
    }

    void testMixingLambdaAndMethodReference() {
        assertScript '''
            import java.util.stream.Collectors
            
            @groovy.transform.CompileStatic
            void p() {
                assert ['1', '2', '3'] == [1, 2, 3].stream().map(Object::toString).collect(Collectors.toList())
                assert [2, 3, 4] == [1, 2, 3].stream().map(e -> e.plus 1).collect(Collectors.toList())
                assert ['1', '2', '3'] == [1, 2, 3].stream().map(Object::toString).collect(Collectors.toList())
            }
            
            p()
        '''
    }

    void testSerialize() {
        assertScript '''
        import java.util.function.Function
        
        interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
        
        @groovy.transform.CompileStatic
        class Test1 implements Serializable {
            private static final long serialVersionUID = -1L;
            def p() {
                    def out = new ByteArrayOutputStream()
                    out.withObjectOutputStream {
                        SerializableFunction<Integer, String> f = ((Integer e) -> 'a' + e)
                        it.writeObject(f)
                    }
                    
                    return out.toByteArray()
            }
        }

        assert new Test1().p().length > 0
        '''
    }

    void testSerializeFailed() {
        shouldFail(NotSerializableException, '''
        import java.util.function.Function
        
        @groovy.transform.CompileStatic
        class Test1 implements Serializable {
            private static final long serialVersionUID = -1L;
            def p() {
                    def out = new ByteArrayOutputStream()
                    out.withObjectOutputStream {
                        Function<Integer, String> f = ((Integer e) -> 'a' + e)
                        it.writeObject(f)
                    }
                    
                    return out.toByteArray()
            }
        }

        new Test1().p()
        ''')
    }

    void testDeserialize() {
        assertScript '''
        package tests.lambda
        import java.util.function.Function
        
        @groovy.transform.CompileStatic
        class Test1 implements Serializable {
            private static final long serialVersionUID = -1L;
            byte[] p() {
                    def out = new ByteArrayOutputStream()
                    out.withObjectOutputStream {
                        SerializableFunction<Integer, String> f = ((Integer e) -> 'a' + e)
                        it.writeObject(f)
                    }
                    
                    return out.toByteArray()
            }
            
            static void main(String[] args) {
                new ByteArrayInputStream(new Test1().p()).withObjectInputStream(Test1.class.classLoader) {
                    SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
                    assert 'a1' == f.apply(1)
                }
            }
            
            interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
        }
        '''
    }


    void testDeserialize2() {
        assertScript '''
        import java.util.function.Function
        
        @groovy.transform.CompileStatic
        class Test1 implements Serializable {
            private static final long serialVersionUID = -1L;
            static byte[] p() {
                    def out = new ByteArrayOutputStream()
                    out.withObjectOutputStream {
                        SerializableFunction<Integer, String> f = ((Integer e) -> 'a' + e)
                        it.writeObject(f)
                    }
                    
                    return out.toByteArray()
            }
            
            static void main(String[] args) {
                new ByteArrayInputStream(Test1.p()).withObjectInputStream(Test1.class.classLoader) {
                    SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
                    assert 'a1' == f.apply(1)
                }
            }
            
            interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
        }
        '''
    }

    void testDeserializeNestedLambda() {
        assertScript '''
        import java.util.function.Function
        
        interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
        
        @groovy.transform.CompileStatic
        class Test1 implements Serializable {
            private static final long serialVersionUID = -1L;
            def p() {
                    def out1 = new ByteArrayOutputStream()
                    SerializableFunction<Integer, String> f1 = (Integer e) -> 'a' + e
                    out1.withObjectOutputStream {
                        it.writeObject(f1)
                    }
                    def result1 = out1.toByteArray()
                    
                    def out2 = new ByteArrayOutputStream()
                    SerializableFunction<Integer, String> f2 = (Integer e) -> 'b' + e
                    out2.withObjectOutputStream {
                        it.writeObject(f2)
                    }
                    def result2 = out2.toByteArray()
                    
                    // nested lambda expression
                    def out3 = new ByteArrayOutputStream()
                    SerializableFunction<Integer, String> f3 = (Integer e) -> {
                        SerializableFunction<Integer, String> nf = ((Integer ne) -> 'n' + ne)
                        'c' + nf(e)
                    }
                    out3.withObjectOutputStream {
                        it.writeObject(f3)
                    }
                    def result3 = out3.toByteArray()
                    
                    return [result1, result2, result3]
            }
        }
        
        def (byte[] serializedLambdaBytes1, byte[] serializedLambdaBytes2, byte[] serializedLambdaBytes3) = new Test1().p()
        new ByteArrayInputStream(serializedLambdaBytes1).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'a1' == f.apply(1)
        }
        
        new ByteArrayInputStream(serializedLambdaBytes2).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'b1' == f.apply(1)
        }
        
        new ByteArrayInputStream(serializedLambdaBytes3).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'cn1' == f.apply(1)
        }
        '''
    }

    void testDeserializeNestedLambda2() {
        assertScript '''
        import java.util.function.Function
        
        interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
        
        @groovy.transform.CompileStatic
        class Test1 implements Serializable {
            private static final long serialVersionUID = -1L;
            def p() {
                    def out1 = new ByteArrayOutputStream()
                    out1.withObjectOutputStream {
                        SerializableFunction<Integer, String> f = ((Integer e) -> 'a' + e)
                        it.writeObject(f)
                    }
                    def result1 = out1.toByteArray()
                    
                    def out2 = new ByteArrayOutputStream()
                    out2.withObjectOutputStream {
                        SerializableFunction<Integer, String> f = ((Integer e) -> 'b' + e)
                        it.writeObject(f)
                    }
                    def result2 = out2.toByteArray()
                    
                    // nested lambda expression
                    def out3 = new ByteArrayOutputStream()
                    out3.withObjectOutputStream {
                        SerializableFunction<Integer, String> f = ((Integer e) -> {
                            SerializableFunction<Integer, String> nf = ((Integer ne) -> 'n' + ne)
                            'c' + nf(e)
                        })
                        it.writeObject(f)
                    }
                    def result3 = out3.toByteArray()
                    
                    return [result1, result2, result3]
            }
        }
        
        def (byte[] serializedLambdaBytes1, byte[] serializedLambdaBytes2, byte[] serializedLambdaBytes3) = new Test1().p()
        new ByteArrayInputStream(serializedLambdaBytes1).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'a1' == f.apply(1)
        }
        
        new ByteArrayInputStream(serializedLambdaBytes2).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'b1' == f.apply(1)
        }
        
        new ByteArrayInputStream(serializedLambdaBytes3).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'cn1' == f.apply(1)
        }
        '''
    }

    void testDeserializeNestedLambda3() {
        assertScript '''
        import java.util.function.Function
        
        interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
        
        @groovy.transform.CompileStatic
        class Test1 implements Serializable {
            private static final long serialVersionUID = -1L;
            static p() {
                    def out1 = new ByteArrayOutputStream()
                    out1.withObjectOutputStream {
                        SerializableFunction<Integer, String> f = ((Integer e) -> 'a' + e)
                        it.writeObject(f)
                    }
                    def result1 = out1.toByteArray()
                    
                    def out2 = new ByteArrayOutputStream()
                    out2.withObjectOutputStream {
                        SerializableFunction<Integer, String> f = ((Integer e) -> 'b' + e)
                        it.writeObject(f)
                    }
                    def result2 = out2.toByteArray()
                    
                    // nested lambda expression
                    def out3 = new ByteArrayOutputStream()
                    out3.withObjectOutputStream {
                        SerializableFunction<Integer, String> f = ((Integer e) -> {
                            SerializableFunction<Integer, String> nf = ((Integer ne) -> 'n' + ne)
                            'c' + nf(e)
                        })
                        it.writeObject(f)
                    }
                    def result3 = out3.toByteArray()
                    
                    return [result1, result2, result3]
            }
        }
        
        def (byte[] serializedLambdaBytes1, byte[] serializedLambdaBytes2, byte[] serializedLambdaBytes3) = Test1.p()
        new ByteArrayInputStream(serializedLambdaBytes1).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'a1' == f.apply(1)
        }
        
        new ByteArrayInputStream(serializedLambdaBytes2).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'b1' == f.apply(1)
        }
        
        new ByteArrayInputStream(serializedLambdaBytes3).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'cn1' == f.apply(1)
        }
        '''
    }

    void testDeserializeNestedLambda4() {
        assertScript '''
        import java.util.function.Function
        
        interface SerializableFunction<T, R> extends Function<T, R>, Serializable {}
        
        @groovy.transform.CompileStatic
        class Test1 implements Serializable {
            private static final long serialVersionUID = -1L;
            static p() {
                    def out1 = new ByteArrayOutputStream()
                    SerializableFunction<Integer, String> f1 = (Integer e) -> 'a' + e
                    out1.withObjectOutputStream {
                        it.writeObject(f1)
                    }
                    def result1 = out1.toByteArray()
                    
                    def out2 = new ByteArrayOutputStream()
                    SerializableFunction<Integer, String> f2 = (Integer e) -> 'b' + e
                    out2.withObjectOutputStream {
                        it.writeObject(f2)
                    }
                    def result2 = out2.toByteArray()
                    
                    // nested lambda expression
                    def out3 = new ByteArrayOutputStream()
                    SerializableFunction<Integer, String> f3 = (Integer e) -> {
                        SerializableFunction<Integer, String> nf = ((Integer ne) -> 'n' + ne)
                        'c' + nf(e)
                    }
                    out3.withObjectOutputStream {
                        it.writeObject(f3)
                    }
                    def result3 = out3.toByteArray()
                    
                    return [result1, result2, result3]
            }
        }
        
        def (byte[] serializedLambdaBytes1, byte[] serializedLambdaBytes2, byte[] serializedLambdaBytes3) = Test1.p()
        new ByteArrayInputStream(serializedLambdaBytes1).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'a1' == f.apply(1)
        }
        
        new ByteArrayInputStream(serializedLambdaBytes2).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'b1' == f.apply(1)
        }
        
        new ByteArrayInputStream(serializedLambdaBytes3).withObjectInputStream(Test1.class.classLoader) {
            SerializableFunction<Integer, String> f = (SerializableFunction<Integer, String>) it.readObject()
            assert 'cn1' == f.apply(1)
        }
        '''
    }
}