1 /*

     2  * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    20  * or visit www.oracle.com if you need additional information or have any

    21  * questions.

    22  */

    23 

    24 /**

    25  * @test

    26  * @bug      8001457

    27  * @author   sogoel

    28  * @summary  Reflection api tests

    29  * @build    Helper

    30  * @compile  expectedFiles/ExpectedBase.java expectedFiles/ExpectedContainer.java

    31  * @run main ReflectionTest

    32  */

    33 import java.io.File;

    34 import java.io.IOException;

    35 import java.lang.annotation.Annotation;

    36 import java.net.MalformedURLException;

    37 import java.net.URL;

    38 import java.net.URLClassLoader;

    39 import java.util.ArrayList;

    40 import java.util.Arrays;

    41 import java.util.List;

    42 

    43 import javax.tools.DiagnosticCollector;

    44 import javax.tools.JavaFileObject;

    45 

    46 import expectedFiles.ExpectedBase;

    47 import expectedFiles.ExpectedContainer;

    48 

    49 /*

    50  * Objective:

    51  * Test the following 6 methods from java.lang.reflect.AnnotatedElement:

    52  * - getAnnotation(Class<T>)

    53  * - getAnnotations()

    54  * - getDeclaredAnnotations()

    55  * - getDeclaredAnnotation(Class<T>)  // new method in JDK8

    56  * - getAnnotationsByType(Class<T>)         // new method in JDK8

    57  * - getDeclaredAnnotationsByType(Class<T>) // new method in JDK8

    58  * for multiple test cases, for example, BasicNonRepeatable case, BasicRepeatable case

    59  * for each of the src types - class, method, field, package

    60  *

    61  * This test uses following three enums:

    62  * 1. TestCase - Defines the ExpectedBase/ExpectedContainer values for each testCase

    63  *             - getTestFiles() - Creates list of JavaFileObjects for the primary

    64  *                                src types (class, method, field, package)

    65  *             - Each testCase is a new scenario with a combination of @Repeatable

    66  *               relationship present/absent in conjunction with @Inherited.

    67  *               For eg: BasicNonRepeatable_Legacy - It is a pre-JDK8 way of writing a single

    68  *                       annotation on a given srcType( class, method, field, package)

    69  *                       BasicRepeatable - It is a JDK8 way of writing repeating annotations

    70  *                       on a given srcType with a @Repeatable relationship

    71  *                       defined between Foo and FooContainer.

    72  *

    73  * 2. SrcType - Defines templates used in creation of test src

    74  *            - Defines getExpectedBase() and getExpectedContainer() for primary src types

    75  * 3. TestMethod - Defines getActualAnnoBase(), getActualAnnoContainer(), getExpectedAnnoBase(),

    76  *                 and getExpectedAnnoContainer() for each of the 6 methods that are being tested

    77  *                 in java.lang.reflect.AnnotatedElement

    78  *

    79  * Test execution flow:

    80  * - Loop over each of the src types and each test cases

    81  * - Creates test src for each flow, compile it, load the class object

    82  * - Run all 6 methods on this class object

    83  * - Get expected and actual annotations for each object and compare them.

    84  * - Increment the error counter if the annotations don't match.

    85  *

    86  * The test fails if the number of errors is greater than 0.

    87  */

    88 public class ReflectionTest {

    89 

    90     static int errors = 0;

    91     // Variables used in creating test src for a given testcase/testSrcType

    92     static final String TESTPKG = "testpkg";

    93     static final String TESTMETHOD = "testMethod";

    94     static final String TESTFIELD = "testField";

    95     static final String PKGINFONAME = TESTPKG + ".package-info";

    96     static final String SUPERCLASS = "SuperClass";

    97     static final String TESTINTERFACE = "TestInterface";

    98     /*

    99      *  Set it to true to get more debug information

   100      */

   101     static final boolean DEBUG = false;

   102 

   103     public static void main(String args[]) throws Exception {

   104         ReflectionTest test = new ReflectionTest();

   105         test.runTest();

   106     }

   107 

   108     public void runTest() throws Exception {

   109 

   110         ClassLoader parentClassLoader = getLoader();

   111         String className = "";

   112         Iterable<? extends JavaFileObject> files = null;

   113 

   114         for (SrcType srcType : SrcType.getSrcTypes()) {

   115             for (TestCase testCase : TestCase.values()) {

   116                 className = testCase + "_" + srcType;

   117                 debugPrint("*****************************************");

   118                 System.out.println("Running Test for ClassName: " + className);

   119 

   120                 // @Inherited only applicable for class, exclude cases for

   121                 // package, method, field

   122                 if (testCase.name().contains("Inherited")

   123                         && (srcType != SrcType.CLASS)) {

   124                     continue;

   125                 }

   126 

   127                 // Get list of JavaFileObjects to be compiled

   128                 files = testCase.getTestFiles(srcType, className);

   129                 if (srcType == SrcType.PACKAGE) {

   130                     className = TESTPKG + "." + className;

   131                 }

   132                 DiagnosticCollector<JavaFileObject> diagnostics = new DiagnosticCollector<>();

   133 

   134                 // Compile the list of JavaFileObjects

   135                 try {

   136                     Helper.compileCode(diagnostics, files);

   137                 } catch (Exception ex) {

   138                     printTestSrc(files);

   139                     throw new RuntimeException(

   140                             "Exception when compiling class " + className, ex);

   141                 }

   142 

   143                 // Get Class object for the compiled class

   144                 Class<?> c = loadClass(className, parentClassLoader, Helper.destDir);

   145                 if (c != null) {

   146                     // For the loaded class object, compare expected and actual annotation values

   147                     // for each of the methods under test from java.lang.reflect.AnnotatedElement

   148                     checkAnnoValues(srcType, c);

   149                 } else {

   150                     error("Could not load className = " + c);

   151                 }

   152             }

   153         }

   154 

   155         if (getNumErrors() > 0) {

   156             System.err.println("Test failed with " + getNumErrors() + " errors");

   157             throw new RuntimeException();

   158         }

   159     }

   160 

   161     /*

   162      *  Each test case in this enum has the following:

   163      *  - Define each test case with its @ExpectedBase and @ExpectedContainer annotations

   164      *  - Override getTestFiles() that creates list of JavaFileObjects for each case

   165      *    based on the src type.

   166      */

   167     enum TestCase {

   168         BasicNonRepeatable_Legacy(

   169         "@ExpectedBase(value=Foo.class, "

   170                 + "getAnnotationVal = \"Foo\", "

   171                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "

   172                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "

   173                 + "getDeclAnnoVal = \"Foo\", "

   174                 + "getAnnosArgs = {\"Foo\"}, "

   175                 + "getDeclAnnosArgs = {\"Foo\"}) ",

   176         "@ExpectedContainer") {

   177 

   178             @Override

   179             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   180                     String className) {

   181                 String anno = "";

   182                 String replaceVal = "";

   183                 String testSrc = "";

   184                 String pkgInfoContents = "";

   185                 String contents = "";

   186 

   187                 JavaFileObject pkgFileObj = null;

   188                 JavaFileObject srcFileObj = null;

   189                 Iterable<? extends JavaFileObject> files = null;

   190 

   191                 String expectedVals = "\n" + getExpectedBase() + "\n"

   192                         + getExpectedContainer() + "\n";

   193                 StringBuilder commonStmts = new StringBuilder();

   194                 anno = Helper.ContentVars.BASEANNO.getVal();

   195                 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

   196                         .append(Helper.ContentVars.IMPORTSTMTS.getVal())

   197                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

   198                         .append(Helper.ContentVars.BASE.getVal());

   199                 switch (srcType) {

   200                     case PACKAGE:

   201                         /*

   202                         Sample package-info.java

   203                         @ExpectedBase

   204                         @ExpectedContainer

   205                         @Foo

   206                         package testpkg;

   207 

   208                         @Retention(RetentionPolicy.RUNTIME)

   209                         @interface Foo {}

   210 

   211                         Sample testSrc:

   212                         package testpkg;

   213                         class A {}

   214                          */

   215                         testSrc = srcType.getTemplate().replace("#CN", className);

   216                         contents = testSrc;

   217                         srcFileObj = Helper.getFile(className, contents);

   218 

   219                         replaceVal = expectedVals + "\n" + anno;

   220                         pkgInfoContents = SrcType.PKGINFO.getTemplate()

   221                                 .replace("#REPLACE1", replaceVal)

   222                                 .replace("#REPLACE2", commonStmts);

   223                         pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents);

   224 

   225                         files = Arrays.asList(pkgFileObj, srcFileObj);

   226                         break;

   227                     default:

   228                         // class, method, field

   229                     /*

   230                         Sample testSrc for class

   231                         @Retention(RetentionPolicy.RUNTIME)

   232                         @interface Foo {}

   233 

   234                         @ExpectedBase

   235                         @ExpectedContainer

   236                         @Foo

   237                         class A {}

   238                          */

   239                         replaceVal = expectedVals + anno;

   240                         testSrc = srcType.getTemplate().replace("#CN", className)

   241                                 .replace("#REPLACE", replaceVal);

   242                         contents = commonStmts + testSrc;

   243                         srcFileObj = Helper.getFile(className, contents);

   244                         files = Arrays.asList(srcFileObj);

   245                 }

   246                 return files;

   247             }

   248         },

   249         SingleAnnoInherited_Legacy(

   250         "@ExpectedBase(value=Foo.class, "

   251                 + "getAnnotationVal = \"Foo\", "

   252                 + "getAnnotationsVals = {\"Foo\", \"ExpectedBase\", \"ExpectedContainer\"}, "

   253                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "

   254                 + "getDeclAnnoVal = \"NULL\", "

   255                 + "getAnnosArgs = {\"Foo\"}, "

   256                 + "getDeclAnnosArgs = {})",

   257         "@ExpectedContainer") {

   258 

   259             @Override

   260             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   261                     String className) {

   262                 String anno = "";

   263                 String replaceVal = "";

   264                 String contents = "";

   265                 JavaFileObject srcFileObj = null;

   266                 Iterable<? extends JavaFileObject> files = null;

   267 

   268                 String expectedVals = "\n" + getExpectedBase() + "\n"

   269                         + getExpectedContainer() + "\n";

   270                 StringBuilder commonStmts = new StringBuilder();

   271 

   272                 /*

   273                 Sample testSrc:

   274                 @Retention(RetentionPolicy.RUNTIME)

   275                 @Inherited

   276                 @interface Foo {}

   277 

   278                 @Foo

   279                 class SuperClass { }

   280 

   281                 @ExpectedBase

   282                 @ExpectedContainer

   283                 class SubClass extends SuperClass {}

   284                  */

   285 

   286                 // @Inherited only works for classes, no switch cases for

   287                 // method, field, package

   288                 anno = Helper.ContentVars.BASEANNO.getVal();

   289                 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

   290                         .append(Helper.ContentVars.IMPORTSTMTS.getVal())

   291                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

   292                         .append(Helper.ContentVars.INHERITED.getVal())

   293                         .append(Helper.ContentVars.BASE.getVal());

   294 

   295                 if (srcType == SrcType.CLASS) {

   296                     // Contents for SuperClass

   297                     replaceVal = commonStmts + "\n" + anno;

   298                     String superClassContents = srcType.getTemplate()

   299                             .replace("#CN", SUPERCLASS).replace("#REPLACE", replaceVal);

   300 

   301                     // Contents for SubClass that extends SuperClass

   302                     replaceVal = expectedVals;

   303                     String subClassContents = SrcType.CLASSEXTENDS.getTemplate()

   304                             .replace("#CN", className).replace("#SN", SUPERCLASS)

   305                             .replace("#REPLACE", replaceVal);

   306 

   307                     contents = superClassContents + subClassContents;

   308                     srcFileObj = Helper.getFile(className, contents);

   309                     files = Arrays.asList(srcFileObj);

   310                 }

   311                 return files;

   312             }

   313         },

   314         InheritedAnnoOnInterface_Legacy(

   315         "@ExpectedBase(value=Foo.class, "

   316                 + "getAnnotationVal = \"NULL\", "

   317                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "

   318                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"},"

   319                 + "getDeclAnnoVal = \"NULL\"," + "getAnnosArgs = {},"

   320                 + "getDeclAnnosArgs = {})",

   321         "@ExpectedContainer") {

   322 

   323             @Override

   324             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   325                     String className) {

   326                 String anno = "";

   327                 String replaceVal = "";

   328                 String contents = "";

   329                 JavaFileObject srcFileObj = null;

   330                 Iterable<? extends JavaFileObject> files = null;

   331 

   332                 String expectedVals = "\n" + getExpectedBase() + "\n"

   333                         + getExpectedContainer() + "\n";

   334                 StringBuilder commonStmts = new StringBuilder();

   335 

   336                 /*

   337                 Sample test src:

   338                 @Retention(RetentionPolicy.RUNTIME)

   339                 @Inherited

   340                 @interface Foo {}

   341 

   342                 @Foo

   343                 interface TestInterface { }

   344 

   345                 @ExpectedBase

   346                 @ExpectedContainer

   347                 class A implements TestInterface {}

   348                  */

   349                 anno = Helper.ContentVars.BASEANNO.getVal();

   350                 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

   351                         .append(Helper.ContentVars.IMPORTSTMTS.getVal())

   352                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

   353                         .append(Helper.ContentVars.INHERITED.getVal())

   354                         .append(Helper.ContentVars.BASE.getVal());

   355 

   356                 if (srcType == SrcType.CLASS) {

   357                     // Contents for TestInterface

   358                     replaceVal = commonStmts + "\n" + anno;

   359                     String interfaceContents = SrcType.INTERFACE.getTemplate()

   360                             .replace("#IN", TESTINTERFACE)

   361                             .replace("#REPLACE", replaceVal);

   362 

   363                     // Contents for class implementing TestInterface

   364                     replaceVal = expectedVals;

   365                     String classContents = SrcType.INTERFACEIMPL.getTemplate()

   366                             .replace("#CN", className).replace("#IN", TESTINTERFACE)

   367                             .replace("#REPLACE", replaceVal);

   368 

   369                     contents = interfaceContents + classContents;

   370                     srcFileObj = Helper.getFile(className, contents);

   371                     files = Arrays.asList(srcFileObj);

   372                 }

   373                 return files;

   374             }

   375         },

   376         AnnoOnSuperAndSubClass_Inherited_Legacy(

   377         "@ExpectedBase(value=Foo.class, "

   378                 + "getAnnotationVal = \"Foo\", "

   379                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "

   380                 + // override every annotation on superClass

   381                 "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "

   382                 + // ignores inherited annotations

   383                 "getDeclAnnoVal = \"Foo\", " // ignores inherited

   384                 + "getAnnosArgs = {\"Foo\"}, "

   385                 + "getDeclAnnosArgs = { \"Foo\" })", // ignores inherited

   386         "@ExpectedContainer(value=FooContainer.class, "

   387                 + "getAnnotationVal = \"NULL\", "

   388                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "

   389                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"}, "

   390                 + // ignores inherited annotations

   391                 "getDeclAnnoVal = \"NULL\", " + // ignores inherited

   392                 "getAnnosArgs = {}, " + "getDeclAnnosArgs = {})") { // ignores inherited

   393 

   394             @Override

   395             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   396                     String className) {

   397                 String anno = "";

   398                 String replaceVal = "";

   399                 String contents = "";

   400                 JavaFileObject srcFileObj = null;

   401                 Iterable<? extends JavaFileObject> files = null;

   402 

   403                 String expectedVals = "\n" + getExpectedBase() + "\n"

   404                         + getExpectedContainer() + "\n";

   405                 StringBuilder commonStmts = new StringBuilder();

   406 

   407                 /*

   408                 Sample test src

   409                 @Retention(RetentionPolicy.RUNTIME)

   410                 @Inherited

   411                 @interface Foo {}

   412 

   413                 @Inherited

   414                 @interface FooContainer {

   415                 Foo[] value();

   416                 }

   417 

   418                 @Foo

   419                 class SuperClass { }

   420 

   421                 @ExpectedBase

   422                 @ExpectedContainer

   423                 @Foo

   424                 class SubClass extends SuperClass {}

   425                  */

   426                 // @Inherited only works for classes, no switch cases for

   427                 // method, field, package

   428                 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

   429                         .append(Helper.ContentVars.IMPORTSTMTS.getVal())

   430                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

   431                         .append(Helper.ContentVars.INHERITED.getVal())

   432                         .append(Helper.ContentVars.BASE.getVal())

   433                         .append(Helper.ContentVars.INHERITED.getVal())

   434                         .append(Helper.ContentVars.CONTAINER.getVal());

   435 

   436                 if (srcType == SrcType.CLASS) {

   437                     // Contents for SuperClass

   438                     anno = Helper.ContentVars.BASEANNO.getVal();

   439                     replaceVal = commonStmts + "\n" + anno;

   440                     String superClassContents = srcType.getTemplate()

   441                             .replace("#CN", SUPERCLASS).replace("#REPLACE", replaceVal);

   442 

   443                     // Contents for SubClass that extends SuperClass

   444                     replaceVal = expectedVals + "\n" + anno;

   445                     String subClassContents = SrcType.CLASSEXTENDS.getTemplate()

   446                             .replace("#CN", className).replace("#SN", SUPERCLASS)

   447                             .replace("#REPLACE", replaceVal);

   448 

   449                     contents = superClassContents + subClassContents;

   450                     srcFileObj = Helper.getFile(className, contents);

   451                     files = Arrays.asList(srcFileObj);

   452                 }

   453                 return files;

   454             }

   455         },

   456         BasicContainer_Legacy(

   457         "@ExpectedBase(value = Foo.class, "

   458                 + "getAnnotationVal = \"NULL\","

   459                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "

   460                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "

   461                 + "getDeclAnnoVal = \"NULL\", " + "getAnnosArgs = {}, "

   462                 + "getDeclAnnosArgs = {} )",

   463         "@ExpectedContainer(value=FooContainer.class, "

   464                 + "getAnnotationVal = \"FooContainer\", "

   465                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "

   466                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "

   467                 + "getDeclAnnoVal = \"FooContainer\", "

   468                 + "getAnnosArgs = {\"FooContainer\"}, "

   469                 + "getDeclAnnosArgs = {\"FooContainer\"} )") {

   470 

   471             @Override

   472             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   473                     String className) {

   474                 String anno = "";

   475                 String replaceVal = "";

   476                 String testSrc = "";

   477                 String pkgInfoContents = "";

   478                 String contents = "";

   479 

   480                 JavaFileObject pkgFileObj = null;

   481                 JavaFileObject srcFileObj = null;

   482                 Iterable<? extends JavaFileObject> files = null;

   483 

   484                 String expectedVals = "\n" + getExpectedBase() + "\n"

   485                         + getExpectedContainer() + "\n";

   486                 StringBuilder commonStmts = new StringBuilder();

   487 

   488                 anno = Helper.ContentVars.LEGACYCONTAINER.getVal();

   489                 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

   490                         .append(Helper.ContentVars.IMPORTSTMTS.getVal())

   491                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

   492                         .append(Helper.ContentVars.BASE.getVal())

   493                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

   494                         .append(Helper.ContentVars.CONTAINER.getVal());

   495                 switch (srcType) {

   496                     case PACKAGE:

   497                         /*

   498                         Sample package-info.java

   499                         @ExpectedBase

   500                         @ExpectedContainer

   501                         @FooContainer(value = {@Foo, @Foo})

   502                         package testpkg;

   503 

   504                         @Retention(RetentionPolicy.RUNTIME)

   505                         @interface Foo {}

   506 

   507                         @Retention(RetentionPolicy.RUNTIME)

   508                         @interface FooContainer {

   509                         Foo[] value();

   510                         }

   511 

   512                         Sample testSrc:

   513                         package testpkg;

   514                         class A {}

   515                          */

   516                         testSrc = srcType.getTemplate().replace("#CN", className);

   517                         contents = testSrc;

   518                         srcFileObj = Helper.getFile(className, contents);

   519 

   520                         replaceVal = "\n" + expectedVals + "\n" + anno;

   521                         pkgInfoContents = SrcType.PKGINFO.getTemplate()

   522                                 .replace("#REPLACE1", replaceVal)

   523                                 .replace("#REPLACE2", commonStmts);

   524                         pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents);

   525                         files = Arrays.asList(pkgFileObj, srcFileObj);

   526                         break;

   527                     default:

   528                         /*

   529                         Sample testSrc for class:

   530                         @Retention(RetentionPolicy.RUNTIME)

   531                         @Inherited

   532                         @interface Foo {}

   533 

   534                         @Retention(RetentionPolicy.RUNTIME)

   535                         @Inherited

   536                         @interface FooContainer {

   537                         Foo[] value();

   538                         }

   539 

   540                         @ExpectedBase

   541                         @ExpectedContainer

   542                         @FooContainer(value = {@Foo, @Foo})

   543                         class A {}

   544                          */

   545                         replaceVal = expectedVals + anno;

   546                         testSrc = srcType.getTemplate().replace("#CN", className)

   547                                 .replace("#REPLACE", replaceVal);

   548                         contents = commonStmts + testSrc;

   549                         srcFileObj = Helper.getFile(className, contents);

   550                         files = Arrays.asList(srcFileObj);

   551                 }

   552                 return files;

   553             }

   554         },

   555         SingleAndContainerOnSuper_Legacy(

   556         "@ExpectedBase(value = Foo.class, "

   557                 + "getAnnotationVal = \"Foo\","

   558                 + "getAnnotationsVals = {"

   559                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   560                 + "getDeclAnnosVals = {"

   561                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   562                 + "getDeclAnnoVal = \"Foo\", "

   563                 + "getAnnosArgs = {\"Foo\"}, "

   564                 + "getDeclAnnosArgs = {\"Foo\"} )",

   565         "@ExpectedContainer(value=FooContainer.class, "

   566                 + "getAnnotationVal = \"FooContainer\", "

   567                 + "getAnnotationsVals = {"

   568                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   569                 + "getDeclAnnosVals = {"

   570                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   571                 + "getDeclAnnoVal = \"FooContainer\", "

   572                 + "getAnnosArgs = {\"FooContainer\"}, "

   573                 + "getDeclAnnosArgs = {\"FooContainer\"} )") {

   574 

   575             @Override

   576             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   577                     String className) {

   578                 String anno = "";

   579                 String replaceVal = "";

   580                 String testSrc = "";

   581                 String pkgInfoContents = "";

   582                 String contents = "";

   583 

   584                 JavaFileObject pkgFileObj = null;

   585                 JavaFileObject srcFileObj = null;

   586                 Iterable<? extends JavaFileObject> files = null;

   587 

   588                 String expectedVals = "\n" + getExpectedBase() + "\n"

   589                         + getExpectedContainer() + "\n";

   590                 StringBuilder commonStmts = new StringBuilder();

   591 

   592                 anno = Helper.ContentVars.LEGACYCONTAINER.getVal()

   593                         + Helper.ContentVars.BASEANNO.getVal();

   594                 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

   595                         .append(Helper.ContentVars.IMPORTSTMTS.getVal())

   596                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

   597                         .append(Helper.ContentVars.BASE.getVal())

   598                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

   599                         .append(Helper.ContentVars.CONTAINER.getVal());

   600                 switch (srcType) {

   601                     case PACKAGE:

   602                         /*

   603                         Sample package-info.java

   604                         @ExpectedBase

   605                         @ExpectedContainer

   606                         @Foo

   607                         @FooContainer(value = {@Foo, @Foo})

   608                         package testpkg;

   609 

   610                         @Retention(RetentionPolicy.RUNTIME)

   611                         @interface Foo {}

   612 

   613                         @Retention(RetentionPolicy.RUNTIME)

   614                         @interface FooContainer {

   615                         Foo[] value();

   616                         }

   617 

   618                         Sample testSrc:

   619                         package testpkg;

   620                         class A {}

   621                          */

   622                         testSrc = srcType.getTemplate().replace("#CN", className);

   623                         contents = testSrc;

   624 

   625                         srcFileObj = Helper.getFile(className, contents);

   626 

   627                         replaceVal = "\n" + expectedVals + "\n" + anno;

   628                         pkgInfoContents = SrcType.PKGINFO.getTemplate()

   629                                 .replace("#REPLACE1", replaceVal)

   630                                 .replace("#REPLACE2", commonStmts);

   631                         pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents);

   632                         files = Arrays.asList(pkgFileObj, srcFileObj);

   633                         break;

   634                     default:

   635                         /*

   636                         Sample testSrc for class:

   637                         @Retention(RetentionPolicy.RUNTIME)

   638                         @Inherited

   639                         @interface Foo {}

   640 

   641                         @Retention(RetentionPolicy.RUNTIME)

   642                         @Inherited

   643                         @interface FooContainer {

   644                         Foo[] value();

   645                         }

   646 

   647                         @ExpectedBase

   648                         @ExpectedContainer

   649                         @Foo

   650                         @FooContainer(value = {@Foo, @Foo})

   651                         class A {}

   652                          */

   653                         replaceVal = expectedVals + anno;

   654                         testSrc = srcType.getTemplate().replace("#CN", className)

   655                                 .replace("#REPLACE", replaceVal);

   656                         contents = commonStmts + testSrc;

   657 

   658                         srcFileObj = Helper.getFile(className, contents);

   659                         files = Arrays.asList(srcFileObj);

   660                 }

   661                 return files;

   662             }

   663         },

   664         BasicContainer_Inherited_Legacy(

   665         "@ExpectedBase(value = Foo.class, "

   666                 + "getAnnotationVal = \"NULL\","

   667                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "

   668                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "

   669                 + "getDeclAnnoVal = \"NULL\", "

   670                 + "getAnnosArgs = {}, "

   671                 + "getDeclAnnosArgs = {} )",

   672         "@ExpectedContainer(value=FooContainer.class, "

   673                 + "getAnnotationVal = \"FooContainer\", "

   674                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "

   675                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\"}, "

   676                 + "getDeclAnnoVal = \"NULL\", "

   677                 + "getAnnosArgs = {\"FooContainer\"}, "

   678                 + "getDeclAnnosArgs = {} )") {

   679 

   680             @Override

   681             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   682                     String className) {

   683                 String anno = "";

   684                 String replaceVal = "";

   685                 String contents = "";

   686                 JavaFileObject srcFileObj = null;

   687                 Iterable<? extends JavaFileObject> files = null;

   688 

   689                 String expectedVals = "\n" + getExpectedBase() + "\n"

   690                         + getExpectedContainer() + "\n";

   691                 StringBuilder commonStmts = getCommonStmts(false);

   692 

   693                 /*

   694                 Sample testSrc:

   695                 @Retention(RetentionPolicy.RUNTIME)

   696                 @Inherited

   697                 @interface Foo {}

   698 

   699                 @Retention(RetentionPolicy.RUNTIME)

   700                 @Inherited

   701                 @interface FooContainer {

   702                 Foo[] value();

   703                 }

   704 

   705                 @FooContainer(value = {@Foo, @Foo})

   706                 class SuperClass { }

   707 

   708                 @ExpectedBase

   709                 @ExpectedContainer

   710                 class SubClass extends SuperClass {}

   711                  */

   712                 // @Inherited only works for classes, no switch cases for

   713                 // method, field, package

   714 

   715                 if (srcType == SrcType.CLASS) {

   716                     // Contents for SuperClass

   717                     anno = Helper.ContentVars.LEGACYCONTAINER.getVal();

   718                     replaceVal = commonStmts + "\n" + anno;

   719                     String superClassContents = srcType.getTemplate()

   720                             .replace("#CN", SUPERCLASS)

   721                             .replace("#REPLACE", replaceVal);

   722 

   723                     // Contents for SubClass that extends SuperClass

   724                     replaceVal = expectedVals;

   725                     String subClassContents = SrcType.CLASSEXTENDS.getTemplate()

   726                             .replace("#CN", className)

   727                             .replace("#SN", SUPERCLASS)

   728                             .replace("#REPLACE", replaceVal);

   729 

   730                     contents = superClassContents + subClassContents;

   731                     srcFileObj = Helper.getFile(className, contents);

   732                     files = Arrays.asList(srcFileObj);

   733                 }

   734                 return files;

   735             }

   736         },

   737         ContainerOnSuperSingleOnSub_Inherited_Legacy(

   738         "@ExpectedBase(value=Foo.class, "

   739                 + "getAnnotationVal = \"Foo\", "

   740                 + "getAnnotationsVals = {"

   741                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   742                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"

   743                 + "getDeclAnnoVal = \"Foo\","

   744                 + "getAnnosArgs = {\"Foo\"},"

   745                 + "getDeclAnnosArgs = {\"Foo\"})",

   746         "@ExpectedContainer(value=FooContainer.class, "

   747                 + "getAnnotationVal = \"FooContainer\", "

   748                 + "getAnnotationsVals = {"

   749                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   750                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"

   751                 + "getDeclAnnoVal = \"NULL\","

   752                 + "getAnnosArgs = {\"FooContainer\"},"

   753                 + "getDeclAnnosArgs = {})") {

   754 

   755             @Override

   756             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   757                     String className) {

   758                 String anno = "";

   759                 String replaceVal = "";

   760                 String contents = "";

   761                 JavaFileObject srcFileObj = null;

   762                 Iterable<? extends JavaFileObject> files = null;

   763 

   764                 String expectedVals = "\n" + getExpectedBase() + "\n"

   765                         + getExpectedContainer() + "\n";

   766                 StringBuilder commonStmts = getCommonStmts(false);

   767 

   768                 /*

   769                 Sample testSrc:

   770                 @Retention(RetentionPolicy.RUNTIME)

   771                 @Inherited

   772                 @interface Foo {}

   773 

   774                 @Retention(RetentionPolicy.RUNTIME)

   775                 @Inherited

   776                 @interface FooContainer {

   777                 Foo[] value();

   778                 }

   779 

   780                 @FooContainer(value = {@Foo, @Foo})

   781                 class SuperClass { }

   782 

   783                 @ExpectedBase

   784                 @ExpectedContainer

   785                 @Foo

   786                 class SubClass extends SuperClass {}

   787                  */

   788                 // @Inherited only works for classes, no switch cases for

   789                 // method, field, package

   790 

   791                 if (srcType == SrcType.CLASS) {

   792                     // Contents for SuperClass

   793                     anno = Helper.ContentVars.LEGACYCONTAINER.getVal();

   794                     replaceVal = commonStmts + "\n" + anno;

   795                     String superClassContents = srcType.getTemplate()

   796                             .replace("#CN", SUPERCLASS)

   797                             .replace("#REPLACE", replaceVal);

   798 

   799                     // Contents for SubClass that extends SuperClass

   800                     anno = Helper.ContentVars.BASEANNO.getVal();

   801                     replaceVal = expectedVals + "\n" + anno;

   802                     String subClassContents = SrcType.CLASSEXTENDS.getTemplate()

   803                             .replace("#CN", className)

   804                             .replace("#SN", SUPERCLASS)

   805                             .replace("#REPLACE", replaceVal);

   806 

   807                     contents = superClassContents + subClassContents;

   808                     srcFileObj = Helper.getFile(className, contents);

   809                     files = Arrays.asList(srcFileObj);

   810                 }

   811                 return files;

   812             }

   813         },

   814         ContainerAndSingleOnSuperSingleOnSub_Inherited_Legacy(

   815         "@ExpectedBase(value=Foo.class, "

   816                 + "getAnnotationVal = \"Foo\", "

   817                 + "getAnnotationsVals = {"

   818                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   819                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"

   820                 + "getDeclAnnoVal = \"Foo\","

   821                 + "getAnnosArgs = {\"Foo\"},"

   822                 + "getDeclAnnosArgs = {\"Foo\"})",

   823         "@ExpectedContainer(value=FooContainer.class, "

   824                 + "getAnnotationVal = \"FooContainer\", "

   825                 + "getAnnotationsVals = {"

   826                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   827                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"Foo\"},"

   828                 + "getDeclAnnoVal = \"NULL\","

   829                 + "getAnnosArgs = {\"FooContainer\"},"

   830                 + "getDeclAnnosArgs = {})") {

   831 

   832             @Override

   833             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   834                     String className) {

   835                 String anno = "";

   836                 String replaceVal = "";

   837                 String contents = "";

   838                 JavaFileObject srcFileObj = null;

   839                 Iterable<? extends JavaFileObject> files = null;

   840 

   841                 String expectedVals = "\n" + getExpectedBase() + "\n"

   842                         + getExpectedContainer() + "\n";

   843                 StringBuilder commonStmts = getCommonStmts(false);

   844 

   845                 /*

   846                 Sample testSrc:

   847                 @Retention(RetentionPolicy.RUNTIME)

   848                 @Inherited

   849                 @interface Foo {}

   850 

   851                 @Retention(RetentionPolicy.RUNTIME)

   852                 @Inherited

   853                 @interface FooContainer {

   854                 Foo[] value();

   855                 }

   856 

   857                 @FooContainer(value = {@Foo, @Foo}) @Foo

   858                 class SuperClass { }

   859 

   860                 @ExpectedBase

   861                 @ExpectedContainer

   862                 @Foo

   863                 class SubClass extends SuperClass {}

   864                  */

   865                 // @Inherited only works for classes, no switch cases for

   866                 // method, field, package

   867 

   868                 if (srcType == SrcType.CLASS) {

   869                     // Contents for SuperClass

   870                     anno = Helper.ContentVars.LEGACYCONTAINER.getVal()

   871                             + Helper.ContentVars.BASEANNO.getVal();

   872                     replaceVal = commonStmts + "\n" + anno;

   873                     String superClassContents = srcType.getTemplate()

   874                             .replace("#CN", SUPERCLASS)

   875                             .replace("#REPLACE", replaceVal);

   876 

   877                     // Contents for SubClass that extends SuperClass

   878                     anno = Helper.ContentVars.BASEANNO.getVal();

   879                     replaceVal = expectedVals + "\n" + anno;

   880                     String subClassContents = SrcType.CLASSEXTENDS.getTemplate()

   881                             .replace("#CN", className).replace("#SN", SUPERCLASS)

   882                             .replace("#REPLACE", replaceVal);

   883 

   884                     contents = superClassContents + subClassContents;

   885                     srcFileObj = Helper.getFile(className, contents);

   886                     files = Arrays.asList(srcFileObj);

   887                 }

   888                 return files;

   889             }

   890         },

   891         SingleOnSuperContainerOnSub_Inherited_Legacy(

   892         "@ExpectedBase(value=Foo.class, "

   893                 + "getAnnotationVal = \"Foo\", "

   894                 + "getAnnotationsVals = {"

   895                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   896                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"

   897                 + "getDeclAnnoVal = \"NULL\","

   898                 + "getAnnosArgs = {\"Foo\"},"

   899                 + "getDeclAnnosArgs = {})",

   900         "@ExpectedContainer(value=FooContainer.class, "

   901                 + "getAnnotationVal = \"FooContainer\", "

   902                 + "getAnnotationsVals = {"

   903                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   904                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"

   905                 + "getDeclAnnoVal = \"FooContainer\","

   906                 + "getAnnosArgs = {\"FooContainer\"},"

   907                 + "getDeclAnnosArgs = {\"FooContainer\"})") {

   908 

   909             @Override

   910             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   911                     String className) {

   912                 String anno = "";

   913                 String replaceVal = "";

   914                 String contents = "";

   915 

   916                 JavaFileObject srcFileObj = null;

   917                 Iterable<? extends JavaFileObject> files = null;

   918 

   919                 String expectedVals = "\n" + getExpectedBase() + "\n"

   920                         + getExpectedContainer() + "\n";

   921                 StringBuilder commonStmts = getCommonStmts(false);

   922 

   923                 /*

   924                 Sample testSrc:

   925                 @Retention(RetentionPolicy.RUNTIME)

   926                 @Inherited

   927                 @interface Foo {}

   928 

   929                 @Retention(RetentionPolicy.RUNTIME)

   930                 @Inherited

   931                 @interface FooContainer {

   932                 Foo[] value();

   933                 }

   934 

   935                 @Foo

   936                 class SuperClass { }

   937 

   938                 @ExpectedBase

   939                 @ExpectedContainer

   940                 @FooContainer(value = {@Foo, @Foo})

   941                 class SubClass extends SuperClass {}

   942                  */

   943 

   944                 if (srcType == SrcType.CLASS) {

   945                     //Contents for SuperClass

   946                     anno = Helper.ContentVars.BASEANNO.getVal();

   947                     replaceVal = commonStmts + "\n" + anno;

   948                     String superClassContents = srcType.getTemplate()

   949                             .replace("#CN", SUPERCLASS)

   950                             .replace("#REPLACE", replaceVal);

   951 

   952                     //Contents for SubClass that extends SuperClass

   953                     anno = Helper.ContentVars.LEGACYCONTAINER.getVal();

   954                     replaceVal = expectedVals + "\n" + anno;

   955                     String subClassContents = SrcType.CLASSEXTENDS.getTemplate()

   956                             .replace("#CN", className).replace("#SN", SUPERCLASS)

   957                             .replace("#REPLACE", replaceVal);

   958 

   959                     contents = superClassContents + subClassContents;

   960                     srcFileObj = Helper.getFile(className, contents);

   961                     files = Arrays.asList(srcFileObj);

   962                 }

   963                 return files;

   964             }

   965         },

   966         SingleOnSuperContainerAndSingleOnSub_Inherited_Legacy(

   967         "@ExpectedBase(value=Foo.class, "

   968                 + "getAnnotationVal = \"Foo\", "

   969                 + "getAnnotationsVals = {"

   970                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   971                 + "getDeclAnnosVals = {"

   972                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"},"

   973                 + "getDeclAnnoVal = \"Foo\","

   974                 + "getAnnosArgs = {\"Foo\"},"

   975                 + "getDeclAnnosArgs = {\"Foo\"})",

   976         "@ExpectedContainer(value=FooContainer.class, "

   977                 + "getAnnotationVal = \"FooContainer\", "

   978                 + "getAnnotationsVals = {"

   979                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"}, "

   980                 + "getDeclAnnosVals = {"

   981                 +       "\"ExpectedBase\", \"ExpectedContainer\", \"Foo\", \"FooContainer\"},"

   982                 + "getDeclAnnoVal = \"FooContainer\","

   983                 + "getAnnosArgs = {\"FooContainer\"},"

   984                 + "getDeclAnnosArgs = {\"FooContainer\"})") {

   985 

   986             @Override

   987             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

   988                     String className) {

   989                 String anno = "";

   990                 String replaceVal = "";

   991                 String contents = "";

   992 

   993                 JavaFileObject srcFileObj = null;

   994                 Iterable<? extends JavaFileObject> files = null;

   995 

   996                 String expectedVals = "\n" + getExpectedBase() + "\n"

   997                         + getExpectedContainer() + "\n";

   998                 StringBuilder commonStmts = getCommonStmts(false);

   999 

  1000                 /*

  1001                 Sample testSrc:

  1002                 @Retention(RetentionPolicy.RUNTIME)

  1003                 @Inherited

  1004                 @interface Foo {}

  1005 

  1006                 @Retention(RetentionPolicy.RUNTIME)

  1007                 @Inherited

  1008                 @interface FooContainer {

  1009                 Foo[] value();

  1010                 }

  1011 

  1012                 @Foo

  1013                 class SuperClass { }

  1014 

  1015                 @ExpectedBase

  1016                 @ExpectedContainer

  1017                 @FooContainer(value = {@Foo, @Foo}) @Foo

  1018                 class SubClass extends SuperClass {}

  1019                  */

  1020 

  1021                 if (srcType == SrcType.CLASS) {

  1022                     //Contents for SuperClass

  1023                     anno = Helper.ContentVars.BASEANNO.getVal();

  1024                     replaceVal = commonStmts + "\n" + anno;

  1025                     String superClassContents = srcType.getTemplate()

  1026                             .replace("#CN", SUPERCLASS)

  1027                             .replace("#REPLACE", replaceVal);

  1028 

  1029                     //Contents for SubClass that extends SuperClass

  1030                     anno = Helper.ContentVars.LEGACYCONTAINER.getVal()

  1031                             + Helper.ContentVars.BASEANNO.getVal();

  1032                     replaceVal = expectedVals + "\n" + anno;

  1033                     String subClassContents = SrcType.CLASSEXTENDS.getTemplate()

  1034                             .replace("#CN", className).replace("#SN", SUPERCLASS)

  1035                             .replace("#REPLACE", replaceVal);

  1036 

  1037                     contents = superClassContents + subClassContents;

  1038                     srcFileObj = Helper.getFile(className, contents);

  1039                     files = Arrays.asList(srcFileObj);

  1040                 }

  1041                 return files;

  1042             }

  1043         },

  1044         BasicRepeatable(

  1045         "@ExpectedBase(value=Foo.class, "

  1046                 + "getAnnotationVal = \"NULL\", "

  1047                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\" }, "

  1048                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"

  1049                 + "getDeclAnnoVal = \"NULL\","

  1050                 + "getAnnosArgs = {\"Foo\", \"Foo\"},"

  1051                 + "getDeclAnnosArgs = {\"Foo\", \"Foo\"})",

  1052         "@ExpectedContainer(value=FooContainer.class, "

  1053                 + "getAnnotationVal = \"FooContainer\","

  1054                 + "getAnnotationsVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"},"

  1055                 + "getDeclAnnosVals = {\"ExpectedBase\", \"ExpectedContainer\", \"FooContainer\"}, "

  1056                 + "getDeclAnnoVal = \"FooContainer\","

  1057                 + "getAnnosArgs = {\"FooContainer\"},"

  1058                 + "getDeclAnnosArgs = {\"FooContainer\"} )") {

  1059 

  1060             @Override

  1061             public Iterable<? extends JavaFileObject> getTestFiles(SrcType srcType,

  1062                     String className) {

  1063                 String anno = "";

  1064                 String replaceVal = "";

  1065                 String testSrc = "";

  1066                 String pkgInfoContents = "";

  1067                 String contents = "";

  1068 

  1069                 JavaFileObject pkgFileObj = null;

  1070                 JavaFileObject srcFileObj = null;

  1071                 Iterable<? extends JavaFileObject> files = null;

  1072 

  1073                 String expectedVals = "\n" + getExpectedBase() + "\n"

  1074                         + getExpectedContainer() + "\n";

  1075                 StringBuilder commonStmts = new StringBuilder();

  1076 

  1077                 anno = Helper.ContentVars.REPEATABLEANNO.getVal();

  1078                 commonStmts.append(Helper.ContentVars.IMPORTEXPECTED.getVal())

  1079                         .append(Helper.ContentVars.IMPORTSTMTS.getVal())

  1080                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

  1081                         .append(Helper.ContentVars.REPEATABLE.getVal())

  1082                         .append(Helper.ContentVars.BASE.getVal())

  1083                         .append(Helper.ContentVars.RETENTIONRUNTIME.getVal())

  1084                         .append(Helper.ContentVars.CONTAINER.getVal());

  1085                 switch (srcType) {

  1086                     case PACKAGE:

  1087                         /*

  1088                         Sample package-info.java

  1089                         @ExpectedBase

  1090                         @ExpectedContainer

  1091                         @Foo() @Foo()

  1092                         package testpkg;

  1093 

  1094                         @Retention(RetentionPolicy.RUNTIME)

  1095                         @Repeatable(FooContainer.class)

  1096                         @interface Foo {}

  1097 

  1098                         @Retention(RetentionPolicy.RUNTIME)

  1099                         @interface FooContainer {

  1100                         Foo[] value();

  1101                         }

  1102 

  1103                         Sample testSrc:

  1104                         package testpkg;

  1105                         class A {}

  1106                          */

  1107                         testSrc = srcType.getTemplate().replace("#CN", className);

  1108                         contents = testSrc;

  1109                         srcFileObj = Helper.getFile(className, contents);

  1110 

  1111                         replaceVal = expectedVals + "\n" + anno;

  1112                         pkgInfoContents = SrcType.PKGINFO.getTemplate()

  1113                                 .replace("#REPLACE1", replaceVal)

  1114                                 .replace("#REPLACE2", commonStmts);

  1115                         pkgFileObj = Helper.getFile(PKGINFONAME, pkgInfoContents);

  1116                         files = Arrays.asList(pkgFileObj, srcFileObj);

  1117                         break;

  1118                     default:

  1119                         /*

  1120                         Sample testSrc for class:

  1121                         @Retention(RetentionPolicy.RUNTIME)

  1122                         @Repeatable(FooContainer.class)

  1123                         @interface Foo {}

  1124 

  1125                         @Retention(RetentionPolicy.RUNTIME)

  1126                         @interface FooContainer {

  1127                         Foo[] value();

  1128                         }

  1129 

  1130                         @ExpectedBase

  1131                         @ExpectedContainer

  1132                         @Foo @Foo

  1133                         class A { }

  1134                          */

  1135                         replaceVal = expectedVals + anno;