jdk8-mips64-public/langtools: test/tools/javac/annotations/repeatingAnnotations/combo/TargetAnnoCombo.java@959103a6100f (annotated)

test/tools/javac/annotations/repeatingAnnotations/combo/TargetAnnoCombo.java@959103a6100f (annotated)

test/tools/javac/annotations/repeatingAnnotations/combo/TargetAnnoCombo.java

Wed, 27 Apr 2016 01:34:52 +0800

author: aoqi
date: Wed, 27 Apr 2016 01:34:52 +0800
changeset 0: 959103a6100f
child 2525: 2eb010b6cb22
permissions: -rw-r--r--

Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/langtools/
changeset: 2573:53ca196be1ae
tag: jdk8u25-b17

 /*
  * Copyright (c) 2013, 2014, 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      7151010 8006547 8007766 8029017
  * @summary  Default test cases for running combinations for Target values
  * @build    Helper
  * @run main TargetAnnoCombo
  */
 import java.util.Set;
 import java.util.List;
 import java.io.IOException;
 import java.lang.annotation.ElementType;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.EnumSet;
 import javax.tools.Diagnostic;
 import javax.tools.DiagnosticCollector;
 import javax.tools.JavaFileObject;
 import static java.lang.annotation.ElementType.ANNOTATION_TYPE;
 import static java.lang.annotation.ElementType.CONSTRUCTOR;
 import static java.lang.annotation.ElementType.FIELD;
 import static java.lang.annotation.ElementType.METHOD;
 import static java.lang.annotation.ElementType.PARAMETER;
 import static java.lang.annotation.ElementType.TYPE;
 import static java.lang.annotation.ElementType.PACKAGE;
 import static java.lang.annotation.ElementType.LOCAL_VARIABLE;
 import static java.lang.annotation.ElementType.TYPE_USE;
 import static java.lang.annotation.ElementType.TYPE_PARAMETER;
 public class TargetAnnoCombo {
     static final String TESTPKG = "testpkg";
     // Set it to true to get more debug information including base and container
     // target sets for a given test case.
     static final boolean DEBUG = false;
     // Define constant target sets to be used for the combination of the target values.
     final static Set<ElementType> noSet = null;
     final static Set<ElementType> empty = EnumSet.noneOf(ElementType.class);
     // [TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE,
     // PACKAGE, TYPE_PARAMETER, TYPE_USE]
     final static Set<ElementType> allTargets = EnumSet.allOf(ElementType.class);
     // [TYPE, FIELD, METHOD, PARAMETER, CONSTRUCTOR, LOCAL_VARIABLE, ANNOTATION_TYPE,
     // PACKAGE]
     final static Set<ElementType> jdk7 = EnumSet.range(TYPE, PACKAGE);
     // [TYPE_USE, TYPE_PARAMETER]
     final static Set<ElementType> jdk8 = EnumSet.range(TYPE_PARAMETER, TYPE_USE);
     // List of test cases to run. This list is created in generate().
     // To run a specific test cases add case number in @run main line.
     List<TestCase> testCases = new ArrayList<TestCase>();
     int errors = 0;
     // Identify test cases that fail.
     enum IgnoreKind {
         RUN,
         IGNORE
     };
     private class TestCase {
         private Set<ElementType> baseAnnotations;
         private Set<ElementType> containerAnnotations;
         private IgnoreKind ignore;
         public TestCase(Set<ElementType> baseAnnotations, Set<ElementType> containerAnnotations) {
             this(baseAnnotations, containerAnnotations, IgnoreKind.RUN);
         }
         public TestCase(Set<ElementType> baseAnnotations, Set<ElementType> containerAnnotations,
                         IgnoreKind ignoreKind) {
             this.baseAnnotations = baseAnnotations;
             this.containerAnnotations = containerAnnotations;
             this.ignore = ignoreKind;
         }
         public Set getBaseAnnotations() {
             return baseAnnotations;
         }
         public Set getContainerAnnotations() {
             return containerAnnotations;
         }
         public boolean isIgnored() {
             return ignore == IgnoreKind.IGNORE;
         }
         // Determine if a testCase should compile or not.
         private boolean isValidSubSet() {
             /*
              *  RULE 1: conAnnoTarget should be a subset of baseAnnoTarget
              *  RULE 2: For empty @Target ({}) - annotation cannot be applied anywhere
              *         - Empty sets for both is valid
              *         - Empty baseTarget set is invalid with non-empty conTarget set
              *         - Non-empty baseTarget set is valid with empty conTarget set
              *  RULE 3: For no @Target specified - annotation can be applied to any JDK 7 targets
              *         - No @Target for both is valid
              *         - No @Target for baseTarget set with @Target conTarget set is valid
              *         - @Target for baseTarget set with no @Target for conTarget is invalid
              */
             /* If baseAnno has no @Target, Foo can be either applied to @Target specified
              * for container annotation else will be applicable for all default targets
              * if no @Target is present for container annotation.
              * In both cases, the set will be a valid set with no @Target for base annotation
              */
             if (baseAnnotations == null) {
                 if (containerAnnotations == null) {
                     return true;
                 }
                 return !(containerAnnotations.contains(TYPE_USE) ||
                          containerAnnotations.contains(TYPE_PARAMETER));
             }
             Set<ElementType> tempBaseSet = EnumSet.noneOf(ElementType.class);
             tempBaseSet.addAll(baseAnnotations);
             // If BaseAnno has TYPE, then ANNOTATION_TYPE is allowed by default.
             if (baseAnnotations.contains(TYPE)) {
                 tempBaseSet.add(ANNOTATION_TYPE);
             }
             // If BaseAnno has TYPE_USE, then add the extra allowed types
             if (baseAnnotations.contains(TYPE_USE)) {
                 tempBaseSet.add(ANNOTATION_TYPE);
                 tempBaseSet.add(TYPE);
                 tempBaseSet.add(TYPE_PARAMETER);
             }
             // If containerAnno has no @Target, only valid case if baseAnnoTarget has
             // all targets defined else invalid set.
             if (containerAnnotations == null) {
                 return tempBaseSet.containsAll(jdk7);
             }
             // At this point, neither conAnnoTarget or baseAnnoTarget are null.
             if (containerAnnotations.isEmpty()) {
                 return true;
             }
             // At this point, conAnnoTarget is non-empty.
             if (baseAnnotations.isEmpty()) {
                 return false;
             }
             // At this point, neither conAnnoTarget or baseAnnoTarget are empty.
             return tempBaseSet.containsAll(containerAnnotations);
         }
     }
     public static void main(String args[]) throws Exception {
         TargetAnnoCombo tac = new TargetAnnoCombo();
         // Generates all test cases to be run.
         tac.generate();
         List<Integer> cases = new ArrayList<Integer>();
         for (int i = 0; i < args.length; i++) {
             cases.add(Integer.parseInt(args[i]));
         }
         if (cases.isEmpty()) {
             tac.run();
         } else {
             for (int index : cases) {
                 tac.executeTestCase(tac.testCases.get(index), index);
             }
         }
     }
     private void generate() {
         // Adding test cases to run.
         testCases.addAll(Arrays.asList(
                 // No base target against no container target.
                 new TestCase(noSet, noSet),
                 // No base target against empty container target.
                 new TestCase(noSet, empty),
                 // No base target against TYPE_USE only container target.
                 new TestCase(noSet, less(jdk8, TYPE_PARAMETER)),
                 // No base target against TYPE_PARAMETER only container target.
                 new TestCase(noSet, less(jdk8, TYPE_USE)),
                 // No base target against TYPE_USE + TYPE_PARAMETER only container target.
                 new TestCase(noSet, jdk8),
                 // No base target against TYPE_USE + some selection of jdk7 targets.
                 new TestCase(noSet,
                 plus(EnumSet.range(TYPE, LOCAL_VARIABLE), TYPE_USE)),
                 // No base target against TYPE_PARAMETER + some selection of jdk7 targets.
                 new TestCase(noSet,
                 plus(EnumSet.range(TYPE, LOCAL_VARIABLE), TYPE_PARAMETER)),
                 // No base target against each jdk7 target alone as container target.
                 new TestCase(noSet, plus(empty, TYPE)),
                 new TestCase(noSet, plus(empty, PARAMETER)),
                 new TestCase(noSet, plus(empty, PACKAGE)),
                 new TestCase(noSet, plus(empty, METHOD)),
                 new TestCase(noSet, plus(empty, LOCAL_VARIABLE)),
                 new TestCase(noSet, plus(empty, FIELD)),
                 new TestCase(noSet, plus(empty, CONSTRUCTOR)),
                 new TestCase(noSet, plus(empty, ANNOTATION_TYPE)),
                 // Empty base target against no container target.
                 new TestCase(empty, noSet),
                 // Empty base target against empty container target.
                 new TestCase(empty, empty),
                 // Empty base target against any lone container target.
                 new TestCase(empty, plus(empty, TYPE)),
                 new TestCase(empty, plus(empty, PARAMETER)),
                 new TestCase(empty, plus(empty, PACKAGE)),
                 new TestCase(empty, plus(empty, METHOD)),
                 new TestCase(empty, plus(empty, LOCAL_VARIABLE)),
                 new TestCase(empty, plus(empty, FIELD)),
                 new TestCase(empty, plus(empty, CONSTRUCTOR)),
                 new TestCase(empty, plus(empty, ANNOTATION_TYPE)),
                 new TestCase(empty, less(jdk8, TYPE_USE)),
                 new TestCase(empty, less(jdk8, TYPE_PARAMETER)),
                 // No container target against all all-but one jdk7 targets.
                 new TestCase(less(jdk7, TYPE), noSet),
                 new TestCase(less(jdk7, PARAMETER), noSet),
                 new TestCase(less(jdk7, PACKAGE), noSet),
                 new TestCase(less(jdk7, METHOD), noSet),
                 new TestCase(less(jdk7, LOCAL_VARIABLE), noSet),
                 new TestCase(less(jdk7, FIELD), noSet),
                 new TestCase(less(jdk7, CONSTRUCTOR), noSet),
                 new TestCase(less(jdk7, ANNOTATION_TYPE), noSet),
                 // No container against all but TYPE and ANNOTATION_TYPE
                 new TestCase(less(jdk7, TYPE, ANNOTATION_TYPE), noSet),
                 // No container against jdk7 targets.
                 new TestCase(jdk7, noSet),
                 // No container against jdk7 targets plus one or both of TYPE_USE, TYPE_PARAMETER
                 new TestCase(plus(jdk7, TYPE_USE), noSet),
                 new TestCase(plus(jdk7, TYPE_PARAMETER), noSet),
                 new TestCase(allTargets, noSet),
                 // Empty container target against any lone target.
                 new TestCase(plus(empty, TYPE), empty),
                 new TestCase(plus(empty, PARAMETER), empty),
                 new TestCase(plus(empty, PACKAGE), empty),
                 new TestCase(plus(empty, METHOD), empty),
                 new TestCase(plus(empty, LOCAL_VARIABLE), empty),
                 new TestCase(plus(empty, FIELD), empty),
                 new TestCase(plus(empty, CONSTRUCTOR), empty),
                 new TestCase(plus(empty, ANNOTATION_TYPE), empty),
                 new TestCase(plus(empty, TYPE_USE), empty),
                 new TestCase(plus(empty, TYPE_PARAMETER), empty),
                 // All base targets against all container targets.
                 new TestCase(allTargets, allTargets),
                 // All base targets against all but one container targets.
                 new TestCase(allTargets, less(allTargets, TYPE)),
                 new TestCase(allTargets, less(allTargets, PARAMETER)),
                 new TestCase(allTargets, less(allTargets, PACKAGE)),
                 new TestCase(allTargets, less(allTargets, METHOD)),
                 new TestCase(allTargets, less(allTargets, LOCAL_VARIABLE)),
                 new TestCase(allTargets, less(allTargets, FIELD)),
                 new TestCase(allTargets, less(allTargets, CONSTRUCTOR)),
                 new TestCase(allTargets, less(allTargets, ANNOTATION_TYPE)),
                 new TestCase(allTargets, less(allTargets, TYPE_USE)),
                 new TestCase(allTargets, less(allTargets, TYPE_PARAMETER)),
                 // All container targets against all but one base targets.
                 new TestCase(less(allTargets, TYPE), allTargets),
                 new TestCase(less(allTargets, PARAMETER), allTargets),
                 new TestCase(less(allTargets, PACKAGE), allTargets),
                 new TestCase(less(allTargets, METHOD), allTargets),
                 new TestCase(less(allTargets, LOCAL_VARIABLE), allTargets),
                 new TestCase(less(allTargets, FIELD), allTargets),
                 new TestCase(less(allTargets, CONSTRUCTOR), allTargets),
                 new TestCase(less(allTargets, ANNOTATION_TYPE), allTargets),
                 new TestCase(less(allTargets, TYPE_USE), allTargets),
                 new TestCase(less(allTargets, TYPE_PARAMETER), allTargets)));
         // Generates 100 test cases for any lone base target contained in Set
         // allTargets against any lone container target.
         for (ElementType b : allTargets) {
             for (ElementType c : allTargets) {
                 testCases.add(new TestCase(plus(empty, b), plus(empty, c)));
             }
         }
     }
     void run() throws Exception {
         int testCtr = 0;
         for (TestCase tc : testCases) {
             if (!tc.isIgnored()) {
                 executeTestCase(tc, testCases.indexOf(tc));
                 testCtr++;
             }
         }
         System.out.println("Total tests run: " + testCtr);
         if (errors > 0) {
             throw new Exception(errors + " errors found");
         }
     }
     private void executeTestCase(TestCase testCase, int index) {
         debugPrint("Test case number = " + index);
         debugPrint(" => baseAnnoTarget = " + testCase.getBaseAnnotations());
         debugPrint(" => containerAnnoTarget = " + testCase.getContainerAnnotations());
         String className = "TC" + index;
         boolean shouldCompile = testCase.isValidSubSet();
         Iterable<? extends JavaFileObject> files = getFileList(className, testCase, shouldCompile);
         // Get result of compiling test src file(s).
         boolean result = getCompileResult(className, shouldCompile, files);
         // List test src code if test fails.
         if (!result) {
             System.out.println("FAIL: Test " + index);
             try {
                 for (JavaFileObject f : files) {
                     System.out.println("File: " + f.getName() + "\n" + f.getCharContent(true));
                 }
             } catch (IOException ioe) {
                 System.out.println("Exception: " + ioe);
             }
         } else {
             debugPrint("PASS: Test " + index);
         }
     }
     // Create src code and corresponding JavaFileObjects.
     private Iterable<? extends JavaFileObject> getFileList(String className,
             TestCase testCase, boolean shouldCompile) {
         Set<ElementType> baseAnnoTarget = testCase.getBaseAnnotations();
         Set<ElementType> conAnnoTarget = testCase.getContainerAnnotations();
         String srcContent = "";
         String pkgInfoContent = "";
         String template = Helper.template;
         String baseTarget = "", conTarget = "";
         String target = Helper.ContentVars.TARGET.getVal();
         if (baseAnnoTarget != null) {
             String tmp = target.replace("#VAL", convertToString(baseAnnoTarget).toString());
             baseTarget = tmp.replace("[", "{").replace("]", "}");
         }
         if (conAnnoTarget != null) {
             String tmp = target.replace("#VAL", convertToString(conAnnoTarget).toString());
             conTarget = tmp.replace("[", "{").replace("]", "}");
         }
         String annoData = Helper.ContentVars.IMPORTSTMTS.getVal()
                 + conTarget
                 + Helper.ContentVars.CONTAINER.getVal()
                 + baseTarget
                 + Helper.ContentVars.REPEATABLE.getVal()
                 + Helper.ContentVars.BASE.getVal();
         JavaFileObject pkgInfoFile = null;
         // If shouldCompile = true and no @Target is specified for container annotation,
         // then all 8 ElementType enum constants are applicable as targets for
         // container annotation.
         if (shouldCompile && conAnnoTarget == null) {
             Set<ElementType> copySet = EnumSet.noneOf(ElementType.class);
             copySet.addAll(jdk7);
             conAnnoTarget = copySet;
         }
         if (shouldCompile) {
             boolean isPkgCasePresent = conAnnoTarget.contains(PACKAGE);
             String repeatableAnno = Helper.ContentVars.BASEANNO.getVal()
                     + " " + Helper.ContentVars.BASEANNO.getVal();
             for (ElementType s : conAnnoTarget) {
                 String replaceStr = "/*" + s.name() + "*/";
                 if (s.name().equalsIgnoreCase("PACKAGE")) {
                     //Create packageInfo file.
                     String pkgInfoName = TESTPKG + "." + "package-info";
                     pkgInfoContent = repeatableAnno + "\npackage " + TESTPKG + ";" + annoData;
                     pkgInfoFile = Helper.getFile(pkgInfoName, pkgInfoContent);
                 } else {
                     template = template.replace(replaceStr, repeatableAnno);
                     if (!isPkgCasePresent) {
                         srcContent = template.replace(
                                 "/*ANNODATA*/", annoData).replace("#ClassName", className);
                     } else {
                         replaceStr = "/*PACKAGE*/";
                         String tmp = template.replace(replaceStr, "package " + TESTPKG + ";");
                         srcContent = tmp.replace("#ClassName", className);
                     }
                 }
             }
         } else {
             // For invalid cases, compilation should fail at declaration site.
             template = "class #ClassName {}";
             srcContent = annoData + template.replace("#ClassName", className);
         }
         JavaFileObject srcFile = Helper.getFile(className, srcContent);
         Iterable<? extends JavaFileObject> files = null;
         if (pkgInfoFile != null) {
             files = Arrays.asList(pkgInfoFile, srcFile);
         } else {
             files = Arrays.asList(srcFile);
         }
         return files;
     }
     // Compile the test source file(s) and return test result.
     private boolean getCompileResult(String className, boolean shouldCompile,
             Iterable<? extends JavaFileObject> files) {
         DiagnosticCollector<JavaFileObject> diagnostics =
                 new DiagnosticCollector<JavaFileObject>();
         Helper.compileCode(diagnostics, files);
         // Test case pass or fail.
         boolean ok = false;
         String errMesg = "";
         int numDiags = diagnostics.getDiagnostics().size();
         if (numDiags == 0) {
             if (shouldCompile) {
                 debugPrint("Test passed, compiled as expected.");
                 ok = true;
             } else {
                 errMesg = "Test failed, compiled unexpectedly.";
                 ok = false;
             }
         } else {
             if (shouldCompile) {
                 // did not compile.
                 errMesg = "Test failed, did not compile.";
                 ok = false;
             } else {
                 // Error in compilation as expected.
                 String expectedErrKey = "compiler.err.invalid.repeatable."
                         + "annotation.incompatible.target";
                 for (Diagnostic<?> d : diagnostics.getDiagnostics()) {
                     if ((d.getKind() == Diagnostic.Kind.ERROR)
                             && d.getCode().contains(expectedErrKey)) {
                         // Error message as expected.
                         debugPrint("Error message as expected.");
                         ok = true;
                         break;
                     } else {
                         // error message is incorrect.
                         ok = false;
                     }
                 }
                 if (!ok) {
                     errMesg = "Incorrect error received when compiling "
                             + className + ", expected: " + expectedErrKey;
                 }
             }
         }
         if (!ok) {
             error(errMesg);
             for (Diagnostic<?> d : diagnostics.getDiagnostics()) {
                 System.out.println(" Diags: " + d);
             }
         }
         return ok;
     }
     private Set<ElementType> less(Set<ElementType> base, ElementType... sub) {
         Set<ElementType> res = EnumSet.noneOf(ElementType.class);
         res.addAll(base);
         for (ElementType t : sub) {
             res.remove(t);
         }
         return res;
     }
     private Set<ElementType> plus(Set<ElementType> base, ElementType... add) {
         Set<ElementType> res = EnumSet.noneOf(ElementType.class);
         res.addAll(base);
         for (ElementType t : add) {
             res.add(t);
         }
         return res;
     }
     // Iterate target set and add "ElementType." in front of every target type.
     private List<String> convertToString(Set<ElementType> annoTarget) {
         if (annoTarget == null) {
             return null;
         }
         List<String> annoTargets = new ArrayList<String>();
         for (ElementType e : annoTarget) {
             annoTargets.add("ElementType." + e.name());
         }
         return annoTargets;
     }
     private void debugPrint(String string) {
         if (DEBUG) {
             System.out.println(string);
         }
     }
     private void error(String msg) {
         System.out.println("ERROR: " + msg);
         errors++;
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/annotations/repeatingAnnotations/combo/TargetAnnoCombo.java@959103a6100f (annotated)

test/tools/javac/annotations/repeatingAnnotations/combo/TargetAnnoCombo.java