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 * @summary javac should generate method parameters correctly.
27 */
28
29 import java.lang.*;
30 import java.lang.reflect.*;
31 import java.util.List;
32
33 public class WithoutParameters {
34
35 private static final Class<?>[] qux_types = {
36 int.class,
37 Foo.class,
38 List.class,
39 List.class,
40 List.class,
41 String[].class
42 };
43
44 public static void main(String argv[]) throws Exception {
45 int error = 0;
46 Method[] methods = Foo.class.getMethods();
47 for(Method m : methods) {
48 System.err.println("Inspecting method " + m);
49 Parameter[] parameters = m.getParameters();
50 if(parameters == null)
51 throw new Exception("getParameters should never be null");
52 for(int i = 0; i < parameters.length; i++) {
53 Parameter p = parameters[i];
54 if(!p.getDeclaringExecutable().equals(m)) {
55 System.err.println(p + ".getDeclaringExecutable != " + m);
56 error++;
57 }
58 if(null == p.getType()) {
59 System.err.println(p + ".getType() == null");
60 error++;
61 }
62 if(null == p.getParameterizedType()) {
63 System.err.println(p + ".getParameterizedType == null");
64 error++;
65 }
66 }
67 if(m.getName().equals("qux")) {
68 if(6 != parameters.length) {
69 System.err.println("Wrong number of parameters for qux");
70 error++;
71 }
72 for(int i = 0; i < parameters.length; i++) {
73 Parameter p = parameters[i];
74 // The getType family work with or without
75 // parameter attributes compiled in.
76 if(!parameters[i].getType().equals(qux_types[i])) {
77 System.err.println("Wrong parameter type for " + parameters[0] + ": expected " + qux_types[i] + ", but got " + parameters[i].getType());
78 error++;
79 }
80 }
81 if(!parameters[0].getParameterizedType().equals(int.class)) {
82 System.err.println("getParameterizedType for quux is wrong");
83 error++;
84 }
85 if(!parameters[1].getParameterizedType().equals(Foo.class)) {
86 System.err.println("getParameterizedType for quux is wrong");
87 error++;
88 }
89 if(!(parameters[2].getParameterizedType() instanceof
90 ParameterizedType)) {
91 System.err.println("getParameterizedType for l is wrong");
92 error++;
93 } else {
94 ParameterizedType pt =
95 (ParameterizedType) parameters[2].getParameterizedType();
96 if(!pt.getRawType().equals(List.class)) {
97 System.err.println("Raw type for l is wrong");
98 error++;
99 }
100 if(1 != pt.getActualTypeArguments().length) {
101 System.err.println("Number of type parameters for l is wrong");
102 error++;
103 }
104 if(!(pt.getActualTypeArguments()[0] instanceof WildcardType)) {
105 System.err.println("Type parameter for l is wrong");
106 error++;
107 }
108 }
109 if(!(parameters[3].getParameterizedType() instanceof
110 ParameterizedType)) {
111 System.err.println("getParameterizedType for l2 is wrong");
112 error++;
113 } else {
114 ParameterizedType pt =
115 (ParameterizedType) parameters[3].getParameterizedType();
116 if(!pt.getRawType().equals(List.class)) {
117 System.err.println("Raw type for l2 is wrong");
118 error++;
119 }
120 if(1 != pt.getActualTypeArguments().length) {
121 System.err.println("Number of type parameters for l2 is wrong");
122 error++;
123 }
124 if(!(pt.getActualTypeArguments()[0].equals(Foo.class))) {
125 System.err.println("Type parameter for l2 is wrong");
126 error++;
127 }
128 }
129 if(!(parameters[4].getParameterizedType() instanceof
130 ParameterizedType)) {
131 System.err.println("getParameterizedType for l3 is wrong");
132 error++;
133 } else {
134 ParameterizedType pt =
135 (ParameterizedType) parameters[4].getParameterizedType();
136 if(!pt.getRawType().equals(List.class)) {
137 System.err.println("Raw type for l3 is wrong");
138 error++;
139 }
140 if(1 != pt.getActualTypeArguments().length) {
141 System.err.println("Number of type parameters for l3 is wrong");
142 error++;
143 }
144 if(!(pt.getActualTypeArguments()[0] instanceof WildcardType)) {
145 System.err.println("Type parameter for l3 is wrong");
146 error++;
147 } else {
148 WildcardType wt = (WildcardType)
149 pt.getActualTypeArguments()[0];
150 if(!wt.getUpperBounds()[0].equals(Foo.class)) {
151 System.err.println("Upper bounds on type parameter fol l3 is wrong");
152 error++;
153 }
154 }
155 }
156 if(!parameters[5].isVarArgs()) {
157 System.err.println("isVarArg for rest is wrong");
158 error++;
159 }
160 if(!(parameters[5].getParameterizedType().equals(String[].class))) {
161 System.err.println("getParameterizedType for rest is wrong");
162 error++;
163 }
164
165 }
166 }
167 if(0 != error)
168 throw new Exception("Failed " + error + " tests");
169 }
170
171 public class Foo {
172 int thing;
173 public void qux(int quux, Foo quuux,
174 List<?> l, List<Foo> l2,
175 List<? extends Foo> l3,
176 String... rest) {}
177 public class Inner {
178 int thang;
179 public Inner(int theng) {
180 thang = theng + thing;
181 }
182 }
183 }
184
185 }
|
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 8004729
27 * @summary javac should generate method parameters correctly.
28 */
29
30 import java.lang.*;
31 import java.lang.reflect.*;
32 import java.lang.annotation.*;
33 import java.util.List;
34 import java.util.Objects;
35
36 import static java.lang.annotation.ElementType.*;
37
38 public class WithoutParameters {
39 int errors = 0;
40
41 private WithoutParameters() {}
42
43 public static void main(String argv[]) throws Exception {
44 WithoutParameters wp = new WithoutParameters();
45 wp.runTests(Foo.class.getMethods());
46 wp.runTests(Foo.Inner.class.getConstructors());
47 wp.checkForErrors();
48 }
49
50 void runTests(Method[] methods) throws Exception {
51 for(Method m : methods) {runTest(m);}
52 }
53
54 void runTests(Constructor[] constructors) throws Exception {
55 for(Constructor c : constructors) {runTest(c);}
56 }
57
58 void runTest(Executable e) throws Exception {
59 System.err.println("Inspecting executable " + e);
60 Parameter[] parameters = e.getParameters();
61 Objects.requireNonNull(parameters, "getParameters should never be null");
62
63 ExpectedParameterInfo epi = e.getAnnotation(ExpectedParameterInfo.class);
64 if (epi != null) {
65 abortIfTrue(epi.parameterCount() != e.getParameterCount(), "Bad parameter count for "+ e);
66 abortIfTrue(epi.isVarArgs() != e.isVarArgs(),"Bad varargs value for "+ e);
67 }
68 abortIfTrue(e.getParameterCount() != parameters.length, "Mismatched of parameter counts.");
69
70 for(int i = 0; i < parameters.length; i++) {
71 Parameter p = parameters[i];
72 errorIfTrue(!p.getDeclaringExecutable().equals(e), p + ".getDeclaringExecutable != " + e);
73 Objects.requireNonNull(p.getType(), "getType() should not be null");
74 Objects.requireNonNull(p.getParameterizedType(), "getParameterizedType() should not be null");
75
76 if (epi != null) {
77 Class<?> expectedParameterType = epi.parameterTypes()[i];
78 errorIfTrue(!p.getType().equals(expectedParameterType),
79 "Wrong parameter type for " + p + ": expected " + expectedParameterType +
80 ", but got " + p.getType());
81
82 ParameterizedInfo[] expectedParameterizedTypes = epi.parameterizedTypes();
83 if (expectedParameterizedTypes.length > 0) {
84 Type parameterizedType = p.getParameterizedType();
85 Class<? extends Type> expectedParameterziedTypeType = expectedParameterizedTypes[i].value();
86 errorIfTrue(!expectedParameterziedTypeType.isAssignableFrom(parameterizedType.getClass()),
87 "Wrong class of parameteried type of " + p + ": expected " + expectedParameterziedTypeType +
88 ", but got " + parameterizedType.getClass());
89
90 if (expectedParameterziedTypeType.equals(Class.class)) {
91 errorIfTrue(!parameterizedType.equals(expectedParameterType),
92 "Wrong parameteried type for " + p + ": expected " + expectedParameterType +
93 ", but got " + parameterizedType);
94 } else {
95 if (expectedParameterziedTypeType.equals(ParameterizedType.class)) {
96 ParameterizedType ptype = (ParameterizedType)parameterizedType;
97 errorIfTrue(!ptype.getRawType().equals(expectedParameterType),
98 "Wrong raw type for " + p + ": expected " + expectedParameterType +
99 ", but got " + ptype.getRawType());
100 }
101
102 // Check string representation
103 String expectedStringOfType = epi.parameterizedTypes()[i].string();
104 errorIfTrue(!expectedStringOfType.equals(parameterizedType.toString()),
105 "Bad type string" + p + ": expected " + expectedStringOfType +
106 ", but got " + parameterizedType.toString());
107 }
108 }
109 }
110 }
111 }
112
113 private void checkForErrors() {
114 if (errors > 0)
115 throw new RuntimeException("Failed " + errors + " tests");
116 }
117
118 private void errorIfTrue(boolean predicate, String errMessage) {
119 if (predicate) {
120 errors++;
121 System.err.println(errMessage);
122 }
123 }
124
125 private void abortIfTrue(boolean predicate, String errMessage) {
126 if (predicate) {
127 throw new RuntimeException(errMessage);
128 }
129 }
130
131 @Retention(RetentionPolicy.RUNTIME)
132 @Target({METHOD, CONSTRUCTOR})
133 @interface ExpectedParameterInfo {
134 int parameterCount() default 0;
135 Class<?>[] parameterTypes() default {};
136 ParameterizedInfo[] parameterizedTypes() default {};
137 boolean isVarArgs() default false;
138 }
139
140 @Target({})
141 @interface ParameterizedInfo {
142 Class<? extends Type> value() default Class.class;
143 String string() default "";
144 }
145
146 public class Foo {
147 int thing;
148 @ExpectedParameterInfo(parameterCount = 6,
149 parameterTypes =
150 {int.class, Foo.class,
151 List.class, List.class,
152 List.class, String[].class},
153 parameterizedTypes =
154 {@ParameterizedInfo(Class.class),
155 @ParameterizedInfo(Class.class),
156 @ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<?>"),
157 @ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<WithoutParameters$Foo>"),
158 @ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<? extends WithoutParameters$Foo>"),
159 @ParameterizedInfo(Class.class)},
160 isVarArgs = true)
161 public void qux(int quux, Foo quuux,
162 List<?> l, List<Foo> l2,
163 List<? extends Foo> l3,
164 String... rest) {}
165 public class Inner {
166 int thang;
167 @ExpectedParameterInfo(parameterCount = 2,
168 parameterTypes = {Foo.class, int.class})
169 public Inner(int theng) {
170 thang = theng + thing;
171 }
172 }
173 }
174 }
|