1/*
2 * Copyright (c) 2017, 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     8074977
27 * @summary Test consistency of annotations on constructor parameters
28 * @compile             TestConstructorParameterTypeAnnotations.java
29 * @run main            TestConstructorParameterTypeAnnotations
30 * @compile -parameters TestConstructorParameterTypeAnnotations.java
31 * @run main            TestConstructorParameterTypeAnnotations
32 */
33
34import java.lang.annotation.*;
35import java.lang.reflect.*;
36import java.util.*;
37
38/*
39 * Some constructor parameters are <em>mandated</em>; that is, they
40 * are not explicitly present in the source code, but required to be
41 * present by the Java Language Specification. In other cases, some
42 * constructor parameters are not present in the source, but are
43 * synthesized by the compiler as an implementation artifact. There is
44 * not a reliable mechanism to consistently determine whether or not
45 * a parameter is implicit or not.
46 *
47 * (Using the "-parameters" option to javac does emit the information
48 * needed to make a reliably determination, but the information is not
49 * present by default.)
50 *
51 * The lack of such a mechanism causes complications reading parameter
52 * annotations in some cases since annotations for parameters are
53 * written out for the parameters in the source code, but when reading
54 * annotations at runtime all the parameters, including implicit ones,
55 * are present.
56 */
57public class TestConstructorParameterTypeAnnotations {
58    public static void main(String... args) {
59        int errors = 0;
60        Class<?>[] classes = {NestedClass0.class,
61                              NestedClass1.class,
62                              NestedClass2.class,
63                              NestedClass3.class,
64                              NestedClass4.class,
65                              StaticNestedClass0.class,
66                              StaticNestedClass1.class,
67                              StaticNestedClass2.class };
68
69        for (Class<?> clazz : classes) {
70            for (Constructor<?> ctor : clazz.getConstructors()) {
71                System.out.println(ctor);
72                errors += checkGetParameterAnnotations(clazz, ctor);
73                errors += checkGetAnnotatedParametersGetAnnotation(clazz, ctor);
74            }
75        }
76
77        if (errors > 0)
78            throw new RuntimeException(errors + " errors.");
79        return;
80    }
81
82    private static int checkGetParameterAnnotations(Class<?> clazz,
83                                                    Constructor<?> ctor) {
84        String annotationString =
85            Arrays.deepToString(ctor.getParameterAnnotations());
86        String expectedString =
87            clazz.getAnnotation(ExpectedGetParameterAnnotations.class).value();
88
89        if (!Objects.equals(annotationString, expectedString)) {
90            System.err.println("Annotation mismatch on " + ctor +
91                               "\n\tExpected:" + expectedString +
92                               "\n\tActual:  " + annotationString);
93            return 1;
94        }
95        return 0;
96    }
97
98    private static int checkGetAnnotatedParametersGetAnnotation(Class<?> clazz,
99                                                       Constructor<?> ctor) {
100        int errors = 0;
101        int i = 0;
102        ExpectedParameterTypeAnnotations epa =
103            clazz.getAnnotation(ExpectedParameterTypeAnnotations.class);
104
105        for (AnnotatedType param : ctor.getAnnotatedParameterTypes() ) {
106            String annotationString =
107                Objects.toString(param.getAnnotation(MarkerTypeAnnotation.class));
108            String expectedString = epa.value()[i];
109
110            if (!Objects.equals(annotationString, expectedString)) {
111                System.err.println("Annotation mismatch on " + ctor +
112                                   " on param " + param +
113                                   "\n\tExpected:" + expectedString +
114                                   "\n\tActual:  " + annotationString);
115                errors++;
116            }
117            i++;
118        }
119        return errors;
120    }
121
122    @ExpectedGetParameterAnnotations("[[]]")
123    @ExpectedParameterTypeAnnotations({"null"})
124    public class NestedClass0 {
125        public NestedClass0() {}
126    }
127
128    @ExpectedGetParameterAnnotations("[[], []]")
129    @ExpectedParameterTypeAnnotations({
130        "null",
131        "@TestConstructorParameterTypeAnnotations$MarkerTypeAnnotation(value=1)"})
132    public class NestedClass1 {
133        public NestedClass1(@MarkerTypeAnnotation(1) int parameter) {}
134    }
135
136    @ExpectedGetParameterAnnotations("[[], [], []]")
137    @ExpectedParameterTypeAnnotations({
138        "null",
139        "@TestConstructorParameterTypeAnnotations$MarkerTypeAnnotation(value=2)",
140        "null"})
141    public class NestedClass2 {
142        public NestedClass2(@MarkerTypeAnnotation(2) int parameter1,
143                            int parameter2) {}
144    }
145
146    @ExpectedGetParameterAnnotations("[[], [], []]")
147    @ExpectedParameterTypeAnnotations({
148        "null",
149        "@TestConstructorParameterTypeAnnotations$MarkerTypeAnnotation(value=3)",
150        "null"})
151    public class NestedClass3 {
152        public <P> NestedClass3(@MarkerTypeAnnotation(3) P parameter1,
153                                int parameter2) {}
154    }
155
156    @ExpectedGetParameterAnnotations("[[], [], []]")
157    @ExpectedParameterTypeAnnotations({
158        "null",
159        "@TestConstructorParameterTypeAnnotations$MarkerTypeAnnotation(value=4)",
160        "null"})
161    public class NestedClass4 {
162        public <P, Q> NestedClass4(@MarkerTypeAnnotation(4) P parameter1,
163                                   Q parameter2) {}
164    }
165
166    @ExpectedGetParameterAnnotations("[]")
167    @ExpectedParameterTypeAnnotations({"null"})
168    public static class StaticNestedClass0 {
169        public StaticNestedClass0() {}
170    }
171
172    @ExpectedGetParameterAnnotations("[[]]")
173    @ExpectedParameterTypeAnnotations({
174        "@TestConstructorParameterTypeAnnotations$MarkerTypeAnnotation(value=1)"})
175    public static class StaticNestedClass1 {
176        public StaticNestedClass1(@MarkerTypeAnnotation(1) int parameter) {}
177    }
178
179    @ExpectedGetParameterAnnotations("[[], []]")
180    @ExpectedParameterTypeAnnotations({
181        "@TestConstructorParameterTypeAnnotations$MarkerTypeAnnotation(value=2)",
182        "null"})
183    public static class StaticNestedClass2 {
184        public StaticNestedClass2(@MarkerTypeAnnotation(2) int parameter1,
185                                  int parameter2) {}
186    }
187
188    @ExpectedGetParameterAnnotations("[[], []]")
189    @ExpectedParameterTypeAnnotations({
190        "@TestConstructorParameterTypeAnnotations$MarkerTypeAnnotation(value=3)",
191        "null"})
192    public static class StaticNestedClass3 {
193         public <P> StaticNestedClass3(@MarkerTypeAnnotation(3) P parameter1,
194                                      int parameter2) {}
195    }
196
197    @ExpectedGetParameterAnnotations("[[], []]")
198    @ExpectedParameterTypeAnnotations({
199        "@TestConstructorParameterTypeAnnotations$MarkerTypeAnnotation(value=4)",
200        "null"})
201    public static class StaticNestedClass4 {
202        public <P, Q> StaticNestedClass4(@MarkerTypeAnnotation(4) P parameter1,
203                                         Q parameter2) {}
204    }
205
206    @Target(ElementType.TYPE_USE)
207    @Retention(RetentionPolicy.RUNTIME)
208    @interface MarkerTypeAnnotation {
209        int value();
210    }
211
212    /**
213     * String form of expected value of calling
214     * getParameterAnnotations on a constructor.
215     */
216    @Target(ElementType.TYPE)
217    @Retention(RetentionPolicy.RUNTIME)
218    @interface ExpectedGetParameterAnnotations {
219        String value();
220    }
221
222    /**
223     * String form of expected value of calling
224     * getAnnotation(MarkerTypeAnnotation.class) on each element of the
225     * result of getParameters() on a constructor.
226     */
227    @Target(ElementType.TYPE)
228    @Retention(RetentionPolicy.RUNTIME)
229    @interface ExpectedParameterTypeAnnotations {
230        String[] value();
231    }
232}
233