JUnit4

JUnit是一個幫助編寫和執(zhí)行單元測試的框架。可能很多人都接觸過單元測試，但是只是停留在copy別人的測試代碼再改一下的狀態(tài)，下文嘗試較為體系列舉JUnit4中比較關(guān)鍵的一些知識點。轉(zhuǎn)載請注明來源「Bug總柴」

Assertions斷言

判斷結(jié)果是否滿足預(yù)期，Junit有以下幾種斷言方法：assertArrayEquals、assertEquals、assertFalse、assertNotNull、assertNotSame、assertNull、assertSame、assertTrue、assertThat。

Hamcrest Mathers

Hamcrest擴展JUnitassertThat的Matcher類型，支持以下matchers:

使用assertThat具有更好的可讀性和出錯信息，建議大多數(shù)情況下使用assertTaht來進行斷言判斷。

Runner執(zhí)行器

Runner執(zhí)行器用于組織和執(zhí)行在一個類中的測試，可以在執(zhí)行器中做一些必須的前置和后置工作。使用@RunWith注解可以指定測試的執(zhí)行類。如果沒有使用@RunWith指定測試執(zhí)行器，默認會使用BlockJunit4ClassRunner。每個測試類只能指定一個Runner。除了默認的Runner還有以下的Runner：

Rule規(guī)則

使用Rule可以對一個或者一組測試的方法進行修改，可以向測試方法中添加額外邏輯來決定測試是否通過，也可以代替@Before、@After、@BeforeClass、@AfterClass來實現(xiàn)初始化和清理工作。換句話而言，Rule相當于是相對測試方法獨立的作用于測試方法中的額外處理邏輯。多個Rule可以順序疊加。如果一個規(guī)則標注為@Rule則對測試類的每個方法生效，如果一個規(guī)則標注為@ClassRule則只會在整個測試類的所有方法開始之前和結(jié)束只會生效一次。以下常見的Rules如下：

測試默認執(zhí)行流程源碼分析

整個測試的執(zhí)行過程是對Statement根據(jù)@BeforeClass、@AfterClass、@Before、@After、Rules的按照裝飾者模式進行的層層包裝。最后會根據(jù)這些包裝的規(guī)則一步一步執(zhí)行測試。

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

    // 執(zhí)行測試
    @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);
        }
    }
    
    // 在執(zhí)行類中測試的前后加上BeforeClass和AfterClass邏輯
    protected Statement classBlock(final RunNotifier notifier) {
        // 執(zhí)行測試類中的測試方法
        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() {
                        // 最終先執(zhí)行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 {
            // 調(diào)用methodBlock加入Before/After以及Rules邏輯
            runLeaf(methodBlock(method), description, notifier);
        }
    }
    
    // 最終會調(diào)用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規(guī)則，最終會調(diào)用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。