1 /*
2 * Copyright 2010 Sun Microsystems, Inc. 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
20 * CA 95054 USA or visit www.sun.com if you need additional information or
21 * have any questions.
22 */
23
24 /*
25 * @test
26 * @bug 6449781
27 * @summary Test that reported names of anonymous classes are non-null.
28 * @author Joseph D. Darcy
29 * @build TestAnonSourceNames
30 * @compile/fail -processor TestAnonSourceNames TestAnonClassNames.java
31 * @build TestAnonClassNames
32 * @run main TestAnonClassNames
33 */
34
35 /*
36 * This test operates in phases to test retrieving the qualified name
37 * of anonymous classes from type elements modeling the anonymous
38 * class. The type elements are generated using both source files and
39 * class files as the basis of constructing the elements.
40 *
41 * Source files will be tested by the @compile line which runs
42 * TestAnonSourceNames as an annotation processor over this file.
43 * This compile line is expected to fail until 6930507 is fixed. Once
44 * bug 6930507 is fixed, the "@compile/fail -processor ..." and
45 * following "@build..." steps can be replaced with a single "@compile
46 * -processor ..." directive.
47 *
48 * Class files are tested by the @run command on this type. This
49 * class gets the names of classes with different nesting kinds,
50 * including anonymous classes, and then invokes the compiler with an
51 * annotation processor having the class files names as inputs. The
52 * compiler is invoked via the javax.tools mechanism.
53 */
54
55 import java.lang.annotation.*;
56 import javax.lang.model.element.*;
57 import javax.annotation.processing.*;
58 import javax.lang.model.SourceVersion;
59 import javax.lang.model.element.*;
60 import javax.lang.model.util.*;
61 import javax.tools.*;
62 import java.util.*;
63
64 import static java.lang.annotation.RetentionPolicy.*;
65 import static javax.lang.model.element.NestingKind.*;
66 import static javax.lang.model.util.ElementFilter.*;
67 import static javax.tools.Diagnostic.Kind.*;
68 import static javax.tools.StandardLocation.*;
69
70 @Nesting(TOP_LEVEL)
71 public class TestAnonClassNames {
72 @Nesting(MEMBER)
73 static class MemberClass1{}
74
75 @Nesting(MEMBER)
76 class MemberClass2{}
77
78 @Nesting(MEMBER)
79 class Win$$AtVegas { } // Class with funny name.
80
81 public static void main(String... argv) {
82 @Nesting(LOCAL)
83 class LocalClass{};
84
85 Object o = new @Nesting(ANONYMOUS) Object() { // An anonymous annotated class
86 public String toString() {
87 return "I have no name!";
88 }
89 };
90
91 Class<?>[] classes = {
92 MemberClass1.class,
93 MemberClass2.class,
94 LocalClass.class,
95 Win$$AtVegas.class,
96 o.getClass(),
97 TestAnonClassNames.class,
98 };
99
100 for(Class<?> clazz : classes) {
101 String name = clazz.getName();
102 System.out.format("%s is %s%n",
103 clazz.getName(),
104 clazz.getAnnotation(Nesting.class).value());
105 testClassName(name);
106 }
107 }
108
109 /**
110 * Perform annotation processing on the class file name and verify
111 * the existence of different flavors of class names when the
112 * input classes are modeled as elements.
113 */
114 static void testClassName(String className) {
115 JavaCompiler javaCompiler = ToolProvider.getSystemJavaCompiler();
116 List<String> classNames = new ArrayList<>();
117 classNames.add(className);
118
119 List<String> options = new ArrayList<>();
120 options.add("-proc:only");
121 options.add("-classpath");
122 options.add(System.getProperty("test.classes"));
123
124 JavaCompiler.CompilationTask compileTask =
125 javaCompiler.getTask(null, // Output
126 null, // File manager
127 null, // Diagnostics
128 options,
129 classNames,
130 null); // Sources
131 List<Processor> processors = new ArrayList<>();
132 processors.add(new ClassNameProber());
133 compileTask.setProcessors(processors);
134 Boolean goodResult = compileTask.call();
135 if (!goodResult) {
136 throw new RuntimeException("Errors found during compile.");
137 }
138 }
139 }
140
141 @Retention(RUNTIME)
142 @interface Nesting {
143 NestingKind value();
144 }
145
146 /**
147 * Probe at the various kinds of names of a type element.
148 */
149 @SupportedAnnotationTypes("*")
150 class ClassNameProber extends AbstractProcessor {
151 public ClassNameProber(){super();}
152
153 private boolean classesFound=false;
154
155 public boolean process(Set<? extends TypeElement> annotations,
156 RoundEnvironment roundEnv) {
157 if (!roundEnv.processingOver()) {
158 for(TypeElement typeElt : typesIn(roundEnv.getRootElements())) {
159 classesFound = true;
160
161 // Verify different names are non-null; an NPE will
162 // result in failed compile status being reported.
163 NestingKind nestingKind = typeElt.getNestingKind();
164 System.out.printf("\tSimple name: ''%s''\tQualified Name: ''%s''\tKind ''%s''\tNesting ''%s''%n",
165 typeElt.getSimpleName().toString(),
166 typeElt.getQualifiedName().toString(),
167 typeElt.getKind().toString(),
168 nestingKind.toString());
169
170 if (typeElt.getAnnotation(Nesting.class).value() != nestingKind) {
171 throw new RuntimeException("Mismatch of expected and reported nesting kind.");
172 }
173 }
174
175 }
176
177 if (!classesFound) {
178 throw new RuntimeException("Error: no classes processed.");
179 }
180 return true;
181 }
182
183 public SourceVersion getSupportedSourceVersion() {
184 return SourceVersion.latest();
185 }
186 }