package org.junit.runners.model;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.List;
import org.junit.internal.runners.model.ReflectiveCallable;
/**
* Represents a method on a test class to be invoked at the appropriate point in
* test execution. These methods are usually marked with an annotation (such as
* {@code @Test}, {@code @Before}, {@code @After}, {@code @BeforeClass},
* {@code @AfterClass}, etc.)
*
* @since 4.5
*/
public class FrameworkMethod extends FrameworkMember<FrameworkMethod> {
private final Method method;
/**
* Returns a new {@code FrameworkMethod} for {@code method}
*/
public FrameworkMethod(Method method) {
if (method == null) {
throw new NullPointerException(
"FrameworkMethod cannot be created without an underlying method.");
}
this.method = method;
}
/**
* Returns the underlying Java method
*/
public Method getMethod() {
return method;
}
/**
* Returns the result of invoking this method on {@code target} with
* parameters {@code params}. {@link InvocationTargetException}s thrown are
* unwrapped, and their causes rethrown.
*/
public Object invokeExplosively(final Object target, final Object... params)
throws Throwable {
return new ReflectiveCallable() {
@Override
protected Object runReflectiveCall() throws Throwable {
return method.invoke(target, params);
}
}.run();
}
/**
* Returns the method's name
*/
@Override
public String getName() {
return method.getName();
}
/**
* Adds to {@code errors} if this method:
* <ul>
* <li>is not public, or
* <li>takes parameters, or
* <li>returns something other than void, or
* <li>is static (given {@code isStatic is false}), or
* <li>is not static (given {@code isStatic is true}).
* </ul>
*/
public void validatePublicVoidNoArg(boolean isStatic, List<Throwable> errors) {
validatePublicVoid(isStatic, errors);
if (method.getParameterTypes().length != 0) {
errors.add(new Exception("Method " + method.getName() + " should have no parameters"));
}
}
/**
* Adds to {@code errors} if this method:
* <ul>
* <li>is not public, or
* <li>returns something other than void, or
* <li>is static (given {@code isStatic is false}), or
* <li>is not static (given {@code isStatic is true}).
* </ul>
*/
public void validatePublicVoid(boolean isStatic, List<Throwable> errors) {
if (isStatic() != isStatic) {
String state = isStatic ? "should" : "should not";
errors.add(new Exception("Method " + method.getName() + "() " + state + " be static"));
}
if (!isPublic()) {
errors.add(new Exception("Method " + method.getName() + "() should be public"));
}
if (method.getReturnType() != Void.TYPE) {
errors.add(new Exception("Method " + method.getName() + "() should be void"));
}
}
@Override
protected int getModifiers() {
return method.getModifiers();
}
/**
* Returns the return type of the method
*/
public Class<?> getReturnType() {
return method.getReturnType();
}
/**
* Returns the return type of the method
*/
@Override
public Class<?> getType() {
return getReturnType();
}
/**
* Returns the class where the method is actually declared
*/
@Override
public Class<?> getDeclaringClass() {
return method.getDeclaringClass();
}
public void validateNoTypeParametersOnArgs(List<Throwable> errors) {
new NoGenericTypeParametersValidator(method).validate(errors);
}
@Override
public boolean isShadowedBy(FrameworkMethod other) {
if (!other.getName().equals(getName())) {
return false;
}
if (other.getParameterTypes().length != getParameterTypes().length) {
return false;
}
for (int i = 0; i < other.getParameterTypes().length; i++) {
if (!other.getParameterTypes()[i].equals(getParameterTypes()[i])) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object obj) {
if (!FrameworkMethod.class.isInstance(obj)) {
return false;
}
return ((FrameworkMethod) obj).method.equals(method);
}
@Override
public int hashCode() {
return method.hashCode();
}
/**
* Returns true if this is a no-arg method that returns a value assignable
* to {@code type}
*
* @deprecated This is used only by the Theories runner, and does not
* use all the generic type info that it ought to. It will be replaced
* with a forthcoming ParameterSignature#canAcceptResultOf(FrameworkMethod)
* once Theories moves to junit-contrib.
*/
@Deprecated
public boolean producesType(Type type) {
return getParameterTypes().length == 0 && type instanceof Class<?>
&& ((Class<?>) type).isAssignableFrom(method.getReturnType());
}
private Class<?>[] getParameterTypes() {
return method.getParameterTypes();
}
/**
* Returns the annotations on this method
*/
public Annotation[] getAnnotations() {
return method.getAnnotations();
}
/**
* Returns the annotation of type {@code annotationType} on this method, if
* one exists.
*/
public <T extends Annotation> T getAnnotation(Class<T> annotationType) {
return method.getAnnotation(annotationType);
}
@Override
public String toString() {
return method.toString();
}
}