/*

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

 * @summary The test checks possibility of class members to be imported.

 * @library /tools/lib

 * @build ToolBox ImportMembersTest

 * @run main ImportMembersTest

 */

import javax.tools.JavaCompiler;

import javax.tools.ToolProvider;

import java.io.StringWriter;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

/**

 * The test checks that members of a class, an enum, an interface or annotation

 * can be imported with help of a static import or an import statement.

 * The tests generates a code, compiles it and checks whether it can be compiled

 * successfully or fails with a proper message.

 * The following is the example of a test case:

 * package pkg;

 * class ChildA extends A {}

 *

 * package pkg;

 * class A {

 *     static class Inner {}

 *     static Object field;

 *     static void method() {}

 * }

 *

 * package pkg;

 * import static pkg.ChildA.method;

 * public class Test {{

 *     method();

 * }}

 *

 */

public class ImportMembersTest {

    private static final String[] expectedErrorMessages = {

            "Test.java:\\d+:\\d+: compiler.err.cant.resolve.location: .*\n1 error\n",

            "Test.java:\\d+:\\d+: compiler.err.import.requires.canonical: .*\n1 error\n"

    };

    private static final String sourceTemplate =

            "package pkg;\n" +

            "#IMPORT\n" +

            "public class Test {{\n" +

            "    #STATEMENT\n" +

            "}}\n";

    public static void main(String[] args) {

        new ImportMembersTest().test();

    }

    public void test() {

        int passed = 0;

        int total = 0;

        for (ClassType classType : ClassType.values()) {

            for (ImportType importType : ImportType.values()) {

                for (MemberType memberType : MemberType.values()) {

                    ++total;

                    List<ToolBox.JavaSource> sources = classType.getSources();

                    sources.add(new ToolBox.JavaSource("Test.java",

                            generateSource(classType, memberType, importType)));

                    CompilationResult compilationResult = compile(sources);

                    boolean isErrorExpected = importType.hasError(classType, memberType);

                    if (!compilationResult.isSuccessful) {

                        if (isErrorExpected) {

                            String expectedErrorMessage =

                                    getExpectedErrorMessage(classType, importType, memberType);

                            if (compilationResult.message.matches(expectedErrorMessage)) {

                                ++passed;

                            } else {

                                reportFailure(sources, String.format("Expected compilation failure message:\n" +

                                                "%s\ngot message:\n%s",

                                        expectedErrorMessage, compilationResult.message));

                            }

                        } else {

                            reportFailure(sources, String.format("Unexpected compilation failure:\n%s",

                                    compilationResult.message));

                        }

                    } else {

                        if (isErrorExpected) {

                            reportFailure(sources, "Expected compilation failure.");

                        } else {

                            ++passed;

                        }

                    }

                }

            }

        }

        String message = String.format(

                "Total test cases run: %d, passed: %d, failed: %d.",

                total, passed, total - passed);

        if (passed != total) {

            throw new RuntimeException(message);

        }

        echo(message);

    }

    private String getExpectedErrorMessage(ClassType classType, ImportType importType, MemberType memberType) {

        String expectedErrorMessage;

        if (importType == ImportType.IMPORT && classType == ClassType.CHILD_A &&

                memberType == MemberType.CLASS) {

            expectedErrorMessage = expectedErrorMessages[1];

        } else {

            expectedErrorMessage = expectedErrorMessages[0];

        }

        return expectedErrorMessage;

    }

    private void reportFailure(List<ToolBox.JavaSource> sources, String message) {

        echo("Test case failed!");

        printSources(sources);

        echo(message);

        echo();

    }

    private String generateSource(ClassType classType, MemberType memberType, ImportType importType) {

        String importString = importType.generateImport(classType.getClassName(), memberType.getMemberType());

        String statement;

        if (importType.hasError(classType, memberType)) {

            // if the source code has a compilation error, nothing is added.

            // just to prevent the compiler from appending additional

            // compilation errors to output

            statement = "";

        } else if (memberType == MemberType.STAR) {

            // in case of import-on-demand, every class member is used

            if (importType == ImportType.STATIC_IMPORT) {

                statement = MemberType.CLASS.getStatement() + "\n    "

                        + MemberType.FIELD.getStatement();

                // an annotation does not have a static method.

                if (classType != ClassType.D) {

                    statement += "\n    " + MemberType.METHOD.getStatement() + "\n";

                }

            } else {

                statement = classType != ClassType.CHILD_A

                        ? MemberType.CLASS.getStatement() : "";

            }

        } else {

            statement = memberType.getStatement();

        }

        return sourceTemplate

                .replace("#IMPORT", importString)

                .replace("#STATEMENT", statement);

    }

    private static class CompilationResult {

        public final boolean isSuccessful;

        public final String message;

        public CompilationResult(boolean isSuccessful, String message) {

            this.isSuccessful = isSuccessful;

            this.message = message;

        }

    }

    private CompilationResult compile(List<ToolBox.JavaSource> sources) {

        StringWriter writer = new StringWriter();

        JavaCompiler jc = ToolProvider.getSystemJavaCompiler();

        Boolean call = jc.getTask(writer, null, null, Arrays.asList("-XDrawDiagnostics"), null, sources).call();

        return new CompilationResult(call, writer.toString().replace(ToolBox.lineSeparator, "\n"));

    }

    public void printSources(List<ToolBox.JavaSource> sources) {

        for (ToolBox.JavaSource javaSource : sources) {

            echo(javaSource.getCharContent(true).toString());

        }

    }

    public void echo() {

        echo("");

    }

    public void echo(String output) {

        printf(output + "\n");

    }

    public void printf(String template, Object...args) {

        System.err.print(String.format(template, args).replace("\n", ToolBox.lineSeparator));

    }

    enum ClassType {

        A("A",

        "package pkg;\n" +

        "class A {\n" +

        "    static class Inner {}\n" +

        "    static Object field;\n" +

        "    static void method() {}\n" +

        "}\n"

        ),

        B("B",

        "package pkg;\n" +

        "interface B {\n" +

        "    static class Inner {}\n" +

        "    static Object field = null;\n" +

        "    static void method() {}\n" +

        "}\n"

        ),

        C("C",

        "package pkg;\n" +

        "enum C {field;\n" +

        "    static class Inner {}\n" +

        "    static void method() {}\n" +

        "}\n"

        ),

        D("D",

        "package pkg;\n" +

        "@interface D {\n" +

        "    static class Inner {}\n" +

        "    static Object field = null;\n" +

        "}\n"

        ),

        CHILD_A("ChildA",

        "package pkg;\n" +

        "class ChildA extends A {}\n",

        A);

        private final String className;

        private final String source;

        private final ClassType parentType;

        private ClassType(String className, String source) {

            this(className, source, null);

        }

        private ClassType(String className, String source, ClassType classType) {

            this.className = className;

            this.source = source;

            this.parentType = classType;

        }

        public String getClassName() {

            return className;

        }

        public List<ToolBox.JavaSource> getSources() {

            List<ToolBox.JavaSource> sourceList = new ArrayList<>();

            ClassType current = this;

            while (current != null) {

                sourceList.add(new ToolBox.JavaSource(current.className, current.source));

                current = current.parentType;

            }

            return sourceList;

        }

    }

    enum MemberType {

        CLASS("Inner", "Inner inner = null;"),

        FIELD("field", "Object o = field;"),

        METHOD("method", "method();"),

        STAR("*", ""),

        NOT_EXIST("NotExist", "");

        private final String memberType;

        private final String statement;

        private MemberType(String memberType, String statement) {

            this.memberType = memberType;

            this.statement = statement;

        }

        public String getStatement() {

            return statement;

        }

        public String getMemberType() {

            return memberType;

        }

    }

    enum ImportType {

        IMPORT("import pkg.#CLASS_NAME.#MEMBER_NAME;"),

        STATIC_IMPORT("import static pkg.#CLASS_NAME.#MEMBER_NAME;");

        private final String importType;

        private ImportType(String importType) {

            this.importType = importType;

        }

        public String generateImport(String className, String memberName) {

            return importType

                    .replace("#CLASS_NAME", className)

                    .replace("#MEMBER_NAME", memberName);

        }

        public boolean hasError(ClassType classType, MemberType memberType) {

            switch (memberType) {

                case FIELD:

                    return this != ImportType.STATIC_IMPORT;

                case METHOD:

                    return this != ImportType.STATIC_IMPORT || classType == ClassType.D;

                case NOT_EXIST:

                    return true;

                case CLASS:

                    return classType.parentType != null && this != STATIC_IMPORT;

                default:

                    return false;

            }

        }

    }

}