org.junit.experimental.theories.ParameterSignature Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of junit Show documentation
Show all versions of junit Show documentation
JUnit is a unit testing framework for Java, created by Erich Gamma and Kent Beck.
package org.junit.experimental.theories;
import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class ParameterSignature {
private static final Map, Class> CONVERTABLE_TYPES_MAP = buildConvertableTypesMap();
private static Map, Class> buildConvertableTypesMap() {
Map, Class> map = new HashMap, Class>();
putSymmetrically(map, boolean.class, Boolean.class);
putSymmetrically(map, byte.class, Byte.class);
putSymmetrically(map, short.class, Short.class);
putSymmetrically(map, char.class, Character.class);
putSymmetrically(map, int.class, Integer.class);
putSymmetrically(map, long.class, Long.class);
putSymmetrically(map, float.class, Float.class);
putSymmetrically(map, double.class, Double.class);
return Collections.unmodifiableMap(map);
}
private static void putSymmetrically(Map map, T a, T b) {
map.put(a, b);
map.put(b, a);
}
public static ArrayList signatures(Method method) {
return signatures(method.getParameterTypes(), method
.getParameterAnnotations());
}
public static List signatures(Constructor constructor) {
return signatures(constructor.getParameterTypes(), constructor
.getParameterAnnotations());
}
private static ArrayList signatures(
Class[] parameterTypes, Annotation[][] parameterAnnotations) {
ArrayList sigs = new ArrayList();
for (int i = 0; i < parameterTypes.length; i++) {
sigs.add(new ParameterSignature(parameterTypes[i],
parameterAnnotations[i]));
}
return sigs;
}
private final Class type;
private final Annotation[] annotations;
private ParameterSignature(Class type, Annotation[] annotations) {
this.type = type;
this.annotations = annotations;
}
public boolean canAcceptValue(Object candidate) {
return (candidate == null) ? !type.isPrimitive() : canAcceptType(candidate.getClass());
}
public boolean canAcceptType(Class candidate) {
return type.isAssignableFrom(candidate) ||
isAssignableViaTypeConversion(type, candidate);
}
public boolean canPotentiallyAcceptType(Class candidate) {
return candidate.isAssignableFrom(type) ||
isAssignableViaTypeConversion(candidate, type) ||
canAcceptType(candidate);
}
private boolean isAssignableViaTypeConversion(Class targetType, Class candidate) {
if (CONVERTABLE_TYPES_MAP.containsKey(candidate)) {
Class wrapperClass = CONVERTABLE_TYPES_MAP.get(candidate);
return targetType.isAssignableFrom(wrapperClass);
} else {
return false;
}
}
public Class getType() {
return type;
}
public List getAnnotations() {
return Arrays.asList(annotations);
}
public boolean hasAnnotation(Class type) {
return getAnnotation(type) != null;
}
public T findDeepAnnotation(Class annotationType) {
Annotation[] annotations2 = annotations;
return findDeepAnnotation(annotations2, annotationType, 3);
}
private T findDeepAnnotation(
Annotation[] annotations, Class annotationType, int depth) {
if (depth == 0) {
return null;
}
for (Annotation each : annotations) {
if (annotationType.isInstance(each)) {
return annotationType.cast(each);
}
Annotation candidate = findDeepAnnotation(each.annotationType()
.getAnnotations(), annotationType, depth - 1);
if (candidate != null) {
return annotationType.cast(candidate);
}
}
return null;
}
public T getAnnotation(Class annotationType) {
for (Annotation each : getAnnotations()) {
if (annotationType.isInstance(each)) {
return annotationType.cast(each);
}
}
return null;
}
}