/*

 * 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.

 */

/**

 * @test

 * @bug 8003280 8004102 8006694

 * @summary Add lambda tests

 *  perform several automated checks in lambda conversion, esp. around accessibility

 *  temporarily workaround combo tests are causing time out in several platforms

 * @author  Maurizio Cimadamore

 * @library ../lib

 * @build JavacTestingAbstractThreadedTest

 * @run main/othervm FunctionalInterfaceConversionTest

 */

// use /othervm to avoid jtreg timeout issues (CODETOOLS-7900047)

// see JDK-8006746

import java.io.IOException;

import java.net.URI;

import java.util.Arrays;

import javax.tools.Diagnostic;

import javax.tools.JavaCompiler;

import javax.tools.JavaFileObject;

import javax.tools.SimpleJavaFileObject;

import javax.tools.ToolProvider;

import com.sun.source.util.JavacTask;

public class FunctionalInterfaceConversionTest

    extends JavacTestingAbstractThreadedTest

    implements Runnable {

    enum PackageKind {

        NO_PKG(""),

        PKG_A("a");

        String pkg;

        PackageKind(String pkg) {

            this.pkg = pkg;

        }

        String getPkgDecl() {

            return this == NO_PKG ?

                "" :

                "package " + pkg + ";";

        }

        String getImportStat() {

            return this == NO_PKG ?

                "" :

                "import " + pkg + ".*;";

        }

    }

    enum SamKind {

        CLASS("public class Sam {  }"),

        ABSTACT_CLASS("public abstract class Sam {  }"),

        ANNOTATION("public @interface Sam {  }"),

        ENUM("public enum Sam { }"),

        INTERFACE("public interface Sam { \n #METH; \n }");

        String sam_str;

        SamKind(String sam_str) {

            this.sam_str = sam_str;

        }

        String getSam(String methStr) {

            return sam_str.replaceAll("#METH", methStr);

        }

    }

    enum ModifierKind {

        PUBLIC("public"),

        PACKAGE("");

        String modifier_str;

        ModifierKind(String modifier_str) {

            this.modifier_str = modifier_str;

        }

        boolean stricterThan(ModifierKind that) {

            return this.ordinal() > that.ordinal();

        }

    }

    enum TypeKind {

        EXCEPTION("Exception"),

        PKG_CLASS("PackageClass");

        String typeStr;

        private TypeKind(String typeStr) {

            this.typeStr = typeStr;

        }

    }

    enum ExprKind {

        LAMBDA("x -> null"),

        MREF("this::m");

        String exprStr;

        private ExprKind(String exprStr) {

            this.exprStr = exprStr;

        }

    }

    enum MethodKind {

        NONE(""),

        NON_GENERIC("public abstract #R m(#ARG s) throws #T;"),

        GENERIC("public abstract <X> #R m(#ARG s) throws #T;");

        String methodTemplate;

        private MethodKind(String methodTemplate) {

            this.methodTemplate = methodTemplate;

        }

        String getMethod(TypeKind retType, TypeKind argType, TypeKind thrownType) {

            return methodTemplate.replaceAll("#R", retType.typeStr).

                    replaceAll("#ARG", argType.typeStr).

                    replaceAll("#T", thrownType.typeStr);

        }

    }

    public static void main(String[] args) throws Exception {

        for (PackageKind samPkg : PackageKind.values()) {

            for (ModifierKind modKind : ModifierKind.values()) {

                for (SamKind samKind : SamKind.values()) {

                    for (MethodKind samMeth : MethodKind.values()) {

                        for (MethodKind clientMeth : MethodKind.values()) {

                            for (TypeKind retType : TypeKind.values()) {

                                for (TypeKind argType : TypeKind.values()) {

                                    for (TypeKind thrownType : TypeKind.values()) {

                                        for (ExprKind exprKind : ExprKind.values()) {

                                            pool.execute(

                                                new FunctionalInterfaceConversionTest(

                                                    samPkg, modKind, samKind,

                                                    samMeth, clientMeth, retType,

                                                    argType, thrownType, exprKind));

                                        }

                                    }

                                }

                            }

                        }

                    }

                }

            }

        }

        checkAfterExec(false);

    }

    PackageKind samPkg;

    ModifierKind modKind;

    SamKind samKind;

    MethodKind samMeth;

    MethodKind clientMeth;

    TypeKind retType;

    TypeKind argType;

    TypeKind thrownType;

    ExprKind exprKind;

    DiagnosticChecker dc;

    SourceFile samSourceFile = new SourceFile("Sam.java", "#P \n #C") {

        @Override

        public String toString() {

            return template.replaceAll("#P", samPkg.getPkgDecl()).

                    replaceAll("#C", samKind.getSam(

                    samMeth.getMethod(retType, argType, thrownType)));

        }

    };

    SourceFile pkgClassSourceFile =

            new SourceFile("PackageClass.java",

                           "#P\n #M class PackageClass extends Exception { }") {

        @Override

        public String toString() {

            return template.replaceAll("#P", samPkg.getPkgDecl()).

                    replaceAll("#M", modKind.modifier_str);

        }

    };

    SourceFile clientSourceFile =

            new SourceFile("Client.java",

                           "#I\n abstract class Client { \n" +

                           "  Sam s = #E;\n" +

                           "  #M \n }") {

        @Override

        public String toString() {

            return template.replaceAll("#I", samPkg.getImportStat())

                    .replaceAll("#E", exprKind.exprStr)

                    .replaceAll("#M", clientMeth.getMethod(retType, argType, thrownType));

        }

    };

    FunctionalInterfaceConversionTest(PackageKind samPkg, ModifierKind modKind,

            SamKind samKind, MethodKind samMeth, MethodKind clientMeth,

            TypeKind retType, TypeKind argType, TypeKind thrownType,

            ExprKind exprKind) {

        this.samPkg = samPkg;

        this.modKind = modKind;

        this.samKind = samKind;

        this.samMeth = samMeth;

        this.clientMeth = clientMeth;

        this.retType = retType;

        this.argType = argType;

        this.thrownType = thrownType;

        this.exprKind = exprKind;

        this.dc = new DiagnosticChecker();

    }

    @Override

    public void run() {

        final JavaCompiler tool = ToolProvider.getSystemJavaCompiler();

        JavacTask ct = (JavacTask)tool.getTask(null, fm.get(), dc, null, null,

                Arrays.asList(samSourceFile, pkgClassSourceFile, clientSourceFile));

        try {

            ct.analyze();

        } catch (IOException ex) {

            throw new AssertionError("Test failing with cause", ex.getCause());

        }

        if (dc.errorFound == checkSamConversion()) {

            throw new AssertionError(samSourceFile + "\n\n" +

                pkgClassSourceFile + "\n\n" + clientSourceFile);

        }

    }

    boolean checkSamConversion() {

        if (samKind != SamKind.INTERFACE) {

            //sam type must be an interface

            return false;

        } else if (samMeth == MethodKind.NONE) {

            //interface must have at least a method

            return false;

        } else if (exprKind == ExprKind.LAMBDA &&

                samMeth != MethodKind.NON_GENERIC) {

            //target method for lambda must be non-generic

            return false;

        } else if (exprKind == ExprKind.MREF &&

                clientMeth == MethodKind.NONE) {

            return false;

        } else if (samPkg != PackageKind.NO_PKG &&

                modKind != ModifierKind.PUBLIC &&

                (retType == TypeKind.PKG_CLASS ||

                argType == TypeKind.PKG_CLASS ||

                thrownType == TypeKind.PKG_CLASS)) {

            //target must not contain inaccessible types

            return false;

        } else {

            return true;

        }

    }

    abstract class SourceFile extends SimpleJavaFileObject {

        protected String template;

        public SourceFile(String filename, String template) {

            super(URI.create("myfo:/" + filename), JavaFileObject.Kind.SOURCE);

            this.template = template;

        }

        @Override

        public CharSequence getCharContent(boolean ignoreEncodingErrors) {

            return toString();

        }

        @Override

        public abstract String toString();

    }

    static class DiagnosticChecker

        implements javax.tools.DiagnosticListener<JavaFileObject> {

        boolean errorFound = false;

        @Override

        public void report(Diagnostic<? extends JavaFileObject> diagnostic) {

            if (diagnostic.getKind() == Diagnostic.Kind.ERROR) {

                errorFound = true;

            }

        }

    }

}