1 /*

     2  * Copyright (c) 2008, 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.io.*;

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

    26 

    27 /*

    28  * @test JSR175Annotations

    29  * @bug 6843077

    30  * @summary test that only type annotations are recorded as such in classfile

    31  */

    32 

    33 public class JSR175Annotations {

    34     public static void main(String[] args) throws Exception {

    35         new JSR175Annotations().run();

    36     }

    37 

    38     public void run() throws Exception {

    39         File javaFile = writeTestFile();

    40         File classFile = compileTestFile(javaFile);

    41 

    42         ClassFile cf = ClassFile.read(classFile);

    43         for (Field f : cf.fields) {

    44             test(cf, f);

    45         }

    46         for (Method m: cf.methods) {

    47             test(cf, m);

    48         }

    49 

    50         countAnnotations();

    51 

    52         if (errors > 0)

    53             throw new Exception(errors + " errors found");

    54         System.out.println("PASSED");

    55     }

    56 

    57     void test(ClassFile cf, Method m) {

    58         test(cf, m, Attribute.RuntimeVisibleTypeAnnotations, true);

    59         test(cf, m, Attribute.RuntimeInvisibleTypeAnnotations, false);

    60     }

    61 

    62     void test(ClassFile cf, Field m) {

    63         test(cf, m, Attribute.RuntimeVisibleTypeAnnotations, true);

    64         test(cf, m, Attribute.RuntimeInvisibleTypeAnnotations, false);

    65     }

    66 

    67     // test the result of Attributes.getIndex according to expectations

    68     // encoded in the method's name

    69     void test(ClassFile cf, Method m, String name, boolean visible) {

    70         int index = m.attributes.getIndex(cf.constant_pool, name);

    71         if (index != -1) {

    72             Attribute attr = m.attributes.get(index);

    73             assert attr instanceof RuntimeTypeAnnotations_attribute;

    74             RuntimeTypeAnnotations_attribute tAttr = (RuntimeTypeAnnotations_attribute)attr;

    75             all += tAttr.annotations.length;

    76             if (visible)

    77                 visibles += tAttr.annotations.length;

    78             else

    79                 invisibles += tAttr.annotations.length;

    80         }

    81     }

    82 

    83     // test the result of Attributes.getIndex according to expectations

    84     // encoded in the method's name

    85     void test(ClassFile cf, Field m, String name, boolean visible) {

    86         int index = m.attributes.getIndex(cf.constant_pool, name);

    87         if (index != -1) {

    88             Attribute attr = m.attributes.get(index);

    89             assert attr instanceof RuntimeTypeAnnotations_attribute;

    90             RuntimeTypeAnnotations_attribute tAttr = (RuntimeTypeAnnotations_attribute)attr;

    91             all += tAttr.annotations.length;

    92             if (visible)

    93                 visibles += tAttr.annotations.length;

    94             else

    95                 invisibles += tAttr.annotations.length;

    96         }

    97     }

    98 

    99     File writeTestFile() throws IOException {

   100         File f = new File("Test.java");

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

   102         out.println("import java.lang.annotation.Retention;");

   103         out.println("import java.lang.annotation.RetentionPolicy;");

   104         out.println("abstract class Test { ");

   105         out.println("  @Retention(RetentionPolicy.RUNTIME)");

   106         out.println("  @interface A { }");

   107         out.println("  @A String m;");

   108         out.println("  @A String method(@A String a) {");

   109         out.println("    return a;");

   110         out.println("  }");

   111         out.println("}");

   112         out.close();

   113         return f;

   114     }

   115 

   116     File compileTestFile(File f) {

   117         int rc = com.sun.tools.javac.Main.compile(new String[] { "-source", "1.7", "-g", f.getPath() });

   118         if (rc != 0)

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

   120         String path = f.getPath();

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

   122     }

   123 

   124     void countAnnotations() {

   125         int expected_visibles = 0, expected_invisibles = 0;

   126         int expected_all = expected_visibles + expected_invisibles;

   127 

   128         if (expected_all != all) {

   129             errors++;

   130             System.err.println("expected " + expected_all

   131                     + " annotations but found " + all);

   132         }

   133 

   134         if (expected_visibles != visibles) {

   135             errors++;

   136             System.err.println("expected " + expected_visibles

   137                     + " visibles annotations but found " + visibles);

   138         }

   139 

   140         if (expected_invisibles != invisibles) {

   141             errors++;

   142             System.err.println("expected " + expected_invisibles

   143                     + " invisibles annotations but found " + invisibles);

   144         }

   145 

   146     }

   147 

   148     int errors;

   149     int all;

   150     int visibles;

   151     int invisibles;

   152 }