Junit 源码剖析（二）

junit4 下的所有的testcase都是在Runner下执行的， 可以将Runner理解为junit运行的容器， 默认情况下junit会使用JUnit4ClassRunner作为所有testcase的执行容器。

如果要定制自己的junit， 则可以实现自己的Runner，最简单的办法就是Junit4ClassRunner继承， spring-test， unitils这些框架就是采用这样的做法。

如在spring中是SpringJUnit4ClassRunner， 在unitils中是UnitilsJUnit4TestClassRunner， 一般我们的testcase都是在通过eclipse插件来执行的， eclipse的junit插件会在执行的时候会初始化指定的Runner。初始化的过程可以在ClassRequest中找到。

org.junit.internal.runners.Junit4ClassRunner

package org.junit.internal.runners;

import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.Comparator;
import java.util.Iterator;
import java.util.List;

import org.junit.runner.Description;
import org.junit.runner.Runner;
import org.junit.runner.manipulation.Filter;
import org.junit.runner.manipulation.Filterable;
import org.junit.runner.manipulation.NoTestsRemainException;
import org.junit.runner.manipulation.Sortable;
import org.junit.runner.manipulation.Sorter;
import org.junit.runner.notification.Failure;
import org.junit.runner.notification.RunNotifier;
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}.
 *
 *             This may disappear as soon as 1 April 2009
 */
@Deprecated
public class JUnit4ClassRunner extends Runner implements Filterable, Sortable
{
    private final List<Method> fTestMethods;

    private TestClass fTestClass;

    //将要测试的TestCase实例Class对象传入
    public JUnit4ClassRunner(Class<?> klass) throws InitializationError
    {
        fTestClass = new TestClass(klass);
        fTestMethods = getTestMethods();
        //对要进行测试的方法展开验证
        validate();
    }

    //获取@test的方法List
    protected List<Method> getTestMethods()
    {
        return fTestClass.getTestMethods();
    }

    //对要进行测试的方法展开验证
    protected void validate() throws InitializationError
    {
        MethodValidator methodValidator = new MethodValidator(fTestClass);
        methodValidator.validateMethodsForDefaultRunner();
        methodValidator.assertValid();
    }

    @Override
    public void run(final RunNotifier notifier)
    {
        new ClassRoadie(notifier, fTestClass, getDescription(), new Runnable()
        {
            public void run()
            {
                runMethods(notifier);
            }
        }).runProtected();
    }

    protected void runMethods(final RunNotifier notifier)
    {
        for (Method method : fTestMethods)
            invokeTestMethod(method, notifier);
    }

    @Override
    public Description getDescription()
    {
        Description spec = Description.createSuiteDescription(getName(), classAnnotations());
        List<Method> testMethods = fTestMethods;
        for (Method method : testMethods)
            spec.addChild(methodDescription(method));
        return spec;
    }

    protected Annotation[] classAnnotations()
    {
        return fTestClass.getJavaClass().getAnnotations();
    }

    protected String getName()
    {
        return getTestClass().getName();
    }

    protected Object createTest() throws Exception
    {
        return getTestClass().getConstructor().newInstance();
    }

    protected void invokeTestMethod(Method method, RunNotifier notifier)
    {
        Description description = methodDescription(method);
        Object test;
        try
        {
            test = createTest();
        }
        catch(InvocationTargetException e)
        {
            testAborted(notifier, description, e.getCause());
            return;
        }
        catch(Exception e)
        {
            testAborted(notifier, description, e);
            return;
        }
        TestMethod testMethod = wrapMethod(method);
        new MethodRoadie(test, testMethod, notifier, description).run();
    }

    private void testAborted(RunNotifier notifier, Description description, Throwable e)
    {
        notifier.fireTestStarted(description);
        notifier.fireTestFailure(new Failure(description, e));
        notifier.fireTestFinished(description);
    }

    protected TestMethod wrapMethod(Method method)
    {
        return new TestMethod(method, fTestClass);
    }

    protected String testName(Method method)
    {
        return method.getName();
    }

    protected Description methodDescription(Method method)
    {
        return Description.createTestDescription(getTestClass().getJavaClass(), testName(method), testAnnotations(method));
    }

    protected Annotation[] testAnnotations(Method method)
    {
        return method.getAnnotations();
    }

    public void filter(Filter filter) throws NoTestsRemainException
    {
        for (Iterator<Method> iter = fTestMethods.iterator(); iter.hasNext();)
        {
            Method method = iter.next();
            if (!filter.shouldRun(methodDescription(method)))
                iter.remove();
        }
        if (fTestMethods.isEmpty())
            throw new NoTestsRemainException();
    }

    public void sort(final Sorter sorter)
    {
        Collections.sort(fTestMethods, new Comparator<Method>()
        {
            public int compare(Method o1, Method o2)
            {
                return sorter.compare(methodDescription(o1), methodDescription(o2));
            }
        });
    }

    protected TestClass getTestClass()
    {
        return fTestClass;
    }
}

　　

org.junit.internal.runners.TestClass类

不同于上一节提到的org.junit.runners.model.TestClass类

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.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<Method> getTestMethods()
    {
        return getAnnotatedMethods(Test.class);
    }

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

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

    public List<Method> getAnnotatedMethods(Class<? extends Annotation> annotationClass)
    {
        List<Method> results = new ArrayList<Method>();
        for (Class<?> eachClass : getSuperClasses(fClass))
        {
            Method[] methods = eachClass.getDeclaredMethods();
            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<? extends Annotation> annotation)
    {
        return annotation.equals(Before.class) || annotation.equals(BeforeClass.class);
    }

    private boolean isShadowed(Method method, List<Method> 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<Class<?>> getSuperClasses(Class<?> testClass)
    {
        ArrayList<Class<?>> results = new ArrayList<Class<?>>();
        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();
    }

}

　　

org.junit.internal.runners.MethodValidator类

用于在org.junit.internal.runners.Junit4ClassRunner 类当中进行方法验证

package org.junit.internal.runners;

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

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
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 MethodValidator {

	private final List<Throwable> fErrors= new ArrayList<Throwable>();

	private TestClass fTestClass;

	//org.junit.internal.runners.JUnit4ClassRunner类中
	//validate()方法中调用该构造函数-----第一步
	public MethodValidator(TestClass testClass) {
		fTestClass = testClass;
	}

	public void validateInstanceMethods() {
		validateTestMethods(After.class, false);
		validateTestMethods(Before.class, false);
		validateTestMethods(Test.class, false);

		List<Method> methods= fTestClass.getAnnotatedMethods(Test.class);
		if (methods.size() == 0)
			fErrors.add(new Exception("No runnable methods"));
	}

	public void validateStaticMethods() {
		validateTestMethods(BeforeClass.class, true);
		validateTestMethods(AfterClass.class, true);
	}

	//Junit4ClassRunner类中调用第二步
	public List<Throwable> validateMethodsForDefaultRunner() {
		//校验无参构造方法
		validateNoArgConstructor();
		//校验注解方法
		validateStaticMethods();
		validateInstanceMethods();
		return fErrors;
	}

	//Junit4ClassRunner类中第三步
	public void assertValid() throws InitializationError {
		if (!fErrors.isEmpty())
			throw new InitializationError(fErrors);
	}

	public void validateNoArgConstructor() {
		try {
			fTestClass.getConstructor();
		} catch (Exception e) {
			fErrors.add(new Exception("Test class should have public zero-argument constructor", e));
		}
	}

    //校验要测试的方法 是否静态方法、是否public方法、是否返回值void、是否无参数
	//@param annotation 要测试的annotation类
	//@param isStatic 是否要求静态方法
	private void validateTestMethods(Class<? extends Annotation> annotation,boolean isStatic) {
		List<Method> methods= fTestClass.getAnnotatedMethods(annotation);

		for (Method each : methods) {
			if (Modifier.isStatic(each.getModifiers()) != isStatic) {
				String state= isStatic ? "should" : "should not";
				fErrors.add(new Exception("Method " + each.getName() + "() "
						+ state + " be static"));
			}
			if (!Modifier.isPublic(each.getDeclaringClass().getModifiers()))
				fErrors.add(new Exception("Class " + each.getDeclaringClass().getName()
						+ " should be public"));
			if (!Modifier.isPublic(each.getModifiers()))
				fErrors.add(new Exception("Method " + each.getName()
						+ " should be public"));
			if (each.getReturnType() != Void.TYPE)
				fErrors.add(new Exception("Method " + each.getName()
						+ " should be void"));
			if (each.getParameterTypes().length != 0)
				fErrors.add(new Exception("Method " + each.getName()
						+ " should have no parameters"));
		}
	}
}