1 /*
2 * Copyright (c) 2016, 2019, 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 /*
25 * @test
26 * @bug 8164819
27 * @summary Test of toString on normal annotations
28 * @library /tools/javac/lib
29 * @build JavacTestingAbstractProcessor AnnotationToStringTest
30 * @compile -processor AnnotationToStringTest -proc:only AnnotationToStringTest.java
31 */
32
33 // See also the sibling core reflection test
34 // test/jdk/java/lang/annotation/AnnotationToStringTest.java
35
36 import java.lang.annotation.*;
37 import java.lang.reflect.*;
38 import java.util.*;
39 import javax.annotation.processing.*;
40 import javax.lang.model.AnnotatedConstruct;
41 import javax.lang.model.element.*;
42 import javax.lang.model.util.*;
43
44 /**
45 * The expected string values are stored in @ExpectedString
46 * annotations. The essence of the test is comparing the toString()
47 * result of annotations to the corresponding ExpectedString.value().
48 *
49 * Two flavors of comparison are made:
50 *
51 * 1) Against the AnnotationMirror value from getAnnotationMirrors()
52 *
53 * 2) Against the *Annotation* from getAnnotation(Class<A>)
54 *
55 * These have separate but related implementations.
56 */
57 public class AnnotationToStringTest extends JavacTestingAbstractProcessor {
58 public boolean process(Set<? extends TypeElement> annotations,
59 RoundEnvironment roundEnv) {
60 if (!roundEnv.processingOver()) {
61
62 int failures = 0;
63
64 TypeElement primHostElt =
65 Objects.requireNonNull(elements.getTypeElement("AnnotationToStringTest.PrimHost"));
66
67 List<? extends AnnotationMirror> annotMirrors = primHostElt.getAnnotationMirrors();
68
69 String expectedString = primHostElt.getAnnotation(MostlyPrimitive.class).toString();
70
71 failures += check(expectedString,
72 primHostElt.getAnnotation(ExpectedString.class).value());
73
74 failures += check(expectedString,
75 retrieveAnnotationMirrorAsString(primHostElt,
76 "MostlyPrimitive"));
77 failures += classyTest();
78 failures += arrayAnnotationTest();
79
80 if (failures > 0)
81 throw new RuntimeException(failures + " failures");
82 }
83 return true;
84 }
85
86 /**
87 * Examine annotation mirrors, find the one that matches
88 * annotationName, and return its toString value.
89 */
90 private String retrieveAnnotationMirrorAsString(AnnotatedConstruct annotated,
91 String annotationName) {
92 return retrieveAnnotationMirror(annotated, annotationName).toString();
93 }
94
95 private String retrieveAnnotationMirrorValue(AnnotatedConstruct annotated,
96 String annotationName) {
97 AnnotationMirror annotationMirror =
98 retrieveAnnotationMirror(annotated, annotationName);
99 for (var entry : annotationMirror.getElementValues().entrySet()) {
100 if (entry.getKey().getSimpleName().contentEquals("value")) {
101 return entry.getValue().toString();
102 }
103 }
104 throw new RuntimeException("Annotation value() method not found: " +
105 annotationMirror.toString());
106 }
107
108 private AnnotationMirror retrieveAnnotationMirror(AnnotatedConstruct annotated,
109 String annotationName) {
110 for (AnnotationMirror annotationMirror : annotated.getAnnotationMirrors()) {
111 System.out.println(annotationMirror.getAnnotationType());
112 if (annotationMirror
113 .getAnnotationType()
114 .toString()
115 .equals(annotationName) ) {
116 return annotationMirror;
117 }
118 }
119 throw new RuntimeException("Annotation " + annotationName + " not found.");
120 }
121
122 private static int check(String expected, String actual) {
123 if (!expected.equals(actual)) {
124 System.err.printf("ERROR: Expected ''%s'';%ngot ''%s''.\n",
125 expected, actual);
126 return 1;
127 } else
128 return 0;
129 }
130
131 @ExpectedString(
132 "@MostlyPrimitive(c0='a', "+
133 "c1='\\'', " +
134 "b0=(byte)0x01, " +
135 "i0=1, " +
136 "i1=2, " +
137 "f0=1.0f, " +
138 "f1=0.0f/0.0f, " +
139 "d0=0.0, " +
140 "d1=1.0/0.0, " +
141 "l0=5L, " +
142 "l1=9223372036854775807L, " +
143 "l2=-9223372036854775808L, " +
144 "l3=-2147483648L, " +
145 "s0=\"Hello world.\", " +
146 "s1=\"a\\\"b\", " +
147 "class0=Obj[].class, " +
148 "classArray={Obj[].class})")
149 @MostlyPrimitive(
150 c0='a',
151 c1='\'',
152 b0=1,
153 i0=1,
154 i1=2,
155 f0=1.0f,
156 f1=Float.NaN,
157 d0=0.0,
158 d1=2.0/0.0,
159 l0=5,
160 l1=Long.MAX_VALUE,
161 l2=Long.MIN_VALUE,
162 l3=Integer.MIN_VALUE,
163 s0="Hello world.",
164 s1="a\"b",
165 class0=Obj[].class,
166 classArray={Obj[].class}
167 )
168 static class PrimHost{}
169
170 private int classyTest() {
171 int failures = 0;
172
173 TypeElement annotationHostElt =
174 Objects.requireNonNull(elements.getTypeElement("AnnotationToStringTest.AnnotationHost"));
175
176 for (VariableElement f : ElementFilter.fieldsIn(annotationHostElt.getEnclosedElements())) {
177 String expected = f.getAnnotation(ExpectedString.class).value();
178 Annotation a = f.getAnnotation(Classy.class);
179
180 System.out.println(a);
181 failures += check(expected, a.toString());
182
183 failures += check(expected,
184 retrieveAnnotationMirrorAsString(f, "Classy") );
185 }
186 return failures;
187 }
188
189 static class AnnotationHost {
190 @ExpectedString(
191 "@Classy(Obj.class)")
192 @Classy(Obj.class)
193 public int f0;
194
195 @ExpectedString(
196 "@Classy(Obj[].class)")
197 @Classy(Obj[].class)
198 public int f1;
199
200 @ExpectedString(
201 "@Classy(Obj[][].class)")
202 @Classy(Obj[][].class)
203 public int f2;
204
205 @ExpectedString(
206 "@Classy(Obj[][][].class)")
207 @Classy(Obj[][][].class)
208 public int f3;
209
210 @ExpectedString(
211 "@Classy(int.class)")
212 @Classy(int.class)
213 public int f4;
214
215 @ExpectedString(
216 "@Classy(int[][][].class)")
217 @Classy(int[][][].class)
218 public int f5;
219 }
220
221 /**
222 * Each field should have two annotations, the first being
223 * @ExpectedString and the second the annotation under test.
224 */
225 private int arrayAnnotationTest() {
226 int failures = 0;
227
228 TypeElement arrayAnnotationHostElt =
229 Objects.requireNonNull(elements
230 .getTypeElement("AnnotationToStringTest.ArrayAnnotationHost"));
231
232 for (VariableElement f :
233 ElementFilter.fieldsIn(arrayAnnotationHostElt.getEnclosedElements())) {
234 var annotations = f.getAnnotationMirrors();
235 // String expected = retrieveAnnotationMirrorValue(f, "ExpectedString");
236 String expected = f.getAnnotation(ExpectedString.class).value();
237
238 // Problem with
239 // Need a de-quote method...
240 // expected = expected.substring(1, expected.length() - 1);
241
242 failures +=
243 check(expected,
244 annotations.get(1).toString());
245
246 // Get the array-valued annotation as an annotation
247 failures +=
248 check(expected,
249 retrieveAnnotationMirrorAsString(f,
250 annotations.get(1)
251 .getAnnotationType().toString()));
252 }
253 return failures;
254 }
255
256 static class ArrayAnnotationHost {
257 @ExpectedString(
258 "@BooleanArray({true, false, true})")
259 @BooleanArray({true, false, true})
260 public boolean[] f0;
261
262 @ExpectedString(
263 "@FloatArray({3.0f, 4.0f, 0.0f/0.0f, -1.0f/0.0f, 1.0f/0.0f})")
264 @FloatArray({3.0f, 4.0f, Float.NaN, Float.NEGATIVE_INFINITY, Float.POSITIVE_INFINITY})
265 public float[] f1;
266
267 @ExpectedString(
268 "@DoubleArray({1.0, 2.0, 0.0/0.0, 1.0/0.0, -1.0/0.0})")
269 @DoubleArray({1.0, 2.0, Double.NaN, Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY,})
270 public double[] f2;
271
272
273 @ExpectedString(
274 "@ByteArray({(byte)0x0a, (byte)0x0b, (byte)0x0c})")
275 @ByteArray({10, 11, 12})
276 public byte[] f3;
277
278 @ExpectedString(
279 "@ShortArray({0, 4, 5})")
280 @ShortArray({0, 4, 5})
281 public short[] f4;
282
283 @ExpectedString(
284 "@CharArray({'a', 'b', 'c', '\\''})")
285 @CharArray({'a', 'b', 'c', '\''})
286 public char[] f5;
287
288 @ExpectedString(
289 "@IntArray({1})")
290 @IntArray({1})
291 public int[] f6;
292
293 @ExpectedString(
294 "@LongArray({-9223372036854775808L, -2147483649L, -2147483648L," +
295 " -2147483647L, 2147483648L, 9223372036854775807L})")
296 @LongArray({Long.MIN_VALUE, Integer.MIN_VALUE-1L, Integer.MIN_VALUE,
297 -Integer.MAX_VALUE, Integer.MAX_VALUE+1L, Long.MAX_VALUE})
298 public long[] f7;
299
300 @ExpectedString(
301 "@StringArray({\"A\", \"B\", \"C\", \"\\\"Quote\\\"\"})")
302 @StringArray({"A", "B", "C", "\"Quote\""})
303 public String[] f8;
304
305 @ExpectedString(
306 "@ClassArray({int.class, Obj[].class})")
307 @ClassArray({int.class, Obj[].class})
308 public Class<?>[] f9;
309
310 @ExpectedString(
311 "@EnumArray({SOURCE})")
312 @EnumArray({RetentionPolicy.SOURCE})
313 public RetentionPolicy[] f10;
314 }
315 }
316
317 // ------------ Supporting types ------------
318
319 class Obj {}
320
321 @Retention(RetentionPolicy.RUNTIME)
322 @interface ExpectedString {
323 String value();
324 }
325
326 @Retention(RetentionPolicy.RUNTIME)
327 @interface Classy {
328 Class<?> value();
329 }
330
331 @Retention(RetentionPolicy.RUNTIME)
332 @interface BooleanArray {
333 boolean[] value();
334 }
335
336 @Retention(RetentionPolicy.RUNTIME)
337 @interface FloatArray {
338 float[] value();
339 }
340
341 @Retention(RetentionPolicy.RUNTIME)
342 @interface DoubleArray {
343 double[] value();
344 }
345
346 @Retention(RetentionPolicy.RUNTIME)
347 @interface ByteArray {
348 byte[] value();
349 }
350
351 @Retention(RetentionPolicy.RUNTIME)
352 @interface ShortArray {
353 short[] value();
354 }
355
356 @Retention(RetentionPolicy.RUNTIME)
357 @interface CharArray {
358 char[] value();
359 }
360
361 @Retention(RetentionPolicy.RUNTIME)
362 @interface IntArray {
363 int[] value();
364 }
365
366 @Retention(RetentionPolicy.RUNTIME)
367 @interface LongArray {
368 long[] value();
369 }
370
371 @Retention(RetentionPolicy.RUNTIME)
372 @interface ClassArray {
373 Class<?>[] value() default {int.class, Obj[].class};
374 }
375
376 @Retention(RetentionPolicy.RUNTIME)
377 @interface StringArray {
378 String[] value();
379 }
380
381 @Retention(RetentionPolicy.RUNTIME)
382 @interface EnumArray {
383 RetentionPolicy[] value();
384 }
385
386 @Retention(RetentionPolicy.RUNTIME)
387 @interface MostlyPrimitive {
388 char c0();
389 char c1();
390 byte b0();
391 int i0();
392 int i1();
393 float f0();
394 float f1();
395 double d0();
396 double d1();
397 long l0();
398 long l1();
399 long l2();
400 long l3();
401 String s0();
402 String s1();
403 Class<?> class0();
404 Class<?>[] classArray();
405 }