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
24import java.lang.annotation.*;
25import java.io.*;
26import java.net.URL;
27import java.util.List;
28
29import com.sun.tools.classfile.*;
30
31public 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.err.println(msg); }
40    void print(String msg) { if (verbose) System.err.print(msg); }
41
42    File writeTestFile(String fname, String source) throws IOException {
43      File f = new File(fname);
44        PrintWriter out = new PrintWriter(new BufferedWriter(new FileWriter(f)));
45        out.println(source);
46        out.close();
47        return f;
48    }
49
50    File compile(File f) {
51        int rc = com.sun.tools.javac.Main.compile(new String[] {
52                "-g", f.getPath() });
53        if (rc != 0)
54            throw new Error("compilation failed. rc=" + rc);
55        String path = f.getPath();
56        return new File(path.substring(0, path.length() - 5) + ".class");
57    }
58
59    ClassFile getClassFile(String name) throws IOException, ConstantPoolException {
60        URL url = getClass().getResource(name);
61        InputStream in = url.openStream();
62        try {
63            return ClassFile.read(in);
64        } finally {
65            in.close();
66        }
67    }
68
69    ClassFile getClassFile(URL url) throws IOException, ConstantPoolException {
70        InputStream in = url.openStream();
71        try {
72            return ClassFile.read(in);
73        } finally {
74            in.close();
75        }
76    }
77
78    /************ Helper annotations counting methods ******************/
79    void test(ClassFile cf) {
80        test("CLASS",cf, null, null, Attribute.RuntimeVisibleTypeAnnotations, true);
81        test("CLASS",cf, null, null, Attribute.RuntimeInvisibleTypeAnnotations, false);
82        //RuntimeAnnotations since one annotation can result in two attributes.
83        test("CLASS",cf, null, null, Attribute.RuntimeVisibleAnnotations, true);
84        test("CLASS",cf, null, null, Attribute.RuntimeInvisibleAnnotations, false);
85    }
86
87    void test(ClassFile cf, Field f, Boolean local) {
88        if (!local) {
89            test("FIELD",cf, f, null, Attribute.RuntimeVisibleTypeAnnotations, true);
90            test("FIELD",cf, f, null, Attribute.RuntimeInvisibleTypeAnnotations, false);
91            test("FIELD",cf, f, null, Attribute.RuntimeVisibleAnnotations, true);
92            test("FIELD",cf, f, null, Attribute.RuntimeInvisibleAnnotations, false);
93        } else {
94            test("CODE",cf, f, null, Attribute.RuntimeVisibleTypeAnnotations, true);
95            test("CODE",cf, f, null, Attribute.RuntimeInvisibleTypeAnnotations, false);
96            test("CODE",cf, f, null, Attribute.RuntimeVisibleAnnotations, true);
97            test("CODE",cf, f, null, Attribute.RuntimeInvisibleAnnotations, false);
98        }
99    }
100
101    void test(ClassFile cf, Field f) {
102        test(cf, f, false);
103    }
104
105    // 'local' determines whether to look for annotations in code attribute or not.
106    void test(ClassFile cf, Method m, Boolean local) {
107        if (!local) {
108            test("METHOD",cf, null, m, Attribute.RuntimeVisibleTypeAnnotations, true);
109            test("METHOD",cf, null, m, Attribute.RuntimeInvisibleTypeAnnotations, false);
110            test("METHOD",cf, null, m, Attribute.RuntimeVisibleAnnotations, true);
111            test("METHOD",cf, null, m, Attribute.RuntimeInvisibleAnnotations, false);
112        } else  {
113            test("MCODE",cf, null, m, Attribute.RuntimeVisibleTypeAnnotations, true);
114            test("MCODE",cf, null, m, Attribute.RuntimeInvisibleTypeAnnotations, false);
115            test("MCODE",cf, null, m, Attribute.RuntimeVisibleAnnotations, true);
116            test("MCODE",cf, null, m, Attribute.RuntimeInvisibleAnnotations, false);
117        }
118    }
119
120    // default to not looking in code attribute
121    void test(ClassFile cf, Method m ) {
122        test(cf, m, false);
123    }
124
125    // Test the result of Attributes.getIndex according to expectations
126    // encoded in the class/field/method name; increment annotations counts.
127    void test(String ttype, ClassFile cf, Field f, Method m, String annName, boolean visible) {
128        String testtype = ttype;
129        String name = null;
130        int index = -1;
131        Attribute attr = null;
132        Code_attribute cAttr = null;
133        boolean isTAattr = annName.contains("TypeAnnotations");
134        try {
135            switch(testtype) {
136                case "FIELD":
137                    name = f.getName(cf.constant_pool);
138                    index = f.attributes.getIndex(cf.constant_pool, annName);
139                    if(index!= -1)
140                        attr = f.attributes.get(index);
141                    break;
142                case "CODE":
143                    name = f.getName(cf.constant_pool);
144                    //fetch index of and code attribute and annotations from code attribute.
145                    index = cf.attributes.getIndex(cf.constant_pool, Attribute.Code);
146                    if(index!= -1) {
147                        attr = cf.attributes.get(index);
148                        assert attr instanceof Code_attribute;
149                        cAttr = (Code_attribute)attr;
150                        index = cAttr.attributes.getIndex(cf.constant_pool, annName);
151                        if(index!= -1)
152                            attr = cAttr.attributes.get(index);
153                    }
154                    break;
155                case "METHOD":
156                    name = m.getName(cf.constant_pool);
157                    index = m.attributes.getIndex(cf.constant_pool, annName);
158                    if(index!= -1)
159                        attr = m.attributes.get(index);
160                    break;
161                case "MCODE":
162                    name = m.getName(cf.constant_pool);
163                    //fetch index of and code attribute and annotations from code attribute.
164                    index = m.attributes.getIndex(cf.constant_pool, Attribute.Code);
165                    if(index!= -1) {
166                        attr = m.attributes.get(index);
167                        assert attr instanceof Code_attribute;
168                        cAttr = (Code_attribute)attr;
169                        index = cAttr.attributes.getIndex(cf.constant_pool, annName);
170                        if(index!= -1)
171                            attr = cAttr.attributes.get(index);
172                    }
173                    break;
174                default:
175                    name = cf.getName();
176                    index = cf.attributes.getIndex(cf.constant_pool, annName);
177                    if(index!= -1) attr = cf.attributes.get(index);
178            }
179        } catch(ConstantPoolException cpe) { cpe.printStackTrace(); }
180
181        if (index != -1) {
182            if(isTAattr) { //count RuntimeTypeAnnotations
183                RuntimeTypeAnnotations_attribute tAttr =
184                        (RuntimeTypeAnnotations_attribute)attr;
185                println(testtype + ": " + name + ", " + annName + ": " +
186                        tAttr.annotations.length );
187                if (tAttr.annotations.length > 0) {
188                    for (int i = 0; i < tAttr.annotations.length; i++) {
189                        println("  types:" + tAttr.annotations[i].position.type);
190                    }
191                } else {
192                    println("");
193                }
194                allt += tAttr.annotations.length;
195                if (visible)
196                    tvisibles += tAttr.annotations.length;
197                else
198                    tinvisibles += tAttr.annotations.length;
199            } else {
200                RuntimeAnnotations_attribute tAttr =
201                        (RuntimeAnnotations_attribute)attr;
202                println(testtype + ": " + name + ", " + annName + ": " +
203                        tAttr.annotations.length );
204                all += tAttr.annotations.length;
205                if (visible)
206                    visibles += tAttr.annotations.length;
207                else
208                    invisibles += tAttr.annotations.length;
209            }
210        }
211    }
212
213    void countAnnotations() {
214        errors=0;
215        int expected_allt = expected_tvisibles + expected_tinvisibles;
216        int expected_all = expected_visibles + expected_invisibles;
217
218        if (expected_allt != allt) {
219            errors++;
220            System.err.println("Failure: expected " + expected_allt +
221                    " type annotations but found " + allt);
222        }
223        if (expected_all != all) {
224            errors++;
225            System.err.println("Failure: expected " + expected_all +
226                    " annotations but found " + all);
227        }
228        if (expected_tvisibles != tvisibles) {
229            errors++;
230            System.err.println("Failure: expected " + expected_tvisibles +
231                    " typevisible annotations but found " + tvisibles);
232        }
233
234        if (expected_tinvisibles != tinvisibles) {
235            errors++;
236            System.err.println("Failure: expected " + expected_tinvisibles +
237                    " typeinvisible annotations but found " + tinvisibles);
238        }
239        allt=0;
240        tvisibles=0;
241        tinvisibles=0;
242        all=0;
243        visibles=0;
244        invisibles=0;
245    }
246
247    int errors;
248    int allt;
249    int tvisibles;
250    int tinvisibles;
251    int all;
252    int visibles;
253    int invisibles;
254}
255