JUnit4

JUnit是一个帮助编写和执行单元测试的框架。可能很多人都接触过单元测试，但是只是停留在copy别人的测试代码再改一下的状态，下文尝试较为体系列举JUnit4中比较关键的一些知识点。转载请注明来源「Bug总柴」

Assertions断言

判断结果是否满足预期，Junit有以下几种断言方法：assertArrayEquals、assertEquals、assertFalse、assertNotNull、assertNotSame、assertNull、assertSame、assertTrue、assertThat。

Hamcrest Mathers

Hamcrest扩展JUnitassertThat的Matcher类型，支持以下matchers:

使用assertThat具有更好的可读性和出错信息，建议大多数情况下使用assertTaht来进行断言判断。

Runner执行器

Runner执行器用于组织和执行在一个类中的测试，可以在执行器中做一些必须的前置和后置工作。使用@RunWith注解可以指定测试的执行类。如果没有使用@RunWith指定测试执行器，默认会使用BlockJunit4ClassRunner。每个测试类只能指定一个Runner。除了默认的Runner还有以下的Runner：

Rule规则

使用Rule可以对一个或者一组测试的方法进行修改，可以向测试方法中添加额外逻辑来决定测试是否通过，也可以代替@Before、@After、@BeforeClass、@AfterClass来实现初始化和清理工作。换句话而言，Rule相当于是相对测试方法独立的作用于测试方法中的额外处理逻辑。多个Rule可以顺序叠加。如果一个规则标注为@Rule则对测试类的每个方法生效，如果一个规则标注为@ClassRule则只会在整个测试类的所有方法开始之前和结束只会生效一次。以下常见的Rules如下：

测试默认执行流程源码分析

整个测试的执行过程是对Statement根据@BeforeClass、@AfterClass、@Before、@After、Rules的按照装饰者模式进行的层层包装。最后会根据这些包装的规则一步一步执行测试。

// BlockJUnit4ClassRunner会继承ParentRunner
public abstract class ParentRunner<T> extends Runner implements Filterable, Sortable {

    // 执行测试
    @Override
    public void run(final RunNotifier notifier) {
        EachTestNotifier testNotifier = new EachTestNotifier(notifier,
                getDescription());
        try {
            Statement statement = classBlock(notifier);
            statement.evaluate();
        } catch (AssumptionViolatedException e) {
            testNotifier.addFailedAssumption(e);
        } catch (StoppedByUserException e) {
            throw e;
        } catch (Throwable e) {
            testNotifier.addFailure(e);
        }
    }
    
    // 在执行类中测试的前后加上BeforeClass和AfterClass逻辑
    protected Statement classBlock(final RunNotifier notifier) {
        // 执行测试类中的测试方法
        Statement statement = childrenInvoker(notifier);
        if (!areAllChildrenIgnored()) {
            // 这里会对类中的测试加上Before和After的逻辑
            statement = withBeforeClasses(statement);
            statement = withAfterClasses(statement);
            statement = withClassRules(statement);
        }
        return statement;
    }
    
    protected Statement childrenInvoker(final RunNotifier notifier) {
        return new Statement() {
            @Override
            public void evaluate() {
                runChildren(notifier);
            }
        };
    }
    
    private void runChildren(final RunNotifier notifier) {
        final RunnerScheduler currentScheduler = scheduler;
        try {
            for (final T each : getFilteredChildren()) {
                currentScheduler.schedule(new Runnable() {
                    public void run() {
                        // 最终先执行runChild
                        ParentRunner.this.runChild(each, notifier);
                    }
                });
            }
        } finally {
            currentScheduler.finished();
        }
    }
}

// 默认JUnit4 Runner BlockJUnit4ClassRunner对runChild进行处理
public class BlockJUnit4ClassRunner extends ParentRunner<FrameworkMethod> {
    @Override
    protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
        Description description = describeChild(method);
        if (isIgnored(method)) {
            notifier.fireTestIgnored(description);
        } else {
            // 调用methodBlock加入Before/After以及Rules逻辑
            runLeaf(methodBlock(method), description, notifier);
        }
    }
    
    // 最终会调用After/Before以及Rule逻辑
    protected Statement methodBlock(FrameworkMethod method) {
        Object test;
        try {
            test = new ReflectiveCallable() {
                @Override
                protected Object runReflectiveCall() throws Throwable {
                    return createTest();
                }
            }.run();
        } catch (Throwable e) {
            return new Fail(e);
        }

        Statement statement = methodInvoker(method, test);
        // 在测试的前后加上Before/After以及withRules
        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);
        return statement;
    }
}

// 对于Rule规则，最终会调用TestRule.apply()方法
public class RunRules extends Statement {
    private final Statement statement;

    public RunRules(Statement base, Iterable<TestRule> rules, Description description) {
        statement = applyAll(base, rules, description);
    }

    @Override
    public void evaluate() throws Throwable {
        statement.evaluate();
    }

    private static Statement applyAll(Statement result, Iterable<TestRule> rules,
            Description description) {
        for (TestRule each : rules) {
            // 顺序加上Rule的逻辑
            result = each.apply(result, description);
        }
        return result;
    }
}

JUnit后记

如果有能代替Runner的Rule，最好使用Rule，因为一个测试类可以指定多个Rule，但是只能声明一个Runner。