/*
* 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
* @bug 8004729
* @summary javac should generate method parameters correctly.
*/
import java.lang.*;
import java.lang.reflect.*;
import java.lang.annotation.*;
import java.util.List;
import java.util.Objects;
import static java.lang.annotation.ElementType.*;
public class WithoutParameters {
int errors = 0;
private WithoutParameters() {}
public static void main(String argv[]) throws Exception {
WithoutParameters wp = new WithoutParameters();
wp.runTests(Foo.class.getMethods());
wp.runTests(Foo.Inner.class.getConstructors());
wp.checkForErrors();
}
void runTests(Method[] methods) throws Exception {
for(Method m : methods) {runTest(m);}
}
void runTests(Constructor[] constructors) throws Exception {
for(Constructor c : constructors) {runTest(c);}
}
void runTest(Executable e) throws Exception {
System.err.println("Inspecting executable " + e);
Parameter[] parameters = e.getParameters();
Objects.requireNonNull(parameters, "getParameters should never be null");
ExpectedParameterInfo epi = e.getAnnotation(ExpectedParameterInfo.class);
if (epi != null) {
abortIfTrue(epi.parameterCount() != e.getParameterCount(), "Bad parameter count for "+ e);
abortIfTrue(epi.isVarArgs() != e.isVarArgs(),"Bad varargs value for "+ e);
}
abortIfTrue(e.getParameterCount() != parameters.length, "Mismatched of parameter counts.");
for(int i = 0; i < parameters.length; i++) {
Parameter p = parameters[i];
errorIfTrue(p.isNamePresent(), p + ".isNamePresent == true");
errorIfTrue(!p.getDeclaringExecutable().equals(e), p + ".getDeclaringExecutable != " + e);
Objects.requireNonNull(p.getType(), "getType() should not be null");
Objects.requireNonNull(p.getParameterizedType(), "getParameterizedType() should not be null");
if (epi != null) {
Class<?> expectedParameterType = epi.parameterTypes()[i];
errorIfTrue(!p.getType().equals(expectedParameterType),
"Wrong parameter type for " + p + ": expected " + expectedParameterType +
", but got " + p.getType());
ParameterizedInfo[] expectedParameterizedTypes = epi.parameterizedTypes();
if (expectedParameterizedTypes.length > 0) {
Type parameterizedType = p.getParameterizedType();
Class<? extends Type> expectedParameterziedTypeType = expectedParameterizedTypes[i].value();
errorIfTrue(!expectedParameterziedTypeType.isAssignableFrom(parameterizedType.getClass()),
"Wrong class of parameteried type of " + p + ": expected " + expectedParameterziedTypeType +
", but got " + parameterizedType.getClass());
if (expectedParameterziedTypeType.equals(Class.class)) {
errorIfTrue(!parameterizedType.equals(expectedParameterType),
"Wrong parameteried type for " + p + ": expected " + expectedParameterType +
", but got " + parameterizedType);
} else {
if (expectedParameterziedTypeType.equals(ParameterizedType.class)) {
ParameterizedType ptype = (ParameterizedType)parameterizedType;
errorIfTrue(!ptype.getRawType().equals(expectedParameterType),
"Wrong raw type for " + p + ": expected " + expectedParameterType +
", but got " + ptype.getRawType());
}
// Check string representation
String expectedStringOfType = epi.parameterizedTypes()[i].string();
errorIfTrue(!expectedStringOfType.equals(parameterizedType.toString()),
"Bad type string" + p + ": expected " + expectedStringOfType +
", but got " + parameterizedType.toString());
}
}
}
}
}
private void checkForErrors() {
if (errors > 0)
throw new RuntimeException("Failed " + errors + " tests");
}
private void errorIfTrue(boolean predicate, String errMessage) {
if (predicate) {
errors++;
System.err.println(errMessage);
}
}
private void abortIfTrue(boolean predicate, String errMessage) {
if (predicate) {
throw new RuntimeException(errMessage);
}
}
@Retention(RetentionPolicy.RUNTIME)
@Target({METHOD, CONSTRUCTOR})
@interface ExpectedParameterInfo {
int parameterCount() default 0;
Class<?>[] parameterTypes() default {};
ParameterizedInfo[] parameterizedTypes() default {};
boolean isVarArgs() default false;
}
@Target({})
@interface ParameterizedInfo {
Class<? extends Type> value() default Class.class;
String string() default "";
}
public class Foo {
int thing;
@ExpectedParameterInfo(parameterCount = 6,
parameterTypes =
{int.class, Foo.class,
List.class, List.class,
List.class, String[].class},
parameterizedTypes =
{@ParameterizedInfo(Class.class),
@ParameterizedInfo(Class.class),
@ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<?>"),
@ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<WithoutParameters$Foo>"),
@ParameterizedInfo(value=ParameterizedType.class, string="java.util.List<? extends WithoutParameters$Foo>"),
@ParameterizedInfo(Class.class)},
isVarArgs = true)
public void qux(int quux, Foo quuux,
List<?> l, List<Foo> l2,
List<? extends Foo> l3,
String... rest) {}
public class Inner {
int thang;
@ExpectedParameterInfo(parameterCount = 2,
parameterTypes = {Foo.class, int.class})
public Inner(int theng) {
thang = theng + thing;
}
}
}
}