org.junit.internal.runners.TestClass Maven / Gradle / Ivy

Go to download
package org.junit.internal.runners;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.internal.MethodSorter;
import org.junit.runners.BlockJUnit4ClassRunner;

/**
 * @deprecated Included for backwards compatibility with JUnit 4.4. Will be
 *             removed in the next release. Please use
 *             {@link BlockJUnit4ClassRunner} in place of {@link JUnit4ClassRunner}.
 */
@Deprecated
public class TestClass {
    private final Class fClass;

    public TestClass(Class klass) {
        fClass = klass;
    }

    public List getTestMethods() {
        return getAnnotatedMethods(Test.class);
    }

    List getBefores() {
        return getAnnotatedMethods(BeforeClass.class);
    }

    List getAfters() {
        return getAnnotatedMethods(AfterClass.class);
    }

    public List getAnnotatedMethods(Class annotationClass) {
        List results = new ArrayList();
        for (Class eachClass : getSuperClasses(fClass)) {
            Method[] methods = MethodSorter.getDeclaredMethods(eachClass);
            for (Method eachMethod : methods) {
                Annotation annotation = eachMethod.getAnnotation(annotationClass);
                if (annotation != null && !isShadowed(eachMethod, results)) {
                    results.add(eachMethod);
                }
            }
        }
        if (runsTopToBottom(annotationClass)) {
            Collections.reverse(results);
        }
        return results;
    }

    private boolean runsTopToBottom(Class annotation) {
        return annotation.equals(Before.class) || annotation.equals(BeforeClass.class);
    }

    private boolean isShadowed(Method method, List results) {
        for (Method each : results) {
            if (isShadowed(method, each)) {
                return true;
            }
        }
        return false;
    }

    private boolean isShadowed(Method current, Method previous) {
        if (!previous.getName().equals(current.getName())) {
            return false;
        }
        if (previous.getParameterTypes().length != current.getParameterTypes().length) {
            return false;
        }
        for (int i = 0; i < previous.getParameterTypes().length; i++) {
            if (!previous.getParameterTypes()[i].equals(current.getParameterTypes()[i])) {
                return false;
            }
        }
        return true;
    }

    private List> getSuperClasses(Class testClass) {
        ArrayList> results = new ArrayList>();
        Class current = testClass;
        while (current != null) {
            results.add(current);
            current = current.getSuperclass();
        }
        return results;
    }

    public Constructor getConstructor() throws SecurityException, NoSuchMethodException {
        return fClass.getConstructor();
    }

    public Class getJavaClass() {
        return fClass;
    }

    public String getName() {
        return fClass.getName();
    }

}