/*

 * 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

 * @author   sogoel

 * @summary  Reflection api tests

 * @modules jdk.compiler

 * @build    Helper

 * @compile  expectedFiles/ExpectedBase.java expectedFiles/ExpectedContainer.java

 * @run main ReflectionTest

 */

import java.io.File;

import java.io.IOException;

import java.lang.annotation.Annotation;

import java.net.MalformedURLException;

import java.net.URL;

import java.net.URLClassLoader;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.List;

import javax.tools.DiagnosticCollector;

import javax.tools.JavaFileObject;

import expectedFiles.ExpectedBase;

import expectedFiles.ExpectedContainer;

import java.util.Iterator;

import java.util.regex.Pattern;

/*

 * Objective:

 * Test the following 6 methods from java.lang.reflect.AnnotatedElement:

 * - getAnnotation(Class<T>)

 * - getAnnotations()

 * - getDeclaredAnnotations()

 * - getDeclaredAnnotation(Class<T>)  // new method in JDK8

 * - getAnnotationsByType(Class<T>)         // new method in JDK8

 * - getDeclaredAnnotationsByType(Class<T>) // new method in JDK8

 * for multiple test cases, for example, BasicNonRepeatable case, BasicRepeatable case

 * for each of the src types - class, method, field, package

 *

 * This test uses following three enums:

 * 1. TestCase - Defines the ExpectedBase/ExpectedContainer values for each testCase

 *             - getTestFiles() - Creates list of JavaFileObjects for the primary

 *                                src types (class, method, field, package)

 *             - Each testCase is a new scenario with a combination of @Repeatable

 *               relationship present/absent in conjunction with @Inherited.

 *               For eg: BasicNonRepeatable_Legacy - It is a pre-JDK8 way of writing a single

 *                       annotation on a given srcType( class, method, field, package)

 *                       BasicRepeatable - It is a JDK8 way of writing repeating annotations

 *                       on a given srcType with a @Repeatable relationship

 *                       defined between Foo and FooContainer.

 *

 * 2. SrcType - Defines templates used in creation of test src

 *            - Defines getExpectedBase() and getExpectedContainer() for primary src types

 * 3. TestMethod - Defines getActualAnnoBase(), getActualAnnoContainer(), getExpectedAnnoBase(),

 *                 and getExpectedAnnoContainer() for each of the 6 methods that are being tested

 *                 in java.lang.reflect.AnnotatedElement

 *

 * Test execution flow:

 * - Loop over each of the src types and each test cases

 * - Creates test src for each flow, compile it, load the class object

 * - Run all 6 methods on this class object

 * - Get expected and actual annotations for each object and compare them.

 * - Increment the error counter if the annotations don't match.

 *

 * The test fails if the number of errors is greater than 0.

 */

public class ReflectionTest {

    static int errors = 0;

    // Variables used in creating test src for a given testcase/testSrcType

    static final String TESTPKG = "testpkg";

    static final String TESTMETHOD = "testMethod";

    static final String TESTFIELD = "testField";

    static final String PKGINFONAME = TESTPKG + ".package-info";

    static final String SUPERCLASS = "SuperClass";

    static final String TESTINTERFACE = "TestInterface";

    /*

     *  Set it to true to get more debug information

     */

    static final boolean DEBUG = false;

    static boolean CHECKORDERING;

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

        ReflectionTest test = new ReflectionTest();

        test.runTest();

    }

    public void runTest() throws Exception {

        ClassLoader parentClassLoader = getLoader();

        String className = "";

        Iterable<? extends JavaFileObject> files = null;

        for (SrcType srcType : SrcType.getSrcTypes()) {

            for (TestCase testCase : TestCase.values()) {

                className = testCase + "_" + srcType;

                debugPrint("*****************************************");

                System.out.println("Running Test for ClassName: " + className);

                // @Inherited only applicable for class, exclude cases for

                // package, method, field

                if (testCase.name().contains("Inherited")

                        && (srcType != SrcType.CLASS)) {

                    continue;

                }

                // Get list of JavaFileObjects to be compiled

                files = testCase.getTestFiles(srcType, className);

                if (srcType == SrcType.PACKAGE) {

                    className = TESTPKG + "." + className;

                }

                DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();

                // Compile the list of JavaFileObjects

                try {

                    Helper.compileCode(diagnostics, files);

                } catch (Exception ex) {

                    printTestSrc(files);

                    throw new RuntimeException(

                            "Exception when compiling class " + className, ex);

                }

                // Get Class object for the compiled class

                Class<?> c = loadClass(className, parentClassLoader, Helper.destDir);

                if (c != null) {

                    // For the loaded class object, compare expected and actual annotation values

                    // for each of the methods under test from java.lang.reflect.AnnotatedElement

                    // Ignoring following test cases since for now they are

                    // failing with ordering issues.

                    // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest

                    // fail with ordering issues

                    List<String> orderingTestFailures = Arrays.asList(

                            "SingleOnSuperContainerOnSub_Inherited_Legacy",

                            "SingleOnSuperContainerAndSingleOnSub_Inherited_Legacy",

                            "ContainerAndSingleOnSuperSingleOnSub_Inherited_Legacy",

                            "SingleAnnoWithContainer",

                            "SingleOnSuperContainerAndSingleOnSub_Inherited",

                            "RepeatableOnSuperSingleOnSub_Inherited",

                            "SingleOnSuperRepeatableOnSub_Inherited",

                            "ContainerOnSuperSingleOnSub_Inherited",

                            "SingleOnSuperContainerOnSub_Inherited",

                            "ContainerAndSingleOnSuperSingleOnSub_Inherited");

                    if (orderingTestFailures.contains(testCase.toString())) {

                        CHECKORDERING = false;

                    } else

                        CHECKORDERING = true;

                    checkAnnoValues(srcType, c);

                } else {

                    error("Could not load className = " + c);

                }

            }

        }

        if (getNumErrors() > 0) {

            System.err.println("Test failed with " + getNumErrors() + " errors");

            throw new RuntimeException();

        }

    }

    /*

     *  Each test case in this enum has the following:

     *  - Define each test case with its @ExpectedBase and @ExpectedContainer annotations

     *  - Override getTestFiles() that creates list of JavaFileObjects for each case

     *    based on the src type.

     */

    enum TestCase {

        BasicNonRepeatable_Legacy(

        "@ExpectedBase(value=Foo.class, "

                + "getAnnotationVal = \"@Foo(value=0)\", "

                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}, "

                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}, "

                + "getDeclAnnoVal = \"@Foo(value=0)\", "

                + "getAnnosArgs = {\"@Foo(value=0)\"}, "

                + "getDeclAnnosArgs = {\"@Foo(value=0)\"}) ",

        "@ExpectedContainer") {

            @Override

            public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

                    String className) {

                String anno = "";

                String replaceVal = "";

                String testSrc = "";

                String pkgInfoContents = "";

                String contents = "";

                JavaFileObject pkgFileObj = null;

                JavaFileObject srcFileObj = null;

                Iterable<? extends JavaFileObject> files = null;

                String expectedVals = "\n" + getExpectedBase() + "\n"

                        + getExpectedContainer() + "\n";

                StringBuilder commonStmts = new StringBuilder();

                anno = Helper.ContentVars.BASEANNO.getVal();

                commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

                        .append(Helper.ContentVars.IMPORTSTMTS.getVal())

                        .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

                        .append(Helper.ContentVars.BASE.getVal());

                switch (srcType) {

                    case PACKAGE:

                        /*

                        Sample package-info.java

                        @ExpectedBase

                        @ExpectedContainer

                        @Foo(0)

                        package testpkg;

                        @Retention(RetentionPolicy.RUNTIME)

                        @interface Foo {int value() default Integer.MAX_VALUE;}

                        Sample testSrc:

                        package testpkg;

                        class A {}

                         */

                        testSrc = srcType.getTemplate().replace("#CN", className);

                        contents = testSrc;

                        srcFileObj = Helper.getFile(className, contents);

                        replaceVal = expectedVals + "\n" + anno;

                        pkgInfoContents = SrcType.PKGINFO.getTemplate()

                                .replace("#REPLACE1", replaceVal)

                                .replace("#REPLACE2", commonStmts);

                        pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents);

                        files = Arrays.asList(pkgFileObj, srcFileObj);

                        break;

                    default:

                        // class, method, field

                    /*

                        Sample testSrc for class

                        @Retention(RetentionPolicy.RUNTIME)

                        @interface Foo {int value() default Integer.MAX_VALUE;}

                        @ExpectedBase

                        @ExpectedContainer

                        @Foo(0)

                        class A {}

                         */

                        replaceVal = expectedVals + anno;

                        testSrc = srcType.getTemplate().replace("#CN", className)

                                .replace("#REPLACE", replaceVal);

                        contents = commonStmts + testSrc;

                        srcFileObj = Helper.getFile(className, contents);

                        files = Arrays.asList(srcFileObj);

                }

                return files;

            }

        },

        SingleAnnoInherited_Legacy(

        "@ExpectedBase(value=Foo.class, "

                + "getAnnotationVal = \"@Foo(value=0)\", "

                + "getAnnotationsVals = {\"@Foo(value=0)\", \"ExpectedBase\", \"ExpectedContainer\"}, "

                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "

                + "getDeclAnnoVal = \"NULL\", "

                + "getAnnosArgs = {\"@Foo(value=0)\"}, "

                + "getDeclAnnosArgs = {})",

        "@ExpectedContainer") {

            @Override

            public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

                    String className) {

                String anno = "";

                String replaceVal = "";

                String contents = "";

                JavaFileObject srcFileObj = null;

                Iterable<? extends JavaFileObject> files = null;

                String expectedVals = "\n" + getExpectedBase() + "\n"

                        + getExpectedContainer() + "\n";

                StringBuilder commonStmts = new StringBuilder();

                /*

                Sample testSrc:

                @Retention(RetentionPolicy.RUNTIME)

                @Inherited

                @interface Foo {int value() default Integer.MAX_VALUE;}

                @Foo(0)

                class SuperClass { }

                @ExpectedBase

                @ExpectedContainer

                class SubClass extends SuperClass {}

                 */

                // @Inherited only works for classes, no switch cases for

                // method, field, package

                anno = Helper.ContentVars.BASEANNO.getVal();

                commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

                        .append(Helper.ContentVars.IMPORTSTMTS.getVal())

                        .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

                        .append(Helper.ContentVars.INHERITED.getVal())

                        .append(Helper.ContentVars.BASE.getVal());

                if (srcType == SrcType.CLASS) {

                    // Contents for SuperClass

                    replaceVal = commonStmts + "\n" + anno;

                    String superClassContents = srcType.getTemplate()

                            .replace("#CN", SUPERCLASS).replace("#REPLACE", replaceVal);

                    // Contents for SubClass that extends SuperClass

                    replaceVal = expectedVals;

                    String subClassContents = SrcType.CLASSEXTENDS.getTemplate()

                            .replace("#CN", className).replace("#SN", SUPERCLASS)

                            .replace("#REPLACE", replaceVal);

                    contents = superClassContents + subClassContents;

                    srcFileObj = Helper.getFile(className, contents);

                    files = Arrays.asList(srcFileObj);

                }

                return files;

            }

        },

        InheritedAnnoOnInterface_Legacy(

        "@ExpectedBase(value=Foo.class, "

                + "getAnnotationVal = \"NULL\", "

                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "

                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"},"

                + "getDeclAnnoVal = \"NULL\"," + "getAnnosArgs = {},"

                + "getDeclAnnosArgs = {})",

        "@ExpectedContainer") {

            @Override

            public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

                    String className) {

                String anno = "";

                String replaceVal = "";

                String contents = "";

                JavaFileObject srcFileObj = null;

                Iterable<? extends JavaFileObject> files = null;

                String expectedVals = "\n" + getExpectedBase() + "\n"

                        + getExpectedContainer() + "\n";

                StringBuilder commonStmts = new StringBuilder();

                /*

                Sample test src:

                @Retention(RetentionPolicy.RUNTIME)

                @Inherited

                @interface Foo {int value() default Integer.MAX_VALUE;}

                @Foo(0)

                interface TestInterface { }

                @ExpectedBase

                @ExpectedContainer

                class A implements TestInterface {}

                 */

                anno = Helper.ContentVars.BASEANNO.getVal();

                commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

                        .append(Helper.ContentVars.IMPORTSTMTS.getVal())

                        .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

                        .append(Helper.ContentVars.INHERITED.getVal())

                        .append(Helper.ContentVars.BASE.getVal());

                if (srcType == SrcType.CLASS) {

                    // Contents for TestInterface

                    replaceVal = commonStmts + "\n" + anno;

                    String interfaceContents = SrcType.INTERFACE.getTemplate()

                            .replace("#IN", TESTINTERFACE)

                            .replace("#REPLACE", replaceVal);

                    // Contents for class implementing TestInterface

                    replaceVal = expectedVals;

                    String classContents = SrcType.INTERFACEIMPL.getTemplate()

                            .replace("#CN", className).replace("#IN", TESTINTERFACE)

                            .replace("#REPLACE", replaceVal);

                    contents = interfaceContents + classContents;

                    srcFileObj = Helper.getFile(className, contents);

                    files = Arrays.asList(srcFileObj);

                }

                return files;

            }

        },

        AnnoOnSuperAndSubClass_Inherited_Legacy(

        "@ExpectedBase(value=Foo.class, "

                + "getAnnotationVal = \"@Foo(value=2)\", "

                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=2)\"}, "

                + // override every annotation on superClass

                "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=2)\"}, "

                + // ignores inherited annotations

                "getDeclAnnoVal = \"@Foo(value=2)\", " // ignores inherited

                + "getAnnosArgs = {\"@Foo(value=2)\"}, "

                + "getDeclAnnosArgs = { \"@Foo(value=2)\" })", // ignores inherited

        "@ExpectedContainer(value=FooContainer.class, "

                + "getAnnotationVal = \"NULL\", "

                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=2)\"}, "

                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=2)\"}, "

                + // ignores inherited annotations

                "getDeclAnnoVal = \"NULL\", " + // ignores inherited

                "getAnnosArgs = {}, " + "getDeclAnnosArgs = {})") { // ignores inherited

            @Override

            public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

                    String className) {

                String anno = "";

                String replaceVal = "";

                String contents = "";

                JavaFileObject srcFileObj = null;

                Iterable<? extends JavaFileObject> files = null;

                String expectedVals = "\n" + getExpectedBase() + "\n"

                        + getExpectedContainer() + "\n";

                StringBuilder commonStmts = new StringBuilder();

                /*

                Sample test src

                @Retention(RetentionPolicy.RUNTIME)

                @Inherited

                @interface Foo {int value() default Integer.MAX_VALUE;}

                @Inherited

                @interface FooContainer {

                Foo[] value();

                }

                @Foo(1)

                class SuperClass { }

                @ExpectedBase

                @ExpectedContainer

                @Foo(2)

                class SubClass extends SuperClass {}

                 */

                // @Inherited only works for classes, no switch cases for

                // method, field, package

                commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

                        .append(Helper.ContentVars.IMPORTSTMTS.getVal())

                        .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

                        .append(Helper.ContentVars.INHERITED.getVal())

                        .append(Helper.ContentVars.BASE.getVal())

                        .append(Helper.ContentVars.INHERITED.getVal())

                        .append(Helper.ContentVars.CONTAINER.getVal());

                if (srcType == SrcType.CLASS) {

                    // Contents for SuperClass

                    anno = "@Foo(1)";

                    replaceVal = commonStmts + "\n" + anno;

                    String superClassContents = srcType.getTemplate()

                            .replace("#CN", SUPERCLASS).replace("#REPLACE", replaceVal);

                    // Contents for SubClass that extends SuperClass

                    anno = "@Foo(2)";

                    replaceVal = expectedVals + "\n" + anno;

                    String subClassContents = SrcType.CLASSEXTENDS.getTemplate()

                            .replace("#CN", className).replace("#SN", SUPERCLASS)

                            .replace("#REPLACE", replaceVal);

                    contents = superClassContents + subClassContents;

                    srcFileObj = Helper.getFile(className, contents);

                    files = Arrays.asList(srcFileObj);

                }

                return files;

            }

        },

        BasicContainer_Legacy(

        "@ExpectedBase(value = Foo.class, "

                + "getAnnotationVal = \"NULL\","

                + "getDeclAnnoVal = \"NULL\", " + "getAnnosArgs = {}, "

                + "getDeclAnnosArgs = {} )",

        "@ExpectedContainer(value=FooContainer.class, "

            @Override

            public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

                    String className) {

                String anno = "";

                String replaceVal = "";

                String testSrc = "";

                String pkgInfoContents = "";

                String contents = "";

                JavaFileObject pkgFileObj = null;

                JavaFileObject srcFileObj = null;

                Iterable<? extends JavaFileObject> files = null;

                String expectedVals = "\n" + getExpectedBase() + "\n"

                        + getExpectedContainer() + "\n";

                StringBuilder commonStmts = new StringBuilder();

                anno = Helper.ContentVars.LEGACYCONTAINER.getVal();

                commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

                        .append(Helper.ContentVars.IMPORTSTMTS.getVal())

                        .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

                        .append(Helper.ContentVars.BASE.getVal())

                        .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())