changeset 1575:63872da94576

8001457: New tests needed for library-side changes for repeating annotations Reviewed-by: darcy Contributed-by: sonali.goel@oracle.com
author darcy
date Wed, 13 Feb 2013 23:05:17 -0800
parents 3f9875aa5d67
children 88286a36bb34
files test/tools/javac/annotations/repeatingAnnotations/combo/Helper.java test/tools/javac/annotations/repeatingAnnotations/combo/ReflectionTest.java test/tools/javac/annotations/repeatingAnnotations/combo/expectedFiles/ExpectedBase.java test/tools/javac/annotations/repeatingAnnotations/combo/expectedFiles/ExpectedContainer.java
diffstat 4 files changed, 3113 insertions(+), 57 deletions(-) [+]
line wrap: on
line diff
--- a/test/tools/javac/annotations/repeatingAnnotations/combo/Helper.java	Wed Feb 13 11:25:58 2013 -0800
+++ b/test/tools/javac/annotations/repeatingAnnotations/combo/Helper.java	Wed Feb 13 23:05:17 2013 -0800
@@ -21,40 +21,51 @@
  * questions.
  */
 
+import java.io.File;
+import java.io.IOException;
 import java.net.URI;
 import java.net.URISyntaxException;
 import java.util.Arrays;
+import java.util.Iterator;
+
+import javax.tools.Diagnostic;
 import javax.tools.DiagnosticCollector;
 import javax.tools.JavaCompiler;
+import javax.tools.JavaCompiler.CompilationTask;
 import javax.tools.JavaFileObject;
 import javax.tools.SimpleJavaFileObject;
+import javax.tools.StandardJavaFileManager;
+import javax.tools.StandardLocation;
 import javax.tools.ToolProvider;
-import javax.tools.JavaCompiler.CompilationTask;
+
+import com.sun.source.util.JavacTask;
 
 public class Helper {
 
     enum ContentVars {
+
         IMPORTCONTAINERSTMTS("\nimport java.lang.annotation.Repeatable;\n"),
         IMPORTDEPRECATED("import java.lang.Deprecated;\n"),
         IMPORTDOCUMENTED("import java.lang.annotation.Documented;\n"),
         IMPORTINHERITED("import java.lang.annotation.Inherited;\n"),
-        IMPORTRETENTION("import java.lang.annotation.Retention;\n" +
-                        "\nimport java.lang.annotation.RetentionPolicy;\n"),
+        IMPORTRETENTION("import java.lang.annotation.Retention;\n"
+        + "\nimport java.lang.annotation.RetentionPolicy;\n"),
         IMPORTSTMTS("import java.lang.annotation.*;\n"),
+        IMPORTEXPECTED("import expectedFiles.*;\n"),
         REPEATABLE("\n@Repeatable(FooContainer.class)\n"),
-        CONTAINER("@interface FooContainer {\n" +"  Foo[] value();\n}\n"),
+        CONTAINER("@interface FooContainer {\n" + "  Foo[] value();\n}\n"),
         BASE("@interface Foo {}\n"),
         BASEANNO("@Foo"),
+        LEGACYCONTAINER("@FooContainer(value = {@Foo, @Foo})\n"),
         REPEATABLEANNO("\n@Foo() @Foo()"),
         DEPRECATED("\n@Deprecated"),
         DOCUMENTED("\n@Documented"),
         INHERITED("\n@Inherited"),
+        TARGET("\n@Target(#VAL)\n"),
         RETENTION("@Retention(RetentionPolicy.#VAL)\n"),
-        TARGET("\n@Target(#VAL)\n");
-
+        RETENTIONRUNTIME("@Retention(RetentionPolicy.RUNTIME)\n");
         private String val;
 
-
         private ContentVars(String val) {
             this.val = val;
         }
@@ -64,49 +75,6 @@
         }
     }
 
-    /* String template where /*<TYPE>*/ /*gets replaced by repeating anno
-     * Used to generate test src for combo tests
-     *   - BasicSyntaxCombo.java
-     *   - TargetAnnoCombo.java
-     */
-    public static final String template =
-            "/*PACKAGE*/\n" +
-            "//pkg test;\n\n" +
-            "/*ANNODATA*/\n" + // import statements, declaration of Foo/FooContainer
-            "/*TYPE*/ //class\n" +
-            "class #ClassName {\n" +
-            "  /*FIELD*/ //instance var\n" +
-            "  public int x = 0;\n\n" +
-            "  /*FIELD*/ //Enum constants\n" +
-            "  TestEnum testEnum;\n\n" +
-            "  /*FIELD*/ // Static field\n" +
-            "  public static int num;\n\n" +
-            "  /*STATIC_INI*/\n" +
-            "  static { \n" + "num = 10; \n  }\n\n" +
-            "  /*CONSTRUCTOR*/\n" +
-            "  #ClassName() {}\n\n" +
-            "  /*INSTANCE_INI*/\n" +
-            "  { \n x = 10; \n }" +
-            "  /*INNER_CLASS*/\n" +
-            "  class innerClass {}\n" +
-            "  /*METHOD*/\n" +
-            "  void bar(/*PARAMETER*/ int baz) {\n" +
-            "    /*LOCAL_VARIABLE*/\n" +
-            "    int y = 0;\n" +
-            "  }\n" +
-            "}\n\n" +
-            "/*TYPE*/ //Enum\n" +
-            "enum TestEnum {}\n\n" +
-            "/*TYPE*/ //Interface\n" +
-            "interface TestInterface {}\n\n" +
-            "/*TYPE*/\n" +
-            "/*ANNOTATION_TYPE*/\n" +
-            "@interface TestAnnotationType{}\n" +
-            "class TestPkg {}\n" +
-            "class TestTypeAnno </*TYPE_PARAMETER*/ T extends Object> {\n" +
-            "  String /*TYPE_USE*/[] arr;\n" +
-            "}";
-
     // Create and compile FileObject using values for className and contents
     public static boolean compileCode(String className, String contents,
             DiagnosticCollector<JavaFileObject> diagnostics) {
@@ -122,21 +90,96 @@
         CompilationTask task = compiler.getTask(null, null, diagnostics, null, null, compilationUnit);
         ok = task.call();
         return ok;
+    }
+    // Compile a list of FileObjects
+    // Used when packages are needed and classes need to be loaded at runtime
+    static File destDir = new File(System.getProperty("user.dir"));
 
-    }
-
-    // Compile a list of FileObjects
     public static boolean compileCode(DiagnosticCollector<JavaFileObject> diagnostics, Iterable<? extends JavaFileObject> files) {
+        boolean ok = false;
         JavaCompiler compiler = ToolProvider.getSystemJavaCompiler();
         if (compiler == null) {
             throw new RuntimeException("can't get javax.tools.JavaCompiler!");
         }
 
-        CompilationTask task = compiler.getTask(null, null, diagnostics, null, null, files);
-        boolean ok = task.call();
+        StandardJavaFileManager fm = compiler.getStandardFileManager(null, null, null);
+
+        // Assuming filesCount can maximum be 2 and if true, one file is package-info.java
+        if (isPkgInfoPresent(files)) {
+            JavacTask task = (JavacTask) compiler.getTask(null, fm, diagnostics, null, null, files);
+            try {
+                fm.setLocation(StandardLocation.CLASS_OUTPUT, Arrays.asList(destDir));
+                task.generate();
+            } catch (IOException ioe) {
+                throw new RuntimeException("Compilation failed for package level tests", ioe);
+            }
+            int err = 0;
+            for (Diagnostic<? extends JavaFileObject> d : diagnostics.getDiagnostics()) {
+                if(d.getKind() == Diagnostic.Kind.ERROR) {
+                  err++;
+                }
+            }
+            ok = (err == 0);
+        } else {
+            CompilationTask task = compiler.getTask(null, null, diagnostics, null, null, files);
+            ok = task.call();
+        }
         return ok;
     }
 
+    static private boolean isPkgInfoPresent(Iterable<? extends JavaFileObject> files) {
+        Iterator<? extends JavaFileObject> itr = files.iterator();
+        while (itr.hasNext()) {
+            String name = itr.next().getName();
+            if (name.contains("package-info")) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /* String template where /*<TYPE>*/ /*gets replaced by repeating anno
+     * Used to generate test src for combo tests
+     *   - BasicSyntaxCombo.java
+     *   - TargetAnnoCombo.java
+     */
+
+    public static final String template =
+            "/*PACKAGE*/\n"
+            + "//pkg test;\n\n"
+            + "/*TYPE*/ //class\n"
+            + "class #ClassName {\n"
+            + "  /*FIELD*/ //instance var\n"
+            + "  public int x = 0;\n\n"
+            + "  /*FIELD*/ //Enum constants\n"
+            + "  TestEnum testEnum;\n\n"
+            + "  /*FIELD*/ // Static field\n"
+            + "  public static int num;\n\n"
+            + "  /*STATIC_INI*/\n"
+            + "  static { \n" + "num = 10; \n  }\n\n"
+            + "  /*CONSTRUCTOR*/\n"
+            + "  #ClassName() {}\n\n"
+            + "  /*INSTANCE_INI*/\n"
+            + "  { \n x = 10; \n }"
+            + "  /*INNER_CLASS*/\n"
+            + "  class innerClass {}\n"
+            + "  /*METHOD*/\n"
+            + "  void bar(/*PARAMETER*/ int baz) {\n"
+            + "    /*LOCAL_VARIABLE*/\n"
+            + "    int y = 0;\n"
+            + "  }\n"
+            + "}\n\n"
+            + "/*TYPE*/ //Enum\n"
+            + "enum TestEnum {}\n\n"
+            + "/*TYPE*/ //Interface\n"
+            + "interface TestInterface {}\n\n"
+            + "/*TYPE*/\n"
+            + "/*ANNOTATION_TYPE*/\n"
+            + "@interface TestAnnotationType{}\n"
+            + "class TestPkg {}\n"
+            + "class TestTypeAnno </*TYPE_PARAMETER*/ T extends Object> {\n"
+            + "  String /*TYPE_USE*/[] arr;\n"
+            + "}";
+
     static JavaFileObject getFile(String name, String code) {
         JavaFileObject o = null;
         try {
@@ -146,16 +189,19 @@
         }
         return o;
     }
+
     static class JavaStringFileObject extends SimpleJavaFileObject {
+
         final String theCode;
+
         public JavaStringFileObject(String fileName, String theCode) throws URISyntaxException {
-            super(new URI("string:///" + fileName.replace('.','/') + ".java"), Kind.SOURCE);
+            super(new URI("string:///" + fileName.replace('.', '/') + ".java"), Kind.SOURCE);
             this.theCode = theCode;
         }
+
         @Override
         public CharSequence getCharContent(boolean ignoreEncodingErrors) {
             return theCode;
         }
     }
 }
-
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/repeatingAnnotations/combo/ReflectionTest.java	Wed Feb 13 23:05:17 2013 -0800
@@ -0,0 +1,2932 @@
+/*
+ * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+
+/**
+ * @test
+ * @bug      8001457
+ * @author   sogoel
+ * @summary  Reflection api tests
+ * @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;
+
+/*
+ * 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;
+
+    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
+                    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\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+                + "getDeclAnnoVal = \"Foo\", "
+                + "getAnnosArgs = {\"Foo\"}, "
+                + "getDeclAnnosArgs = {\"Foo\"}) ",
+        "@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
+                        package testpkg;
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @interface Foo {}
+
+                        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 {}
+
+                        @ExpectedBase
+                        @ExpectedContainer
+                        @Foo
+                        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\", "
+                + "getAnnotationsVals = {\"Foo\", \"ExpectedBase\", \"ExpectedContainer\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
+                + "getDeclAnnoVal = \"NULL\", "
+                + "getAnnosArgs = {\"Foo\"}, "
+                + "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 {}
+
+                @Foo
+                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 {}
+
+                @Foo
+                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\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+                + // override every annotation on superClass
+                "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+                + // ignores inherited annotations
+                "getDeclAnnoVal = \"Foo\", " // ignores inherited
+                + "getAnnosArgs = {\"Foo\"}, "
+                + "getDeclAnnosArgs = { \"Foo\" })", // ignores inherited
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"NULL\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+                + // 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 {}
+
+                @Inherited
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @Foo
+                class SuperClass { }
+
+                @ExpectedBase
+                @ExpectedContainer
+                @Foo
+                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 = 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" + 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\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+                + "getDeclAnnoVal = \"NULL\", " + "getAnnosArgs = {}, "
+                + "getDeclAnnosArgs = {} )",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+                + "getDeclAnnoVal = \"FooContainer\", "
+                + "getAnnosArgs = {\"FooContainer\"}, "
+                + "getDeclAnnosArgs = {\"FooContainer\"} )") {
+
+            @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, @Foo})
+                        package testpkg;
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @interface Foo {}
+
+                        @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 {}
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @Inherited
+                        @interface FooContainer {
+                        Foo[] value();
+                        }
+
+                        @ExpectedBase
+                        @ExpectedContainer
+                        @FooContainer(value = {@Foo, @Foo})
+                        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\","
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnoVal = \"Foo\", "
+                + "getAnnosArgs = {\"Foo\"}, "
+                + "getDeclAnnosArgs = {\"Foo\"} )",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnoVal = \"FooContainer\", "
+                + "getAnnosArgs = {\"FooContainer\"}, "
+                + "getDeclAnnosArgs = {\"FooContainer\"} )") {
+
+            @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()
+                        + 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())
+                        .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())
+                        .append(Helper.ContentVars.CONTAINER.getVal());
+                switch (srcType) {
+                    case PACKAGE:
+                        /*
+                        Sample package-info.java
+                        @ExpectedBase
+                        @ExpectedContainer
+                        @Foo
+                        @FooContainer(value = {@Foo, @Foo})
+                        package testpkg;
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @interface Foo {}
+
+                        @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 {}
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @Inherited
+                        @interface FooContainer {
+                        Foo[] value();
+                        }
+
+                        @ExpectedBase
+                        @ExpectedContainer
+                        @Foo
+                        @FooContainer(value = {@Foo, @Foo})
+                        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\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
+                + "getDeclAnnoVal = \"NULL\", "
+                + "getAnnosArgs = {}, "
+                + "getDeclAnnosArgs = {} )",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
+                + "getDeclAnnoVal = \"NULL\", "
+                + "getAnnosArgs = {\"FooContainer\"}, "
+                + "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 {}
+
+                @Retention(RetentionPolicy.RUNTIME)
+                @Inherited
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @FooContainer(value = {@Foo, @Foo})
+                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\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"
+                + "getDeclAnnoVal = \"Foo\","
+                + "getAnnosArgs = {\"Foo\"},"
+                + "getDeclAnnosArgs = {\"Foo\"})",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"
+                + "getDeclAnnoVal = \"NULL\","
+                + "getAnnosArgs = {\"FooContainer\"},"
+                + "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 {}
+
+                @Retention(RetentionPolicy.RUNTIME)
+                @Inherited
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @FooContainer(value = {@Foo, @Foo})
+                class SuperClass { }
+
+                @ExpectedBase
+                @ExpectedContainer
+                @Foo
+                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;
+            }
+        },
+        ContainerAndSingleOnSuperSingleOnSub_Inherited_Legacy(
+        "@ExpectedBase(value=Foo.class, "
+                + "getAnnotationVal = \"Foo\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"
+                + "getDeclAnnoVal = \"Foo\","
+                + "getAnnosArgs = {\"Foo\"},"
+                + "getDeclAnnosArgs = {\"Foo\"})",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"
+                + "getDeclAnnoVal = \"NULL\","
+                + "getAnnosArgs = {\"FooContainer\"},"
+                + "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 {}
+
+                @Retention(RetentionPolicy.RUNTIME)
+                @Inherited
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @FooContainer(value = {@Foo, @Foo}) @Foo
+                class SuperClass { }
+
+                @ExpectedBase
+                @ExpectedContainer
+                @Foo
+                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()
+                            + 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.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;
+            }
+        },
+        SingleOnSuperContainerOnSub_Inherited_Legacy(
+        "@ExpectedBase(value=Foo.class, "
+                + "getAnnotationVal = \"Foo\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"
+                + "getDeclAnnoVal = \"NULL\","
+                + "getAnnosArgs = {\"Foo\"},"
+                + "getDeclAnnosArgs = {})",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"
+                + "getDeclAnnoVal = \"FooContainer\","
+                + "getAnnosArgs = {\"FooContainer\"},"
+                + "getDeclAnnosArgs = {\"FooContainer\"})") {
+
+            @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 {}
+
+                @Retention(RetentionPolicy.RUNTIME)
+                @Inherited
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @Foo
+                class SuperClass { }
+
+                @ExpectedBase
+                @ExpectedContainer
+                @FooContainer(value = {@Foo, @Foo})
+                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;
+            }
+        },
+        SingleOnSuperContainerAndSingleOnSub_Inherited_Legacy(
+        "@ExpectedBase(value=Foo.class, "
+                + "getAnnotationVal = \"Foo\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"},"
+                + "getDeclAnnoVal = \"Foo\","
+                + "getAnnosArgs = {\"Foo\"},"
+                + "getDeclAnnosArgs = {\"Foo\"})",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"},"
+                + "getDeclAnnoVal = \"FooContainer\","
+                + "getAnnosArgs = {\"FooContainer\"},"
+                + "getDeclAnnosArgs = {\"FooContainer\"})") {
+
+            @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 {}
+
+                @Retention(RetentionPolicy.RUNTIME)
+                @Inherited
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @Foo
+                class SuperClass { }
+
+                @ExpectedBase
+                @ExpectedContainer
+                @FooContainer(value = {@Foo, @Foo}) @Foo
+                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()
+                            + 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;
+            }
+        },
+        BasicRepeatable(
+        "@ExpectedBase(value=Foo.class, "
+                + "getAnnotationVal = \"NULL\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\" }, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"
+                + "getDeclAnnoVal = \"NULL\","
+                + "getAnnosArgs = {\"Foo\", \"Foo\"},"
+                + "getDeclAnnosArgs = {\"Foo\", \"Foo\"})",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\","
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+                + "getDeclAnnoVal = \"FooContainer\","
+                + "getAnnosArgs = {\"FooContainer\"},"
+                + "getDeclAnnosArgs = {\"FooContainer\"} )") {
+
+            @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() @Foo()
+                        package testpkg;
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @Repeatable(FooContainer.class)
+                        @interface Foo {}
+
+                        @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 {}
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @interface FooContainer {
+                        Foo[] value();
+                        }
+
+                        @ExpectedBase
+                        @ExpectedContainer
+                        @Foo @Foo
+                        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\"}, "
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"
+                + "getDeclAnnoVal = \"NULL\","
+                + "getAnnosArgs = {\"Foo\", \"Foo\"},"
+                + "getDeclAnnosArgs = {\"Foo\", \"Foo\"})",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\","
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+                + "getDeclAnnoVal = \"FooContainer\","
+                + "getAnnosArgs = {\"FooContainer\"},"
+                + "getDeclAnnosArgs = {\"FooContainer\"} )") {
+
+            @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, @Foo})
+                        package testpkg;
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @Repeatable(FooContainer.class)
+                        @interface Foo {}
+
+                        @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 {}
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @interface FooContainer {
+                        Foo[] value();
+                        }
+
+                        @ExpectedBase
+                        @ExpectedContainer
+                        @FooContainer(value = {@Foo, @Foo})
+                        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\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
+                + "getDeclAnnoVal = \"NULL\", "
+                + "getAnnosArgs = {\"Foo\", \"Foo\"}, "
+                + "getDeclAnnosArgs = {})",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = { \"ExpectedBase\", \"ExpectedContainer\"}, "
+                + "getDeclAnnoVal = \"NULL\", "
+                + "getAnnosArgs = {\"FooContainer\"}, "
+                + "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 {}
+
+                @Retention(RetentionPolicy.RUNTIME)
+                @Inherited
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @FooContainer(value = {@Foo, @Foo})
+                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\"}, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "
+                + // ignores inherited annotations
+                "getDeclAnnoVal = \"NULL\", "
+                + // ignores inherited
+                "getAnnosArgs = {\"Foo\", \"Foo\"}, "
+                + "getDeclAnnosArgs = {})", // ignores inherited
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = { \"ExpectedBase\", \"ExpectedContainer\"}, "
+                + // ignores inherited annotations
+                "getDeclAnnoVal = \"NULL\", "
+                + // ignores inherited
+                "getAnnosArgs = {\"FooContainer\"}, "
+                + "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 {}
+
+                @Retention(RetentionPolicy.RUNTIME)
+                @Inherited
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @Foo() @Foo()
+                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;
+            }
+        },
+        SingleAnnoWithContainer(
+        "@ExpectedBase(value=Foo.class, "
+                + "getAnnotationVal = \"Foo\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"},"
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"},"
+                + "getDeclAnnoVal = \"Foo\","
+                + "getAnnosArgs = {\"Foo\", \"Foo\", \"Foo\"},"
+                + "getDeclAnnosArgs = {\"Foo\", \"Foo\",\"Foo\"})",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"},"
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnoVal = \"FooContainer\","
+                + "getDeclAnnosArgs = {\"FooContainer\"},"
+                + "getAnnosArgs = {\"FooContainer\"})") {
+
+            @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 @FooContainer(value = {@Foo, @Foo})
+                        package testpkg;
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @Repeatable(FooContainer.class)
+                        @interface Foo {}
+
+                        @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 {}
+
+                        @Retention(RetentionPolicy.RUNTIME)
+                        @Inherited
+                        @interface FooContainer {
+                        Foo[] value();
+                        }
+
+                        @ExpectedBase
+                        @ExpectedContainer
+                        @Foo @FooContainer(value = {@Foo, @Foo})
+                        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\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\" }, "
+                + // override every annotation on superClass
+                "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+                + // ignores inherited annotations
+                "getDeclAnnoVal = \"Foo\", " // ignores inherited
+                + "getAnnosArgs = {\"Foo\"}, "
+                + "getDeclAnnosArgs = { \"Foo\" })", // ignores inherited
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"NULL\", "
+                + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\" }, "
+                + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+                + // 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 {}
+
+                @Retention(RetentionPolicy.RUNTIME)
+                @Inherited
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @Foo()
+                class SuperClass { }
+
+                @ExpectedBase
+                @ExpectedContainer
+                @Foo
+                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" + 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;
+            }
+        },
+//         // Testcase not working as expected, JDK-8004912
+//         RepeatableOnSuperSingleOnSub_Inherited(
+//         "@ExpectedBase(value=Foo.class, "
+//                 + "getAnnotationVal = \"Foo\", "
+//                 + "getAnnotationsVals = {"
+//                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                 + //override every annotation on superClass
+//                 "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+//                 + // ignores inherited annotations
+//                 "getDeclAnnoVal = \"Foo\", " // ignores inherited
+//                 + "getAnnosArgs = {\"Foo\"}, "
+//                 + "getDeclAnnosArgs = { \"Foo\" })", // ignores inherited
+//         "@ExpectedContainer(value=FooContainer.class, "
+//                 + "getAnnotationVal = \"FooContainer\", "
+//                 + "getAnnotationsVals = {"
+//                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "
+//                 + // ignores inherited annotations
+//                 "getDeclAnnoVal = \"NULL\", "
+//                 + "getAnnosArgs = {\"FooContainer\"}, "
+//                 + "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 {}
+
+//                 @Retention(RetentionPolicy.RUNTIME)
+//                 @Inherited
+//                 @interface FooContainer {
+//                 Foo[] value();
+//                 }
+
+//                 @Foo() @Foo
+//                 class SuperClass { }
+
+//                 @ExpectedBase
+//                 @ExpectedContainer
+//                 @Foo
+//                 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 = 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;
+//             }
+//         },
+//         //Testcase not working as expected, JDK-8004912
+//         SingleOnSuperRepeatableOnSub_Inherited(
+//         "@ExpectedBase(value=Foo.class, "
+//                 + "getAnnotationVal = \"Foo\", "
+//                 + "getAnnotationsVals = {"
+//                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                 + //override every annotation on superClass
+//                 "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+//                 + // ignores inherited annotations
+//                 "getDeclAnnoVal = \"NULL\","// ignores inherited
+//                 + "getAnnosArgs = {\"Foo\", \"Foo\"}, "
+//                 + "getDeclAnnosArgs = { \"Foo\", \"Foo\"})",
+//         "@ExpectedContainer(value=FooContainer.class, "
+//                 + "getAnnotationVal = \"FooContainer\", "
+//                 + "getAnnotationsVals = {"
+//                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "
+//                 + // ignores inherited annotations
+//                 "getDeclAnnoVal = \"FooContainer\", "// ignores inherited
+//                 + "getAnnosArgs = {\"FooContainer\"}, "
+//                 + "getDeclAnnosArgs = {\"FooContainer\"})") {
+
+//             @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 {}
+
+//                 @Retention(RetentionPolicy.RUNTIME)
+//                 @Inherited
+//                 @interface FooContainer {
+//                 Foo[] value();
+//                 }
+
+//                 @Foo()
+//                 class SuperClass { }
+
+//                 @ExpectedBase
+//                 @ExpectedContainer
+//                 @Foo @Foo
+//                 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;
+//             }
+//         },
+//         //Testcase not working as expected, JDK-8004912
+//         ContainerOnSuperSingleOnSub_Inherited(
+//         "@ExpectedBase(value=Foo.class, "
+//                 + "getAnnotationVal = \"Foo\", "
+//                 + "getAnnotationsVals = {"
+//                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"
+//                 + "getDeclAnnoVal = \"Foo\","
+//                 + "getAnnosArgs = {\"Foo\"},"
+//                 + "getDeclAnnosArgs = {\"Foo\"})",
+//         "@ExpectedContainer(value=FooContainer.class, "
+//                 + "getAnnotationVal = \"FooContainer\", "
+//                 + "getAnnotationsVals = {"
+//                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"
+//                 + "getDeclAnnoVal = \"NULL\","
+//                 + "getAnnosArgs = {\"FooContainer\"},"
+//                 + "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 {}
+
+//                 @Retention(RetentionPolicy.RUNTIME)
+//                 @Inherited
+//                 @interface FooContainer {
+//                 Foo[] value();
+//                 }
+
+//                 @FooContainer(value = {@Foo, @Foo})
+//                 class SuperClass { }
+
+//                 @ExpectedBase
+//                 @ExpectedContainer
+//                 @Foo
+//                 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;
+//             }
+//         },
+//         // TestCase not working as expected, JDK-8004912
+//         SingleOnSuperContainerOnSub_Inherited(
+//         "@ExpectedBase(value=Foo.class, "
+//                 + "getAnnotationVal = \"Foo\", "
+//                 + "getAnnotationsVals = {"
+//                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"
+//                 + "getDeclAnnoVal = \"NULL\","
+//                 + "getAnnosArgs = {\"Foo\", \"Foo\"},"
+//                 + "getDeclAnnosArgs = {\"Foo\", \"Foo\"})",
+//         "@ExpectedContainer(value=FooContainer.class, "
+//                 + "getAnnotationVal = \"FooContainer\", "
+//                 + "getAnnotationsVals = {"
+//                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"
+//                 + "getDeclAnnoVal = \"FooContainer\","
+//                 + "getAnnosArgs = {\"FooContainer\"},"
+//                 + "getDeclAnnosArgs = {\"FooContainer\"})") {
+
+//             @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 {}
+
+//                 @Retention(RetentionPolicy.RUNTIME)
+//                 @Inherited
+//                 @interface FooContainer {
+//                 Foo[] value();
+//                 }
+
+//                 @Foo
+//                 class SuperClass { }
+
+//                 @ExpectedBase
+//                 @ExpectedContainer
+//                 @FooContainer(value = {@Foo, @Foo})
+//                 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;
+//             }
+//         },
+        SingleOnSuperContainerAndSingleOnSub_Inherited(
+        "@ExpectedBase(value=Foo.class, "
+                + "getAnnotationVal = \"Foo\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"},"
+                + "getDeclAnnoVal = \"Foo\","
+                + "getAnnosArgs = {\"Foo\", \"Foo\", \"Foo\"},"
+                + "getDeclAnnosArgs = {\"Foo\", \"Foo\", \"Foo\"})",
+        "@ExpectedContainer(value=FooContainer.class, "
+                + "getAnnotationVal = \"FooContainer\", "
+                + "getAnnotationsVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+                + "getDeclAnnosVals = {"
+                +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"},"
+                + "getDeclAnnoVal = \"FooContainer\","
+                + "getAnnosArgs = {\"FooContainer\"},"
+                + "getDeclAnnosArgs = {\"FooContainer\"})") {
+
+            @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 {}
+
+                @Retention(RetentionPolicy.RUNTIME)
+                @Inherited
+                @Repeatable(FooContainer.class)
+                @interface FooContainer {
+                Foo[] value();
+                }
+
+                @Foo
+                class SuperClass { }
+
+                @ExpectedBase
+                @ExpectedContainer
+                @FooContainer(value = {@Foo, @Foo}) @Foo
+                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()
+                            + 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;
+            }
+        },
+//          // TestCase not working as expected, JDK-8004912
+//          ContainerAndSingleOnSuperSingleOnSub_Inherited(
+//          "@ExpectedBase(value=Foo.class, "
+//                  + "getAnnotationVal = \"Foo\", "
+//                  + "getAnnotationsVals = {"
+//                  +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                  + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"
+//                  + "getDeclAnnoVal = \"Foo\","
+//                  + "getAnnosArgs = {\"Foo\"},"
+//                  + "getDeclAnnosArgs = {\"Foo\"})",
+//          "@ExpectedContainer(value=FooContainer.class, "
+//                  + "getAnnotationVal = \"FooContainer\", "
+//                  + "getAnnotationsVals = {"
+//                  +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "
+//                  + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"
+//                  + "getDeclAnnoVal = \"NULL\","
+//                  + "getAnnosArgs = {\"FooContainer\"},"
+//                  + "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 {}
+
+//                  @Retention(RetentionPolicy.RUNTIME)
+//                  @Inherited
+//                  @interface FooContainer {
+//                  Foo[] value();
+//                  }
+
+//                  @FooContainer(value = {@Foo, @Foo})
+//                  @Foo
+//                  class SuperClass { }
+
+//                  @ExpectedBase
+//                  @ExpectedContainer
+//                  @Foo
+//                  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()
+//                              + 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.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) {
+        // 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) {
+                actualArr[i++] = a.annotationType().getSimpleName();
+            }
+
+            List<String> actualList = Arrays.asList(actualArr);
+            List<String> expectedList = 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");
+            }
+        }
+        return true;
+    }
+
+    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.annotationType().getSimpleName() + "]");
+            } 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);
+    }
+}
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/repeatingAnnotations/combo/expectedFiles/ExpectedBase.java	Wed Feb 13 23:05:17 2013 -0800
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2012, 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.
+ */
+
+package expectedFiles;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ExpectedBase {
+    Class<? extends Annotation> value() default Annotation.class;
+    String getAnnotationVal() default "";
+    String[] getAnnotationsVals() default {};
+    String[] getDeclAnnosVals() default {};
+    // JDK8 methods
+    String getDeclAnnoVal() default "";
+    String[] getAnnosArgs() default{};
+    String[] getDeclAnnosArgs() default {};
+}
+
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/test/tools/javac/annotations/repeatingAnnotations/combo/expectedFiles/ExpectedContainer.java	Wed Feb 13 23:05:17 2013 -0800
@@ -0,0 +1,39 @@
+/*
+ * Copyright (c) 2012, 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.
+ */
+
+package expectedFiles;
+import java.lang.annotation.Annotation;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+@Retention(RetentionPolicy.RUNTIME)
+public @interface ExpectedContainer {
+    Class<? extends Annotation> value() default Annotation.class;
+    String getAnnotationVal() default "";
+    String[] getAnnotationsVals() default {};
+    String[] getDeclAnnosVals() default {};
+    // JDK8 methods
+    String getDeclAnnoVal() default "";
+    String[] getAnnosArgs() default{};
+    String[] getDeclAnnosArgs() default {};
+}
+