package org.junit.runners.model; import static java.lang.reflect.Modifier.isStatic; import static org.junit.internal.MethodSorter.NAME_ASCENDING; import java.lang.annotation.Annotation; import java.lang.reflect.Constructor; import java.lang.reflect.Field; import java.lang.reflect.Method; import java.lang.reflect.Modifier; import java.util.ArrayList; import java.util.Arrays; import java.util.Collections; import java.util.Comparator; import java.util.LinkedHashMap; import java.util.LinkedHashSet; import java.util.List; import java.util.Map; import java.util.Set; import org.junit.Assert; import org.junit.Before; import org.junit.BeforeClass; import org.junit.internal.MethodSorter; /** * Wraps a class to be run, providing method validation and annotation searching * * @since 4.5 */ public class TestClass implements Annotatable { private static final FieldComparator FIELD_COMPARATOR = new FieldComparator(); private static final MethodComparator METHOD_COMPARATOR = new MethodComparator(); private final Class clazz; private final Map, List> methodsForAnnotations; private final Map, List> fieldsForAnnotations; /** * Creates a {@code TestClass} wrapping {@code clazz}. Each time this * constructor executes, the class is scanned for annotations, which can be * an expensive process (we hope in future JDK's it will not be.) Therefore, * try to share instances of {@code TestClass} where possible. */ public TestClass(Class clazz) { this.clazz = clazz; if (clazz != null && clazz.getConstructors().length > 1) { throw new IllegalArgumentException( "Test class can only have one constructor"); } Map, List> methodsForAnnotations = new LinkedHashMap, List>(); Map, List> fieldsForAnnotations = new LinkedHashMap, List>(); scanAnnotatedMembers(methodsForAnnotations, fieldsForAnnotations); this.methodsForAnnotations = makeDeeplyUnmodifiable(methodsForAnnotations); this.fieldsForAnnotations = makeDeeplyUnmodifiable(fieldsForAnnotations); } protected void scanAnnotatedMembers(Map, List> methodsForAnnotations, Map, List> fieldsForAnnotations) { for (Class eachClass : getSuperClasses(clazz)) { for (Method eachMethod : MethodSorter.getDeclaredMethods(eachClass)) { addToAnnotationLists(new FrameworkMethod(eachMethod), methodsForAnnotations); } // ensuring fields are sorted to make sure that entries are inserted // and read from fieldForAnnotations in a deterministic order for (Field eachField : getSortedDeclaredFields(eachClass)) { addToAnnotationLists(new FrameworkField(eachField), fieldsForAnnotations); } } } private static Field[] getSortedDeclaredFields(Class clazz) { Field[] declaredFields = clazz.getDeclaredFields(); Arrays.sort(declaredFields, FIELD_COMPARATOR); return declaredFields; } protected static > void addToAnnotationLists(T member, Map, List> map) { for (Annotation each : member.getAnnotations()) { Class type = each.annotationType(); List members = getAnnotatedMembers(map, type, true); if (member.isShadowedBy(members)) { return; } if (runsTopToBottom(type)) { members.add(0, member); } else { members.add(member); } } } private static > Map, List> makeDeeplyUnmodifiable(Map, List> source) { LinkedHashMap, List> copy = new LinkedHashMap, List>(); for (Map.Entry, List> entry : source.entrySet()) { copy.put(entry.getKey(), Collections.unmodifiableList(entry.getValue())); } return Collections.unmodifiableMap(copy); } /** * Returns, efficiently, all the non-overridden methods in this class and * its superclasses that are annotated}. * * @since 4.12 */ public List getAnnotatedMethods() { List methods = collectValues(methodsForAnnotations); Collections.sort(methods, METHOD_COMPARATOR); return methods; } /** * Returns, efficiently, all the non-overridden methods in this class and * its superclasses that are annotated with {@code annotationClass}. */ public List getAnnotatedMethods( Class annotationClass) { return Collections.unmodifiableList(getAnnotatedMembers(methodsForAnnotations, annotationClass, false)); } /** * Returns, efficiently, all the non-overridden fields in this class and its * superclasses that are annotated. * * @since 4.12 */ public List getAnnotatedFields() { return collectValues(fieldsForAnnotations); } /** * Returns, efficiently, all the non-overridden fields in this class and its * superclasses that are annotated with {@code annotationClass}. */ public List getAnnotatedFields( Class annotationClass) { return Collections.unmodifiableList(getAnnotatedMembers(fieldsForAnnotations, annotationClass, false)); } private List collectValues(Map> map) { Set values = new LinkedHashSet(); for (List additionalValues : map.values()) { values.addAll(additionalValues); } return new ArrayList(values); } private static List getAnnotatedMembers(Map, List> map, Class type, boolean fillIfAbsent) { if (!map.containsKey(type) && fillIfAbsent) { map.put(type, new ArrayList()); } List members = map.get(type); return members == null ? Collections.emptyList() : members; } private static boolean runsTopToBottom(Class annotation) { return annotation.equals(Before.class) || annotation.equals(BeforeClass.class); } private static List> getSuperClasses(Class testClass) { ArrayList> results = new ArrayList>(); Class current = testClass; while (current != null) { results.add(current); current = current.getSuperclass(); } return results; } /** * Returns the underlying Java class. */ public Class getJavaClass() { return clazz; } /** * Returns the class's name. */ public String getName() { if (clazz == null) { return "null"; } return clazz.getName(); } /** * Returns the only public constructor in the class, or throws an {@code * AssertionError} if there are more or less than one. */ public Constructor getOnlyConstructor() { Constructor[] constructors = clazz.getConstructors(); Assert.assertEquals(1, constructors.length); return constructors[0]; } /** * Returns the annotations on this class */ public Annotation[] getAnnotations() { if (clazz == null) { return new Annotation[0]; } return clazz.getAnnotations(); } public T getAnnotation(Class annotationType) { if (clazz == null) { return null; } return clazz.getAnnotation(annotationType); } public List getAnnotatedFieldValues(Object test, Class annotationClass, Class valueClass) { List results = new ArrayList(); for (FrameworkField each : getAnnotatedFields(annotationClass)) { try { Object fieldValue = each.get(test); if (valueClass.isInstance(fieldValue)) { results.add(valueClass.cast(fieldValue)); } } catch (IllegalAccessException e) { throw new RuntimeException( "How did getFields return a field we couldn't access?", e); } } return results; } public List getAnnotatedMethodValues(Object test, Class annotationClass, Class valueClass) { List results = new ArrayList(); for (FrameworkMethod each : getAnnotatedMethods(annotationClass)) { try { /* * A method annotated with @Rule may return a @TestRule or a @MethodRule, * we cannot call the method to check whether the return type matches our * expectation i.e. subclass of valueClass. If we do that then the method * will be invoked twice and we do not want to do that. So we first check * whether return type matches our expectation and only then call the method * to fetch the MethodRule */ if (valueClass.isAssignableFrom(each.getReturnType())) { Object fieldValue = each.invokeExplosively(test); results.add(valueClass.cast(fieldValue)); } } catch (Throwable e) { throw new RuntimeException( "Exception in " + each.getName(), e); } } return results; } public boolean isPublic() { return Modifier.isPublic(clazz.getModifiers()); } public boolean isANonStaticInnerClass() { return clazz.isMemberClass() && !isStatic(clazz.getModifiers()); } @Override public int hashCode() { return (clazz == null) ? 0 : clazz.hashCode(); } @Override public boolean equals(Object obj) { if (this == obj) { return true; } if (obj == null) { return false; } if (getClass() != obj.getClass()) { return false; } TestClass other = (TestClass) obj; return clazz == other.clazz; } /** * Compares two fields by its name. */ private static class FieldComparator implements Comparator { public int compare(Field left, Field right) { return left.getName().compareTo(right.getName()); } } /** * Compares two methods by its name. */ private static class MethodComparator implements Comparator { public int compare(FrameworkMethod left, FrameworkMethod right) { return NAME_ASCENDING.compare(left.getMethod(), right.getMethod()); } } }