Junit關於併發執行測試的源碼簡單分析和使用

併發執行測試用例目的很簡單：就是爲了高效使用資源降低測試時間，俗話說天下武功，唯快不破，對，就是求追速度。

Junit中有關並行執行測試的關鍵組件爲ParallelComputer，ParallelComputer的基類爲Computer。Computer在Junit項目中是一個執行runners或者suites的角色（Runner是一個執行測試用例的執行器；Suite繼承至Runner，Suite允許將多個測試用例封裝到一個suite中）。所以爲了併發測試就需要使用ParallelComputer類，先簡單分析一下ParallelComputer的源碼簡單瞭解一下實現原理，對以後的使用應該幫助還是比較有好處的。ParallelComputer源碼如下：

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

import org.junit.runner.Computer;
import org.junit.runner.Runner;
import org.junit.runners.ParentRunner;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.RunnerBuilder;
import org.junit.runners.model.RunnerScheduler;

public class ParallelComputer extends Computer {
    private final boolean classes;

    private final boolean methods;
    //參數1：測試類是否併發執行， 參數2：測試方法是否併發執行   
    public ParallelComputer(boolean classes, boolean methods) {
        this.classes = classes;
        this.methods = methods;
    }

    public static Computer classes() {
        return new ParallelComputer(true, false);
    }

    public static Computer methods() {
        return new ParallelComputer(false, true);
    }
    // 實現併發執行的關鍵方法，在該方法中使用線程池實現併發測試
    private static Runner parallelize(Runner runner) {
        if (runner instanceof ParentRunner) {
             // 重點代碼處：setScheduler方法是設置測試執行器(Runner)爲並行執行器，因此可以得以並行執行
            ((ParentRunner<?>) runner).setScheduler(new RunnerScheduler() {
                //創建一個線程池，用於執行測試用例
                private final ExecutorService fService = Executors.newCachedThreadPool();
                //用於提交測試用例
                public void schedule(Runnable childStatement) {
                    fService.submit(childStatement);
                }

                //所有測試用例執行完畢之後釋放資源
                public void finished() {
                    try {
                        fService.shutdown();
                        fService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS);
                    } catch (InterruptedException e) {
                        e.printStackTrace(System.err);
                    }
                }
            });
        }
        return runner;
    }

    @Override
    public Runner getSuite(RunnerBuilder builder, java.lang.Class<?>[] classes)
            throws InitializationError {
        Runner suite = super.getSuite(builder, classes);
        //通過classes字段是否並行執行測試用例類
        return this.classes ? parallelize(suite) : suite;
    }

    @Override
    protected Runner getRunner(RunnerBuilder builder, Class<?> testClass)
            throws Throwable {
        Runner runner = super.getRunner(builder, testClass);
        //通過methods方法判斷是否並行執行測試方法
        return methods ? parallelize(runner) : runner;
    }
}

ParallelComputer的關鍵代碼說明見註釋。接下來看一下如何使用併發執行測試用例，測試用例如下：

import org.junit.Test;

import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.is;
import static org.hamcrest.Matchers.not;

/**
 * Created by daxin on 2018/6/9.
 */
public class TestA {

    @Test
    public void testA() {
        ConcurrentTest.printThreadName();
        assertThat(3, is(1));
    }

    @Test
    public void testB() {
        ConcurrentTest.printThreadName();
        assertThat(3, not(1));
    }

}

import org.junit.Test;
import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.lessThan;


public class TestB {
    @Test
    public void testC() {
        ConcurrentTest.printThreadName();
        assertThat(3, greaterThan(1));
    }
    @Test
    public void testD() {
        ConcurrentTest.printThreadName();
        assertThat(3, lessThan(1));
    }
}

併發測試的示例代碼：

import org.junit.experimental.ParallelComputer;
import org.junit.runner.JUnitCore;
import org.junit.runner.Result;

public class ConcurrentTest {

    /**
     * 該方法在真是測試環境下沒有實際用途，只是爲了驗證是否是併發測試
     */
    public static void printThreadName() {
        System.out.println("線程名字 = " + Thread.currentThread().getName());
    }


    public static void main(String[] args) {

        Class[] cls = {TestA.class, TestB.class};
        //JUnitCore是一個執行測試用例的門面（facade設計模式）
        //ParallelComputer：兩個參數分別表示類和方法都並行執行
        Result rt = JUnitCore.runClasses(new ParallelComputer(true, true), cls);
        //打印執行結果
        System.out.println(rt.getRunCount() + "  " + rt.getRunTime());
        System.out.println("================華麗的分割線==================");
        rt.getFailures().forEach(System.out::println);
    }
}

輸出結果信息如下：

通過打印線程名字客戶以看出JUint是以併發的方式執行測試用例。分割線下面可以看出各個存在問題的測試用例的信息。