3030 lines
136 KiB
Java
3030 lines
136 KiB
Java
/*
|
|
* Copyright (c) 2013, 2019, 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(0)\", "
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"}, "
|
|
+ "getDeclAnnoVal = \"@Foo(0)\", "
|
|
+ "getAnnosArgs = {\"@Foo(0)\"}, "
|
|
+ "getDeclAnnosArgs = {\"@Foo(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(0)\", "
|
|
+ "getAnnotationsVals = {\"@Foo(0)\", \"ExpectedBase\", \"ExpectedContainer\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
|
|
+ "getDeclAnnoVal = \"NULL\", "
|
|
+ "getAnnosArgs = {\"@Foo(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(2)\", "
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(2)\"}, "
|
|
+ // override every annotation on superClass
|
|
"getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(2)\"}, "
|
|
+ // ignores inherited annotations
|
|
"getDeclAnnoVal = \"@Foo(2)\", " // ignores inherited
|
|
+ "getAnnosArgs = {\"@Foo(2)\"}, "
|
|
+ "getDeclAnnosArgs = { \"@Foo(2)\" })", // ignores inherited
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"NULL\", "
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(2)\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(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({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnoVal = \"NULL\", " + "getAnnosArgs = {}, "
|
|
+ "getDeclAnnosArgs = {} )",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(0)\","
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnoVal = \"@Foo(0)\", "
|
|
+ "getAnnosArgs = {\"@Foo(0)\"}, "
|
|
+ "getDeclAnnosArgs = {\"@Foo(0)\"} )",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
|
|
+ "getDeclAnnoVal = \"NULL\", "
|
|
+ "getAnnosArgs = {}, "
|
|
+ "getDeclAnnosArgs = {} )",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
|
|
+ "getDeclAnnoVal = \"NULL\", "
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(0)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(0)\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"},"
|
|
+ "getDeclAnnoVal = \"@Foo(0)\","
|
|
+ "getAnnosArgs = {\"@Foo(0)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(0)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(0)\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"},"
|
|
+ "getDeclAnnoVal = \"NULL\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(0)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(0)\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"},"
|
|
+ "getDeclAnnoVal = \"@Foo(0)\","
|
|
+ "getAnnosArgs = {\"@Foo(0)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(0)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(0)\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"},"
|
|
+ "getDeclAnnoVal = \"NULL\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(0)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnoVal = \"NULL\","
|
|
+ "getAnnosArgs = {\"@Foo(0)\"},"
|
|
+ "getDeclAnnosArgs = {})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(3)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(3)\"}, "
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(3)\"},"
|
|
+ "getDeclAnnoVal = \"@Foo(3)\","
|
|
+ "getAnnosArgs = {\"@Foo(3)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(3)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(3)\"}, "
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(3)\"},"
|
|
+ "getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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({@Foo(1), @Foo(2)})\" }, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnoVal = \"NULL\","
|
|
+ "getAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\","
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnoVal = \"NULL\","
|
|
+ "getAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\","
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
|
|
+ "getDeclAnnoVal = \"NULL\", "
|
|
+ "getAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\"}, "
|
|
+ "getDeclAnnosArgs = {})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = { \"ExpectedBase\", \"ExpectedContainer\"}, "
|
|
+ "getDeclAnnoVal = \"NULL\", "
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
|
|
+ // ignores inherited annotations
|
|
"getDeclAnnoVal = \"NULL\", "
|
|
+ // ignores inherited
|
|
"getAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\"}, "
|
|
+ "getDeclAnnosArgs = {})", // ignores inherited
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = { \"ExpectedBase\", \"ExpectedContainer\"}, "
|
|
+ // ignores inherited annotations
|
|
"getDeclAnnoVal = \"NULL\", "
|
|
+ // ignores inherited
|
|
"getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(0)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnoVal = \"@Foo(0)\","
|
|
+ "getAnnosArgs = {\"@Foo(0)\", \"@Foo(1)\", \"@Foo(2)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(0)\", \"@Foo(1)\",\"@Foo(2)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\","
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(1)\", "
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(1)\" }, "
|
|
+ // override every annotation on superClass
|
|
"getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(1)\"}, "
|
|
+ // ignores inherited annotations
|
|
"getDeclAnnoVal = \"@Foo(1)\", " // ignores inherited
|
|
+ "getAnnosArgs = {\"@Foo(1)\"}, "
|
|
+ "getDeclAnnosArgs = { \"@Foo(1)\" })", // ignores inherited
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"NULL\", "
|
|
+ "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(1)\" }, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(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(3)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(3)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ //override every annotation on superClass
|
|
"getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(3)\"}, "
|
|
+ // ignores inherited annotations
|
|
"getDeclAnnoVal = \"@Foo(3)\", " // ignores inherited
|
|
+ "getAnnosArgs = {\"@Foo(3)\"}, "
|
|
+ "getDeclAnnosArgs = { \"@Foo(3)\" })", // ignores inherited
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(3)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(3)\"}, "
|
|
+ // ignores inherited annotations
|
|
"getDeclAnnoVal = \"NULL\", "
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(0)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ //override every annotation on superClass
|
|
"getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ // ignores inherited annotations
|
|
"getDeclAnnoVal = \"NULL\","// ignores inherited
|
|
+ "getAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\"}, "
|
|
+ "getDeclAnnosArgs = { \"@Foo(1)\", \"@Foo(2)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ // ignores inherited annotations
|
|
"getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "// ignores inherited
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(0)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"},"
|
|
+ "getDeclAnnoVal = \"@Foo(0)\","
|
|
+ "getAnnosArgs = {\"@Foo(0)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(0)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"},"
|
|
+ "getDeclAnnoVal = \"NULL\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(0)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnoVal = \"NULL\","
|
|
+ "getAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(3)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(3)\"}, "
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(3)\"},"
|
|
+ "getDeclAnnoVal = \"@Foo(3)\","
|
|
+ "getAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\", \"@Foo(3)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(1)\", \"@Foo(2)\", \"@Foo(3)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(3)\"}, "
|
|
+ "getDeclAnnosVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@FooContainer({@Foo(1), @Foo(2)})\", \"@Foo(3)\"},"
|
|
+ "getDeclAnnoVal = \"@FooContainer({@Foo(1), @Foo(2)})\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(2)})\"},"
|
|
+ "getDeclAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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(0)\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"},"
|
|
+ "getDeclAnnoVal = \"@Foo(0)\","
|
|
+ "getAnnosArgs = {\"@Foo(0)\"},"
|
|
+ "getDeclAnnosArgs = {\"@Foo(0)\"})",
|
|
"@ExpectedContainer(value=FooContainer.class, "
|
|
+ "getAnnotationVal = \"@FooContainer({@Foo(1), @Foo(2)})\", "
|
|
+ "getAnnotationsVals = {"
|
|
+ "\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\", \"@FooContainer({@Foo(1), @Foo(2)})\"}, "
|
|
+ "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"@Foo(0)\"},"
|
|
+ "getDeclAnnoVal = \"NULL\","
|
|
+ "getAnnosArgs = {\"@FooContainer({@Foo(1), @Foo(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);
|
|
}
|
|
}
|