250 lines
11 KiB
Java
250 lines
11 KiB
Java
/*
|
|
* Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @compile -parameters WithParameters.java
|
|
* @run main WithParameters
|
|
* @summary javac should generate method parameters correctly.
|
|
*/
|
|
|
|
import java.lang.*;
|
|
import java.lang.annotation.*;
|
|
import java.lang.reflect.*;
|
|
import java.util.List;
|
|
|
|
public class WithParameters {
|
|
|
|
private static final Class<?>[] qux_types = {
|
|
int.class, Foo.class, List.class, List.class, List.class, String[].class
|
|
};
|
|
|
|
private static final String[] qux_names = {
|
|
"quux", "quuux", "l", "l2", "l3", "rest"
|
|
};
|
|
|
|
public static void main(String argv[]) throws Exception {
|
|
int error = 0;
|
|
Method[] methods = Foo.class.getMethods();
|
|
for(Method m : methods) {
|
|
System.err.println("Inspecting method " + m.getName());
|
|
Parameter[] parameters = m.getParameters();
|
|
if(parameters == null)
|
|
throw new Exception("getParameters should never be null");
|
|
for(int i = 0; i < parameters.length; i++) {
|
|
Parameter p = parameters[i];
|
|
if(!p.getDeclaringExecutable().equals(m)) {
|
|
System.err.println(p + ".getDeclaringExecutable != " + m);
|
|
error++;
|
|
}
|
|
if(null == p.getType()) {
|
|
System.err.println(p + ".getType() == null");
|
|
error++;
|
|
}
|
|
if(null == p.getParameterizedType()) {
|
|
System.err.println(p + ".getParameterizedType == null");
|
|
error++;
|
|
}
|
|
}
|
|
if(m.getName().equals("qux")) {
|
|
if(6 != parameters.length) {
|
|
System.err.println("Wrong number of parameters for qux");
|
|
error++;
|
|
}
|
|
for(int i = 0; i < parameters.length; i++) {
|
|
Parameter p = parameters[i];
|
|
if(!p.isNamePresent()) {
|
|
System.err.println(p + ".isNamePresent == false");
|
|
error++;
|
|
}
|
|
if(!parameters[i].getName().equals(qux_names[i])) {
|
|
System.err.println("Wrong parameter name for " + parameters[i]);
|
|
error++;
|
|
}
|
|
// The getType family work with or without
|
|
// parameter attributes compiled in.
|
|
if(!parameters[i].getType().equals(qux_types[i])) {
|
|
System.err.println("Wrong parameter type for " + parameters[0] + ": expected " + qux_types[i] + ", but got " + parameters[i].getType());
|
|
error++;
|
|
}
|
|
}
|
|
if(!parameters[0].toString().equals("final int quux")) {
|
|
System.err.println("toString for quux is wrong, expected \"final int quux\", got \"" + parameters[0] + "\"");
|
|
error++;
|
|
}
|
|
if(parameters[0].getModifiers() != Modifier.FINAL) {
|
|
System.err.println("quux is not final");
|
|
error++;
|
|
}
|
|
if(parameters[0].isVarArgs()) {
|
|
System.err.println("isVarArg for quux is wrong");
|
|
error++;
|
|
}
|
|
if(!parameters[0].getParameterizedType().equals(int.class)) {
|
|
System.err.println("getParameterizedType for quux is wrong");
|
|
error++;
|
|
}
|
|
if(!parameters[1].toString().equals("WithParameters$Foo quuux")) {
|
|
System.err.println("toString for quuux is wrong, expected \"WithParameters$Foo quuux\", got \"" + parameters[1] + "\"");
|
|
error++;
|
|
}
|
|
if(parameters[1].isVarArgs()) {
|
|
System.err.println("isVarArg for quuux is wrong");
|
|
error++;
|
|
}
|
|
if(!parameters[1].getParameterizedType().equals(Foo.class)) {
|
|
System.err.println("getParameterizedType for quuux is wrong");
|
|
error++;
|
|
}
|
|
Annotation[] anns = parameters[1].getAnnotations();
|
|
if(1 != anns.length) {
|
|
System.err.println("getAnnotations missed an annotation");
|
|
error++;
|
|
} else if(!anns[0].annotationType().equals(Thing.class)) {
|
|
System.err.println("getAnnotations has the wrong annotation");
|
|
error++;
|
|
}
|
|
if(!parameters[2].toString().equals("java.util.List<?> l")) {
|
|
System.err.println("toString for l is wrong, expected \"java.util.List<?> l\", got \"" + parameters[2] + "\"");
|
|
error++;
|
|
}
|
|
if(parameters[2].isVarArgs()) {
|
|
System.err.println("isVarArg for l is wrong");
|
|
error++;
|
|
}
|
|
if(!(parameters[2].getParameterizedType() instanceof
|
|
ParameterizedType)) {
|
|
System.err.println("getParameterizedType for l is wrong");
|
|
error++;
|
|
} else {
|
|
ParameterizedType pt =
|
|
(ParameterizedType) parameters[2].getParameterizedType();
|
|
if(!pt.getRawType().equals(List.class)) {
|
|
System.err.println("Raw type for l is wrong");
|
|
error++;
|
|
}
|
|
if(1 != pt.getActualTypeArguments().length) {
|
|
System.err.println("Number of type parameters for l is wrong");
|
|
error++;
|
|
}
|
|
if(!(pt.getActualTypeArguments()[0] instanceof WildcardType)) {
|
|
System.err.println("Type parameter for l is wrong");
|
|
error++;
|
|
}
|
|
}
|
|
if(!parameters[3].toString().equals("java.util.List<WithParameters$Foo> l2")) {
|
|
System.err.println("toString for l2 is wrong, expected \"java.util.List<WithParameters$Foo> l2\", got \"" + parameters[3] + "\"");
|
|
error++;
|
|
}
|
|
if(parameters[3].isVarArgs()) {
|
|
System.err.println("isVarArg for l2 is wrong");
|
|
error++;
|
|
}
|
|
if(!(parameters[3].getParameterizedType() instanceof
|
|
ParameterizedType)) {
|
|
System.err.println("getParameterizedType for l2 is wrong");
|
|
error++;
|
|
} else {
|
|
ParameterizedType pt =
|
|
(ParameterizedType) parameters[3].getParameterizedType();
|
|
if(!pt.getRawType().equals(List.class)) {
|
|
System.err.println("Raw type for l2 is wrong");
|
|
error++;
|
|
}
|
|
if(1 != pt.getActualTypeArguments().length) {
|
|
System.err.println("Number of type parameters for l2 is wrong");
|
|
error++;
|
|
}
|
|
if(!(pt.getActualTypeArguments()[0].equals(Foo.class))) {
|
|
System.err.println("Type parameter for l2 is wrong");
|
|
error++;
|
|
}
|
|
}
|
|
if(!parameters[4].toString().equals("java.util.List<? extends WithParameters$Foo> l3")) {
|
|
System.err.println("toString for l3 is wrong, expected \"java.util.List<? extends WithParameters$Foo> l3\", got \"" + parameters[3] + "\"");
|
|
error++;
|
|
}
|
|
if(parameters[4].isVarArgs()) {
|
|
System.err.println("isVarArg for l3 is wrong");
|
|
error++;
|
|
}
|
|
if(!(parameters[4].getParameterizedType() instanceof
|
|
ParameterizedType)) {
|
|
System.err.println("getParameterizedType for l3 is wrong");
|
|
error++;
|
|
} else {
|
|
ParameterizedType pt =
|
|
(ParameterizedType) parameters[4].getParameterizedType();
|
|
if(!pt.getRawType().equals(List.class)) {
|
|
System.err.println("Raw type for l3 is wrong");
|
|
error++;
|
|
}
|
|
if(1 != pt.getActualTypeArguments().length) {
|
|
System.err.println("Number of type parameters for l3 is wrong");
|
|
error++;
|
|
}
|
|
if(!(pt.getActualTypeArguments()[0] instanceof WildcardType)) {
|
|
System.err.println("Type parameter for l3 is wrong");
|
|
error++;
|
|
} else {
|
|
WildcardType wt = (WildcardType)
|
|
pt.getActualTypeArguments()[0];
|
|
if(!wt.getUpperBounds()[0].equals(Foo.class)) {
|
|
System.err.println("Upper bounds on type parameter fol l3 is wrong");
|
|
error++;
|
|
}
|
|
}
|
|
}
|
|
if(!parameters[5].toString().equals("java.lang.String... rest")) {
|
|
System.err.println("toString for rest is wrong, expected \"java.lang.String... rest\", got \"" + parameters[5] + "\"");
|
|
error++;
|
|
}
|
|
if(!parameters[5].isVarArgs()) {
|
|
System.err.println("isVarArg for rest is wrong");
|
|
error++;
|
|
}
|
|
if(!(parameters[5].getParameterizedType().equals(String[].class))) {
|
|
System.err.println("getParameterizedType for rest is wrong");
|
|
error++;
|
|
}
|
|
}
|
|
}
|
|
if(0 != error)
|
|
throw new Exception("Failed " + error + " tests");
|
|
}
|
|
|
|
void test(int test) {}
|
|
|
|
public class Foo {
|
|
int thing;
|
|
public void qux(final int quux, @Thing Foo quuux,
|
|
List<?> l, List<Foo> l2,
|
|
List<? extends Foo> l3,
|
|
String... rest) {}
|
|
}
|
|
|
|
@Retention(RetentionPolicy.RUNTIME)
|
|
public @interface Thing {}
|
|
|
|
}
|