1 /*
   2  * Copyright (c) 2013, 2015, 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 8004698 8007073 8022343 8054304 8057804 8058595
  27  * @summary Unit test for type annotations
  28  */
  29 
  30 import java.util.*;
  31 import java.lang.annotation.*;
  32 import java.lang.reflect.*;
  33 import java.io.Serializable;
  34 
  35 public class TypeAnnotationReflection {
  36     public static void main(String[] args) throws Exception {
  37         testSuper();
  38         testInterfaces();
  39         testReturnType();
  40         testNested();
  41         testArray();
  42         testRunException();
  43         testClassTypeVarBounds();
  44         testMethodTypeVarBounds();
  45         testFields();
  46         testClassTypeVar();
  47         testMethodTypeVar();
  48         testParameterizedType();
  49         testNestedParameterizedType();
  50         testWildcardType();
  51         testParameterTypes();
  52         testParameterType();
  53     }
  54 
  55     private static void check(boolean b) {
  56         if (!b)
  57             throw new RuntimeException();
  58     }
  59 
  60     private static void testSuper() throws Exception {
  61         check(Object.class.getAnnotatedSuperclass() == null);
  62         check(Class.class.getAnnotatedSuperclass().getAnnotations().length == 0);
  63 
  64         AnnotatedType a;
  65         a = TestClassArray.class.getAnnotatedSuperclass();
  66         Annotation[] annos = a.getAnnotations();
  67         check(annos.length == 2);
  68         check(annos[0].annotationType().equals(TypeAnno.class));
  69         check(annos[1].annotationType().equals(TypeAnno2.class));
  70         check(((TypeAnno)annos[0]).value().equals("extends"));
  71         check(((TypeAnno2)annos[1]).value().equals("extends2"));
  72     }
  73 
  74     private static void testInterfaces() throws Exception {
  75         AnnotatedType[] as;
  76         as = TestClassArray.class.getAnnotatedInterfaces();
  77         check(as.length == 3);
  78         check(as[1].getAnnotations().length == 0);
  79 
  80         Annotation[] annos;
  81         annos = as[0].getAnnotations();
  82         check(annos.length == 2);
  83         check(annos[0].annotationType().equals(TypeAnno.class));
  84         check(annos[1].annotationType().equals(TypeAnno2.class));
  85         check(((TypeAnno)annos[0]).value().equals("implements serializable"));
  86         check(((TypeAnno2)annos[1]).value().equals("implements2 serializable"));
  87 
  88         annos = as[2].getAnnotations();
  89         check(annos.length == 2);
  90         check(annos[0].annotationType().equals(TypeAnno.class));
  91         check(annos[1].annotationType().equals(TypeAnno2.class));
  92         check(((TypeAnno)annos[0]).value().equals("implements cloneable"));
  93         check(((TypeAnno2)annos[1]).value().equals("implements2 cloneable"));
  94     }
  95 
  96     private static void testReturnType() throws Exception {
  97         Method m = TestClassArray.class.getDeclaredMethod("foo", (Class<?>[])null);
  98         Annotation[] annos = m.getAnnotatedReturnType().getAnnotations();
  99         check(annos.length == 1);
 100         check(annos[0].annotationType().equals(TypeAnno.class));
 101         check(((TypeAnno)annos[0]).value().equals("return1"));
 102     }
 103 
 104     private static void testNested() throws Exception {
 105         Method m = TestClassNested.class.getDeclaredMethod("foo", (Class<?>[])null);
 106         Annotation[] annos = m.getAnnotatedReturnType().getAnnotations();
 107         check(annos.length == 1);
 108         check(annos[0].annotationType().equals(TypeAnno.class));
 109         check(((TypeAnno)annos[0]).value().equals("array"));
 110 
 111         AnnotatedType t = m.getAnnotatedReturnType();
 112         t = ((AnnotatedArrayType)t).getAnnotatedGenericComponentType();
 113         annos = t.getAnnotations();
 114         check(annos.length == 1);
 115         check(annos[0].annotationType().equals(TypeAnno.class));
 116         check(((TypeAnno)annos[0]).value().equals("Inner"));
 117     }
 118 
 119     private static void testArray() throws Exception {
 120         Method m = TestClassArray.class.getDeclaredMethod("foo", (Class<?>[])null);
 121         AnnotatedArrayType t = (AnnotatedArrayType) m.getAnnotatedReturnType();
 122         Annotation[] annos = t.getAnnotations();
 123         check(annos.length == 1);
 124         check(annos[0].annotationType().equals(TypeAnno.class));
 125         check(((TypeAnno)annos[0]).value().equals("return1"));
 126 
 127         t = (AnnotatedArrayType)t.getAnnotatedGenericComponentType();
 128         annos = t.getAnnotations();
 129         check(annos.length == 0);
 130 
 131         t = (AnnotatedArrayType)t.getAnnotatedGenericComponentType();
 132         annos = t.getAnnotations();
 133         check(annos.length == 1);
 134         check(annos[0].annotationType().equals(TypeAnno.class));
 135         check(((TypeAnno)annos[0]).value().equals("return3"));
 136 
 137         AnnotatedType tt = t.getAnnotatedGenericComponentType();
 138         check(!(tt instanceof AnnotatedArrayType));
 139         annos = tt.getAnnotations();
 140         check(annos.length == 1);
 141         check(annos[0].annotationType().equals(TypeAnno.class));
 142         check(((TypeAnno)annos[0]).value().equals("return4"));
 143     }
 144 
 145     private static void testRunException() throws Exception {
 146         Method m = TestClassException.class.getDeclaredMethod("foo", (Class<?>[])null);
 147         AnnotatedType[] ts = m.getAnnotatedExceptionTypes();
 148         check(ts.length == 3);
 149 
 150         AnnotatedType t;
 151         Annotation[] annos;
 152         t = ts[0];
 153         annos = t.getAnnotations();
 154         check(annos.length == 2);
 155         check(annos[0].annotationType().equals(TypeAnno.class));
 156         check(annos[1].annotationType().equals(TypeAnno2.class));
 157         check(((TypeAnno)annos[0]).value().equals("RE"));
 158         check(((TypeAnno2)annos[1]).value().equals("RE2"));
 159 
 160         t = ts[1];
 161         annos = t.getAnnotations();
 162         check(annos.length == 0);
 163 
 164         t = ts[2];
 165         annos = t.getAnnotations();
 166         check(annos.length == 1);
 167         check(annos[0].annotationType().equals(TypeAnno.class));
 168         check(((TypeAnno)annos[0]).value().equals("AIOOBE"));
 169     }
 170 
 171     private static void testClassTypeVarBounds() throws Exception {
 172         Method m = TestClassTypeVarAndField.class.getDeclaredMethod("foo", (Class<?>[])null);
 173         AnnotatedType ret = m.getAnnotatedReturnType();
 174         Annotation[] annos = ret.getAnnotations();
 175         check(annos.length == 2);
 176 
 177         AnnotatedType[] annotatedBounds = ((AnnotatedTypeVariable)ret).getAnnotatedBounds();
 178         check(annotatedBounds.length == 2);
 179 
 180         annos = annotatedBounds[0].getAnnotations();
 181         check(annos.length == 1);
 182         check(annos[0].annotationType().equals(TypeAnno.class));
 183         check(((TypeAnno)annos[0]).value().equals("Object1"));
 184 
 185         annos = annotatedBounds[1].getAnnotations();
 186         check(annos.length == 2);
 187         check(annos[0].annotationType().equals(TypeAnno.class));
 188         check(annos[1].annotationType().equals(TypeAnno2.class));
 189         check(((TypeAnno)annos[0]).value().equals("Runnable1"));
 190         check(((TypeAnno2)annos[1]).value().equals("Runnable2"));
 191     }
 192 
 193     private static void testMethodTypeVarBounds() throws Exception {
 194         Method m2 = TestClassTypeVarAndField.class.getDeclaredMethod("foo2", (Class<?>[])null);
 195         AnnotatedType ret2 = m2.getAnnotatedReturnType();
 196         AnnotatedType[] annotatedBounds2 = ((AnnotatedTypeVariable)ret2).getAnnotatedBounds();
 197         check(annotatedBounds2.length == 1);
 198 
 199         Annotation[] annos = annotatedBounds2[0].getAnnotations();
 200         check(annos.length == 1);
 201         check(annos[0].annotationType().equals(TypeAnno.class));
 202         check(((TypeAnno)annos[0]).value().equals("M Runnable"));
 203 
 204         // Check that AnnotatedTypeVariable.getAnnotatedBounds() returns jlO for a naked
 205         // type variable (i.e no bounds, no annotations)
 206         Method m4 = TestClassTypeVarAndField.class.getDeclaredMethod("foo4", (Class<?>[])null);
 207         AnnotatedType ret4 = m4.getAnnotatedReturnType();
 208         AnnotatedType[] annotatedBounds4 = ((AnnotatedTypeVariable)ret4).getAnnotatedBounds();
 209         check(annotatedBounds4.length == 1);
 210 
 211         annos = annotatedBounds4[0].getAnnotations();
 212         check(annos.length == 0);
 213         check(annotatedBounds4[0].getType().equals(Object.class));
 214     }
 215 
 216     private static void testFields() throws Exception {
 217         Field f1 = TestClassTypeVarAndField.class.getDeclaredField("field1");
 218         AnnotatedType at;
 219         Annotation[] annos;
 220 
 221         at = f1.getAnnotatedType();
 222         annos = at.getAnnotations();
 223         check(annos.length == 2);
 224         check(annos[0].annotationType().equals(TypeAnno.class));
 225         check(annos[1].annotationType().equals(TypeAnno2.class));
 226         check(((TypeAnno)annos[0]).value().equals("T1 field"));
 227         check(((TypeAnno2)annos[1]).value().equals("T2 field"));
 228 
 229         Field f2 = TestClassTypeVarAndField.class.getDeclaredField("field2");
 230         at = f2.getAnnotatedType();
 231         annos = at.getAnnotations();
 232         check(annos.length == 0);
 233 
 234         Field f3 = TestClassTypeVarAndField.class.getDeclaredField("field3");
 235         at = f3.getAnnotatedType();
 236         annos = at.getAnnotations();
 237         check(annos.length == 1);
 238         check(annos[0].annotationType().equals(TypeAnno.class));
 239         check(((TypeAnno)annos[0]).value().equals("Object field"));
 240     }
 241 
 242     private static void testClassTypeVar() throws Exception {
 243         TypeVariable[] typeVars = TestClassTypeVarAndField.class.getTypeParameters();
 244         Annotation[] annos;
 245         check(typeVars.length == 3);
 246 
 247         // First TypeVar
 248         AnnotatedType[] annotatedBounds = typeVars[0].getAnnotatedBounds();
 249         check(annotatedBounds.length == 2);
 250 
 251         annos = annotatedBounds[0].getAnnotations();
 252         check(annos.length == 1);
 253         check(annos[0].annotationType().equals(TypeAnno.class));
 254         check(((TypeAnno)annos[0]).value().equals("Object1"));
 255 
 256         annos = annotatedBounds[1].getAnnotations();
 257         check(annos.length == 2);
 258         check(annos[0].annotationType().equals(TypeAnno.class));
 259         check(annos[1].annotationType().equals(TypeAnno2.class));
 260         check(((TypeAnno)annos[0]).value().equals("Runnable1"));
 261         check(((TypeAnno2)annos[1]).value().equals("Runnable2"));
 262 
 263         // second TypeVar regular anno
 264         Annotation[] regularAnnos = typeVars[1].getAnnotations();
 265         check(regularAnnos.length == 1);
 266         check(typeVars[1].getAnnotation(TypeAnno.class).value().equals("EE"));
 267 
 268         // second TypeVar
 269         annotatedBounds = typeVars[1].getAnnotatedBounds();
 270         check(annotatedBounds.length == 1);
 271 
 272         annos = annotatedBounds[0].getAnnotations();
 273         check(annos.length == 1);
 274         check(annos[0].annotationType().equals(TypeAnno2.class));
 275         check(((TypeAnno2)annos[0]).value().equals("EEBound"));
 276 
 277         // third Typevar V declared without explicit bounds should see jlO as its bound.
 278         annotatedBounds = typeVars[2].getAnnotatedBounds();
 279         check(annotatedBounds.length == 1);
 280 
 281         annos = annotatedBounds[0].getAnnotations();
 282         check(annos.length == 0);
 283         check(annotatedBounds[0].getType().equals(Object.class));
 284     }
 285 
 286     private static void testMethodTypeVar() throws Exception {
 287         Method m2 = TestClassTypeVarAndField.class.getDeclaredMethod("foo2", (Class<?>[])null);
 288         TypeVariable[] t = m2.getTypeParameters();
 289         check(t.length == 1);
 290         Annotation[] annos = t[0].getAnnotations();
 291         check(annos.length == 0);
 292 
 293         AnnotatedType[] annotatedBounds2 = t[0].getAnnotatedBounds();
 294         check(annotatedBounds2.length == 1);
 295 
 296         annos = annotatedBounds2[0].getAnnotations();
 297         check(annos.length == 1);
 298         check(annos[0].annotationType().equals(TypeAnno.class));
 299         check(((TypeAnno)annos[0]).value().equals("M Runnable"));
 300 
 301         // Second method
 302         m2 = TestClassTypeVarAndField.class.getDeclaredMethod("foo3", (Class<?>[])null);
 303         t = m2.getTypeParameters();
 304         check(t.length == 2);
 305         annos = t[0].getAnnotations();
 306         check(annos.length == 1);
 307         check(annos[0].annotationType().equals(TypeAnno.class));
 308         check(((TypeAnno)annos[0]).value().equals("K"));
 309 
 310         annotatedBounds2 = t[0].getAnnotatedBounds();
 311         check(annotatedBounds2.length == 1);
 312 
 313         annos = annotatedBounds2[0].getAnnotations();
 314         check(annos.length == 0);
 315 
 316         // for the naked type variable L of foo3, we should see jlO as its bound.
 317         annotatedBounds2 = t[1].getAnnotatedBounds();
 318         check(annotatedBounds2.length == 1);
 319         check(annotatedBounds2[0].getType().equals(Object.class));
 320 
 321         annos = annotatedBounds2[0].getAnnotations();
 322         check(annos.length == 0);
 323     }
 324 
 325     private static void testParameterizedType() {
 326         // Base
 327         AnnotatedType[] as;
 328         as = TestParameterizedType.class.getAnnotatedInterfaces();
 329         check(as.length == 1);
 330         check(as[0].getAnnotations().length == 1);
 331         check(as[0].getAnnotation(TypeAnno.class).value().equals("M"));
 332 
 333         Annotation[] annos;
 334         as = ((AnnotatedParameterizedType)as[0]).getAnnotatedActualTypeArguments();
 335         check(as.length == 2);
 336         annos = as[0].getAnnotations();
 337         check(annos.length == 1);
 338         check(as[0].getAnnotation(TypeAnno.class).value().equals("S"));
 339         check(as[0].getAnnotation(TypeAnno2.class) == null);
 340 
 341         annos = as[1].getAnnotations();
 342         check(annos.length == 2);
 343         check(((TypeAnno)annos[0]).value().equals("I"));
 344         check(as[1].getAnnotation(TypeAnno2.class).value().equals("I2"));
 345     }
 346 
 347     private static void testNestedParameterizedType() throws Exception {
 348         Method m = TestParameterizedType.class.getDeclaredMethod("foo2", (Class<?>[])null);
 349         AnnotatedType ret = m.getAnnotatedReturnType();
 350         Annotation[] annos;
 351         annos = ret.getAnnotations();
 352         check(annos.length == 1);
 353         check(((TypeAnno)annos[0]).value().equals("I"));
 354 
 355         AnnotatedType[] args = ((AnnotatedParameterizedType)ret).getAnnotatedActualTypeArguments();
 356         check(args.length == 1);
 357         annos = args[0].getAnnotations();
 358         check(annos.length == 2);
 359         check(((TypeAnno)annos[0]).value().equals("I1"));
 360         check(args[0].getAnnotation(TypeAnno2.class).value().equals("I2"));
 361 
 362         // check type args
 363         Field f = TestParameterizedType.class.getDeclaredField("theField");
 364         AnnotatedParameterizedType fType = (AnnotatedParameterizedType)f.getAnnotatedType();
 365         args = fType.getAnnotatedActualTypeArguments();
 366         check(args.length == 1);
 367         annos = args[0].getAnnotations();
 368         check(annos.length == 1);
 369         check(((TypeAnno2)annos[0]).value().equals("Map Arg"));
 370         check(args[0].getAnnotation(TypeAnno2.class).value().equals("Map Arg"));
 371 
 372         // check outer type type args
 373         fType = (AnnotatedParameterizedType)fType.getAnnotatedOwnerType();
 374         args = fType.getAnnotatedActualTypeArguments();
 375         check(args.length == 1);
 376         annos = args[0].getAnnotations();
 377         check(annos.length == 1);
 378         check(((TypeAnno2)annos[0]).value().equals("String Arg"));
 379         check(args[0].getAnnotation(TypeAnno2.class).value().equals("String Arg"));
 380 
 381         // check outer type normal type annotations
 382         annos = fType.getAnnotations();
 383         check(annos.length == 1);
 384         check(((TypeAnno)annos[0]).value().equals("FieldOuter"));
 385         check(fType.getAnnotation(TypeAnno.class).value().equals("FieldOuter"));
 386     }
 387 
 388     private static void testWildcardType() throws Exception {
 389         Method m = TestWildcardType.class.getDeclaredMethod("foo", (Class<?>[])null);
 390         AnnotatedType ret = m.getAnnotatedReturnType();
 391         AnnotatedType[] t;
 392         t = ((AnnotatedParameterizedType)ret).getAnnotatedActualTypeArguments();
 393         check(t.length == 1);
 394         ret = t[0];
 395 
 396         Field f = TestWildcardType.class.getDeclaredField("f1");
 397         AnnotatedWildcardType w = (AnnotatedWildcardType)((AnnotatedParameterizedType)f
 398             .getAnnotatedType()).getAnnotatedActualTypeArguments()[0];
 399         t = w.getAnnotatedLowerBounds();
 400         check(t.length == 0);
 401         t = w.getAnnotatedUpperBounds();
 402         check(t.length == 1);
 403         Annotation[] annos;
 404         annos = t[0].getAnnotations();
 405         check(annos.length == 1);
 406         check(((TypeAnno)annos[0]).value().equals("2"));
 407 
 408         f = TestWildcardType.class.getDeclaredField("f2");
 409         w = (AnnotatedWildcardType)((AnnotatedParameterizedType)f
 410             .getAnnotatedType()).getAnnotatedActualTypeArguments()[0];
 411         t = w.getAnnotatedUpperBounds();
 412         check(t.length == 1);
 413         check(t[0].getType().equals(Object.class));
 414         annos = t[0].getAnnotations();
 415         check(annos.length == 0);
 416         t = w.getAnnotatedLowerBounds();
 417         check(t.length == 1);
 418 
 419         // for an unbounded wildcard, we should see jlO as its upperbound and null type as its lower bound.
 420         f = TestWildcardType.class.getDeclaredField("f3");
 421         w = (AnnotatedWildcardType)((AnnotatedParameterizedType)f
 422             .getAnnotatedType()).getAnnotatedActualTypeArguments()[0];
 423         t = w.getAnnotatedUpperBounds();
 424         check(t.length == 1);
 425         check(t[0].getType().equals(Object.class));
 426         annos = t[0].getAnnotations();
 427         check(annos.length == 0);
 428         t = w.getAnnotatedLowerBounds();
 429         check(t.length == 0);
 430     }
 431 
 432     private static void testParameterTypes() throws Exception {
 433         // NO PARAMS
 434         Method m = Params.class.getDeclaredMethod("noParams", (Class<?>[])null);
 435         AnnotatedType[] t = m.getAnnotatedParameterTypes();
 436         check(t.length == 0);
 437 
 438         // ONLY ANNOTATED PARAM TYPES
 439         Class[] argsArr = {String.class, String.class, String.class};
 440         m = Params.class.getDeclaredMethod("onlyAnnotated", (Class<?>[])argsArr);
 441         t = m.getAnnotatedParameterTypes();
 442         check(t.length == 3);
 443 
 444         check(t[0].getAnnotations().length == 1);
 445         check(t[0].getAnnotation(TypeAnno.class) != null);
 446         check(t[0].getAnnotationsByType(TypeAnno.class)[0].value().equals("1"));
 447 
 448         check(t[1].getAnnotations().length == 1);
 449         check(t[1].getAnnotation(TypeAnno.class) != null);
 450         check(t[1].getAnnotationsByType(TypeAnno.class)[0].value().equals("2"));
 451 
 452         check(t[2].getAnnotations().length == 2);
 453         check(t[2].getAnnotations()[0].annotationType().equals(TypeAnno.class));
 454         check(t[2].getAnnotation(TypeAnno.class) != null);
 455         check(t[2].getAnnotation(TypeAnno2.class) != null);
 456         check(t[2].getAnnotationsByType(TypeAnno.class)[0].value().equals("3a"));
 457         check(t[2].getAnnotationsByType(TypeAnno2.class)[0].value().equals("3b"));
 458 
 459         // MIXED ANNOTATED PARAM TYPES
 460         m = Params.class.getDeclaredMethod("mixed", (Class<?>[])argsArr);
 461         t = m.getAnnotatedParameterTypes();
 462         check(t.length == 3);
 463 
 464         check(t[0].getAnnotations().length == 1);
 465         check(t[0].getAnnotation(TypeAnno.class) != null);
 466         check(t[0].getAnnotationsByType(TypeAnno.class)[0].value().equals("1"));
 467 
 468         check(t[1].getAnnotations().length == 0);
 469         check(t[1].getAnnotation(TypeAnno.class) == null);
 470         check(t[1].getAnnotation(TypeAnno2.class) == null);
 471 
 472         check(t[2].getAnnotations().length == 2);
 473         check(t[2].getAnnotations()[0].annotationType().equals(TypeAnno.class));
 474         check(t[2].getAnnotation(TypeAnno.class) != null);
 475         check(t[2].getAnnotation(TypeAnno2.class) != null);
 476         check(t[2].getAnnotationsByType(TypeAnno.class)[0].value().equals("3a"));
 477         check(t[2].getAnnotationsByType(TypeAnno2.class)[0].value().equals("3b"));
 478 
 479         // NO ANNOTATED PARAM TYPES
 480         m = Params.class.getDeclaredMethod("unAnnotated", (Class<?>[])argsArr);
 481         t = m.getAnnotatedParameterTypes();
 482         check(t.length == 3);
 483 
 484         check(t[0].getAnnotations().length == 0);
 485         check(t[0].getAnnotation(TypeAnno.class) == null);
 486         check(t[0].getAnnotation(TypeAnno2.class) == null);
 487 
 488         check(t[1].getAnnotations().length == 0);
 489         check(t[1].getAnnotation(TypeAnno.class) == null);
 490         check(t[1].getAnnotation(TypeAnno2.class) == null);
 491 
 492         check(t[2].getAnnotations().length == 0);
 493         check(t[2].getAnnotation(TypeAnno.class) == null);
 494         check(t[2].getAnnotation(TypeAnno2.class) == null);
 495     }
 496 
 497     private static void testParameterType() throws Exception {
 498         // NO PARAMS
 499         Method m = Params.class.getDeclaredMethod("noParams", (Class<?>[])null);
 500         Parameter[] p = m.getParameters();
 501         check(p.length == 0);
 502 
 503         // ONLY ANNOTATED PARAM TYPES
 504         Class[] argsArr = {String.class, String.class, String.class};
 505         m = Params.class.getDeclaredMethod("onlyAnnotated", (Class<?>[])argsArr);
 506         p = m.getParameters();
 507         check(p.length == 3);
 508         AnnotatedType t0 = p[0].getAnnotatedType();
 509         AnnotatedType t1 = p[1].getAnnotatedType();
 510         AnnotatedType t2 = p[2].getAnnotatedType();
 511 
 512         check(t0.getAnnotations().length == 1);
 513         check(t0.getAnnotation(TypeAnno.class) != null);
 514         check(t0.getAnnotationsByType(TypeAnno.class)[0].value().equals("1"));
 515 
 516         check(t1.getAnnotations().length == 1);
 517         check(t1.getAnnotation(TypeAnno.class) != null);
 518         check(t1.getAnnotationsByType(TypeAnno.class)[0].value().equals("2"));
 519 
 520         check(t2.getAnnotations().length == 2);
 521         check(t2.getAnnotations()[0].annotationType().equals(TypeAnno.class));
 522         check(t2.getAnnotation(TypeAnno.class) != null);
 523         check(t2.getAnnotation(TypeAnno2.class) != null);
 524         check(t2.getAnnotationsByType(TypeAnno.class)[0].value().equals("3a"));
 525         check(t2.getAnnotationsByType(TypeAnno2.class)[0].value().equals("3b"));
 526 
 527         // MIXED ANNOTATED PARAM TYPES
 528         m = Params.class.getDeclaredMethod("mixed", (Class<?>[])argsArr);
 529         p = m.getParameters();
 530         check(p.length == 3);
 531 
 532         t0 = p[0].getAnnotatedType();
 533         t1 = p[1].getAnnotatedType();
 534         t2 = p[2].getAnnotatedType();
 535 
 536         check(t0.getAnnotations().length == 1);
 537         check(t0.getAnnotation(TypeAnno.class) != null);
 538         check(t0.getAnnotationsByType(TypeAnno.class)[0].value().equals("1"));
 539 
 540         check(t1.getAnnotations().length == 0);
 541         check(t1.getAnnotation(TypeAnno.class) == null);
 542         check(t1.getAnnotation(TypeAnno2.class) == null);
 543 
 544         check(t2.getAnnotations().length == 2);
 545         check(t2.getAnnotations()[0].annotationType().equals(TypeAnno.class));
 546         check(t2.getAnnotation(TypeAnno.class) != null);
 547         check(t2.getAnnotation(TypeAnno2.class) != null);
 548         check(t2.getAnnotationsByType(TypeAnno.class)[0].value().equals("3a"));
 549         check(t2.getAnnotationsByType(TypeAnno2.class)[0].value().equals("3b"));
 550 
 551         // NO ANNOTATED PARAM TYPES
 552         m = Params.class.getDeclaredMethod("unAnnotated", (Class<?>[])argsArr);
 553         p = m.getParameters();
 554         check(p.length == 3);
 555 
 556         t0 = p[0].getAnnotatedType();
 557         t1 = p[1].getAnnotatedType();
 558         t2 = p[2].getAnnotatedType();
 559 
 560         check(t0.getAnnotations().length == 0);
 561         check(t0.getAnnotation(TypeAnno.class) == null);
 562         check(t0.getAnnotation(TypeAnno2.class) == null);
 563 
 564         check(t1.getAnnotations().length == 0);
 565         check(t1.getAnnotation(TypeAnno.class) == null);
 566         check(t1.getAnnotation(TypeAnno2.class) == null);
 567 
 568         check(t2.getAnnotations().length == 0);
 569         check(t2.getAnnotation(TypeAnno.class) == null);
 570         check(t2.getAnnotation(TypeAnno2.class) == null);
 571     }
 572 }
 573 
 574 class Params {
 575     public void noParams() {}
 576     public void onlyAnnotated(@TypeAnno("1") String s1, @TypeAnno("2") String s2, @TypeAnno("3a") @TypeAnno2("3b") String s3) {}
 577     public void mixed(@TypeAnno("1") String s1, String s2, @TypeAnno("3a") @TypeAnno2("3b") String s3) {}
 578     public void unAnnotated(String s1, String s2, String s3) {}
 579 }
 580 
 581 abstract class TestWildcardType {
 582     public <T> List<? super T> foo() { return null;}
 583     public Class<@TypeAnno("1") ? extends @TypeAnno("2") Annotation> f1;
 584     public Class<@TypeAnno("3") ? super @TypeAnno("4") Annotation> f2;
 585     public Class<@TypeAnno("5") ?> f3;
 586 }
 587 
 588 abstract class TestParameterizedType implements @TypeAnno("M") Map<@TypeAnno("S")String, @TypeAnno("I") @TypeAnno2("I2")Integer> {
 589     public ParameterizedOuter<String>.ParameterizedInner<Integer> foo() {return null;}
 590     public @TypeAnno("O") ParameterizedOuter<@TypeAnno("S1") @TypeAnno2("S2") String>.
 591             @TypeAnno("I") ParameterizedInner<@TypeAnno("I1") @TypeAnno2("I2")Integer> foo2() {
 592         return null;
 593     }
 594 
 595     public @TypeAnno("FieldOuter") ParameterizedOuter<@TypeAnno2("String Arg") String>.
 596             @TypeAnno("FieldInner")ParameterizedInner<@TypeAnno2("Map Arg")Map> theField;
 597 }
 598 
 599 class ParameterizedOuter <T> {
 600     class ParameterizedInner <U> {}
 601 }
 602 
 603 abstract class TestClassArray extends @TypeAnno("extends") @TypeAnno2("extends2") Object
 604     implements @TypeAnno("implements serializable") @TypeAnno2("implements2 serializable") Serializable,
 605     Readable,
 606     @TypeAnno("implements cloneable") @TypeAnno2("implements2 cloneable") Cloneable {
 607     public @TypeAnno("return4") Object @TypeAnno("return1") [][] @TypeAnno("return3")[] foo() { return null; }
 608 }
 609 
 610 abstract class TestClassNested {
 611     public @TypeAnno("Outer") Outer.@TypeAnno("Inner")Inner @TypeAnno("array")[] foo() { return null; }
 612 }
 613 
 614 class Outer {
 615     class Inner {
 616     }
 617 }
 618 
 619 abstract class TestClassException {
 620     public Object foo() throws @TypeAnno("RE") @TypeAnno2("RE2") RuntimeException,
 621                                                                  NullPointerException,
 622                                              @TypeAnno("AIOOBE") ArrayIndexOutOfBoundsException {
 623         return null;
 624     }
 625 }
 626 
 627 abstract class TestClassTypeVarAndField <T extends @TypeAnno("Object1") Object
 628                                           & @TypeAnno("Runnable1") @TypeAnno2("Runnable2") Runnable,
 629                                         @TypeAnno("EE")EE extends @TypeAnno2("EEBound") Runnable, V > {
 630     @TypeAnno("T1 field") @TypeAnno2("T2 field") T field1;
 631     T field2;
 632     @TypeAnno("Object field") Object field3;
 633 
 634     public @TypeAnno("t1") @TypeAnno2("t2") T foo(){ return null; }
 635     public <M extends @TypeAnno("M Runnable") Runnable> M foo2() {return null;}
 636     public <@TypeAnno("K") K extends Cloneable, L> K foo3() {return null;}
 637     public <L> L foo4() {return null;}
 638 }
 639 
 640 @Target(ElementType.TYPE_USE)
 641 @Retention(RetentionPolicy.RUNTIME)
 642 @interface TypeAnno {
 643     String value();
 644 }
 645 
 646 @Target(ElementType.TYPE_USE)
 647 @Retention(RetentionPolicy.RUNTIME)
 648 @interface TypeAnno2 {
 649     String value();
 650 }
--- EOF ---