Junit源码阅读笔记一(从JunitCore开始)

1.写在前面

基于junit 4.12版本，对junit源码阅读之后的理解和总结，如有不正确的地方，请多指正

2.junit的模块

根据自己对源码的理解，junit大体可以划分为以下几个模块

模块图

1.Request负责发送测试指令
2.Runner负责运行测试用例
3.RunnerBuilder负责创建Runner
4.所有编写的测试用例都被描述为一个TestClass，Runner运行时是通过解析TestClass来进行
5.Runner只是运行测试的一个入口，真正运行测试用例的实际上是Statement，Statement执行的时候会回调Runner子类中的一些具体方法
6.在Statement执行时，会过各种Rule
7.Statement执行完成后会产生一个执行结果Result
8.Notifier负责在测试用例运行期间的各种通知
接下对，结合源码，对各个模块进行分析

2.从JunitCore开始

junit是从JunitCore的main函数开始的

public static void main(String... args) {
    //创建JunitCore实例,并且运行runaMain方法
    //RealSystem只是封装了打印输出流，不影响主流程，暂时忽略
    Result result = new JUnitCore().runMain(new RealSystem(), args);

    //测试运行成功时正常退出，失败时非正常退出
    System.exit(result.wasSuccessful() ? 0 : 1);
}

接下来看runMain方法

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()));
}

先忽略细枝末节，先来看下最主要的run方法做了什么事

public Result run(Request request) {
    //从Request中获取Runner并调用run方法
    return run(request.getRunner());
}

继续看run方法

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;
}

先忽略监听，首先让我们重点来关注是测试是怎么运行的。
进入runner.run方法可见，调用的是Runner的抽象run方法，可见真正的执行是由具体的实现来执行的
从以上流程中不难发现这个Runner是从Request中获取的，那让我们回过头来看一下Request的蹊跷

3.Request的创建

让我们回到runMain方法中最后一行return run(jUnitCommandLineParseResult.createRequest(defaultComputer()));
由此可见Request是通过JUnitCommandLineParseResult来创建见的，我们先来看一下入参Computer，是通过defaultComputer()方法获取的，这个方法很简单，只是return new Computer()，看类的注释Represents a strategy for computing runners and suites.，字面意思好像是说表示一种计算runners和suites的策略，先不管了，继续看createRequest方法

public Request createRequest(Computer computer) {
    //参数解析失败的集合如果为空进入if块
    //parserErrors是runMain方法中JUnitCommandLineParseResult. parse方法获得
    if (parserErrors.isEmpty()) {
        //创建请求
        Request request = Request.classes(
                computer, classes.toArray(new Class<?>[classes.size()]));
        //对创建的默认的请求添加过滤功能
        return applyFilterSpecs(request);
    } else {
        //如果参数解析出错，导出错误
        return errorReport(new InitializationError(parserErrors));
    }
}

进入Request.classes()方法继续向下看

/**
 * Create a <code>Request</code> that, when processed, will run all the tests
 * in a set of classes.
 *
 * @param computer Helps construct Runners from classes
 * @param classes the classes containing the tests
 * @return a <code>Request</code> that will cause all tests in the classes to be run
 */
public static Request classes(Computer computer, Class<?>... classes) {
    try {
        //创建所有默认的可能的RunnerBuilder
        AllDefaultPossibilitiesBuilder builder = new AllDefaultPossibilitiesBuilder(true);
        //获取�Suite，Suite是Runner的具体实现
        Runner suite = computer.getSuite(builder, classes);
        //调用runner方法并返回
        return runner(suite);
    } catch (InitializationError e) {
        throw new RuntimeException(
                "Bug in saff's brain: Suite constructor, called as above, should always complete");
    }
}

看来这Request是从runner方法中创建的，继续看runner方法

public static Request runner(final Runner runner) {
    return new Request() {
        @Override
        public Runner getRunner() {
            return runner;
        }
    };
}

Request的创建很简单，直接new了一个匿名的Request并实现了getRunner()的抽象方法
至此，可以看到runMain方法中终于调用的Runner是哪来的了
就是从这个匿名的Request中实现的getRunner方法中获取的，而这个Runner是由Request.classes方法中创建的，而这个Runner正是由Computer这个类获取的Suite
以上是默认的Request方法的创建的Request中Runner的获取，让我们回到createRequest方法中继续向下看applyFilterSpecs方法

private Request applyFilterSpecs(Request request) {
    try {
        for (String filterSpec : filterSpecs) {
            //根据参数解析的filterSpecs创建过滤器
            Filter filter = FilterFactories.createFilterFromFilterSpec(
                    request, filterSpec);
            request = request.filterWith(filter);
        }
        return request;
    } catch (FilterNotCreatedException e) {
        return errorReport(e);
    }
}

继续看request.filterWith

public Request filterWith(Filter filter) {
    return new FilterRequest(this, filter);
}

直接new了一个FilterRequest，此处是采用装饰者模式，对原有的Request进行加工，增加了过滤功能，不再赘述
因此可以看出，JunitCore中的run方法

public Result run(Request request) {
    return run(request.getRunner());
}

是从Request实例中(如果设置了过滤器,则是FilterRequest实例)调用getRunner()方法，获取Suite实例，真正运行的是Suite中的run()方法
（FilterRequest中的getRunner方法会过滤掉实现了Filterable并满足过滤条件的Runner）

下面让我们来总结一下这个调用的时序

junitCore运行时.png