1 /*

     2  * Copyright (c) 2012, 2014, 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 import java.lang.annotation.*;

    25 import java.io.*;

    26 import java.net.URL;

    27 import java.util.List;

    28 

    29 import com.sun.tools.classfile.*;

    30 

    31 /**

    32  * A class providing utilities for writing tests that inspect class

    33  * files directly, looking for specific type annotations.

    34  *

    35  * Note: this framework does not currently handle repeating

    36  * annotations.

    37  */

    38 public class ClassfileInspector {

    39 

    40     /**

    41      * A group of expected annotations to be found in a given class.

    42      * If the class name is null, then the template will be applied to

    43      * every class.

    44      */

    45     public static class Expected {

    46         /**

    47          * The name of the class.  If {@code null} this template will

    48          * apply to every class; otherwise, it will only be applied to

    49          * the named class.

    50          */

    51         public final String classname;

    52 

    53         /**

    54          * The expected class annotations.  These will be checked

    55          * against the class' attributes.

    56          */

    57         public final ExpectedTypeAnnotation[] classAnnos;

    58 

    59         /**

    60          * The expected method annotations.  These will be checked

    61          * against all methods in the class.

    62          */

    63         public final ExpectedMethodTypeAnnotation[] methodAnnos;

    64 

    65         /**

    66          * The expected field annotations.  These will be checked

    67          * against all fields in the class.

    68          */

    69         public final ExpectedFieldTypeAnnotation[] fieldAnnos;

    70 

    71         /**

    72          * Create an {@code Expected} from its components.

    73          *

    74          * @param classname The name of the class to match, or {@code

    75          *                  null} for all classes.

    76          * @param classAnnos The expected class annotations.

    77          * @param methodAnnos The expected method annotations.

    78          * @param fieldAnnos The expected field annotations.

    79          */

    80         public Expected(String classname,

    81                         ExpectedTypeAnnotation[] classAnnos,

    82                         ExpectedMethodTypeAnnotation[] methodAnnos,

    83                         ExpectedFieldTypeAnnotation[] fieldAnnos) {

    84             this.classname = classname;

    85             this.classAnnos = classAnnos;

    86             this.methodAnnos = methodAnnos;

    87             this.fieldAnnos = fieldAnnos;

    88         }

    89 

    90         public String toString() {

    91             final StringBuilder sb = new StringBuilder();

    92             final String newline = System.lineSeparator();

    93             sb.append("Expected on class ").append(classname);

    94             if (null != classAnnos) {

    95                 sb.append(newline).append("Class annotations:").append(newline);

    96                 for(ExpectedTypeAnnotation anno : classAnnos) {

    97                     sb.append(anno).append(newline);

    98                 }

    99             }

   100             if (null != methodAnnos) {

   101                 sb.append(newline).append("Method annotations:").append(newline);

   102                 for(ExpectedTypeAnnotation anno : methodAnnos) {

   103                     sb.append(anno).append(newline);

   104                 }

   105             }

   106             if (null != fieldAnnos) {

   107                 sb.append(newline).append("Field annotations:").append(newline);

   108                 for(ExpectedTypeAnnotation anno : fieldAnnos) {

   109                     sb.append(anno).append(newline);

   110                 }

   111             }

   112             return sb.toString();

   113         }

   114 

   115         /**

   116          * See if this template applies to a class.

   117          *

   118          * @param classname The classname to check.

   119          * @return Whether or not this template should apply.

   120          */

   121         public boolean matchClassName(String classname) {

   122             return this.classname == null || this.classname.equals(classname);

   123         }

   124 

   125         /**

   126          * After applying the template to all classes, check to see if

   127          * any of the expected annotations weren't matched.

   128          *

   129          * @return The number of missed matches.

   130          */

   131         public int check() {

   132             int count = 0;

   133             if (classAnnos != null) {

   134                 for(ExpectedTypeAnnotation expected : classAnnos) {

   135                     if (!expected.check()) {

   136                         count++;

   137                     }

   138                 }

   139             }

   140             if (methodAnnos != null) {

   141                 for(ExpectedMethodTypeAnnotation expected : methodAnnos) {

   142                     if (!expected.check()) {

   143                         count++;

   144                     }

   145                 }

   146             }

   147             if (fieldAnnos != null) {

   148                 for(ExpectedFieldTypeAnnotation expected : fieldAnnos) {

   149                     if (!expected.check()) {

   150                         count++;

   151                     }

   152                 }

   153             }

   154             return count;

   155         }

   156     }

   157 

   158     /**

   159      * An expected type annotation.  This is both a superclass for

   160      * method and field type annotations, as well as a class for type

   161      * annotations on a class.

   162      */

   163     public static class ExpectedTypeAnnotation {

   164         private int count = 0;

   165         protected final String expectedName;

   166         protected final int expectedCount;

   167         protected final TypeAnnotation.TargetType targetType;

   168         protected final int bound_index;

   169         protected final int parameter_index;

   170         protected final int type_index;

   171         protected final int exception_index;

   172         protected final TypeAnnotation.Position.TypePathEntry[] typePath;

   173         protected final boolean visibility;

   174 

   175         /**

   176          * Create an {@code ExpectedTypeAnnotation} from its

   177          * components.  It is usually a better idea to use a {@code

   178          * Builder} to do this.

   179          *

   180          * @param expectedName The expected annotation name.

   181          * @param visibility Whether this annotation should be runtime-visible.

   182          * @param expectedCount The number of annotations that should

   183          *                      be seen.  If 0, this asserts that the

   184          *                      described annotation is not present.

   185          * @param targetType The expected target type.

   186          * @param bound_index The expected bound index, or {@code Integer.MIN_VALUE}.

   187          * @param parameter_index The expected parameter index, or

   188          *                        {@code Integer.MIN_VALUE}.

   189          * @param type_index The expected type index, or {@code Integer.MIN_VALUE}.

   190          * @param exception_index The expected exception index, or

   191          *                        {@code Integer.MIN_VALUE}.

   192          * @param typePath The expected type path.

   193          */

   194         public ExpectedTypeAnnotation(String expectedName,

   195                                       boolean visibility,

   196                                       int expectedCount,

   197                                       TypeAnnotation.TargetType targetType,

   198                                       int bound_index,

   199                                       int parameter_index,

   200                                       int type_index,

   201                                       int exception_index,

   202                                       TypeAnnotation.Position.TypePathEntry... typePath) {

   203             this.expectedName = expectedName;

   204             this.visibility = visibility;

   205             this.expectedCount = expectedCount;

   206             this.targetType = targetType;

   207             this.bound_index = bound_index;

   208             this.parameter_index = parameter_index;

   209             this.type_index = type_index;

   210             this.exception_index = exception_index;

   211             this.typePath = typePath;

   212         }

   213 

   214         public String toString() {

   215             final StringBuilder sb = new StringBuilder();

   216             sb.append("Expected ");

   217             sb.append(expectedCount);

   218             sb.append(" annotation ");

   219             sb.append(expectedName);

   220             sb.append(visibility ? ", runtime visibile " : ", runtime invisibile ");

   221             sb.append(targetType);

   222             sb.append(", bound_index = ");

   223             sb.append(bound_index);

   224             sb.append(", parameter_index = ");

   225             sb.append(parameter_index);

   226             sb.append(", type_index = ");

   227             sb.append(type_index);

   228             sb.append(", exception_index = ");

   229             sb.append(exception_index);

   230             sb.append(", type_path = [");

   231             for(int i = 0; i < typePath.length; i++) {

   232                 if (i != 0) {

   233                     sb.append(", ");

   234                 }

   235                 sb.append(typePath[i]);

   236             }

   237             sb.append("]");

   238             return sb.toString();

   239         }

   240 

   241         /**

   242          * See if this template matches the given visibility.

   243          *

   244          * @param Whether or not the annotation is visible at runtime.

   245          * @return Whether or not this template matches the visibility.

   246          */

   247         public boolean matchVisibility(boolean visibility) {

   248             return this.visibility == visibility;

   249         }

   250 

   251         /**

   252          * Attempty to match this template against an annotation.  If

   253          * it does match, then the match count for the template will

   254          * be incremented.  Otherwise, nothing will be done.

   255          *

   256          * @param anno The annotation to attempt to match.

   257          */

   258         public void matchAnnotation(TypeAnnotation anno) {

   259             boolean matches = true;

   260 

   261             try {

   262                 matches = anno.constant_pool.getUTF8Info(anno.annotation.type_index).value.equals("L" + expectedName + ";");

   263             } catch(Exception e) {

   264                 matches = false;

   265             }

   266 

   267             matches = matches && anno.position.type == targetType;

   268             matches = matches && anno.position.bound_index == bound_index;

   269             matches = matches && anno.position.parameter_index == parameter_index;

   270             matches = matches && anno.position.type_index == type_index;

   271             matches = matches && anno.position.exception_index == exception_index;

   272             matches = matches && anno.position.location.size() == typePath.length;

   273 

   274             if (matches) {

   275                 int i = 0;

   276                 for(TypeAnnotation.Position.TypePathEntry entry :

   277                          anno.position.location) {

   278                     matches = matches && typePath[i++].equals(entry);

   279                 }

   280             }

   281 

   282             if (matches) {

   283                 count++;

   284             }

   285         }

   286 

   287         /**

   288          * After all matching, check to see if the expected number of

   289          * matches equals the actual number.  If not, then print a

   290          * failure message and return {@code false}.

   291          *

   292          * @return Whether or not the expected number of matched

   293          *         equals the actual number.

   294          */

   295         public boolean check() {

   296             if (count != expectedCount) {

   297                 System.err.println(this + ", but saw " + count);

   298                 return false;

   299             } else {

   300                 return true;

   301             }

   302         }

   303 

   304         /**

   305          * A builder class for creating {@code

   306          * ExpectedTypeAnnotation}s in a more convenient fashion.  The

   307          * constructor for {@code ExpectedTypeAnnotation} takes a

   308          * large number of parameters (by necessity).  This class

   309          * allows users to construct a {@code ExpectedTypeAnnotation}s

   310          * using only the ones they need.

   311          */

   312         public static class Builder {

   313             protected final String expectedName;

   314             protected final int expectedCount;

   315             protected final TypeAnnotation.TargetType targetType;

   316             protected final boolean visibility;

   317             protected int bound_index = Integer.MIN_VALUE;

   318             protected int parameter_index = Integer.MIN_VALUE;

   319             protected int type_index = Integer.MIN_VALUE;

   320             protected int exception_index = Integer.MIN_VALUE;

   321             protected TypeAnnotation.Position.TypePathEntry[] typePath =

   322                 new TypeAnnotation.Position.TypePathEntry[0];

   323 

   324             /**

   325              * Create a {@code Builder} from the mandatory parameters.

   326              *

   327              * @param expectedName The expected annotation name.

   328              * @param targetType The expected target type.

   329              * @param visibility Whether this annotation should be runtime-visible.

   330              * @param expectedCount The number of annotations that should be seen.

   331              */

   332             public Builder(String expectedName,

   333                            TypeAnnotation.TargetType targetType,

   334                            boolean visibility,

   335                            int expectedCount) {

   336                 this.expectedName = expectedName;

   337                 this.visibility = visibility;

   338                 this.expectedCount = expectedCount;

   339                 this.targetType = targetType;

   340             }

   341 

   342             /**

   343              * Create an {@code ExpectedTypeAnnotation} from all

   344              * parameters that have been provided.  The default values

   345              * will be used for those that have not.

   346              *

   347              * @return The cretaed {@code ExpectedTypeAnnotation}.

   348              */

   349             public ExpectedTypeAnnotation build() {

   350                 return new ExpectedTypeAnnotation(expectedName, visibility,

   351                                                   expectedCount, targetType,

   352                                                   bound_index, parameter_index,

   353                                                   type_index, exception_index,

   354                                                   typePath);

   355             }

   356 

   357             /**

   358              * Provide a bound index parameter.

   359              *

   360              * @param bound_index The bound_index value.

   361              */

   362             public Builder setBoundIndex(int bound_index) {

   363                 this.bound_index = bound_index;

   364                 return this;

   365             }

   366 

   367             /**

   368              * Provide a parameter index parameter.

   369              *

   370              * @param bound_index The parameter_index value.

   371              */

   372             public Builder setParameterIndex(int parameter_index) {

   373                 this.parameter_index = parameter_index;

   374                 return this;

   375             }

   376 

   377             /**

   378              * Provide a type index parameter.

   379              *

   380              * @param type_index The type_index value.

   381              */

   382             public Builder setTypeIndex(int type_index) {

   383                 this.type_index = type_index;

   384                 return this;

   385             }

   386 

   387             /**

   388              * Provide an exception index parameter.

   389              *

   390              * @param exception_index The exception_index value.

   391              */

   392             public Builder setExceptionIndex(int exception_index) {

   393                 this.exception_index = exception_index;

   394                 return this;

   395             }

   396 

   397             /**

   398              * Provide a type path parameter.

   399              *

   400              * @param typePath The type path value.

   401              */

   402             public Builder setTypePath(TypeAnnotation.Position.TypePathEntry[] typePath) {

   403                 this.typePath = typePath;

   404                 return this;

   405             }

   406         }

   407     }

   408 

   409     /**

   410      * A type annotation found on a method.

   411      */

   412     public static class ExpectedMethodTypeAnnotation extends ExpectedTypeAnnotation {

   413         private final String methodname;

   414 

   415         /**

   416          * Create an {@code ExpectedMethodTypeAnnotation} from its

   417          * components.  It is usually a better idea to use a {@code

   418          * Builder} to do this.

   419          *

   420          * @param methodname The expected method name.

   421          * @param expectedName The expected annotation name.

   422          * @param visibility Whether this annotation should be runtime-visible.

   423          * @param expectedCount The number of annotations that should be seen.

   424          * @param targetType The expected target type.

   425          * @param bound_index The expected bound index, or {@code Integer.MIN_VALUE}.

   426          * @param parameter_index The expected parameter index, or

   427          *                        {@code Integer.MIN_VALUE}.

   428          * @param type_index The expected type index, or {@code Integer.MIN_VALUE}.

   429          * @param exception_index The expected exception index, or

   430          *                        {@code Integer.MIN_VALUE}.

   431          * @param typePath The expected type path.

   432          */

   433         public ExpectedMethodTypeAnnotation(String methodname,

   434                                             String expectedName,

   435                                             boolean visibility,

   436                                             int expectedCount,

   437                                             TypeAnnotation.TargetType targetType,

   438                                             int bound_index,

   439                                             int parameter_index,

   440                                             int type_index,

   441                                             int exception_index,

   442                                             TypeAnnotation.Position.TypePathEntry... typePath) {

   443             super(expectedName, visibility, expectedCount, targetType, bound_index,

   444                   parameter_index, type_index, exception_index, typePath);

   445             this.methodname = methodname;

   446         }

   447 

   448         public String toString() {

   449             final StringBuilder sb = new StringBuilder();

   450             sb.append("Expected ");

   451             sb.append(expectedCount);

   452             sb.append(" annotation ");

   453             sb.append(expectedName);

   454             sb.append(visibility ? ", runtime visibile " : ", runtime invisibile ");

   455             sb.append(targetType);

   456             sb.append(", bound_index = ");

   457             sb.append(bound_index);

   458             sb.append(", parameter_index = ");

   459             sb.append(parameter_index);

   460             sb.append(", type_index = ");

   461             sb.append(type_index);

   462             sb.append(", exception_index = ");

   463             sb.append(exception_index);

   464             sb.append(", type_path = [");

   465             for(int i = 0; i < typePath.length; i++) {

   466                 if (i != 0) {

   467                     sb.append(", ");

   468                 }

   469                 sb.append(typePath[i]);

   470             }

   471             sb.append("]");

   472             sb.append(" on method ");

   473             sb.append(methodname);

   474             return sb.toString();

   475         }

   476 

   477         /**

   478          * See if this template applies to a method.

   479          *

   480          * @param methodname The method name to check.

   481          * @return Whether or not this template should apply.

   482          */

   483         public boolean matchMethodName(String methodname) {

   484             return this.methodname.equals(methodname);

   485         }

   486 

   487         /**

   488          * A builder class for creating {@code

   489          * ExpectedMethodTypeAnnotation}s in a more convenient fashion.  The

   490          * constructor for {@code ExpectedMethodTypeAnnotation} takes a

   491          * large number of parameters (by necessity).  This class

   492          * allows users to construct a {@code ExpectedMethodTypeAnnotation}s

   493          * using only the ones they need.

   494          */

   495         public static class Builder extends ExpectedTypeAnnotation.Builder {

   496             protected final String methodname;

   497 

   498             /**

   499              * Create a {@code Builder} from the mandatory parameters.

   500              *

   501              * @param methodname The expected method name.

   502              * @param expectedName The expected annotation name.

   503              * @param targetType The expected target type.

   504              * @param visibility Whether this annotation should be runtime-visible.

   505              * @param expectedCount The number of annotations that should be seen.

   506              */

   507             public Builder(String methodname,

   508                            String expectedName,

   509                            TypeAnnotation.TargetType targetType,

   510                            boolean visibility,

   511                            int expectedCount) {

   512                 super(expectedName, targetType, visibility, expectedCount);

   513                 this.methodname = methodname;

   514             }

   515 

   516             /**

   517              * Create an {@code ExpectedMethodTypeAnnotation} from all

   518              * parameters that have been provided.  The default values

   519              * will be used for those that have not.

   520              *

   521              * @return The cretaed {@code ExpectedMethodTypeAnnotation}.

   522              */

   523             public ExpectedMethodTypeAnnotation build() {

   524                 return new ExpectedMethodTypeAnnotation(methodname, expectedName,

   525                                                         visibility, expectedCount,

   526                                                         targetType, bound_index,

   527                                                         parameter_index, type_index,

   528                                                         exception_index, typePath);

   529             }

   530         }

   531     }

   532 

   533     /**

   534      * A type annotation found on a field.

   535      */

   536     public static class ExpectedFieldTypeAnnotation extends ExpectedTypeAnnotation {

   537         private final String fieldname;

   538 

   539         /**

   540          * Create an {@code ExpectedFieldTypeAnnotation} from its

   541          * components.  It is usually a better idea to use a {@code

   542          * Builder} to do this.

   543          *

   544          * @param fieldname The expected field name.

   545          * @param expectedName The expected annotation name.

   546          * @param visibility Whether this annotation should be runtime-visible.

   547          * @param expectedCount The number of annotations that should be seen.

   548          * @param targetType The expected target type.

   549          * @param bound_index The expected bound index, or {@code Integer.MIN_VALUE}.

   550          * @param parameter_index The expected parameter index, or

   551          *                        {@code Integer.MIN_VALUE}.

   552          * @param type_index The expected type index, or {@code Integer.MIN_VALUE}.

   553          * @param exception_index The expected exception index, or

   554          *                        {@code Integer.MIN_VALUE}.

   555          * @param typePath The expected type path.

   556          */

   557         public ExpectedFieldTypeAnnotation(String fieldname,

   558                                            String expectedName,

   559                                            boolean visibility,

   560                                            int expectedCount,

   561                                            TypeAnnotation.TargetType targetType,

   562                                            int bound_index,

   563                                            int parameter_index,

   564                                            int type_index,

   565                                            int exception_index,

   566                                            TypeAnnotation.Position.TypePathEntry... typePath) {

   567             super(expectedName, visibility, expectedCount, targetType, bound_index,

   568                   parameter_index, type_index, exception_index, typePath);

   569             this.fieldname = fieldname;

   570         }

   571 

   572         public String toString() {

   573             final StringBuilder sb = new StringBuilder();

   574             sb.append("Expected ").append(expectedCount)

   575             .append(" annotation ").append(expectedName)

   576             .append(visibility ? ", runtime visibile " : ", runtime invisibile ")

   577             .append(targetType)

   578             .append(", bound_index = ").append(bound_index)

   579             .append(", parameter_index = ").append(parameter_index)

   580             .append(", type_index = ").append(type_index)

   581             .append(", exception_index = ").append(exception_index)

   582             .append(", type_path = [");

   583 

   584             for(int i = 0; i < typePath.length; i++) {

   585                 if (i != 0) {

   586                     sb.append(", ");

   587                 }

   588                 sb.append(typePath[i]);

   589             }

   590             sb.append("]")

   591             .append(" on field ").append(fieldname);

   592             return sb.toString();

   593         }

   594 

   595         /**

   596          * See if this template applies to a field.

   597          *

   598          * @param fieldname The field name to check.

   599          * @return Whether or not this template should apply.

   600          */

   601         public boolean matchFieldName(String fieldname) {

   602             return this.fieldname.equals(fieldname);

   603         }

   604 

   605         /**

   606          * A builder class for creating {@code

   607          * ExpectedFieldTypeAnnotation}s in a more convenient fashion.  The

   608          * constructor for {@code ExpectedFieldTypeAnnotation} takes a

   609          * large number of parameters (by necessity).  This class

   610          * allows users to construct a {@code ExpectedFieldTypeAnnotation}s

   611          * using only the ones they need.

   612          */

   613         public static class Builder extends ExpectedTypeAnnotation.Builder {

   614             protected final String fieldname;

   615 

   616             /**

   617              * Create a {@code Builder} from the mandatory parameters.

   618              *

   619              * @param fieldname The expected field name.

   620              * @param expectedName The expected annotation name.

   621              * @param targetType The expected target type.

   622              * @param visibility Whether this annotation should be runtime-visible.

   623              * @param expectedCount The number of annotations that should be seen.

   624              */

   625             public Builder(String fieldname,

   626                            String expectedName,

   627                            TypeAnnotation.TargetType targetType,

   628                            boolean visibility,

   629                            int expectedCount) {

   630                 super(expectedName, targetType, visibility, expectedCount);

   631                 this.fieldname = fieldname;

   632             }

   633 

   634             /**

   635              * Create an {@code ExpectedFieldTypeAnnotation} from all

   636              * parameters that have been provided.  The default values

   637              * will be used for those that have not.

   638              *

   639              * @return The cretaed {@code ExpectedFieldTypeAnnotation}.

   640              */

   641             public ExpectedFieldTypeAnnotation build() {

   642                 return new ExpectedFieldTypeAnnotation(fieldname, expectedName,

   643                                                        visibility, expectedCount,

   644                                                        targetType, bound_index,

   645                                                        parameter_index, type_index,

   646                                                        exception_index, typePath);

   647             }

   648         }

   649     }

   650 

   651     private void matchClassTypeAnnotation(ClassFile classfile,

   652                                           ExpectedTypeAnnotation expected)

   653         throws ConstantPoolException {

   654         for(Attribute attr : classfile.attributes) {

   655             attr.accept(typeAnnoMatcher, expected);

   656         }

   657     }

   658 

   659     private void matchMethodTypeAnnotation(ClassFile classfile,

   660                                            ExpectedMethodTypeAnnotation expected)

   661         throws ConstantPoolException {

   662         for(Method meth : classfile.methods) {

   663             if (expected.matchMethodName(meth.getName(classfile.constant_pool))) {

   664                 for(Attribute attr : meth.attributes) {

   665                     attr.accept(typeAnnoMatcher, expected);

   666                 }

   667             }

   668         }

   669     }

   670 

   671     private void matchFieldTypeAnnotation(ClassFile classfile,

   672                                           ExpectedFieldTypeAnnotation expected)

   673         throws ConstantPoolException {

   674         for(Field field : classfile.fields) {

   675             if (expected.matchFieldName(field.getName(classfile.constant_pool))) {

   676                 for(Attribute attr : field.attributes) {

   677                     attr.accept(typeAnnoMatcher, expected);

   678                 }

   679             }

   680         }

   681     }

   682 

   683     private void matchClassTypeAnnotations(ClassFile classfile,

   684                                            ExpectedTypeAnnotation[] expected)

   685         throws ConstantPoolException {

   686         for(ExpectedTypeAnnotation one : expected) {

   687             matchClassTypeAnnotation(classfile, one);

   688         }

   689     }

   690 

   691     private void matchMethodTypeAnnotations(ClassFile classfile,

   692                                             ExpectedMethodTypeAnnotation[] expected)

   693         throws ConstantPoolException {

   694         for(ExpectedMethodTypeAnnotation one : expected) {

   695             matchMethodTypeAnnotation(classfile, one);

   696         }

   697     }

   698 

   699     private void matchFieldTypeAnnotations(ClassFile classfile,

   700                                            ExpectedFieldTypeAnnotation[] expected)

   701         throws ConstantPoolException {

   702         for(ExpectedFieldTypeAnnotation one : expected) {

   703             matchFieldTypeAnnotation(classfile, one);

   704         }

   705     }

   706 

   707     /**

   708      * Run a template on a single {@code ClassFile}.

   709      *

   710      * @param classfile The {@code ClassFile} on which to run tests.

   711      * @param expected The expected annotation template.

   712      */

   713     public void run(ClassFile classfile,

   714                     Expected... expected)

   715             throws ConstantPoolException {

   716         run(new ClassFile[] { classfile }, expected);

   717     }

   718 

   719     /**

   720      * Run a template on multiple {@code ClassFile}s.

   721      *

   722      * @param classfile The {@code ClassFile}s on which to run tests.

   723      * @param expected The expected annotation template.

   724      */

   725     public void run(ClassFile[] classfiles,

   726                     Expected... expected)

   727             throws ConstantPoolException {

   728         for(ClassFile classfile : classfiles) {

   729             for(Expected one : expected) {

   730                 if (one.matchClassName(classfile.getName())) {

   731                     if (one.classAnnos != null)

   732                         matchClassTypeAnnotations(classfile, one.classAnnos);

   733                     if (one.methodAnnos != null)

   734                         matchMethodTypeAnnotations(classfile, one.methodAnnos);

   735                     if (one.fieldAnnos != null)

   736                         matchFieldTypeAnnotations(classfile, one.fieldAnnos);

   737                 }

   738             }

   739         }

   740         int count = 0;

   741         for (Expected one : expected) {

   742             count += one.check();

   743         }

   744 

   745         if (count != 0) {

   746             throw new RuntimeException(count + " errors occurred in test");

   747         }

   748     }

   749 

   750     /**

   751      * Get a {@code ClassFile} from its file name.

   752      *

   753      * @param name The class' file name.

   754      * @return The {@code ClassFile}

   755      */

   756     public static ClassFile getClassFile(String name)

   757         throws IOException, ConstantPoolException {

   758         final URL url = ClassfileInspector.class.getResource(name);

   759         final InputStream in = url.openStream();

   760         try {

   761             return ClassFile.read(in);

   762         } finally {

   763             in.close();

   764         }

   765     }

   766 

   767     private static final Attribute.Visitor<Void, ExpectedTypeAnnotation> typeAnnoMatcher =

   768         new Attribute.Visitor<Void, ExpectedTypeAnnotation>() {

   769 

   770         @Override

   771         public Void visitBootstrapMethods(BootstrapMethods_attribute attr,

   772                                           ExpectedTypeAnnotation expected) {

   773             return null;

   774         }

   775 

   776         @Override

   777         public Void visitDefault(DefaultAttribute attr,

   778                                  ExpectedTypeAnnotation expected) {

   779             return null;

   780         }

   781 

   782         @Override

   783         public Void visitAnnotationDefault(AnnotationDefault_attribute attr,

   784                                            ExpectedTypeAnnotation expected) {

   785             return null;

   786         }

   787 

   788         @Override

   789         public Void visitCharacterRangeTable(CharacterRangeTable_attribute attr,

   790                                              ExpectedTypeAnnotation expected) {

   791             return null;

   792         }

   793 

   794         @Override

   795         public Void visitCode(Code_attribute attr,

   796                               ExpectedTypeAnnotation expected) {

   797             return null;

   798         }

   799 

   800         @Override

   801         public Void visitCompilationID(CompilationID_attribute attr,

   802                                        ExpectedTypeAnnotation expected) {

   803             return null;

   804         }

   805 

   806         @Override

   807         public Void visitConstantValue(ConstantValue_attribute attr,

   808                                        ExpectedTypeAnnotation expected) {

   809             return null;

   810         }

   811 

   812         @Override

   813         public Void visitDeprecated(Deprecated_attribute attr,

   814                                     ExpectedTypeAnnotation expected) {

   815             return null;

   816         }

   817 

   818         @Override

   819         public Void visitEnclosingMethod(EnclosingMethod_attribute attr,

   820                                          ExpectedTypeAnnotation expected) {

   821             return null;

   822         }

   823 

   824         @Override

   825         public Void visitExceptions(Exceptions_attribute attr,

   826                                     ExpectedTypeAnnotation expected) {

   827             return null;

   828         }

   829 

   830         @Override

   831         public Void visitInnerClasses(InnerClasses_attribute attr,

   832                                       ExpectedTypeAnnotation expected) {

   833             return null;

   834         }

   835 

   836         @Override

   837         public Void visitLineNumberTable(LineNumberTable_attribute attr,

   838                                          ExpectedTypeAnnotation expected) {

   839             return null;

   840         }

   841 

   842         @Override

   843         public Void visitLocalVariableTable(LocalVariableTable_attribute attr,

   844                                             ExpectedTypeAnnotation expected) {

   845             return null;

   846         }

   847 

   848         @Override

   849         public Void visitLocalVariableTypeTable(LocalVariableTypeTable_attribute attr,

   850                                                 ExpectedTypeAnnotation expected) {

   851             return null;

   852         }

   853 

   854         @Override

   855         public Void visitMethodParameters(MethodParameters_attribute attr,

   856                                           ExpectedTypeAnnotation expected) {

   857             return null;

   858         }

   859 

   860         @Override

   861             public Void visitRuntimeVisibleAnnotations(RuntimeVisibleAnnotations_attribute attr,

   862                                                        ExpectedTypeAnnotation expected) {

   863             return null;

   864         }

   865 

   866         @Override

   867         public Void visitRuntimeInvisibleAnnotations(RuntimeInvisibleAnnotations_attribute attr,

   868                                                      ExpectedTypeAnnotation expected) {

   869             return null;

   870         }

   871 

   872         @Override

   873         public Void visitRuntimeVisibleParameterAnnotations(RuntimeVisibleParameterAnnotations_attribute attr,

   874                                                             ExpectedTypeAnnotation expected) {

   875             return null;

   876         }

   877 

   878         @Override

   879         public Void visitRuntimeInvisibleParameterAnnotations(RuntimeInvisibleParameterAnnotations_attribute attr,

   880                                                               ExpectedTypeAnnotation expected) {

   881             return null;

   882         }

   883 

   884         @Override

   885         public Void visitSignature(Signature_attribute attr,

   886                                    ExpectedTypeAnnotation expected) {

   887             return null;

   888         }

   889 

   890         @Override

   891         public Void visitSourceDebugExtension(SourceDebugExtension_attribute attr,

   892                                               ExpectedTypeAnnotation expected) {

   893             return null;

   894         }

   895 

   896         @Override

   897         public Void visitSourceFile(SourceFile_attribute attr,

   898                                     ExpectedTypeAnnotation expected) {

   899             return null;

   900         }

   901 

   902         @Override

   903         public Void visitSourceID(SourceID_attribute attr,

   904                                   ExpectedTypeAnnotation expected) {

   905             return null;

   906         }

   907 

   908         @Override

   909         public Void visitStackMap(StackMap_attribute attr,

   910                                   ExpectedTypeAnnotation expected) {

   911             return null;

   912         }

   913 

   914         @Override

   915         public Void visitStackMapTable(StackMapTable_attribute attr,

   916                                        ExpectedTypeAnnotation expected) {

   917             return null;

   918         }

   919 

   920         @Override

   921         public Void visitSynthetic(Synthetic_attribute attr,

   922                                    ExpectedTypeAnnotation expected) {

   923             return null;

   924         }

   925 

   926         @Override

   927         public Void visitRuntimeVisibleTypeAnnotations(RuntimeVisibleTypeAnnotations_attribute attr,

   928                                                        ExpectedTypeAnnotation expected) {

   929             if (expected.matchVisibility(true)) {

   930                 for(TypeAnnotation anno : attr.annotations) {

   931                     expected.matchAnnotation(anno);

   932                 }

   933             }

   934 

   935             return null;

   936         }

   937 

   938         @Override

   939         public Void visitRuntimeInvisibleTypeAnnotations(RuntimeInvisibleTypeAnnotations_attribute attr,

   940                                                          ExpectedTypeAnnotation expected) {

   941             if (expected.matchVisibility(false)) {

   942                 for(TypeAnnotation anno : attr.annotations) {

   943                     expected.matchAnnotation(anno);

   944                 }

   945             }

   946 

   947             return null;

   948         }

   949     };

   950 }