1 /*
2 * Copyright (c) 2012, 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 * @ignore
26 * @test
27 * @compile -parameters WithParameters.java
28 * @run main WithParameters
29 * @summary javac should generate method parameters correctly.
30 */
31
32 import java.lang.*;
33 import java.lang.annotation.*;
34 import java.lang.reflect.*;
35 import java.util.List;
36
37 public class WithParameters {
38
39 private static final Class<?>[] qux_types = {
40 int.class, Foo.class, List.class, List.class, List.class, String[].class
41 };
42
43 private static final String[] qux_names = {
44 "quux", "quuux", "l", "l2", "l3", "rest"
45 };
46
47 public static void main(String argv[]) throws Exception {
48 int error = 0;
49 Method[] methods = Foo.class.getMethods();
50 for(Method m : methods) {
51 System.err.println("Inspecting method " + m.getName());
52 Parameter[] parameters = m.getParameters();
53 if(parameters == null)
54 throw new Exception("getParameters should never be null");
55 for(int i = 0; i < parameters.length; i++) {
56 Parameter p = parameters[i];
57 if(!p.getDeclaringExecutable().equals(m)) {
58 System.err.println(p + ".getDeclaringExecutable != " + m);
59 error++;
60 }
61 if(null == p.getType()) {
62 System.err.println(p + ".getType() == null");
63 error++;
64 }
65 if(null == p.getParameterizedType()) {
66 System.err.println(p + ".getParameterizedType == null");
67 error++;
68 }
69 }
70 if(m.getName().equals("qux")) {
71 if(6 != parameters.length) {
72 System.err.println("Wrong number of parameters for qux");
73 error++;
74 }
75 for(int i = 0; i < parameters.length; i++) {
76 Parameter p = parameters[i];
77 if(!parameters[i].getName().equals(qux_names[i])) {
78 System.err.println("Wrong parameter name for " + parameters[i]);
79 error++;
80 }
81 // The getType family work with or without
82 // parameter attributes compiled in.
83 if(!parameters[i].getType().equals(qux_types[i])) {
84 System.err.println("Wrong parameter type for " + parameters[0] + ": expected " + qux_types[i] + ", but got " + parameters[i].getType());
85 error++;
86 }
87 }
88 if(parameters[0].toString().equals("int quux")) {
89 System.err.println("toString for quux is wrong");
90 error++;
91 }
92 if(parameters[0].getModifiers() != Modifier.FINAL) {
93 System.err.println("quux is not final");
94 error++;
95 }
96 if(parameters[0].isVarArgs()) {
97 System.err.println("isVarArg for quux is wrong");
98 error++;
99 }
100 if(!parameters[0].getParameterizedType().equals(int.class)) {
101 System.err.println("getParameterizedType for quux is wrong");
102 error++;
103 }
104 if(parameters[1].toString().equals("WithParameters$Foo quuux")) {
105 System.err.println("toString for quuux is wrong");
106 error++;
107 }
108 if(parameters[1].isVarArgs()) {
109 System.err.println("isVarArg for quuux is wrong");
110 error++;
111 }
112 if(!parameters[1].getParameterizedType().equals(Foo.class)) {
113 System.err.println("getParameterizedType for quuux is wrong");
114 error++;
115 }
116 Annotation[] anns = parameters[1].getAnnotations();
117 if(1 != anns.length) {
118 System.err.println("getAnnotations missed an annotation");
119 error++;
120 } else if(!anns[0].annotationType().equals(Thing.class)) {
121 System.err.println("getAnnotations has the wrong annotation");
122 error++;
123 }
124 if(parameters[2].toString().equals("java.util.List<?> quuux")) {
125 System.err.println("toString for l is wrong");
126 error++;
127 }
128 if(parameters[2].isVarArgs()) {
129 System.err.println("isVarArg for l is wrong");
130 error++;
131 }
132 if(!(parameters[2].getParameterizedType() instanceof
133 ParameterizedType)) {
134 System.err.println("getParameterizedType for l is wrong");
135 error++;
136 } else {
137 ParameterizedType pt =
138 (ParameterizedType) parameters[2].getParameterizedType();
139 if(!pt.getRawType().equals(List.class)) {
140 System.err.println("Raw type for l is wrong");
141 error++;
142 }
143 if(1 != pt.getActualTypeArguments().length) {
144 System.err.println("Number of type parameters for l is wrong");
145 error++;
146 }
147 if(!(pt.getActualTypeArguments()[0] instanceof WildcardType)) {
148 System.err.println("Type parameter for l is wrong");
149 error++;
150 }
151 }
152 if(parameters[3].toString().equals("java.util.List<WithParameters$Foo> l")) {
153 System.err.println("toString for l2 is wrong");
154 error++;
155 }
156 if(parameters[3].isVarArgs()) {
157 System.err.println("isVarArg for l2 is wrong");
158 error++;
159 }
160 if(!(parameters[3].getParameterizedType() instanceof
161 ParameterizedType)) {
162 System.err.println("getParameterizedType for l2 is wrong");
163 error++;
164 } else {
165 ParameterizedType pt =
166 (ParameterizedType) parameters[3].getParameterizedType();
167 if(!pt.getRawType().equals(List.class)) {
168 System.err.println("Raw type for l2 is wrong");
169 error++;
170 }
171 if(1 != pt.getActualTypeArguments().length) {
172 System.err.println("Number of type parameters for l2 is wrong");
173 error++;
174 }
175 if(!(pt.getActualTypeArguments()[0].equals(Foo.class))) {
176 System.err.println("Type parameter for l2 is wrong");
177 error++;
178 }
179 }
180 if(parameters[4].toString().equals("java.util.List<? extends WithParameters$Foo> l")) {
181 System.err.println("toString for l3 is wrong");
182 error++;
183 }
184 if(parameters[4].isVarArgs()) {
185 System.err.println("isVarArg for l3 is wrong");
186 error++;
187 }
188 if(!(parameters[4].getParameterizedType() instanceof
189 ParameterizedType)) {
190 System.err.println("getParameterizedType for l3 is wrong");
191 error++;
192 } else {
193 ParameterizedType pt =
194 (ParameterizedType) parameters[4].getParameterizedType();
195 if(!pt.getRawType().equals(List.class)) {
196 System.err.println("Raw type for l3 is wrong");
197 error++;
198 }
199 if(1 != pt.getActualTypeArguments().length) {
200 System.err.println("Number of type parameters for l3 is wrong");
201 error++;
202 }
203 if(!(pt.getActualTypeArguments()[0] instanceof WildcardType)) {
204 System.err.println("Type parameter for l3 is wrong");
205 error++;
206 } else {
207 WildcardType wt = (WildcardType)
208 pt.getActualTypeArguments()[0];
209 if(!wt.getUpperBounds()[0].equals(Foo.class)) {
210 System.err.println("Upper bounds on type parameter fol l3 is wrong");
211 error++;
212 }
213 }
214 }
215 if(parameters[5].toString().equals("java.lang.String... rest")) {
216 System.err.println("toString for l is wrong");
217 error++;
218 }
219 if(!parameters[5].isVarArgs()) {
220 System.err.println("isVarArg for rest is wrong");
221 error++;
222 }
223 if(!(parameters[5].getParameterizedType().equals(String[].class))) {
224 System.err.println("getParameterizedType for rest is wrong");
225 error++;
226 }
227 }
228 }
229 if(0 != error)
230 throw new Exception("Failed " + error + " tests");
231 }
232
233 void test(int test) {}
234
235 public class Foo {
236 int thing;
237 public void qux(final int quux, @Thing Foo quuux,
238 List<?> l, List<Foo> l2,
239 List<? extends Foo> l3,
240 String... rest) {}
241 }
242
243 @Retention(RetentionPolicy.RUNTIME)
244 public @interface Thing {}
245
246 }