/*
 * 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: AnnotatedArrayType.getAnnotatedGenericComponentType()
 * @author Charlie Wang
 * @library ../../../../
 * @build AnnotationTest TestCaseGenerator DeclarationGenerator Helper
 * @run main AnnotatedArrayTypeGetAnnotatedGenericComponentTypeTest
 */
import java.lang.reflect.AnnotatedType;
import java.util.LinkedHashMap;
import java.util.Map;

/*
 * This file is intended to test API: AnnotatedArrayType.getAnnotatedGenericComponentType(). 
 * It can be run directly by java command or by jtreg.
 * By setting Helper.DEBUG = true/false, one can display/hide the test code
 * on the command line output, which is constructed for the annotation test.
 * Here's more details about test code generation:
 * 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. 1-dimension array with annotations on type and array"[]"
 * 2. 2-dimension array with annotations on type and array"[]"
 * 3. 3-dimension array with annotations on type and array"[]"
 * 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 AnnotatedArrayTypeGetAnnotatedGenericComponentTypeTest
    extends AnnotationTest {

    enum TestCase implements TestCaseGenerator {

        TESTBASECLSSTART() {
            /**
             * 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) {
                return AnnotationTest.genBaseClassStart(testBaseClsName);
            }
        },
        ARRAYFIELD() {
            /**
             * generate single dimension array: 
             * public String [#ANNO] [] f1;
             * 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 = "";
                int clsIdx = testInput.size();
                TestCodeGenerator tcg = new TestCodeGenerator();
                tcg.put(Helper.Declaration.FIELD_TYPE, str + " String");
                tcg.put(Helper.Declaration.FIELD_ARRAY, str);
                tcg.put(Helper.Declaration.FIELD_NAME, 
                        testBaseFieldName + clsIdx + "1");
                testInput.put(testBaseFieldName + clsIdx + "1", str);
                testCode += tcg.genTestCode(Helper.Declaration.FIELD_ARRAY);

                tcg = new TestCodeGenerator();
                tcg.put(Helper.Declaration.FIELD_TYPE, str + " String");
                tcg.put(Helper.Declaration.FIELD_ARRAY, 
                        new String[]{str, str});
                tcg.put(Helper.Declaration.FIELD_NAME, 
                        testBaseFieldName + clsIdx + "2");
                testInput.put(testBaseFieldName + clsIdx + "2", str);
                testCode += tcg.genTestCode(Helper.Declaration.FIELD_ARRAY);

                tcg = new TestCodeGenerator();
                tcg.put(Helper.Declaration.FIELD_TYPE, str + " String");
                tcg.put(Helper.Declaration.FIELD_ARRAY, 
                        new String[]{str, str, str});
                tcg.put(Helper.Declaration.FIELD_NAME, 
                        testBaseFieldName + clsIdx + "3");
                testInput.put(testBaseFieldName + clsIdx + "3", str);
                testCode += tcg.genTestCode(Helper.Declaration.FIELD_ARRAY);

                tcg = new TestCodeGenerator();
                tcg.put(Helper.Declaration.FIELD_TYPE, str + " String");
                tcg.put(Helper.Declaration.FIELD_ARRAY, 
                        new String[]{str, str, str, str});
                tcg.put(Helper.Declaration.FIELD_NAME, 
                        testBaseFieldName + clsIdx + "4");
                testInput.put(testBaseFieldName + clsIdx + "4", str);
                testCode += tcg.genTestCode(Helper.Declaration.FIELD_ARRAY);
                
                return testCode;
            }
        },
        TESTBASECLSEND() {
            /**
             * generate end of the test base class: }
             *
             */
            public String genTestCase(String str) {
                return AnnotationTest.genBaseClassEnd(testBaseClsName);
            }
        };
        
        // a place to hold class name -- annotation correspondence
        public static Map<String, String> testInput = new LinkedHashMap<>();
        
        // generate test class of a specific case
        public String genTestCase(String str) {
            return "";
        }
    }

    // generate source code for test according to TestCase
    protected String genTestCode(Class<? extends TestCaseGenerator> tcg) {
        String testCode = "";
        testCode += TestCase.TESTBASECLSSTART.genTestCase(null);
        for (String anno : annotationCombinations) {
            // append annotation on field
            testCode += TestCase.ARRAYFIELD.genTestCase(anno);
        }
        testCode += TestCase.TESTBASECLSEND.genTestCase(null);
        
        return testCode;
    }

    // compare input with result
    protected boolean checkResult() throws Exception {
        compileCode(TestCase.class);
        // Get Class object for the compiled class
        Class cls = Helper.loadClass(TestCaseGenerator.testBaseClsName);
        for (String fieldName : TestCase.testInput.keySet()) {
            AnnotatedType at = 
                    cls.getDeclaredField(fieldName).
                    getAnnotatedType();
            String[] result = Helper.getArrAT(at).split(";");
            for (String anno : result) {
                if (!"".equals(anno) 
                        && !anno.equals(TestCase.testInput.get(fieldName))) {
                    Helper.debugPrint(fieldName 
                            + " failed with faulty annotations.");
                    return false;
                }
            }
        }
        return true;
    }

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