摘要：的作用是包裝從生成的邏輯，提供兩種方案生成和。最后從生成也異常簡單，也就是實現(xiàn)其方法返回該。

盡管在第二次博客中我們講述了Runner的運行機(jī)制，但是許多其他特性比如Filter是如何與運行流程結(jié)合卻并不清楚。這次我們來回顧整理一下Junit的執(zhí)行流程，給出各種特性生效的機(jī)理，并分析一些代碼中精妙的地方。

JUnitCore的RunMain方法，使用jUnitCommandLineParseResult解析參數(shù)并生成Request。

Result runMain(JUnitSystem system, String... args) {
        system.out().println("JUnit version " + Version.id());

        JUnitCommandLineParseResult jUnitCommandLineParseResult = JUnitCommandLineParseResult.parse(args);

        RunListener listener = new TextListener(system);
        addListener(listener);

        return run(jUnitCommandLineParseResult.createRequest(defaultComputer()));
    }

在jUnitCommandLineParseResult的createRequest方法中，調(diào)用Request的classes方法生成Request，并對生成的Request進(jìn)行過濾

public Request createRequest(Computer computer) {
        if (parserErrors.isEmpty()) {
            Request request = Request.classes(
                    computer, classes.toArray(new Class[classes.size()]));
            return applyFilterSpecs(request);
        } else {
            return errorReport(new InitializationError(parserErrors));
        }
    }

接下來我們就要進(jìn)入核心部分了，先提出以下幾個問題：

如何為單個類生成Request

Filter的實現(xiàn)機(jī)制

對于錯誤如何把它納入以Request為初始并最終使用Runner的run這一套機(jī)制中

我們先回答第一個問題，其他問題我們會在之后慢慢解答：

接下來先給出classes方法的代碼

public static Request classes(Computer computer, Class... classes) {
        try {
            AllDefaultPossibilitiesBuilder builder = new AllDefaultPossibilitiesBuilder(true);
            Runner suite = computer.getSuite(builder, classes);
            return runner(suite);
        } catch (InitializationError e) {
            return runner(new ErrorReportingRunner(e, classes));
        }
    }

問題再次被拆分為三個：

生成一個Builder

從Builder導(dǎo)出一個Runner

從Runner生成一個Request

AllDefaultPossibilitiesBuilder的邏輯是先后使用ignoredBuilder、annotatedBuilder、suiteMethodBuilder、junit3Builder、junit4Builder來生成Runner直到有一個成功則返回，然后getSuite方法將返回的Runner變?yōu)镾uite。

Computer的作用是包裝從builder生成Runner的邏輯，提供兩種方案——生成SingleClassRunner和Suite。我們在這里提一下生成Suite的邏輯，就是使用該builder不停為多個測試類生成對應(yīng)的Runner并放置到Suite的Runner列表中，Suite其他的初始化過程依從其父類，此處就不詳述。

最后從Runner生成Request也異常簡單，也就是實現(xiàn)其getRunner方法返回該Runner?，F(xiàn)在我們把注意力投放到builder如何導(dǎo)出Runner，以JUnit4Builder為例，下面給出代碼：

 public class JUnit4Builder extends RunnerBuilder {
    @Override
    public Runner runnerForClass(Class testClass) throws Throwable {
        return new BlockJUnit4ClassRunner(testClass);
    }
}

可以看出它其實就是直接生成了一個BlockJUnit4ClassRunner，下面我們關(guān)注該Runner的構(gòu)造過程。

    protected ParentRunner(Class testClass) throws InitializationError {
        this.testClass = createTestClass(testClass);
        validate();
    }

    protected TestClass createTestClass(Class testClass) {
        return new TestClass(testClass);
    }

可以看出構(gòu)造SingleClassRunne的過程就是解析生成TestClass的過程，我們在第二篇博客里已經(jīng)詳細(xì)講解過了，此處就不再贅述了?？赡茉S多讀者看到這兒會很困惑，之前一直強調(diào)的描述測試樣例的Description到底是在哪里生成的呢？其實是在Runner的run過程里生成的，如下：

@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);
        }
    }
    @Override
    public Description getDescription() {
        Description description = Description.createSuiteDescription(getName(),
                getRunnerAnnotations());
        for (T child : getFilteredChildren()) {
            description.addChild(describeChild(child));
        }
        return description;
    }

可以明顯地得知Description是依據(jù)Runner來建立的，它的結(jié)構(gòu)和Runner應(yīng)該保持一致，它是Runner的附屬品，用來供與Runner交互的Notifier獲得信息。

下面我們主要關(guān)注在運行之后Result的生成和Failure的處理。Result是Notifier通過fireTestRunFinished(result)生成的，我們來看一看它具體做了什么。

    private abstract class SafeNotifier {
        private final List currentListeners;

        SafeNotifier() {
            this(listeners);
        }

        SafeNotifier(List currentListeners) {
            this.currentListeners = currentListeners;
        }

        void run() {
            int capacity = currentListeners.size();
            List safeListeners = new ArrayList(capacity);
            List failures = new ArrayList(capacity);
            for (RunListener listener : currentListeners) {
                try {
                    notifyListener(listener);
                    safeListeners.add(listener);
                } catch (Exception e) {
                    failures.add(new Failure(Description.TEST_MECHANISM, e));
                }
            }
            fireTestFailures(safeListeners, failures);
        }

        abstract protected void notifyListener(RunListener each) throws Exception;
    }

    public void fireTestRunFinished(final Result result) {
        new SafeNotifier() {
            @Override
            protected void notifyListener(RunListener each) throws Exception {
                each.testRunFinished(result);
            }
        }.run();
    }
    public void fireTestAssumptionFailed(final Failure failure) {
        new SafeNotifier() {
            @Override
            protected void notifyListener(RunListener each) throws Exception {
                each.testAssumptionFailure(failure);
            }
        }.run();
    }
     private void fireTestFailures(List listeners,
            final List failures) {
        if (!failures.isEmpty()) {
            new SafeNotifier(listeners) {
                @Override
                protected void notifyListener(RunListener listener) throws Exception {
                    for (Failure each : failures) {
                        listener.testFailure(each);
                    }
                }
            }.run();
        }
    }

簡單概括一下，就是調(diào)用它所管理的Listener的testRunFinished來處理Result，處理完畢之后就把該Listener標(biāo)記為安全的，如果處理過程中出現(xiàn)異常，則將該異常加入failures列表，全部通知完畢后再次通知所有安全的Listener處理之前所有的Failure。這里還有一個問題，那就是Failure到底是怎樣在運行時生成的。由于斷言機(jī)制，所有的斷言失敗都會拋出對應(yīng)的異常，對于斷言異常，請看下文：

@Override
    protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
        Description description = describeChild(method);
        if (isIgnored(method)) {
            notifier.fireTestIgnored(description);
        } else {
            Statement statement;
            try {
                statement = methodBlock(method);
            }
            catch (Throwable ex) {
                statement = new Fail(ex);
            }
            runLeaf(statement, description, notifier);
        }
    }

Fail會直接拋出原有的異常，再次調(diào)用RunLeaf

    protected final void runLeaf(Statement statement, Description description,
            RunNotifier notifier) {
        EachTestNotifier eachNotifier = new EachTestNotifier(notifier, description);
        eachNotifier.fireTestStarted();
        try {
            statement.evaluate();
        } catch (AssumptionViolatedException e) {
            eachNotifier.addFailedAssumption(e);
        } catch (Throwable e) {
            eachNotifier.addFailure(e);
        } finally {
            eachNotifier.fireTestFinished();
        }
    }

最后轉(zhuǎn)入addFailure處理，而addFailure會最終通知Notifier中的各個Listener處理
。那JunitCore到底使用了怎樣的Listener，它又執(zhí)行了怎樣的操作。

public Result run(Runner runner) {
        Result result = new Result();
        RunListener listener = result.createListener();
        notifier.addFirstListener(listener);
        try {
            notifier.fireTestRunStarted(runner.getDescription());
            runner.run(notifier);
            notifier.fireTestRunFinished(result);
        } finally {
            removeListener(listener);
        }
        return result;
    }

注意JunitCore的Run方法中加入了一個Result中內(nèi)置的Listener，其定義如下

@RunListener.ThreadSafe
    private class Listener extends RunListener {
        @Override
        public void testRunStarted(Description description) throws Exception {
            startTime.set(System.currentTimeMillis());
        }

        @Override
        public void testRunFinished(Result result) throws Exception {
            long endTime = System.currentTimeMillis();
            runTime.addAndGet(endTime - startTime.get());
        }

        @Override
        public void testFinished(Description description) throws Exception {
            count.getAndIncrement();
        }

        @Override
        public void testFailure(Failure failure) throws Exception {
            failures.add(failure);
        }

        @Override
        public void testIgnored(Description description) throws Exception {
            ignoreCount.getAndIncrement();
        }

        @Override
        public void testAssumptionFailure(Failure failure) {
            // do nothing: same as passing (for 4.5; may change in 4.6)
        }
    }

可以看出該Listener在testFailure中完成了添加Failure的動作，看到這里我簡直激動莫名，使用一個內(nèi)置的Listener子類來避免顯式為Result添加Failure，而是依然把這些操作集中在Notifier——Listener的觀察者體系里，可謂精妙絕倫！

同時還需注意在runMain方法中加入了一個TextListener來完成打印結(jié)果的工作。

上面我們講述了Junit如何處理樣例中的斷言錯誤以及運行時錯誤，但是當(dāng)初始化Request的過程中一旦發(fā)生異常依然需要繼續(xù)運行并提示測試失敗，這又是怎么實現(xiàn)的呢？

我們回顧之前createRequest方法中的errorReport，代碼如下：

    public static Request errorReport(Class klass, Throwable cause) {
        return runner(new ErrorReportingRunner(klass, cause));
    }

我們來看一下這個ErrorReportingRunner的實現(xiàn)

public class ErrorReportingRunner extends Runner {
    private final List causes;

    private final String classNames;

    public ErrorReportingRunner(Class testClass, Throwable cause) {
        this(cause, new Class[] { testClass });
    }
    
    public ErrorReportingRunner(Throwable cause, Class... testClasses) {
        if (testClasses == null || testClasses.length == 0) {
            throw new NullPointerException("Test classes cannot be null or empty");
        }
        for (Class testClass : testClasses) {
            if (testClass == null) {
                throw new NullPointerException("Test class cannot be null");
            }
        }
        classNames = getClassNames(testClasses);
        causes = getCauses(cause);
    }
    
    @Override
    public Description getDescription() {
        Description description = Description.createSuiteDescription(classNames);
        for (Throwable each : causes) {
            description.addChild(describeCause(each));
        }
        return description;
    }

    @Override
    public void run(RunNotifier notifier) {
        for (Throwable each : causes) {
            runCause(each, notifier);
        }
    }

    private String getClassNames(Class... testClasses) {
        final StringBuilder builder = new StringBuilder();
        for (Class testClass : testClasses) {
            if (builder.length() != 0) {
                builder.append(", ");
            }
            builder.append(testClass.getName());
        }
        return builder.toString();
    }

    @SuppressWarnings("deprecation")
    private List getCauses(Throwable cause) {
        if (cause instanceof InvocationTargetException) {
            return getCauses(cause.getCause());
        }
        if (cause instanceof InitializationError) {
            return ((InitializationError) cause).getCauses();
        }
        if (cause instanceof org.junit.internal.runners.InitializationError) {
            return ((org.junit.internal.runners.InitializationError) cause)
                    .getCauses();
        }
        return Arrays.asList(cause);
    }

    private Description describeCause(Throwable child) {
        return Description.createTestDescription(classNames, "initializationError");
    }

    private void runCause(Throwable child, RunNotifier notifier) {
        Description description = describeCause(child);
        notifier.fireTestStarted(description);
        notifier.fireTestFailure(new Failure(description, child));
        notifier.fireTestFinished(description);
    }
}

上面的大致邏輯依然是先生成Description（因為沒有到ParentRunner的run那一步，Description沒有生成，故需要在此生成），然后移交給Notifier處理