--- /dev/null Mon Sep 23 02:04:41 2013 +++ new/test/type-annotations/java/lang/Class/ClassGetAnnotatedSuperclassTest.java Mon Sep 23 02:04:40 2013 @@ -0,0 +1,214 @@ +/* + * 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.getAnnotatedSuperclass() + * @author Charlie Wang + * @library ../../../ + * @build AnnotationTest TestCaseGenerator DeclarationGenerator Helper + * @run main ClassGetAnnotatedSuperclassTest + */ +import java.lang.reflect.AnnotatedType; +import java.util.LinkedHashMap; +import java.util.List; +import java.util.Map; + +/* + * This file is intended to test API: Class.getAnnotatedSuperclass(). + * 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. Single class + * 2. Class extends interface + * 3. Class extends 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 ClassGetAnnotatedSuperclassTest 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 == testInput.size()) { + testInput.put(null, null); + 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 = ""; + int clsIdx = testInput.size(); + TestCodeGenerator tcg = new TestCodeGenerator(); + tcg.put(Helper.Declaration.CLASS, typeAnnoClsName + clsIdx); + tcg.put(Helper.Declaration.CLASS_BODY_START, ""); + tcg.put(Helper.Declaration.CLASS_BODY_END, ""); + testCode += tcg.genTestCode(); + testInput.put(typeAnnoClsName + 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 = ""; + int clsIdx = testInput.size(); + TestCodeGenerator tcg = new TestCodeGenerator(); + tcg.put(Helper.Declaration.CLASS, typeAnnoClsName + clsIdx); + tcg.put(Helper.Declaration.EXTENDS, new String[]{ + str + " Object"}); + tcg.put(Helper.Declaration.CLASS_BODY_START, ""); + tcg.put(Helper.Declaration.CLASS_BODY_END, ""); + testCode += tcg.genTestCode(); + testInput.put(typeAnnoClsName + clsIdx, str); + 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 = ""; + int clsIdx = testInput.size(); + TestCodeGenerator tcg = new TestCodeGenerator(); + tcg.put(Helper.Declaration.CLASS, typeAnnoClsName + clsIdx); + tcg.put(Helper.Declaration.EXTENDS, new String[]{ + str + " Object"}); + tcg.put(Helper.Declaration.IMPLEMENTS, new String[]{ + str + " Serializable"}); + tcg.put(Helper.Declaration.CLASS_BODY_START, ""); + tcg.put(Helper.Declaration.CLASS_BODY_END, ""); + testCode += tcg.genTestCode(); + testInput.put(typeAnnoClsName + clsIdx, str); + return testCode; + } + }; + + // a place to hold class name -- annotation correspondence + public static Map 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 tcg) { + String testCode = ""; + testCode += super.genTestCode(tcg); + + // special cases + TestCase.testInput.put("int.class", null); + TestCase.testInput.put("int[].class", null); + TestCase.testInput.put("void.class", null); + TestCase.testInput.put("Object.class", null); + return testCode; + } + + // compare input with result + protected boolean checkResult() throws Exception { + boolean ret = true; + compileCode(TestCase.class); + for (String clsName : TestCase.testInput.keySet()) { + if (null == clsName) { + continue; + } + Class cls = loadClass(clsName); + AnnotatedType as = cls.getAnnotatedSuperclass(); + List result = Helper.getMultipleAT(new AnnotatedType[]{as}); + if (0 == result.size()) { + if (null != TestCase.testInput.get(clsName)) { + // should be empty output + ret = false; + Helper.debugPrint(clsName.toString() + + " failed without empty output."); + } + } else { + for (int i = 0; i < result.size(); i++) { + if (!result.get(i).equals(TestCase.testInput.get(clsName))) { + // annotations not match + ret = false; + Helper.debugPrint(clsName.toString() + + " failed with faulty annotations."); + } + } + } + } + return ret; + } + + public static void main(String[] args) throws Exception { + new ClassGetAnnotatedSuperclassTest().test(); + } +}