jdk8-mips64-public/langtools: comparison test/tools/javac/processing/model/element/TestTypeParameterAnnotations.java

-:829f01e7f732
+:a3ad6e2ede44
 /*
-* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
+* 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.
 * questions.
 */
 /*
 * @test
-* @bug 8011027
+* @bug 8011027 8046916
 * @library /tools/javac/lib
 * @build JavacTestingAbstractProcessor TestTypeParameterAnnotations
 * @compile -processor TestTypeParameterAnnotations -proc:only TestTypeParameterAnnotations.java
 */
 import java.util.*;
 import java.lang.annotation.*;
 import javax.annotation.processing.*;
 import javax.lang.model.element.*;
-import javax.lang.model.util.*;
 import javax.tools.*;
-public class TestTypeParameterAnnotations<@Foo @Bar @Baz T> extends JavacTestingAbstractProcessor {
+@ExpectedTypeParameterAnnotations(typeParameterName="T1",
+annotations={"Foo1", "Bar1", "Baz1"})
+@ExpectedTypeParameterAnnotations(typeParameterName="T2", annotations={})
+@ExpectedTypeParameterAnnotations(typeParameterName="T3",
+annotations={"Foo2", "Bar2", "Baz2"})
+@ExpectedTypeParameterAnnotations(typeParameterName="T4", annotations={})
+public class TestTypeParameterAnnotations<@Foo1 @Bar1 @Baz1 T1, T2, @Foo2 @Bar2 @Baz2 T3, T4> extends
+JavacTestingAbstractProcessor {
 int round = 0;
 public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
 if (++round == 1) {
 int found = (new Scanner()).scan(roundEnv.getRootElements(), null);
 }
 int check(Element e, List<? extends TypeParameterElement> typarams) {
 if (typarams.isEmpty())
 return 0;
-if (typarams.size() != 1)
-return 0;
+for (TypeParameterElement tpe : typarams) {
+ExpectedTypeParameterAnnotations expected = null;
-for (TypeParameterElement tpe: typarams) {
+for (ExpectedTypeParameterAnnotations a : e.getAnnotationsByType(ExpectedTypeParameterAnnotations.class)) {
-boolean b1 = checkAnnotationMirrors(tpe, tpe.getAnnotationMirrors());
+if (tpe.getSimpleName().contentEquals(a.typeParameterName())) {
-boolean b2 = checkAnnotationMirrors(tpe, elements.getAllAnnotationMirrors(tpe));
+expected = a;
-boolean b3 = checkGetAnnotation(tpe);
+break;
-boolean b4 = checkGetAnnotations(tpe);
+}
-return b1 && b2 && b3 && b4 ? 1 : 0;
+}
-}
+if (expected == null) {
-return 0;
+throw new IllegalStateException("Does not have expected values annotation.");
 }
+checkAnnotationMirrors(tpe, tpe.getAnnotationMirrors(), expected);
-boolean checkAnnotationMirrors(TypeParameterElement tpe, List<? extends AnnotationMirror> l) {
+checkAnnotationMirrors(tpe, elements.getAllAnnotationMirrors(tpe), expected);
-if (l.size() != 3) {
+checkGetAnnotation(tpe, expected);
-error("To few annotations, got " + l.size() +
+checkGetAnnotations(tpe, expected);
-", should be 3", tpe);
+}
-return false;
-}
+return typarams.size();
+}
-AnnotationMirror m = l.get(0);
-if (!m.getAnnotationType().asElement().equals(elements.getTypeElement("Foo"))) {
+void checkAnnotationMirrors(TypeParameterElement tpe, List<? extends AnnotationMirror> l, ExpectedTypeParameterAnnotations expected) {
-error("Wrong type of annotation, was expecting @Foo", m.getAnnotationType().asElement());
+String[] expectedAnnotations = expected.annotations();
-return false;
-}
+if (l.size() != expectedAnnotations.length) {
-m = l.get(1);
+error("Incorrect number of annotations, got " + l.size() +
-if (!m.getAnnotationType().asElement().equals(elements.getTypeElement("Bar"))) {
+", should be " + expectedAnnotations.length, tpe);
-error("Wrong type of annotation, was expecting @Bar", m.getAnnotationType().asElement());
+return ;
-return false;
+}
-}
-m = l.get(2);
+for (int i = 0; i < expectedAnnotations.length; i++) {
-if (!m.getAnnotationType().asElement().equals(elements.getTypeElement("Baz"))) {
+AnnotationMirror m = l.get(i);
-error("Wrong type of annotation, was expecting @Baz", m.getAnnotationType().asElement());
+if (!m.getAnnotationType().asElement().equals(elements.getTypeElement(expectedAnnotations[i]))) {
-return false;
+error("Wrong type of annotation, was expecting @Foo", m.getAnnotationType().asElement());
-}
+return ;
-return true;
+}
 }
+}
-boolean checkGetAnnotation(TypeParameterElement tpe) {
-Foo f = tpe.getAnnotation(Foo.class);
+void checkGetAnnotation(TypeParameterElement tpe, ExpectedTypeParameterAnnotations expected) {
-if (f == null)
+List<String> expectedAnnotations = Arrays.asList(expected.annotations());
-error("Expecting @Foo to be present in getAnnotation()", tpe);
+for (Class<? extends Annotation> c : ALL_ANNOTATIONS) {
-Bar b = tpe.getAnnotation(Bar.class);
+Object a = tpe.getAnnotation(c);
-if (b == null)
-error("Expecting @Bar to be present in getAnnotation()", tpe);
+if (a != null ^ expectedAnnotations.indexOf(c.getName()) != (-1)) {
+error("Unexpected behavior for " + c.getName(), tpe);
-Baz z = tpe.getAnnotation(Baz.class);
+return ;
-if (z == null)
+}
-error("Expecting @Baz to be present in getAnnotation()", tpe);
+}
+}
-return f != null &&
-b != null &&
+void checkGetAnnotations(TypeParameterElement tpe, ExpectedTypeParameterAnnotations expected) {
-z != null;
+List<String> expectedAnnotations = Arrays.asList(expected.annotations());
-}
+for (Class<? extends Annotation> c : ALL_ANNOTATIONS) {
-boolean checkGetAnnotations(TypeParameterElement tpe) {
+Object[] a = tpe.getAnnotationsByType(c);
-Foo[] f = tpe.getAnnotationsByType(Foo.class);
-if (f.length != 1) {
+if (a.length > 0 ^ expectedAnnotations.indexOf(c.getName()) != (-1)) {
-error("Expecting 1 @Foo to be present in getAnnotationsByType()", tpe);
+error("Unexpected behavior for " + c.getName(), tpe);
-return false;
+return ;
 }
+}
-Bar[] b = tpe.getAnnotationsByType(Bar.class);
-if (b.length != 1) {
-error("Expecting 1 @Bar to be present in getAnnotationsByType()", tpe);
-return false;
-}
-Baz[] z = tpe.getAnnotationsByType(Baz.class);
-if (z.length != 1) {
-error("Expecting 1 @Baz to be present in getAnnotationsByType()", tpe);
-return false;
-}
-return true;
 }
 void note(String msg) {
 messager.printMessage(Diagnostic.Kind.NOTE, msg);
 }
 void error(String msg) {
 messager.printMessage(Diagnostic.Kind.ERROR, msg);
 }
+Class<? extends Annotation>[] ALL_ANNOTATIONS = new Class[] {
+Foo1.class, Bar1.class, Baz1.class,
+Foo2.class, Bar2.class, Baz2.class,
+};
 // additional generic elements to test
-<@Foo @Bar @Baz X> X m(X x) { return x; }
+@ExpectedTypeParameterAnnotations(typeParameterName="W",
+annotations={"Foo1", "Bar1", "Baz1"})
-interface Intf<@Foo @Bar @Baz X> { X m() ; }
+@ExpectedTypeParameterAnnotations(typeParameterName="X", annotations={})
+@ExpectedTypeParameterAnnotations(typeParameterName="Y",
-class Class<@Foo @Bar @Baz X> {
+annotations={"Foo2", "Bar2", "Baz2"})
-<@Foo @Bar @Baz Y> Class() { }
+@ExpectedTypeParameterAnnotations(typeParameterName="Z", annotations={})
-}
+<@Foo1 @Bar1 @Baz1 W, X, @Foo2 @Bar2 @Baz2 Y, Z> X m(X x) { return x; }
-final int expect = 5;  // top level class, plus preceding examples
+@ExpectedTypeParameterAnnotations(typeParameterName="W",
+annotations={"Foo1", "Bar1", "Baz1"})
+@ExpectedTypeParameterAnnotations(typeParameterName="X", annotations={})
+@ExpectedTypeParameterAnnotations(typeParameterName="Y",
+annotations={"Foo2", "Bar2", "Baz2"})
+@ExpectedTypeParameterAnnotations(typeParameterName="Z", annotations={})
+interface Intf<@Foo1 @Bar1 @Baz1 W, X, @Foo2 @Bar2 @Baz2 Y, Z> { X m() ; }
+@ExpectedTypeParameterAnnotations(typeParameterName="W",
+annotations={"Foo1", "Bar1", "Baz1"})
+@ExpectedTypeParameterAnnotations(typeParameterName="X", annotations={})
+@ExpectedTypeParameterAnnotations(typeParameterName="Y",
+annotations={"Foo2", "Bar2", "Baz2"})
+@ExpectedTypeParameterAnnotations(typeParameterName="Z", annotations={})
+class Clazz<@Foo1 @Bar1 @Baz1 W, X, @Foo2 @Bar2 @Baz2 Y, Z> {
+@ExpectedTypeParameterAnnotations(typeParameterName="W",
+annotations={"Foo1", "Bar1", "Baz1"})
+@ExpectedTypeParameterAnnotations(typeParameterName="X", annotations={})
+@ExpectedTypeParameterAnnotations(typeParameterName="Y",
+annotations={"Foo2", "Bar2", "Baz2"})
+@ExpectedTypeParameterAnnotations(typeParameterName="Z", annotations={})
+<@Foo1 @Bar1 @Baz1 W, X, @Foo2 @Bar2 @Baz2 Y, Z> Clazz() { }
+}
+final int expect = 5 * 4;  // top level class, plus preceding examples, 4 type variables each
 }
 @Target(ElementType.TYPE_PARAMETER)
-@interface Foo {}
+@interface Foo1 {}
 @Target(ElementType.TYPE_PARAMETER)
-@interface Bar {}
+@interface Bar1 {}
 @Target(ElementType.TYPE_PARAMETER)
-@interface Baz {}
+@interface Baz1 {}
+@Target(ElementType.TYPE_PARAMETER)
+@interface Foo2 {}
+@Target(ElementType.TYPE_PARAMETER)
+@interface Bar2 {}
+@Target(ElementType.TYPE_PARAMETER)
+@interface Baz2 {}
+@Repeatable(ExpectedTypeParameterAnnotationsCollection.class)
+@interface ExpectedTypeParameterAnnotations {
+public String typeParameterName();
+public String[] annotations();
+}
+@interface ExpectedTypeParameterAnnotationsCollection {
+public ExpectedTypeParameterAnnotations[] value();
+}

Mercurial > jdk8-mips64-public > langtools / file comparison

comparison: test/tools/javac/processing/model/element/TestTypeParameterAnnotations.java

test/tools/javac/processing/model/element/TestTypeParameterAnnotations.java