/*
 * Copyright (c) 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 8013497
 * @summary test for API: Class.getAnnotationsByType()
 * @library ../../../
 * @build AnnotationTest TestCaseGenerator DeclarationGenerator Helper
 * @author Charlie Wang
 * @run main ClassGetAnnotationsByTypeTest
 */
import java.lang.annotation.Annotation;

/*
 * Construct the test code in a structure specified in TestCase.
 * In each of the following cases, different combinations of annotation 
 * specified in AnnotationTest.annotationCombinations are tested. The output
 * annotations must be the same as input both in value and order.
 * 1. Single interface
 * 2. Class extends class
 * 3. Class implements interface
 * The program test all the cases in TestCase by looping over each one of it.
 * Test cases are constructed with small code snippet from Helper.SrcType
 * using changable annotations, type and name. After these values are specified,
 * the method GenTestCode() generates corresponding java code, encapsulate them
 * with a class. Then this class is compiled by Helper.compileCode() into
 * classes which is later loaded into memory by Helper.loadClass().
 * The test fails if any of the cases fail.
 */
public class ClassGetAnnotationsByTypeTest extends AnnotationTest {

    enum TestCase implements TestCaseGenerator {
        TESTBASECLS() {
            /**
             * generate test base, which is the class name used to compile the code: 
             * import java.io.*; 
             * import java.util.*; 
             * import java.lang.*; 
             * import java.lang.reflect.*;
             * import java.lang.annotation.*; 
             * class testBaseClsName { }
             */
            public String genTestCase(String str) {
                if (0 == clsIdx) {
                    clsIdx++;
                    return AnnotationTest.genBaseClass(testBaseClsName);
                } else {
                    return "";
                }
            }
        },
        SINGLECLS() {
            /**
             * generate single class: 
             * [#ANNO] class TypeAnnoCls1 { } 
             * then append annotations on [#ANNO]
             *
             * input should be like [@anno]
             */
            public String genTestCase(String str) {
                if (null == str) {
                    throw new RuntimeException("bad test case.");
                }
                String testCode = "";
                lhm.put(Helper.Declaration.CLASS, 
                        new String[]{str + " " + typeAnnoClsName + clsIdx});
                testCode += Helper.genDeclaration(lhm);
                lhm.clear();
                testInput.put(typeAnnoClsName + clsIdx, str);
                clsIdx++;
                return testCode;
            }
        },
        CLSEXTCLS() {
            /**
             * generate cls extends cls: 
             * [#ANNO] class TypeAnnoCls2 extends [#ANNO] Object {} 
             * then append annotations on [#ANNO]
             *
             * input should be like [@anno]
             */
            public String genTestCase(String str) {
                if (null == str) {
                    throw new RuntimeException("bad test case.");
                }
                String testCode = "";
                lhm.put(Helper.Declaration.CLASS, new String[]{
                    str + " " + typeAnnoClsName + clsIdx});
                lhm.put(Helper.Declaration.EXTENDS, new String[]{
                    str + " Object"});
                testCode += Helper.genDeclaration(lhm);
                lhm.clear();
                testInput.put(typeAnnoClsName + clsIdx, str);
                clsIdx++;
                return testCode;
            }
        },
        CLSEXTCLSIMPINT() {
            /**
             * generate cls implements interface: 
             * [#ANNO] class TypeAnnoCls3 extends 
             * [#ANNO] Object implements [#ANNO] Serializable {} 
             * then append annotations on [#ANNO]
             *
             * input should be like [@anno]
             */
            public String genTestCase(String str) {
                if (null == str) {
                    throw new RuntimeException("bad test case.");
                }
                String testCode = "";
                lhm.put(Helper.Declaration.CLASS, new String[]{
                    str + " " + typeAnnoClsName + clsIdx});
                lhm.put(Helper.Declaration.EXTENDS, new String[]{
                    str + " Object"});
                lhm.put(Helper.Declaration.IMPLEMENTS, new String[]{
                    str + " Serializable"});
                testCode += Helper.genDeclaration(lhm);
                lhm.clear();
                testInput.put(typeAnnoClsName + clsIdx, str);
                clsIdx++;
                return testCode;
            }
        };

        // generate test class of a specific case
        public String genTestCase(String str) {
            return "";
        }
    }

    // compare input with result
    protected boolean checkResult() throws Exception {
        boolean ret = true;
        compileCode(TestCase.class);
        for (Object clsName : testInput.keySet()) {
            Class cls = loadClass(clsName);
            Class argCls = Helper.loadClass(TestCaseGenerator.argClsName);
            Annotation[] as = cls.getAnnotationsByType(argCls);
            String result = Helper.getAnno(as);
            if (null == result || 0 == result.length()) {
                if (-1 != testInput.get(clsName)
                        .indexOf(TestCaseGenerator.argClsName)) {
                    // should be empty output
                    ret = false;
                    Helper.debugPrint(clsName.toString() 
                            + " failed without empty output.");
                }
            } else {
                if (-1 == testInput.get(clsName)
                        .indexOf(TestCaseGenerator.argClsName)) {
                    // should not be empty output
                    ret = false;
                    Helper.debugPrint(clsName.toString()
                            + " failed with faulty annotations.");
                }
            }
        }
        return ret;
    }

    public static void main(String[] args) throws Exception {
        new ClassGetAnnotationsByTypeTest().test();
    }
}