Junit 运行流程

import org.junit.*;

public class JunitSamplesTest {

    @Before
    public void before(){
        System.out.println(".....this is before test......");
    }

    @After
    public void after(){
        System.out.println(".....this is after test......");
    }

    @BeforeClass
    public static void beforeClass(){
        System.out.println(".....this is before class test......");
    }

    @AfterClass
    public static void afterClass(){
        System.out.println(".....this is after class test......");
    }

    @Test
    public void testOne(){
        System.out.println("this is test one");
    }

    @Test
    public void testTwo(){
        System.out.println("this is test two");
    }
}

/**
 * Run the tests contained in the classes named in the <code>args</code>.
 * If all tests run successfully, exit with a status of 0. Otherwise exit with a status of 1.
 * Write feedback while tests are running and write
 * stack traces for all failed tests after the tests all complete.
 *
 * @param args names of classes in which to find tests to run
 */
public static void main(String... args) {
    Result result = new JUnitCore().runMain(new RealSystem(), args);
    System.exit(result.wasSuccessful() ? 0 : 1);
}

@Override
protected List<FrameworkMethod> getChildren() {
    return computeTestMethods();
}

// clazz 是待测试类
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<Class<? extends Annotation>, List<FrameworkMethod>> methodsForAnnotations =
        new LinkedHashMap<Class<? extends Annotation>, List<FrameworkMethod>>();
    Map<Class<? extends Annotation>, List<FrameworkField>> fieldsForAnnotations =
        new LinkedHashMap<Class<? extends Annotation>, List<FrameworkField>>();
    // 扫描待测试类中所有的 Junit 注解，包括 @Test @Before @After 等等
    scanAnnotatedMembers(methodsForAnnotations, fieldsForAnnotations);
	// 过滤出打在方法上的注解，
    this.methodsForAnnotations = makeDeeplyUnmodifiable(methodsForAnnotations);
    // 过滤出打在变量上的注解
    this.fieldsForAnnotations = makeDeeplyUnmodifiable(fieldsForAnnotations);
}

public abstract class Statement {
    /**
     * Run the action, throwing a {@code Throwable} if anything goes wrong.
     */
    public abstract void evaluate() throws Throwable;
}

protected Statement methodBlock(final FrameworkMethod method) {
    Object test;
    try {
        test = new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                return createTest(method);
            }
        }.run();
    } catch (Throwable e) {
        return new Fail(e);
    }

    Statement statement = methodInvoker(method, test);
    statement = possiblyExpectingExceptions(method, test, statement);
    statement = withPotentialTimeout(method, test, statement);
    statement = withBefores(method, test, statement);
    statement = withAfters(method, test, statement);
    statement = withRules(method, test, statement);
    statement = withInterruptIsolation(statement);
    return statement;
}

@Override
public void evaluate() throws Throwable {
    List<Throwable> errors = new ArrayList<Throwable>();
    try {
        next.evaluate();
    } catch (Throwable e) {
        errors.add(e);
    } finally {
        // 在 finally 中执行 after 方法
        for (FrameworkMethod each : afters) {
            try {
                invokeMethod(each);
            } catch (Throwable e) {
                errors.add(e);
            }
        }
    }
    MultipleFailureException.assertEmpty(errors);
}

protected Statement classBlock(final RunNotifier notifier) {
    // childrenInvoker 这里会调用到 methodBlock
    Statement statement = childrenInvoker(notifier);
    if (!areAllChildrenIgnored()) {
        statement = withBeforeClasses(statement);
        statement = withAfterClasses(statement);
        statement = withClassRules(statement);
        statement = withInterruptIsolation(statement);
    }
    return statement;
}

// 所有 case 数
private final AtomicInteger count;
// 忽略执行的 case 数（被打了 ignore）
private final AtomicInteger ignoreCount;
// 失败 case 数
private final AtomicInteger assumptionFailureCount;
// 所有失败 case 的结果
private final CopyOnWriteArrayList<Failure> failures;
// 执行时间
private final AtomicLong runTime;
// 开始时间
private final AtomicLong startTime;

@RunListener.ThreadSafe
private class Listener extends RunListener {
// 设置开始时间
    @Override
    public void testRunStarted(Description description) throws Exception {
        startTime.set(System.currentTimeMillis());
    }
    
    // 执行完所有 case
    @Override
    public void testRunFinished(Result result) throws Exception {
        long endTime = System.currentTimeMillis();
        runTime.addAndGet(endTime - startTime.get());
    }
    // 执行完某个 case
    @Override
    public void testFinished(Description description) throws Exception {
        count.getAndIncrement();
    }
    // 执行完某个 case 失败
    @Override
    public void testFailure(Failure failure) throws Exception {
        failures.add(failure);
    }
    // 执行完某个ignore case
    @Override
    public void testIgnored(Description description) throws Exception {
        ignoreCount.getAndIncrement();
    }

    @Override
    public void testAssumptionFailure(Failure failure) {
    // Assumption 产生的失败
        assumptionFailureCount.getAndIncrement();
    }
}