| /* |
| * Copyright (c) 2013, 2016, 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 8001457 8027477 8163113 |
| * @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\"," |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnoVal = \"NULL\", " + "getAnnosArgs = {}, " |
| + "getDeclAnnosArgs = {} )", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"} )") { |
| |
| @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()) |
| .append(Helper.ContentVars.CONTAINER.getVal()); |
| switch (srcType) { |
| case PACKAGE: |
| /* |
| Sample package-info.java |
| @ExpectedBase |
| @ExpectedContainer |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| package testpkg; |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| Sample testSrc: |
| package testpkg; |
| class A {} |
| */ |
| testSrc = srcType.getTemplate().replace("#CN", className); |
| contents = testSrc; |
| srcFileObj = Helper.getFile(className, contents); |
| |
| replaceVal = "\n" + 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: |
| /* |
| Sample testSrc for class: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| 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; |
| } |
| }, |
| SingleAndContainerOnSuper_Legacy( |
| "@ExpectedBase(value = Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=0)\"," |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnoVal = \"@Foo(value=0)\", " |
| + "getAnnosArgs = {\"@Foo(value=0)\"}, " |
| + "getDeclAnnosArgs = {\"@Foo(value=0)\"} )", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"} )") { |
| |
| @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() + |
| 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()) |
| .append(Helper.ContentVars.CONTAINER.getVal()); |
| switch (srcType) { |
| case PACKAGE: |
| /* |
| Sample package-info.java |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(0) |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| package testpkg; |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| Sample testSrc: |
| package testpkg; |
| class A {} |
| */ |
| testSrc = srcType.getTemplate().replace("#CN", className); |
| contents = testSrc; |
| |
| srcFileObj = Helper.getFile(className, contents); |
| |
| replaceVal = "\n" + 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: |
| /* |
| Sample testSrc for class: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(0) |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| 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; |
| } |
| }, |
| BasicContainer_Inherited_Legacy( |
| "@ExpectedBase(value = Foo.class, " |
| + "getAnnotationVal = \"NULL\"," |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " |
| + "getDeclAnnoVal = \"NULL\", " |
| + "getAnnosArgs = {}, " |
| + "getDeclAnnosArgs = {} )", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " |
| + "getDeclAnnoVal = \"NULL\", " |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosArgs = {} )") { |
| |
| @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 = getCommonStmts(false); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| class SubClass extends SuperClass {} |
| */ |
| // @Inherited only works for classes, no switch cases for |
| // method, field, package |
| |
| if (srcType == SrcType.CLASS) { |
| // Contents for SuperClass |
| anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); |
| 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; |
| } |
| }, |
| ContainerOnSuperSingleOnSub_Inherited_Legacy( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=0)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=0)\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," |
| + "getDeclAnnoVal = \"@Foo(value=0)\"," |
| + "getAnnosArgs = {\"@Foo(value=0)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=0)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=0)\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," |
| + "getDeclAnnoVal = \"NULL\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {})") { |
| |
| @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 = getCommonStmts(false); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(0) |
| class SubClass extends SuperClass {} |
| */ |
| // @Inherited only works for classes, no switch cases for |
| // method, field, package |
| |
| if (srcType == SrcType.CLASS) { |
| // Contents for SuperClass |
| anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| // Contents for SubClass that extends SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| 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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| ContainerAndSingleOnSuperSingleOnSub_Inherited_Legacy( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=0)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=0)\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," |
| + "getDeclAnnoVal = \"@Foo(value=0)\"," |
| + "getAnnosArgs = {\"@Foo(value=0)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=0)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=0)\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," |
| + "getDeclAnnoVal = \"NULL\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {})") { |
| |
| @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 = getCommonStmts(false); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @FooContainer(value = {@Foo(1), @Foo(2)}) @Foo(3) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(0) |
| class SubClass extends SuperClass {} |
| */ |
| // @Inherited only works for classes, no switch cases for |
| // method, field, package |
| |
| if (srcType == SrcType.CLASS) { |
| // Contents for SuperClass |
| anno = Helper.ContentVars.LEGACYCONTAINER.getVal() |
| + "@Foo(3)"; |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| // Contents for SubClass that extends SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| 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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| SingleOnSuperContainerOnSub_Inherited_Legacy( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=0)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnoVal = \"NULL\"," |
| + "getAnnosArgs = {\"@Foo(value=0)\"}," |
| + "getDeclAnnosArgs = {})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { |
| |
| @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 = getCommonStmts(false); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @Foo(0) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| class SubClass extends SuperClass {} |
| */ |
| |
| if (srcType == SrcType.CLASS) { |
| //Contents for SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| //Contents for SubClass that extends SuperClass |
| anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); |
| 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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| SingleOnSuperContainerAndSingleOnSub_Inherited_Legacy( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=3)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}, " |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}," |
| + "getDeclAnnoVal = \"@Foo(value=3)\"," |
| + "getAnnosArgs = {\"@Foo(value=3)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=3)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}, " |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}," |
| + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { |
| |
| @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 = getCommonStmts(false); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @Foo(0) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @FooContainer(value = {@Foo(1), @Foo(2)}) @Foo(3) |
| class SubClass extends SuperClass {} |
| */ |
| |
| if (srcType == SrcType.CLASS) { |
| //Contents for SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| //Contents for SubClass that extends SuperClass |
| anno = Helper.ContentVars.LEGACYCONTAINER.getVal() |
| + "@Foo(3)"; |
| 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; |
| } |
| }, |
| BasicRepeatable( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"NULL\", " |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\" }, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnoVal = \"NULL\"," |
| + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"} )") { |
| |
| @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.REPEATABLEANNO.getVal(); |
| commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) |
| .append(Helper.ContentVars.IMPORTSTMTS.getVal()) |
| .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) |
| .append(Helper.ContentVars.REPEATABLE.getVal()) |
| .append(Helper.ContentVars.BASE.getVal()) |
| .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) |
| .append(Helper.ContentVars.CONTAINER.getVal()); |
| switch (srcType) { |
| case PACKAGE: |
| /* |
| Sample package-info.java |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(1) @Foo(2) |
| package testpkg; |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @interface FooContainer { |
| Foo[] 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: |
| /* |
| Sample testSrc for class: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(1) @Foo(2) |
| 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; |
| } |
| }, |
| BasicContainerRepeatable( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"NULL\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnoVal = \"NULL\"," |
| + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"} )") { |
| |
| @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.REPEATABLE.getVal()) |
| .append(Helper.ContentVars.BASE.getVal()) |
| .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) |
| .append(Helper.ContentVars.CONTAINER.getVal()); |
| switch (srcType) { |
| case PACKAGE: |
| /* |
| Sample package-info.java |
| @ExpectedBase |
| @ExpectedContainer |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| package testpkg; |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @interface FooContainer { |
| Foo[] 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: |
| /* |
| Sample testSrc for class: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| 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; |
| } |
| }, |
| BasicContainerRepeatable_Inherited( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"NULL\", " |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " |
| + "getDeclAnnoVal = \"NULL\", " |
| + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}, " |
| + "getDeclAnnosArgs = {})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = { \"ExpectedBase\", \"ExpectedContainer\"}, " |
| + "getDeclAnnoVal = \"NULL\", " |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosArgs = {})") { |
| |
| @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 = getCommonStmts(true); |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| class SubClass extends SuperClass { } |
| */ |
| // @Inherited only works for classes, no switch cases for |
| // method, field, package |
| anno = Helper.ContentVars.LEGACYCONTAINER.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; |
| } |
| }, |
| RepeatableAnnoInherited( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"NULL\", " |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, " |
| + // ignores inherited annotations |
| "getDeclAnnoVal = \"NULL\", " |
| + // ignores inherited |
| "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}, " |
| + "getDeclAnnosArgs = {})", // ignores inherited |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = { \"ExpectedBase\", \"ExpectedContainer\"}, " |
| + // ignores inherited annotations |
| "getDeclAnnoVal = \"NULL\", " |
| + // ignores inherited |
| "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "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 = getCommonStmts(true); |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @Foo(1) @Foo(2) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| class SubClass extends SuperClass { } |
| */ |
| // @Inherited only works for classes, no switch cases for |
| // method, field, package |
| anno = Helper.ContentVars.REPEATABLEANNO.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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| SingleAnnoWithContainer( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=0)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnoVal = \"@Foo(value=0)\"," |
| + "getAnnosArgs = {\"@Foo(value=0)\", \"@Foo(value=1)\", \"@Foo(value=2)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=0)\", \"@Foo(value=1)\",\"@Foo(value=2)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { |
| |
| @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() + " " |
| + Helper.ContentVars.LEGACYCONTAINER.getVal(); |
| commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) |
| .append(Helper.ContentVars.IMPORTSTMTS.getVal()) |
| .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) |
| .append(Helper.ContentVars.REPEATABLE.getVal()) |
| .append(Helper.ContentVars.BASE.getVal()) |
| .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) |
| .append(Helper.ContentVars.CONTAINER.getVal()); |
| switch (srcType) { |
| case PACKAGE: |
| /* |
| Sample package-info.java |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(0) @FooContainer(value = {@Foo(1), @Foo(2)}) |
| package testpkg; |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @interface FooContainer { |
| Foo[] 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: |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(0) @FooContainer(value = {@Foo(1), @Foo(2)}) |
| 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; |
| } |
| }, |
| AnnoOnSuperAndSubClass_Inherited( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=1)\", " |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=1)\" }, " |
| + // override every annotation on superClass |
| "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=1)\"}, " |
| + // ignores inherited annotations |
| "getDeclAnnoVal = \"@Foo(value=1)\", " // ignores inherited |
| + "getAnnosArgs = {\"@Foo(value=1)\"}, " |
| + "getDeclAnnosArgs = { \"@Foo(value=1)\" })", // ignores inherited |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"NULL\", " |
| + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=1)\" }, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=1)\"}, " |
| + // ignores inherited annotations |
| "getDeclAnnoVal = \"NULL\", " + // ignores inherited |
| "getAnnosArgs = {}, " + "getDeclAnnosArgs = {})") { |
| |
| @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 = getCommonStmts(true); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @Foo(0) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(1) |
| class SubClass extends SuperClass { } |
| */ |
| // @Inherited only works for classes, no switch cases for |
| // method, field, package |
| |
| if (srcType == SrcType.CLASS) { |
| // Contents for SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| // Contents for SubClass that extends SuperClass |
| replaceVal = expectedVals + "\n" + "@Foo(1)"; |
| 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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| RepeatableOnSuperSingleOnSub_Inherited( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=3)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=3)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + //override every annotation on superClass |
| "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=3)\"}, " |
| + // ignores inherited annotations |
| "getDeclAnnoVal = \"@Foo(value=3)\", " // ignores inherited |
| + "getAnnosArgs = {\"@Foo(value=3)\"}, " |
| + "getDeclAnnosArgs = { \"@Foo(value=3)\" })", // ignores inherited |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=3)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=3)\"}, " |
| + // ignores inherited annotations |
| "getDeclAnnoVal = \"NULL\", " |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "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 = getCommonStmts(true); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @Foo(1) @Foo(2) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(3) |
| class SubClass extends SuperClass { } |
| */ |
| //@Inherited only works for classes, no switch cases for method, field, package |
| if (srcType == SrcType.CLASS) { |
| //Contents for SuperClass |
| anno = Helper.ContentVars.REPEATABLEANNO.getVal(); |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| //Contents for SubClass that extends SuperClass |
| anno = "@Foo(3)"; |
| 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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| SingleOnSuperRepeatableOnSub_Inherited( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=0)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + //override every annotation on superClass |
| "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + // ignores inherited annotations |
| "getDeclAnnoVal = \"NULL\","// ignores inherited |
| + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}, " |
| + "getDeclAnnosArgs = { \"@Foo(value=1)\", \"@Foo(value=2)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + // ignores inherited annotations |
| "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", "// ignores inherited |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { |
| |
| @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 = getCommonStmts(true); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @Foo(0) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(1) @Foo(2) |
| class SubClass extends SuperClass { } |
| */ |
| //@Inherited only works for classes, no switch cases for method, field, package |
| if (srcType == SrcType.CLASS) { |
| //Contents for SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| //Contents for SubClass that extends SuperClass |
| anno = Helper.ContentVars.REPEATABLEANNO.getVal(); |
| 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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| ContainerOnSuperSingleOnSub_Inherited( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=0)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," |
| + "getDeclAnnoVal = \"@Foo(value=0)\"," |
| + "getAnnosArgs = {\"@Foo(value=0)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=0)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," |
| + "getDeclAnnoVal = \"NULL\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {})") { |
| |
| @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 = getCommonStmts(true); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(0) |
| class SubClass extends SuperClass { } |
| */ |
| //@Inherited only works for classes, no switch cases for method, field, package |
| if (srcType == SrcType.CLASS) { |
| //Contents for SuperClass |
| anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| //Contents for SubClass that extends SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| 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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| SingleOnSuperContainerOnSub_Inherited( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=0)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnoVal = \"NULL\"," |
| + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { |
| |
| @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 = getCommonStmts(true); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @Foo(0) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| class SubClass extends SuperClass { } |
| */ |
| //@Inherited only works for classes, no switch cases for method, field, package |
| if (srcType == SrcType.CLASS) { |
| //Contents for SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| //Contents for SubClass that extends SuperClass |
| anno = Helper.ContentVars.LEGACYCONTAINER.getVal(); |
| 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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| SingleOnSuperContainerAndSingleOnSub_Inherited( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=3)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}, " |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}," |
| + "getDeclAnnoVal = \"@Foo(value=3)\"," |
| + "getAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\", \"@Foo(value=3)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=1)\", \"@Foo(value=2)\", \"@Foo(value=3)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}, " |
| + "getDeclAnnosVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", \"@Foo(value=3)\"}," |
| + "getDeclAnnoVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"})") { |
| |
| @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 = getCommonStmts(true); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @Foo(0) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @FooContainer(value = {@Foo(1), @Foo(2)}) @Foo(3) |
| class SubClass extends SuperClass {} |
| */ |
| |
| if (srcType == SrcType.CLASS) { |
| //Contents for SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| //Contents for SubClass that extends SuperClass |
| anno = Helper.ContentVars.LEGACYCONTAINER.getVal() |
| + "@Foo(3)"; |
| 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; |
| } |
| }, |
| // @ignore 8025924: Several test cases in repeatingAnnotations/combo/ReflectionTest |
| // fail with ordering issues |
| ContainerAndSingleOnSuperSingleOnSub_Inherited( |
| "@ExpectedBase(value=Foo.class, " |
| + "getAnnotationVal = \"@Foo(value=0)\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," |
| + "getDeclAnnoVal = \"@Foo(value=0)\"," |
| + "getAnnosArgs = {\"@Foo(value=0)\"}," |
| + "getDeclAnnosArgs = {\"@Foo(value=0)\"})", |
| "@ExpectedContainer(value=FooContainer.class, " |
| + "getAnnotationVal = \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\", " |
| + "getAnnotationsVals = {" |
| + "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\", \"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}, " |
| + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(value=0)\"}," |
| + "getDeclAnnoVal = \"NULL\"," |
| + "getAnnosArgs = {\"@FooContainer(value={@Foo(value=1), @Foo(value=2)})\"}," |
| + "getDeclAnnosArgs = {})") { |
| |
| @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 = getCommonStmts(true); |
| |
| /* |
| Sample testSrc: |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @Repeatable(FooContainer.class) |
| @interface Foo {int value() default Integer.MAX_VALUE;} |
| |
| @Retention(RetentionPolicy.RUNTIME) |
| @Inherited |
| @interface FooContainer { |
| Foo[] value(); |
| } |
| |
| @FooContainer(value = {@Foo(1), @Foo(2)}) |
| @Foo(3) |
| class SuperClass { } |
| |
| @ExpectedBase |
| @ExpectedContainer |
| @Foo(0) |
| class SubClass extends SuperClass { } |
| */ |
| |
| //@Inherited only works for classes, no switch cases for method, field, package |
| if (srcType == SrcType.CLASS) { |
| //Contents for SuperClass |
| anno = Helper.ContentVars.LEGACYCONTAINER.getVal() |
| + "@Foo(3)" ; |
| replaceVal = commonStmts + "\n" + anno; |
| String superClassContents = srcType.getTemplate() |
| .replace("#CN", SUPERCLASS) |
| .replace("#REPLACE", replaceVal); |
| |
| //Contents for SubClass that extends SuperClass |
| anno = Helper.ContentVars.BASEANNO.getVal(); |
| 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; |
| } |
| }; |
| |
| private String expectedBase, expectedContainer; |
| |
| private TestCase(String expectedBase, String expectedContainer) { |
| this.expectedBase = expectedBase; |
| this.expectedContainer = expectedContainer; |
| } |
| |
| public String getExpectedBase() { |
| return expectedBase; |
| } |
| |
| public String getExpectedContainer() { |
| return expectedContainer; |
| } |
| |
| // Each enum element should override this method |
| public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType, |
| String className) { |
| return null; |
| } |
| } |
| |
| /* |
| * Each srctype has its template defined used for test src generation |
| * Primary src types: class, method, field, package define |
| * getExpectedBase() and getExpectedContainer() |
| */ |
| enum SrcType { |
| |
| CLASS("\n#REPLACE\nclass #CN { } ") { |
| |
| @Override |
| public ExpectedBase getExpectedBase(Class<?> c) { |
| return c.getAnnotation(ExpectedBase.class); |
| } |
| |
| @Override |
| public ExpectedContainer getExpectedContainer(Class<?> c) { |
| return c.getAnnotation(ExpectedContainer.class); |
| } |
| }, |
| METHOD("class #CN {\n" + " " + "#REPLACE\n" + " void " |
| + TESTMETHOD + "() {} \n" + "}\n") { |
| |
| @Override |
| public ExpectedBase getExpectedBase(Class<?> c) { |
| ExpectedBase ret = null; |
| try { |
| ret = c.getDeclaredMethod(TESTMETHOD).getAnnotation( |
| ExpectedBase.class); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD + " for className " |
| + c.getName() + " Exception:\n" + nme); |
| } |
| return ret; |
| } |
| |
| @Override |
| public ExpectedContainer getExpectedContainer(Class<?> c) { |
| ExpectedContainer ret = null; |
| try { |
| ret = c.getDeclaredMethod(TESTMETHOD).getAnnotation( |
| ExpectedContainer.class); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD + " for className " |
| + c.getName() + " Exception:\n" + nme); |
| } |
| return ret; |
| |
| } |
| }, |
| FIELD("class #CN {\n" + " " + "#REPLACE\n" + " int " + TESTFIELD |
| + " = 0; \n" + "}\n") { |
| |
| @Override |
| public ExpectedBase getExpectedBase(Class<?> c) { |
| ExpectedBase ret = null; |
| try { |
| ret = c.getDeclaredField(TESTFIELD).getAnnotation( |
| ExpectedBase.class); |
| } catch (NoSuchFieldException nme) { |
| error("Could not get " + TESTFIELD + " for className " |
| + c.getName() + " Exception:\n" + nme); |
| } |
| return ret; |
| } |
| |
| @Override |
| public ExpectedContainer getExpectedContainer(Class<?> c) { |
| ExpectedContainer ret = null; |
| try { |
| ret = c.getDeclaredField(TESTFIELD).getAnnotation( |
| ExpectedContainer.class); |
| } catch (NoSuchFieldException nme) { |
| error("Could not get " + TESTFIELD + " for className " |
| + c.getName() + " Exception:\n" + nme); |
| } |
| return ret; |
| |
| } |
| }, |
| PACKAGE("package " + TESTPKG + "; \n" + "class #CN {}") { |
| |
| @Override |
| public ExpectedBase getExpectedBase(Class<?> c) { |
| return c.getPackage().getAnnotation(ExpectedBase.class); |
| } |
| |
| @Override |
| public ExpectedContainer getExpectedContainer(Class<?> c) { |
| return c.getPackage().getAnnotation(ExpectedContainer.class); |
| } |
| }, |
| PKGINFO("#REPLACE1\npackage " + TESTPKG + "; \n" + "#REPLACE2"), |
| INTERFACE("#REPLACE\ninterface #IN { } "), |
| INTERFACEIMPL("#REPLACE\nclass #CN implements #IN {}"), |
| CLASSEXTENDS("#REPLACE\nclass #CN extends #SN {}"); |
| String template; |
| |
| private SrcType(String template) { |
| this.template = template; |
| } |
| |
| public String getTemplate() { |
| return template; |
| } |
| |
| // Elements should override |
| public ExpectedBase getExpectedBase(Class<?> c) { |
| return null; |
| } |
| |
| public ExpectedContainer getExpectedContainer(Class<?> c) { |
| return null; |
| } |
| |
| /* |
| * Returns only primary src types ; |
| */ |
| public static SrcType[] getSrcTypes() { |
| return new SrcType[]{CLASS, PACKAGE, METHOD, FIELD}; |
| } |
| } |
| |
| /* |
| * Each enum constant is one of the 6 methods from AnnotatedElement interface |
| * that needs to be tested. |
| * Each enum constant overrides these 4 methods: |
| * - getActualAnnoBase(SrcType srcType, Class<?> c) |
| * - getActualAnnoContainer(SrcType srcType, Class<?> c) |
| * - getExpectedAnnoBase(SrcType srcType, Class<?> c) |
| * - getExpectedAnnoContainer(SrcType srcType, Class<?> c) |
| */ |
| enum TestMethod { |
| |
| GET_ANNO("getAnnotation") { |
| |
| @Override |
| public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { |
| Annotation[] actualAnno = new Annotation[1]; |
| switch (srcType) { |
| case CLASS: |
| actualAnno[0] = c.getAnnotation(srcType.getExpectedBase(c).value()); |
| break; |
| case PACKAGE: |
| actualAnno[0] = c.getPackage().getAnnotation( |
| srcType.getExpectedBase(c).value()); |
| break; |
| case METHOD: |
| try { |
| actualAnno[0] = c.getDeclaredMethod(TESTMETHOD).getAnnotation( |
| srcType.getExpectedBase(c).value()); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualAnno[0] = c.getDeclaredField(TESTFIELD).getAnnotation( |
| srcType.getExpectedBase(c).value()); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualAnno; |
| } |
| |
| @Override |
| public Annotation[] getActualAnnoContainer(SrcType srcType, |
| Class<?> c) { |
| Annotation[] actualAnno = new Annotation[1]; |
| switch (srcType) { |
| case CLASS: |
| actualAnno[0] = c.getAnnotation(srcType.getExpectedContainer(c).value()); |
| break; |
| case PACKAGE: |
| actualAnno[0] = c.getPackage().getAnnotation( |
| srcType.getExpectedContainer(c).value()); |
| break; |
| case METHOD: |
| try { |
| actualAnno[0] = c.getDeclaredMethod(TESTMETHOD).getAnnotation( |
| srcType.getExpectedContainer(c).value()); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualAnno[0] = c.getDeclaredField(TESTFIELD).getAnnotation( |
| srcType.getExpectedContainer(c).value()); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualAnno; |
| } |
| |
| @Override |
| public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { |
| String[] expAnno = {srcType.getExpectedBase(c).getAnnotationVal()}; |
| return expAnno; |
| } |
| |
| @Override |
| public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { |
| String[] expAnno = {srcType.getExpectedContainer(c).getAnnotationVal()}; |
| return expAnno; |
| } |
| }, |
| GET_ANNOS("getAnnotations") { |
| |
| @Override |
| public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { |
| Annotation[] actualAnnos = null; |
| switch (srcType) { |
| case CLASS: |
| actualAnnos = c.getAnnotations(); |
| break; |
| case PACKAGE: |
| actualAnnos = c.getPackage().getAnnotations(); |
| break; |
| case METHOD: |
| try { |
| actualAnnos = c.getDeclaredMethod(TESTMETHOD).getAnnotations(); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualAnnos = c.getDeclaredField(TESTFIELD).getAnnotations(); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualAnnos; |
| } |
| |
| @Override |
| public Annotation[] getActualAnnoContainer(SrcType srcType, |
| Class<?> c) { |
| Annotation[] actualAnnos = null; |
| switch (srcType) { |
| case CLASS: |
| actualAnnos = c.getAnnotations(); |
| break; |
| case PACKAGE: |
| actualAnnos = c.getPackage().getAnnotations(); |
| break; |
| case METHOD: |
| try { |
| actualAnnos = c.getDeclaredMethod(TESTMETHOD).getAnnotations(); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualAnnos = c.getDeclaredField(TESTFIELD).getAnnotations(); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualAnnos; |
| } |
| |
| @Override |
| public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { |
| return srcType.getExpectedBase(c).getAnnotationsVals(); |
| } |
| |
| @Override |
| public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { |
| return srcType.getExpectedContainer(c).getAnnotationsVals(); |
| } |
| }, |
| GET_DECL_ANNOS("getDeclaredAnnotations") { |
| |
| @Override |
| public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { |
| Annotation[] actualDeclAnnos = null; |
| switch (srcType) { |
| case CLASS: |
| actualDeclAnnos = c.getDeclaredAnnotations(); |
| break; |
| case PACKAGE: |
| actualDeclAnnos = c.getPackage().getDeclaredAnnotations(); |
| break; |
| case METHOD: |
| try { |
| actualDeclAnnos = c.getDeclaredMethod(TESTMETHOD) |
| .getDeclaredAnnotations(); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualDeclAnnos = c.getDeclaredField(TESTFIELD) |
| .getDeclaredAnnotations(); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualDeclAnnos; |
| } |
| |
| @Override |
| public Annotation[] getActualAnnoContainer(SrcType srcType, |
| Class<?> c) { |
| Annotation[] actualDeclAnnos = null; |
| switch (srcType) { |
| case CLASS: |
| actualDeclAnnos = c.getDeclaredAnnotations(); |
| break; |
| case PACKAGE: |
| actualDeclAnnos = c.getPackage().getDeclaredAnnotations(); |
| break; |
| case METHOD: |
| try { |
| actualDeclAnnos = c.getDeclaredMethod(TESTMETHOD) |
| .getDeclaredAnnotations(); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualDeclAnnos = c.getDeclaredField(TESTFIELD) |
| .getDeclaredAnnotations(); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualDeclAnnos; |
| } |
| |
| @Override |
| public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { |
| return srcType.getExpectedBase(c).getDeclAnnosVals(); |
| } |
| |
| @Override |
| public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { |
| return srcType.getExpectedContainer(c).getDeclAnnosVals(); |
| } |
| }, |
| GET_DECL_ANNO("getDeclaredAnnotation") { |
| |
| @Override |
| public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { |
| Annotation[] actualDeclAnno = new Annotation[1]; |
| switch (srcType) { |
| case CLASS: |
| actualDeclAnno[0] = c.getDeclaredAnnotation( |
| srcType.getExpectedBase(c).value()); |
| break; |
| case PACKAGE: |
| actualDeclAnno[0] = c.getPackage().getDeclaredAnnotation( |
| srcType.getExpectedBase(c).value()); |
| break; |
| case METHOD: |
| try { |
| actualDeclAnno[0] = c.getDeclaredMethod(TESTMETHOD) |
| .getDeclaredAnnotation( |
| srcType.getExpectedBase(c).value()); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualDeclAnno[0] = c.getDeclaredField(TESTFIELD) |
| .getDeclaredAnnotation( |
| srcType.getExpectedBase(c).value()); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualDeclAnno; |
| } |
| |
| @Override |
| public Annotation[] getActualAnnoContainer(SrcType srcType, |
| Class<?> c) { |
| Annotation[] actualDeclAnno = new Annotation[1]; |
| switch (srcType) { |
| case CLASS: |
| actualDeclAnno[0] = c.getDeclaredAnnotation( |
| srcType.getExpectedContainer(c).value()); |
| break; |
| case PACKAGE: |
| actualDeclAnno[0] = c.getPackage().getDeclaredAnnotation( |
| srcType.getExpectedContainer(c).value()); |
| break; |
| case METHOD: |
| try { |
| actualDeclAnno[0] = c.getDeclaredMethod(TESTMETHOD) |
| .getDeclaredAnnotation( |
| srcType.getExpectedContainer(c).value()); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualDeclAnno[0] = c.getDeclaredField(TESTFIELD) |
| .getDeclaredAnnotation( |
| srcType.getExpectedContainer(c).value()); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualDeclAnno; |
| } |
| |
| @Override |
| public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { |
| String[] expAnno = {srcType.getExpectedBase(c).getDeclAnnoVal()}; |
| return expAnno; |
| } |
| |
| @Override |
| public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { |
| String[] expAnno = {srcType.getExpectedContainer(c).getDeclAnnoVal()}; |
| return expAnno; |
| } |
| }, // new |
| GET_ANNOS_ARG("getAnnotationsArg") { |
| |
| @Override |
| public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { |
| Annotation[] actualAnnoArgs = null; |
| switch (srcType) { |
| case CLASS: |
| actualAnnoArgs = c.getAnnotationsByType(srcType.getExpectedBase(c).value()); |
| break; |
| case PACKAGE: |
| actualAnnoArgs = c.getPackage().getAnnotationsByType( |
| srcType.getExpectedBase(c).value()); |
| break; |
| case METHOD: |
| try { |
| actualAnnoArgs = c.getDeclaredMethod(TESTMETHOD) |
| .getAnnotationsByType( |
| srcType.getExpectedBase(c).value()); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualAnnoArgs = c.getDeclaredField(TESTFIELD) |
| .getAnnotationsByType( |
| srcType.getExpectedBase(c).value()); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualAnnoArgs; |
| } |
| |
| @Override |
| public Annotation[] getActualAnnoContainer(SrcType srcType, |
| Class<?> c) { |
| Annotation[] actualAnnoArgs = null; |
| switch (srcType) { |
| case CLASS: |
| actualAnnoArgs = c.getAnnotationsByType(srcType.getExpectedContainer(c).value()); |
| break; |
| case PACKAGE: |
| actualAnnoArgs = c.getPackage().getAnnotationsByType( |
| srcType.getExpectedContainer(c).value()); |
| break; |
| case METHOD: |
| try { |
| actualAnnoArgs = c.getDeclaredMethod(TESTMETHOD) |
| .getAnnotationsByType( |
| srcType.getExpectedContainer(c).value()); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualAnnoArgs = c.getDeclaredField(TESTFIELD) |
| .getAnnotationsByType( |
| srcType.getExpectedContainer(c).value()); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualAnnoArgs; |
| } |
| |
| @Override |
| public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { |
| return srcType.getExpectedBase(c).getAnnosArgs(); |
| } |
| |
| @Override |
| public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { |
| return srcType.getExpectedContainer(c).getAnnosArgs(); |
| } |
| }, // new |
| GET_DECL_ANNOS_ARG("getDeclAnnosArg") { |
| |
| @Override |
| public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { |
| Annotation[] actualDeclAnnosArgs = null; |
| switch (srcType) { |
| case CLASS: |
| actualDeclAnnosArgs = c.getDeclaredAnnotationsByType( |
| srcType.getExpectedBase(c).value()); |
| break; |
| case PACKAGE: |
| actualDeclAnnosArgs = c.getPackage().getDeclaredAnnotationsByType( |
| srcType.getExpectedBase(c).value()); |
| break; |
| case METHOD: |
| try { |
| actualDeclAnnosArgs = c.getDeclaredMethod(TESTMETHOD) |
| .getDeclaredAnnotationsByType( |
| srcType.getExpectedBase(c).value()); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualDeclAnnosArgs = c.getDeclaredField(TESTFIELD) |
| .getDeclaredAnnotationsByType( |
| srcType.getExpectedBase(c).value()); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualDeclAnnosArgs; |
| } |
| |
| @Override |
| public Annotation[] getActualAnnoContainer(SrcType srcType, |
| Class<?> c) { |
| Annotation[] actualDeclAnnosArgs = null; |
| switch (srcType) { |
| case CLASS: |
| actualDeclAnnosArgs = c.getDeclaredAnnotationsByType( |
| srcType.getExpectedContainer(c).value()); |
| break; |
| case PACKAGE: |
| actualDeclAnnosArgs = c.getPackage().getDeclaredAnnotationsByType( |
| srcType.getExpectedContainer(c).value()); |
| break; |
| case METHOD: |
| try { |
| actualDeclAnnosArgs = c.getDeclaredMethod(TESTMETHOD) |
| .getDeclaredAnnotationsByType( |
| srcType.getExpectedContainer(c).value()); |
| } catch (NoSuchMethodException nme) { |
| error("Could not get " + TESTMETHOD |
| + " for className = " + c.getName() |
| + "Exception = " + nme); |
| } |
| break; |
| case FIELD: |
| try { |
| actualDeclAnnosArgs = c.getDeclaredField(TESTFIELD) |
| .getDeclaredAnnotationsByType( |
| srcType.getExpectedContainer(c).value()); |
| } catch (NoSuchFieldException nfe) { |
| error("Could not get " + TESTFIELD |
| + " for className = " + c.getName() |
| + "Exception = " + nfe); |
| } |
| break; |
| } |
| return actualDeclAnnosArgs; |
| } |
| |
| @Override |
| public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { |
| return srcType.getExpectedBase(c).getDeclAnnosArgs(); |
| } |
| |
| @Override |
| public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { |
| return srcType.getExpectedContainer(c).getDeclAnnosArgs(); |
| } |
| }; // new |
| String name; |
| |
| private TestMethod(String name) { |
| this.name = name; |
| } |
| |
| public Annotation[] getActualAnnoBase(SrcType srcType, Class<?> c) { |
| return null; |
| } |
| |
| public Annotation[] getActualAnnoContainer(SrcType srcType, Class<?> c) { |
| return null; |
| } |
| |
| public String[] getExpectedAnnoBase(SrcType srcType, Class<?> c) { |
| return null; |
| } |
| |
| public String[] getExpectedAnnoContainer(SrcType srcType, Class<?> c) { |
| return null; |
| } |
| } |
| |
| /* |
| * For a given srcType and class object, compare expectedBase and actualBase |
| * annotations as well as expectedContainer and actualContainer annotations. |
| * |
| * Return true if both comparisons are true else return false. |
| * |
| */ |
| protected static void checkAnnoValues(SrcType srcType, Class<?> c) { |
| |
| // Load @ExpectedBase and @ExpectedContainer |
| ExpectedBase eb = srcType.getExpectedBase(c); |
| ExpectedContainer ec = srcType.getExpectedContainer(c); |
| if (eb == null) { |
| error("Did not find ExpectedBase Annotation, Test will exit"); |
| throw new RuntimeException(); |
| } |
| if (ec == null) { |
| error("Did not find ExpectedContainer Annotation, Test will exit"); |
| throw new RuntimeException(); |
| } |
| |
| for (TestMethod testMethod : TestMethod.values()) { |
| debugPrint("---------------------------------------------"); |
| debugPrint("Test method = " + testMethod); |
| boolean isBasePass = true; |
| boolean isConPass = true; |
| // ExpectedBase = Annotation, no annotation is defined, skip comparison |
| if (!eb.value().getSimpleName().equalsIgnoreCase("Annotation")) { |
| isBasePass = compareAnnotations( |
| testMethod.getActualAnnoBase(srcType, c), |
| testMethod.getExpectedAnnoBase(srcType, c)); |
| } |
| |
| // ExpectedContainer = Annotation, no annotation is defined, skip comparison |
| if (!ec.value().getSimpleName().equalsIgnoreCase("Annotation")) { |
| isConPass = compareAnnotations( |
| testMethod.getActualAnnoContainer(srcType, c), |
| testMethod.getExpectedAnnoContainer(srcType, c)); |
| } |
| if (isBasePass && isConPass) { |
| debugPrint("Testcase passed for " + testMethod + |
| " for className = " + c.getName()); |
| } else { |
| debugPrint("Testcase failed for " + testMethod + |
| " for className = " + c.getName()); |
| } |
| } |
| } |
| |
| // Annotation comparison: Length should be same and all expected values |
| // should be present in actualAnno[]. |
| private static boolean compareAnnotations(Annotation[] actualAnnos, |
| String[] expectedAnnos) { |
| boolean compOrder = false; |
| |
| // Length is different |
| if (actualAnnos.length != expectedAnnos.length) { |
| error("Length not same, Actual length = " + actualAnnos.length |
| + " Expected length = " + expectedAnnos.length); |
| printArrContents(actualAnnos); |
| printArrContents(expectedAnnos); |
| return false; |
| } else { |
| int i = 0; |
| // Length is same and 0 |
| if (actualAnnos.length == 0) { |
| // Expected/actual lengths already checked for |
| // equality; no more checks do to |
| return true; |
| } |
| // Expected annotation should be NULL |
| if (actualAnnos[0] == null) { |
| if (expectedAnnos[0].equals("NULL")) { |
| debugPrint("Arr values are NULL as expected"); |
| return true; |
| } else { |
| error("Array values are not NULL"); |
| printArrContents(actualAnnos); |
| printArrContents(expectedAnnos); |
| return false; |
| } |
| } |
| // Lengths are same, compare array contents |
| String[] actualArr = new String[actualAnnos.length]; |
| for (Annotation a : actualAnnos) { |
| if (a.annotationType().getSimpleName().contains("Expected")) |
| actualArr[i++] = a.annotationType().getSimpleName(); |
| else if (a.annotationType().getName().contains(TESTPKG)) { |
| String replaced = a.toString().replaceAll(Pattern.quote("testpkg."),""); |
| actualArr[i++] = replaced; |
| } else |
| actualArr[i++] = a.toString(); |
| } |
| List<String> actualList = new ArrayList<String>(Arrays.asList(actualArr)); |
| List<String> expectedList = new ArrayList<String>(Arrays.asList(expectedAnnos)); |
| if (!actualList.containsAll(expectedList)) { |
| error("Array values are not same"); |
| printArrContents(actualAnnos); |
| printArrContents(expectedAnnos); |
| return false; |
| } else { |
| debugPrint("Arr values are same as expected"); |
| if (CHECKORDERING) { |
| debugPrint("Checking if annotation ordering is as expected.."); |
| compOrder = compareOrdering(actualList, expectedList); |
| if (compOrder) |
| debugPrint("Arr values ordering is as expected"); |
| else |
| error("Arr values ordering is not as expected! actual values: " |
| + actualList + " expected values: " + expectedList); |
| } else |
| compOrder = true; |
| } |
| } |
| return compOrder; |
| } |
| |
| // Annotation ordering comparison |
| private static boolean compareOrdering(List<String> actualList, List<String> expectedList) { |
| boolean order = true; |
| // Discarding Expected* annotations before comparison of ordering |
| actualList = iterateList(actualList); |
| expectedList = iterateList(expectedList); |
| // Length is different |
| if (actualList.size() != expectedList.size()) { |
| error("Length not same, Actual list length = " + actualList.size() |
| + " Expected list length = " + expectedList.size()); |
| return false; |
| } else { |
| if (actualList.isEmpty() && expectedList.isEmpty()) { |
| return true; |
| } |
| boolean tmp = true; |
| for (int i = 0; i < actualList.size(); i++) { |
| // Checking ordering |
| if (order) { |
| if (!actualList.get(i).equals(expectedList.get(i))) { |
| tmp = false; |
| debugPrint("Odering is false"); |
| debugPrint("actualList values: " + actualList |
| + " expectedList values: " + expectedList); |
| } |
| } |
| } |
| order = tmp; |
| } |
| return order; |
| } |
| |
| private static List<String> iterateList(List<String> list) { |
| Iterator<String> iter = list.iterator(); |
| while (iter.hasNext()) { |
| String anno = iter.next(); |
| if (anno.contains("Expected")) { |
| iter.remove(); |
| } |
| } |
| return list; |
| } |
| |
| private static void printArrContents(Annotation[] actualAnnos) { |
| System.out.print("Actual Arr Values: "); |
| for (Annotation a : actualAnnos) { |
| if (a != null && a.annotationType() != null) { |
| System.out.print("[" + a.toString() + "]"); |
| } else { |
| System.out.println("[null]"); |
| } |
| } |
| System.out.println(); |
| } |
| |
| private static void printArrContents(String[] expectedAnnos) { |
| System.out.print("Expected Arr Values: "); |
| for (String s : expectedAnnos) { |
| System.out.print("[" + s + "]"); |
| } |
| System.out.println(); |
| } |
| |
| private ClassLoader getLoader() { |
| return getClass().getClassLoader(); |
| } |
| |
| private static Class<?> loadClass(String className, ClassLoader parentClassLoader, File... destDirs) { |
| try { |
| List<URL> list = new ArrayList<>(); |
| for (File f : destDirs) { |
| list.add(new URL("file:" + f.toString().replace("\\", "/") + "/")); |
| } |
| return Class.forName(className, true, new URLClassLoader( |
| list.toArray(new URL[list.size()]), parentClassLoader)); |
| } catch (ClassNotFoundException | MalformedURLException e) { |
| throw new RuntimeException("Error loading class " + className, e); |
| } |
| } |
| |
| private static void printTestSrc(Iterable<? extends JavaFileObject> files) { |
| for (JavaFileObject f : files) { |
| System.out.println("Test file " + f.getName() + ":"); |
| try { |
| System.out.println("" + f.getCharContent(true)); |
| } catch (IOException e) { |
| throw new RuntimeException( |
| "Exception when printing test src contents for class " + |
| f.getName(), e); |
| } |
| } |
| |
| } |
| |
| public static StringBuilder getCommonStmts(boolean isRepeatable) { |
| StringBuilder sb = new StringBuilder(); |
| |
| sb.append(Helper.ContentVars.IMPORTEXPECTED.getVal()) |
| .append(Helper.ContentVars.IMPORTSTMTS.getVal()) |
| .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) |
| .append(Helper.ContentVars.INHERITED.getVal()); |
| if(isRepeatable) { |
| sb.append(Helper.ContentVars.REPEATABLE.getVal()); |
| } |
| sb.append(Helper.ContentVars.BASE.getVal()) |
| .append(Helper.ContentVars.RETENTIONRUNTIME.getVal()) |
| .append(Helper.ContentVars.INHERITED.getVal()) |
| .append(Helper.ContentVars.CONTAINER.getVal()); |
| return sb; |
| } |
| |
| private static int getNumErrors() { |
| return errors; |
| } |
| |
| private static void error(String msg) { |
| System.out.println("error: " + msg); |
| errors++; |
| } |
| |
| private static void debugPrint(String string) { |
| if(DEBUG) |
| System.out.println(string); |
| } |
| } |