jdk8-mips64-public/langtools: test/tools/javac/processing/model/element/repeatingAnnotations/ElementRepAnnoTester.java@abd153854f16 (annotated)

test/tools/javac/processing/model/element/repeatingAnnotations/ElementRepAnnoTester.java@abd153854f16 (annotated)

test/tools/javac/processing/model/element/repeatingAnnotations/ElementRepAnnoTester.java

Fri, 03 May 2013 09:56:56 -0700

author: jjg
date: Fri, 03 May 2013 09:56:56 -0700
changeset 1721: abd153854f16
parent 1564: aeadaf905d78
child 2525: 2eb010b6cb22
permissions: -rw-r--r--

8012728: Normalize @ignore comments on langtools tests
Reviewed-by: vromero, mcimadamore

 /*
  * 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.
  */
 import java.lang.annotation.Annotation;
 import java.util.Arrays;
 import java.util.EnumSet;
 import java.util.List;
 import java.util.Set;
 import javax.annotation.processing.*;
 import javax.lang.model.element.*;
 import javax.lang.model.type.MirroredTypeException;
 import javax.lang.model.type.TypeMirror;
 import javax.lang.model.util.Elements;
 public class ElementRepAnnoTester extends JavacTestingAbstractProcessor {
     // All methods to test.
     final EnumSet<TestMethod> ALL_TEST_METHODS = EnumSet.allOf(TestMethod.class);
     int count = 0;
     int error = 0;
     public boolean process(Set<? extends TypeElement> annotations,
             RoundEnvironment roundEnv) {
         if (!roundEnv.processingOver()) {
             List<String> superClass = Arrays.asList("A", "B", "C", "D", "E",
                     "F", "G", "H", "I", "J", "K", "L", "M", "N", "O", "P");
             // Go through all test classes
             for (Element element : roundEnv.getRootElements()) {
                 // For now, no testing super classes (TODO)
                 if (element.getKind() == ElementKind.CLASS
                         && !superClass.contains(element.getSimpleName().toString())) {
                     // Compare expected and actual values from methods.
                     checkAnnoValues(element, ALL_TEST_METHODS);
                     // Now, look for enclosed elements in test classes.
                     for (Element elements : element.getEnclosedElements()) {
                         // Look for Methods annotations.
                         if (elements.getKind() == ElementKind.METHOD
                                 && elements.getSimpleName().toString().equals("testMethod")) {
                             checkAnnoValues(elements, ALL_TEST_METHODS);
                         }
                         // Look for Field annotations.
                         if (elements.getKind() == ElementKind.FIELD
                                 && elements.getSimpleName().toString().equals("testField")) {
                             checkAnnoValues(elements, ALL_TEST_METHODS);
                         }
                     }
                 }
             }
             if (error != 0) {
                 System.out.println("Total tests : " + count);
                 System.out.println("Total test failures : " + error);
                 throw new RuntimeException();
             } else {
                 System.out.println("ALL TESTS PASSED. " + count);
             }
         }
         return true;
     }
     enum TestMethod {
         getAnnotation,
         getAnnotationsByType,
         getAllAnnotationMirrors,
         getAnnotationMirrors
     }
     protected void checkAnnoValues(Element element, EnumSet<TestMethod> testMethods) {
         boolean baseAnnoPresent = false;
         boolean conAnnoPresent = false;
         ExpectedBase eb = null;
         ExpectedContainer ec = null;
         // Getting the expected values to compare with.
         eb = element.getAnnotation(ExpectedBase.class);
         ec = element.getAnnotation(ExpectedContainer.class);
         if (eb == null) {
             System.out.println("Did not find ExpectedBase Annotation in  "
                     + element.getSimpleName().toString() + ", Test will exit");
             throw new RuntimeException();
         }
         if (ec == null) {
             System.out.println("Did not find ExpectedContainer Annotation in "
                     + element.getSimpleName().toString() + " Test will exit");
             throw new RuntimeException();
         }
         // Look if all test cases have ExpectedBase and ExpectedContainer values().
         TypeMirror valueBase = null;
         TypeMirror valueCon = null;
         try {
             eb.value();
         } catch (MirroredTypeException mte) {
             valueBase = mte.getTypeMirror();
         }
         try {
             ec.value();
         } catch (MirroredTypeException mte1) {
             valueCon = mte1.getTypeMirror();
         }
         String expectedBaseAnno = valueBase.toString();
         String expectedConAnno = valueCon.toString();
         if (!expectedBaseAnno.equals("java.lang.annotation.Annotation")) {
             baseAnnoPresent = true;
         }
         if (!expectedConAnno.equalsIgnoreCase("java.lang.annotation.Annotation")) {
             conAnnoPresent = true;
         }
         // Look into TestMethod and compare method's output with expected values.
         for (TestMethod testMethod : testMethods) {
             boolean isBasePass = true;
             boolean isConPass = true;
             switch (testMethod) {
                 case getAnnotation:
                     if (baseAnnoPresent) {
                         count++;
                         Annotation actualAnno = getAnnotationBase(element);
                         String expectedAnno = eb.getAnnotation();
                         isBasePass = compareAnnotation(actualAnno, expectedAnno);
                     }
                     if (conAnnoPresent) {
                         count++;
                         Annotation actualAnno = getAnnotationContainer(element);
                         String expectedAnno = ec.getAnnotation();
                         isConPass = compareAnnotation(actualAnno, expectedAnno);
                     }
                     if (!isBasePass || !isConPass) {
                         System.out.println("FAIL in " + element.getSimpleName()
                                 + "-" + element.getKind()
                                 + " method: getAnnotation(class <T>)");
                         error++;
                     }
                     break;
                 case getAnnotationMirrors:
                     if (baseAnnoPresent) {
                         count++;
                         List<? extends AnnotationMirror> actualDeclAnnos =
                                 element.getAnnotationMirrors();
                         String[] expectedAnnos = eb.getAnnotationMirrors();
                         isBasePass = compareArrVals(actualDeclAnnos, expectedAnnos);
                     }
                     if (conAnnoPresent) {
                         isConPass = true;
                     }
                     if (!isBasePass || !isConPass) {
                         System.out.println("FAIL in " + element.getSimpleName()
                                 + "-" + element.getKind()
                                 + " method: getAnnotationMirrors()");
                         error++;
                     }
                     break;
                 case getAnnotationsByType:
                     if (baseAnnoPresent) {
                         count++;
                         Annotation[] actualAnnosArgs = getAnnotationsBase(element);
                         String[] expectedAnnos = eb.getAnnotationsByType();
                         isBasePass = compareArrVals(actualAnnosArgs, expectedAnnos);
                     }
                     if (conAnnoPresent) {
                         count++;
                         Annotation[] actualAnnosArgs = getAnnotationsContainer(element);
                         String[] expectedAnnos = ec.getAnnotationsByType();
                         isConPass = compareArrVals(actualAnnosArgs, expectedAnnos);
                     }
                     if (!isBasePass || !isConPass) {
                         System.out.println("FAIL in " + element.getSimpleName()
                                 + "-" + element.getKind()
                                 + " method: getAnnotationsByType(class <T>)");
                         error++;
                     }
                     break;
                 case getAllAnnotationMirrors:
                     if (baseAnnoPresent) {
                         count++;
                         Elements elements = processingEnv.getElementUtils();
                         List<? extends AnnotationMirror> actualAnnosMirrors =
                                 elements.getAllAnnotationMirrors(element);
                         String[] expectedAnnos = eb.getAllAnnotationMirrors();
                         isBasePass = compareArrVals(actualAnnosMirrors, expectedAnnos);
                     }
                     if (conAnnoPresent) {
                         isConPass = true;
                     }
                     if (!isBasePass || !isConPass) {
                         System.out.println("FAIL in " + element.getSimpleName()
                                 + "-" + element.getKind()
                                 + " method: getAllAnnotationMirrors(e)");
                         error++;
                     }
                     break;
             }
         }
     }
     // Sort tests to be run with different anno processors.
     final List<String> singularAnno = Arrays.asList(
             "SingularBasicTest"
             );
     final List<String> singularInheritedAnno = Arrays.asList(
             "SingularInheritedATest"
             );
     final List<String> repeatableAnno = Arrays.asList(
             "RepeatableBasicTest",
             "MixRepeatableAndOfficialContainerBasicTest",
             "OfficialContainerBasicTest",
             "RepeatableOfficialContainerBasicTest"
             );
     final List<String> repeatableInheritedAnno = Arrays.asList(
             "RepeatableInheritedTest",
             "RepeatableOverrideATest",
             "RepeatableOverrideBTest",
             "OfficialContainerInheritedTest",
             "MixRepeatableAndOfficialContainerInheritedA1Test",
             "MixRepeatableAndOfficialContainerInheritedB1Test",
             "MixRepeatableAndOfficialContainerInheritedA2Test",
             "MixRepeatableAndOfficialContainerInheritedB2Test"
             );
     final List<String> repeatableContainerInheritedAnno = Arrays.asList(
             "RepeatableOfficialContainerInheritedTest"
             );
     final List<String> unofficialAnno = Arrays.asList(
             "UnofficialContainerBasicTest",
             "MixSingularAndUnofficialContainerBasicTest"
             );
     final List<String> unofficialInheritedAnno = Arrays.asList(
             "UnofficialContainerInheritedTest",
             "SingularInheritedBTest",
             "MixSingularAndUnofficialContainerInheritedA1Test",
             "MixSingularAndUnofficialContainerInheritedB1Test",
             "MixSingularAndUnofficialContainerInheritedA2Test",
             "MixSingularAndUnofficialContainerInheritedB2Test"
             );
     // Respective container annotation for the different test cases to test.
     final List<String> repeatableAnnoContainer = repeatableAnno;
     final List<String> repeatableInheritedAnnoContainer = repeatableInheritedAnno;
     final List<String> repeatableContainerInheritedAnnoContainer =
             repeatableContainerInheritedAnno;
     final List<String> unofficialAnnoContainer = unofficialAnno;
     final List<String> unofficialInheritedAnnoContainer = unofficialInheritedAnno;
     // Variables to verify if all test cases have been run.
     private Annotation specialAnno = new Annotation() {
        @Override
         public Class annotationType() {
             return null;
         }
     };
     private Annotation[] specialAnnoArray = new Annotation[1];
     private List<AnnotationMirror> specialAnnoMirrors =
             new java.util.ArrayList<AnnotationMirror>(2);
     private Annotation getAnnotationBase(Element e) {
         Annotation actualAnno = specialAnno;
         if (singularAnno.contains(
                 e.getEnclosingElement().toString())
                 || singularAnno.contains(
                 e.getSimpleName().toString())
                 || unofficialAnno.contains(
                 e.getEnclosingElement().toString())
                 || unofficialAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(Foo.class);
         }
         if (singularInheritedAnno.contains(
                 e.getEnclosingElement().toString())
                 || singularInheritedAnno.contains(
                 e.getSimpleName().toString())
                 || unofficialInheritedAnno.contains(
                 e.getEnclosingElement().toString())
                 || unofficialInheritedAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(FooInherited.class);
         }
         if (repeatableAnno.contains(
                 e.getEnclosingElement().toString())
                 || repeatableAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(Bar.class);
         }
         if (repeatableInheritedAnno.contains(
                 e.getEnclosingElement().toString())
                 || repeatableInheritedAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(BarInherited.class);
         }
         if (repeatableContainerInheritedAnno.contains(
                 e.getEnclosingElement().toString())
                 || repeatableContainerInheritedAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(BarInheritedContainer.class);
         }
         return actualAnno;
     }
     private Annotation getAnnotationContainer(Element e) {
         Annotation actualAnno = specialAnno;
         if (repeatableAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || repeatableAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(BarContainer.class);
         }
         if (repeatableInheritedAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || repeatableInheritedAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(BarInheritedContainer.class);
         }
         if (repeatableContainerInheritedAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || repeatableContainerInheritedAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(BarInheritedContainerContainer.class);
         }
         if (unofficialAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || unofficialAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(UnofficialContainer.class);
         }
         if (unofficialInheritedAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || unofficialInheritedAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnno = e.getAnnotation(UnofficialInheritedContainer.class);
         }
         return actualAnno;
     }
     private Annotation[] getAnnotationsBase(Element e) {
         Annotation[] actualAnnosArgs = specialAnnoArray;
         if (singularAnno.contains(
                 e.getEnclosingElement().toString())
                 || singularAnno.contains(
                 e.getSimpleName().toString())
                 || unofficialAnno.contains(
                 e.getEnclosingElement().toString())
                 || unofficialAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(Foo.class);
         }
         if (singularInheritedAnno.contains(
                 e.getEnclosingElement().toString())
                 || singularInheritedAnno.contains(
                 e.getSimpleName().toString())
                 || unofficialInheritedAnno.contains(
                 e.getEnclosingElement().toString())
                 || unofficialInheritedAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(FooInherited.class);
         }
         if (repeatableAnno.contains(
                 e.getEnclosingElement().toString())
                 || repeatableAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(Bar.class);
         }
         if (repeatableInheritedAnno.contains(
                 e.getEnclosingElement().toString())
                 || repeatableInheritedAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(BarInherited.class);
         }
         if (repeatableContainerInheritedAnno.contains(
                 e.getEnclosingElement().toString())
                 || repeatableContainerInheritedAnno.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(BarInheritedContainer.class);
         }
         return actualAnnosArgs;
     }
     private Annotation[] getAnnotationsContainer(Element e) {
         Annotation[] actualAnnosArgs = specialAnnoArray;
         if (repeatableAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || repeatableAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(BarContainer.class);
         }
         if (repeatableInheritedAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || repeatableInheritedAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(BarInheritedContainer.class);
         }
         if (repeatableContainerInheritedAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || repeatableContainerInheritedAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(BarInheritedContainerContainer.class);
         }
         if (unofficialAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || unofficialAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(UnofficialContainer.class);
         }
         if (unofficialInheritedAnnoContainer.contains(
                 e.getEnclosingElement().toString())
                 || unofficialInheritedAnnoContainer.contains(
                 e.getSimpleName().toString())) {
             actualAnnosArgs = e.getAnnotationsByType(UnofficialInheritedContainer.class);
         }
         return actualAnnosArgs;
     }
     // Array comparison: Length should be same and all expected values
     // should be present in actualAnnos[].
     private boolean compareArrVals(Annotation[] actualAnnos, String[] expectedAnnos) {
         // Look if test case was run.
         if (actualAnnos == specialAnnoArray) {
             return false; // no testcase matches
         }
         if (actualAnnos.length != expectedAnnos.length) {
             System.out.println("Length not same. "
                     + " actualAnnos length = " + actualAnnos.length
                     + " expectedAnnos length = " + expectedAnnos.length);
             printArrContents(actualAnnos);
             printArrContents(expectedAnnos);
             return false;
         } else {
             int i = 0;
             String[] actualArr = new String[actualAnnos.length];
             for (Annotation a : actualAnnos) {
                 actualArr[i++] = a.toString();
             }
             List<String> actualList = Arrays.asList(actualArr);
             List<String> expectedList = Arrays.asList(expectedAnnos);
             if (!actualList.containsAll(expectedList)) {
                 System.out.println("Array values are not same");
                 printArrContents(actualAnnos);
                 printArrContents(expectedAnnos);
                 return false;
             }
         }
         return true;
     }
     // Array comparison: Length should be same and all expected values
     // should be present in actualAnnos List<?>.
     private boolean compareArrVals(List<? extends AnnotationMirror> actualAnnos,
             String[] expectedAnnos) {
         // Look if test case was run.
         if (actualAnnos == specialAnnoMirrors) {
             return false; //no testcase run
         }
         if (actualAnnos.size() != expectedAnnos.length) {
             System.out.println("Length not same. "
                     + " actualAnnos length = " + actualAnnos.size()
                     + " expectedAnnos length = " + expectedAnnos.length);
             printArrContents(actualAnnos);
             printArrContents(expectedAnnos);
             return false;
         } else {
             int i = 0;
             String[] actualArr = new String[actualAnnos.size()];
             String annoTypeName = "";
             for (AnnotationMirror annotationMirror : actualAnnos) {
                 if (annotationMirror.getAnnotationType().toString().contains("Expected")) {
                     annoTypeName = annotationMirror.getAnnotationType().toString();
                 } else {
                      annoTypeName = annotationMirror.toString();
                 }
                 actualArr[i++] = annoTypeName;
             }
             List<String> actualList = Arrays.asList(actualArr);
             List<String> expectedList = Arrays.asList(expectedAnnos);
             if (!actualList.containsAll(expectedList)) {
                 System.out.println("Array values are not same");
                 printArrContents(actualAnnos);
                 printArrContents(expectedAnnos);
                 return false;
             }
         }
         return true;
     }
     private void printArrContents(Annotation[] actualAnnos) {
         for (Annotation a : actualAnnos) {
             System.out.println("actualAnnos values = " + a);
         }
     }
     private void printArrContents(String[] expectedAnnos) {
         for (String s : expectedAnnos) {
             System.out.println("expectedAnnos values =  " + s);
         }
     }
     private void printArrContents(List<? extends AnnotationMirror> actualAnnos) {
         for (AnnotationMirror annotationMirror : actualAnnos) {
             System.out.println("actualAnnos values = " + annotationMirror);
         }
     }
     private boolean compareAnnotation(Annotation actualAnno, String expectedAnno) {
         //String actualAnnoName = "";
         boolean isSame = true;
         // Look if test case was run.
         if (actualAnno == specialAnno) {
             return false; //no testcase run
         }
         if (actualAnno != null) {
             if (!actualAnno.toString().equalsIgnoreCase(expectedAnno)) {
                 System.out.println("Anno did not match. "
                         + " expectedAnno = " + expectedAnno
                         + " actualAnno = " + actualAnno);
                 isSame = false;
             } else {
                 isSame = true;
             }
         } else {
             if (expectedAnno.compareToIgnoreCase("null") == 0) {
                 isSame = true;
             } else {
                 System.out.println("Actual anno is null");
                 isSame = false;
             }
         }
         return isSame;
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/processing/model/element/repeatingAnnotations/ElementRepAnnoTester.java@abd153854f16 (annotated)

test/tools/javac/processing/model/element/repeatingAnnotations/ElementRepAnnoTester.java