1 /*

     2  * Copyright (c) 2012, 2013 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 public class ClassfileTestHelper {

    32     int expected_tinvisibles = 0;

    33     int expected_tvisibles = 0;

    34     int expected_invisibles = 0;

    35     int expected_visibles = 0;

    36 

    37     //Makes debugging much easier. Set to 'false' for less output.

    38     public Boolean verbose = true;

    39     void println(String msg) { if(verbose) System.out.println(msg); }

    40 

    41     File writeTestFile(String fname, String source) throws IOException {

    42       File f = new File(fname);

    43         PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(f)));

    44         out.println(source);

    45         out.close();

    46         return f;

    47     }

    48 

    49     File compile(File f) {

    50         int rc = com.sun.tools.javac.Main.compile(new String[] {

    51                 "-source", "1.8", "-g", f.getPath() });

    52         if (rc != 0)

    53             throw new Error("compilation failed. rc=" + rc);

    54         String path = f.getPath();

    55         return new File(path.substring(0, path.length() - 5) + ".class");

    56     }

    57 

    58     ClassFile getClassFile(String name) throws IOException, ConstantPoolException {

    59         URL url = getClass().getResource(name);

    60         InputStream in = url.openStream();

    61         try {

    62             return ClassFile.read(in);

    63         } finally {

    64             in.close();

    65         }

    66     }

    67 

    68     ClassFile getClassFile(URL url) throws IOException, ConstantPoolException {

    69             InputStream in = url.openStream();

    70             try {

    71                 return ClassFile.read(in);

    72             } finally {

    73                 in.close();

    74             }

    75     }

    76 

    77     /************ Helper annotations counting methods ******************/

    78     void test(ClassFile cf) {

    79         test("CLASS",cf, null, null, Attribute.RuntimeVisibleTypeAnnotations, true);

    80         test("CLASS",cf, null, null, Attribute.RuntimeInvisibleTypeAnnotations, false);

    81         //RuntimeAnnotations since one annotation can result in two attributes.

    82         test("CLASS",cf, null, null, Attribute.RuntimeVisibleAnnotations, true);

    83         test("CLASS",cf, null, null, Attribute.RuntimeInvisibleAnnotations, false);

    84     }

    85 

    86     void test(ClassFile cf, Method m) {

    87         test("METHOD",cf, null, m, Attribute.RuntimeVisibleTypeAnnotations, true);

    88         test("METHOD",cf, null, m, Attribute.RuntimeInvisibleTypeAnnotations, false);

    89         test("METHOD",cf, null, m, Attribute.RuntimeVisibleAnnotations, true);

    90         test("METHOD",cf, null, m, Attribute.RuntimeInvisibleAnnotations, false);

    91     }

    92 

    93     void test(ClassFile cf, Field f) {

    94         test("FIELD",cf, f, null, Attribute.RuntimeVisibleTypeAnnotations, true);

    95         test("FIELD",cf, f, null, Attribute.RuntimeInvisibleTypeAnnotations, false);

    96         test("FIELD",cf, f, null, Attribute.RuntimeVisibleAnnotations, true);

    97         test("FIELD",cf, f, null, Attribute.RuntimeInvisibleAnnotations, false);

    98     }

    99 

   100 

   101     // Test the result of Attributes.getIndex according to expectations

   102     // encoded in the class/field/method name; increment annotations counts.

   103     void test(String ttype, ClassFile cf, Field f, Method m, String annName, boolean visible) {

   104         String testtype = ttype;

   105         String name = null;

   106         int index = -1;

   107         Attribute attr = null;

   108         boolean isTAattr = annName.contains("TypeAnnotations");

   109         try {

   110             switch(testtype) {

   111                 case "FIELD":

   112                     name = f.getName(cf.constant_pool);

   113                     index = f.attributes.getIndex(cf.constant_pool, annName);

   114                     if(index!= -1) attr = f.attributes.get(index);

   115                     break;

   116                 case "METHOD":

   117                     name = m.getName(cf.constant_pool);

   118                     index = m.attributes.getIndex(cf.constant_pool, annName);

   119                     if(index!= -1) attr = m.attributes.get(index);

   120                     break;

   121                 default:

   122                     name = cf.getName();

   123                     index = cf.attributes.getIndex(cf.constant_pool, annName);

   124                     if(index!= -1) attr = cf.attributes.get(index);

   125             }

   126         } catch(ConstantPoolException cpe) { cpe.printStackTrace(); }

   127 

   128         if (index != -1) {

   129             assert attr instanceof RuntimeTypeAnnotations_attribute;

   130             if(isTAattr) { //count RuntimeTypeAnnotations

   131                 RuntimeTypeAnnotations_attribute tAttr =

   132                         (RuntimeTypeAnnotations_attribute)attr;

   133                 println(testtype + ": " + name + ", " + annName + ": " +

   134                         tAttr.annotations.length );

   135                 allt += tAttr.annotations.length;

   136                 if (visible)

   137                     tvisibles += tAttr.annotations.length;

   138                 else

   139                     tinvisibles += tAttr.annotations.length;

   140             } else {

   141                 RuntimeAnnotations_attribute tAttr =

   142                         (RuntimeAnnotations_attribute)attr;

   143                 println(testtype + ": " + name + ", " + annName + ": " +

   144                         tAttr.annotations.length );

   145                 all += tAttr.annotations.length;

   146                 if (visible)

   147                     visibles += tAttr.annotations.length;

   148                 else

   149                     invisibles += tAttr.annotations.length;

   150             }

   151         }

   152     }

   153 

   154     void countAnnotations() {

   155         errors=0;

   156         int expected_allt = expected_tvisibles + expected_tinvisibles;

   157         int expected_all = expected_visibles + expected_invisibles;

   158 

   159         if (expected_allt != allt) {

   160             errors++;

   161             System.err.println("Failure: expected " + expected_allt +

   162                     " type annotations but found " + allt);

   163         }

   164         if (expected_all != all) {

   165             errors++;

   166             System.err.println("Failure: expected " + expected_all +

   167                     " annotations but found " + all);

   168         }

   169         if (expected_tvisibles != tvisibles) {

   170             errors++;

   171             System.err.println("Failure: expected " + expected_tvisibles +

   172                     " typevisible annotations but found " + tvisibles);

   173         }

   174 

   175         if (expected_tinvisibles != tinvisibles) {

   176             errors++;

   177             System.err.println("Failure: expected " + expected_tinvisibles +

   178                     " typeinvisible annotations but found " + tinvisibles);

   179         }

   180         allt=0;

   181         tvisibles=0;

   182         tinvisibles=0;

   183         all=0;

   184         visibles=0;

   185         invisibles=0;

   186     }

   187 

   188     int errors;

   189     int allt;

   190     int tvisibles;

   191     int tinvisibles;

   192     int all;

   193     int visibles;

   194     int invisibles;

   195 }