| /* | |
| * 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; | |
| } | |
| } |