单元测试之junit基本使用

侧耳倾听111

已于 2025-04-04 16:35:38 修改

阅读量525

点赞数 5

文章标签： junit java

于 2024-09-28 15:28:56 首次发布

本文链接：https://blog.youkuaiyun.com/qq_44818304/article/details/142616439

版权

简介

junit：开源的单元测试框架，使用Java编写

单元测试：用于验证程序中某个单元是否正确，这个单元通常是一个可以被外部访问的函数。单元测试是程序员的测试，是白盒测试。

白盒测试和黑盒测试：

白盒测试：测试者清楚软件内部的运行逻辑，程序员自己编写测试案例就是一种白盒测试
黑盒测试：测试者不清楚软件内部的运行逻辑

一个好的单元测试应该具备的要求：

独立可重复：单元测试不依赖外部环境，多次执行，可以获得相同的结果，这是回归测试的基础
断言：单元测试的结尾必须要有断言，越详细越好
考虑正反两种情况
考虑边界值，考虑值为null的情况

单测案例命名模板：test{被测方法名}{测试场景}{预期行为}，其中，每个部分采用驼峰命名。举例：testCreateOrder_noInventory_fail。

入门案例

需求：学习使用junit来编写单元测试

第一步：创建maven项目，添加依赖

<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.12</version>
    <scope>test</scope>
</dependency>

第二步：编写测试类，直接执行即可

public class LearnJunitTest {
    @Test
    public void test1() {
        System.out.println("hello junit");

        Properties properties = System.getProperties();
        assert properties != null;
    }
}

因为IDEA支持junit框架，所以可以直接运行被@Test注解标注的方法，被@Test注解标注的方法就是一个单元测试。

案例讲解：测试案例是要验证某个功能，在这个测试案例中，简单验证了一下System类中的getProperties()方法，判断它的返回值不为null。如果没有特殊注释，测试方法默认在main线程中执行

junit的使用

常用注解

junit在用户层面的api是一系列注解，用户通过这些注解来使用junit

junit中的注解：

@Test：标注在一个 public void类型的方法上，此时该方法时一个单元测试
- 有两个参数可以选择：
  - expected：一个期待的异常类型，如果没有抛出这个异常，算测试失败
  - timeout：单位为毫秒，超过多少毫秒方法没有执行完成，算测试失败
@Before：注解一个无参无返回值的方法，在@Test方法执行之前执行
@After：注解一个无参无返回值的方法，在@Test方法执行之后执行
@BeforeClass：注解在静态方法上，在所有测试案例之前执行
@AfterClass：注解在静态方法上，在所有测试案例之后执行

入门案例中展示了@Test注解的基本用法，在这里再详细介绍一下

案例1：@Test注解和expect，指定期待的异常，测试用例抛出指定异常，算执行成功，用于验证错误情况

@Test(expected = ArithmeticException.class)
public void test4() {
    int i = 1 / 0; // 除零异常。java.lang.ArithmeticException: / by zero
}

这个案例中，代码会抛出运算异常，是期待的异常，所以案例执行成功

案例2：@Test中的属性timeout，指定超时时间，如果测试用例执行超时，算执行失败

@Test(timeout = 2000L)
public void test3() {
    try {
        Thread.sleep(3000L);
    } catch (InterruptedException e) {
        throw new RuntimeException(e);
    }
    Utils.println("test3");
}

执行结果：

org.junit.runners.model.TestTimedOutException: test timed out after 2000 milliseconds

	at java.lang.Thread.sleep(Native Method)
	at org.wyj.LearnJunit2Test.test3(LearnJunit2Test.java:51)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.internal.runners.statements.FailOnTimeout$CallableStatement.call(FailOnTimeout.java:298)
	at org.junit.internal.runners.statements.FailOnTimeout$CallableStatement.call(FailOnTimeout.java:292)
	at java.util.concurrent.FutureTask.run(FutureTask.java:266)
	at java.lang.Thread.run(Thread.java:750)

案例3：@BeforeClass、@AfterClass、@Before、@After

import org.junit.*;
import org.utils.Utils;

public class LearnJunit2Test {

    @BeforeClass
    public static void beforeClass(){
        Utils.println("beforeClass");
    }

    @AfterClass
    public static void afterClass(){
        Utils.println("afterClass");
    }


    @Before
    public void before() {
        Utils.println("before");
    }

    @After
    public void after() {
        Utils.println("after");
    }

    /**
     * 测试在有before方法和after方法的情况下，测试用例的执行流程
     */
    @Test
    public void test1() {
        Utils.println("test1");
    }

    @Test
    public void test2() {
        Utils.println("test2");
    }
}

执行整个测试类，执行结果：

[main] [2024-08-25 15:26:17.430] beforeClass
[main] [2024-08-25 15:26:17.432] before
[main] [2024-08-25 15:26:17.432] test1
[main] [2024-08-25 15:26:17.433] after
[main] [2024-08-25 15:26:17.434] before
[main] [2024-08-25 15:26:17.434] test2
[main] [2024-08-25 15:26:17.434] after
[main] [2024-08-25 15:26:17.434] afterClass

可以看到，@Before、@After在每个测试案例的前后执行，@BeforeClass、@AfterClass在所有测试案例的前后执行，只执行一次，@BeforeClass在@Before之前，@AfterClass在@After之后

测试过程中依赖的代码：主要是为了观察测试案例的执行顺序

public class Utils {

    // 不允许实例化
    private Utils(){}

    // 返回日期格式化器，以指定的格式来格式化日期
    private static DateTimeFormatter getFormatter(){
        return StoreSingleton.formatter;
    }

    // 使用静态内部类的形式来存储日期格式化器
    private static class StoreSingleton{
        private static final DateTimeFormatter formatter
                = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS");
    }

    /**
     * 以指定的格式打印消息
     * @param msg 消息
     */
    public static void println(String msg){
        System.out.printf("[%s] [%s] %s%n", Thread.currentThread().getName()
                , getFormatter().format(LocalDateTime.now()), msg);
    }

    public static void println(Object msg){
        System.out.printf("[%s] [%s] %s%n", Thread.currentThread().getName()
                , getFormatter().format(LocalDateTime.now()), msg);
    }
}

@Ignore

忽略测试案例，被@Ignore标注的测试案例或测试类不会执行

@RunWith

用于指定用于运行测试类的运行器。JUnit 的运行器是一个特殊的类，它负责在测试执行期间控制执行流程，包括初始化测试环境、执行测试方法、收集测试结果等。通过@RunWith注解，用户可以指定自己的运行器，例如，springboot通过@RunWith注解，指定自己的执行器，使得测试用例可以跑在spring容器中。

案例：

@RunWith(BlockJUnit4ClassRunner.class) // 如果没有使用@RunWith注解，这就是默认的配置
public class ExampleTest {
    @Test
    public void testMethod() {
        // 测试逻辑
    }
}

断言

断言：计算机自动判断两组数据关系是否为真时的过程。每一个测试的结尾，最好有一个断言，表示这个测试验证了什么功能，功能的执行结果是什么

Assert类：junit中用于断言的类

案例：

@Test
public void test1() {
    Properties properties = System.getProperties();
    // 验证方法的返回值不为null，如果为null，测试失败，只有在不为null的情况下，才算成功
    Assert.assertNotNull(properties);
}

assert关键字：Java自带的关键字，它只应该使用在单元测试中，不应该在正式代码中使用它

案例：

@Test
public void test2() {
    Properties properties = System.getProperties();
    // 验证方法的返回值不为null，如果为null，测试失败，只有在不为null的情况下，才算成功
    assert properties != null;
}

测试类的命名规范

'[A-Z][A-Za-z\d]*Test(s|Case)?|Test[A-Z][A-Za-z\d]*|IT(.*)|(.*)IT(Case)?'，这个正则表达式中描述了测试类的命名规范，在这里做如下总结：

以Test开始或以Test结尾

测试案例的执行顺序

测试案例之间应该是独立的，不应该有顺序上的依赖，如果需要测试案例依据顺序执行，在编写测试案例时，案例的名称依据字母顺序排序

源码

在学习完junit的基本使用之后，接下来深入了解junit的内部原理。

junit的作用，是帮助用户组织测试用例的代码，执行测试用例，并且提供一个界面来查询测试用例的执行结果，在这里，学习junit的源码，了解junit是如何执行测试用例的。

通过debug来查看源码的执行流程

之前的内容介绍了junit执行的基本流程，接下来通过debug源码，来详细地查看其中的每一步。

测试用例：

public class LearnJunit5Test {
    @BeforeClass
    public static void beforeClass(){
        Utils.println("beforeClass");
    }

    @AfterClass
    public static void afterClass(){
        Utils.println("afterClass");
    }

    @Before
    public void before() {
        Utils.println("before");
    }

    @After
    public void after() {
        Utils.println("after");
    }

    @Test(expected = ArithmeticException.class, timeout = 2000L)
    public void test() {
        Utils.println("test");
        int i = 1 / 0; // 除零异常。java.lang.ArithmeticException: / by zero
    }
}

在这个测试用例中，涉及到了junit所有常用的功能，包括@BeforeClass、@AfterClass、@Before、@After，@Test注解中的expected和timeout，接下来就通过debug查看junit是如何执行这个测试用例的。

这段代码是通过IDEA来执行的，代码的启动命令：java com.intellij.rt.junit.JUnitStarter -ideVersion5 -junit4 org.wyj.LearnJunit5Test,test，这里做了一些简化，IDEA通过Java命令，启动JUnitStarter，并且传入测试用例的类名和方法名。

第一步：IDEA调用JunitCore类中的run方法，传入Runner对象，这里的Runner对象如果没有特殊配置，默认是BlockJUnit4ClassRunner，Runner对象中封装了需要被执行的测试类和测试方法的类对象。

在这里插入图片描述

第二步：JunitCore中的run方法，这个方法由IDEA来调用。这个方法描述了测试用例的基本执行流程，因为整个执行流程从这个方法进入，也从这个方法结束。方法中的步骤：

创建result实例，它用于统计测试用例的执行结果，包括执行时间、成功个数、失败个数，
创建监听器，然后把监听器添加到通知器中，result实例持有监听器，
调用运行器，同时传入通知器的实例，运行器运行测试案例，同时调用通知器，来记录测试流程中的各个事件。
在运行器的运行前后和运行过程中，都会调用通知器的实例，来记录关键事件，

public Result run(Runner runner) {
    // 创建result实例：用于封装测试结果，包括测试案例的运行时间、成功或失败的个数等。
    Result result = new Result();
    // 创建监听器：调用Result实例创建一个监听器
    RunListener listener = result.createListener();
    // 把监听器添加到通知器中
    notifier.addFirstListener(listener);
    try {
        // 调用通知器：记录测试案例启动时间
        notifier.fireTestRunStarted(runner.getDescription());
        // 运行测试案例，这里的runner，是BlockJUnit4ClassRunner类型的实例
        runner.run(notifier);
        // 调用通知器：记录测试案例结束时间
        notifier.fireTestRunFinished(result);
    } finally {
        // 移除监视器
        removeListener(listener);
    }
    // 返回测试结果
    return result;
}

第三步：上一步中的runner.run(notifier)语句，这行代码是调用执行器来执行测试用例。BlockJUnit4ClassRunner继承了ParentRunner，这里调用ParentRunner中的run方法。

@Override
public void run(final RunNotifier notifier) {
    // 把通知器和描述信息封装到一起，在测试用例执行失败时使用
    EachTestNotifier testNotifier = new EachTestNotifier(notifier,
            getDescription());
    try {
        // 创建Statement实例，它封装了测试用例的执行流程
        Statement statement = classBlock(notifier);
        // 执行测试用例
        statement.evaluate();
    } catch (AssumptionViolatedException e) {
        testNotifier.addFailedAssumption(e);
    } catch (StoppedByUserException e) {
        throw e;
    } catch (Throwable e) {
        testNotifier.addFailure(e);
    }
}

第四步：上一步中的classBlock(notifier)语句，它是如何创建Statement实例的

protected Statement classBlock(final RunNotifier notifier) {
    // 在childrenInvoker方法中，会返回Statement的匿名内部类，类中重写了Statement的evaluate方法
    Statement statement = childrenInvoker(notifier);
    if (!areAllChildrenIgnored()) {
        // 处理@BeforeClass注解
        statement = withBeforeClasses(statement);
        // 处理@AfterClass注解
        statement = withAfterClasses(statement);
        // @ClassRules注解很少使用，这里先不看
        statement = withClassRules(statement);
    }
    // 返回statement实例，在这里，statement实例实际上是一个链表，statement是链表的头结点
    return statement;
}

这一步中的每一行代码都很重要，这里逐行分析：

childrenInvoker(notifier)：

protected Statement childrenInvoker(final RunNotifier notifier) {
    // 返回Statement的匿名内部类，它重写了evaluate方法，在evaluate方法中，调用了ParentRunner中的runChildren方法
    return new Statement() {
        @Override
        public void evaluate() {
            runChildren(notifier);
        }
    };
}

private void runChildren(final RunNotifier notifier) {
    // schedule变量是ParentRunner类中的成员变量，代表了一个调度策略
    final RunnerScheduler currentScheduler = scheduler;
    try {
        // getFilteredChildren方法，是获取所有被@Test注解标注的方法
        for (final T each : getFilteredChildren()) {
            // 通过调度器来执行被@Test注解标注的方法
            currentScheduler.schedule(new Runnable() {
                public void run() {
                    ParentRunner.this.runChild(each, notifier);
                }
            });
        }
    } finally {
        currentScheduler.finished();
    }
}


// schedule变量的赋值
private volatile RunnerScheduler scheduler = new RunnerScheduler() {
    public void schedule(Runnable childStatement) {
        childStatement.run();
    }
    public void finished() {
        // do nothing
    }
};

withBeforeClasses(statement)：如果测试类中有@BeforeClass注解，则创建RunBefores的实例

protected Statement withBeforeClasses(Statement statement) {
    // 获取测试类中所有被@BeforeClass注解标注的方法
    List<FrameworkMethod> befores = testClass
            .getAnnotatedMethods(BeforeClass.class);
    // 如果没有，返回原来的statement实例，如果有，新建一个RunBefores实例
    return befores.isEmpty() ? statement :
            new RunBefores(statement, befores, null);
}

withAfterClasses(statement)：如果测试类中有@AfterClass注解，则创建RunAfters的实例

protected Statement withAfterClasses(Statement statement) {
    // 获取测试类中所有被@AfterClass注解标注的方法
    List<FrameworkMethod> afters = testClass
            .getAnnotatedMethods(AfterClass.class);
    // 如果没有，返回原来的statement实例，如果有，新建一个RunAfters实例，
    return afters.isEmpty() ? statement :
            new RunAfters(statement, afters, null);
}

第五步：第四步 classBlock(notifier) 执行完之后退出，执行第三步中的statement.evaluate语句。因为statement对象是一个匿名内部类，所以这里调用匿名内部类中的evaluate方法。statement实际上是一个链表，链表中的每一个节点负责处理一个功能，在这里，首先处理@AfterClass注解。

第六步：处理@AfterClass注解，

public class RunAfters extends Statement {
    private final Statement next;

    private final Object target;

    private final List<FrameworkMethod> afters;

    public RunAfters(Statement next, List<FrameworkMethod> afters, Object target) {
        this.next = next;
        this.afters = afters;
        this.target = target;
    }

    // RunAfters继承了Statement，所以statement.evaluate，实际上是调用RunAfters中的evaluate方法，
    @Override
    public void evaluate() throws Throwable {
        List<Throwable> errors = new ArrayList<Throwable>();
        try {
            // next，是下一个步骤的实例，RunAfter实例虽然最先被调用，但是在RunAfter中，首先会执行
            // 下一个节点的方法
            next.evaluate();
        } catch (Throwable e) {
            errors.add(e);
        } finally {
            // 处理@AfterClass注解
            for (FrameworkMethod each : afters) {
                try {
                    each.invokeExplosively(target);
                } catch (Throwable e) {
                    errors.add(e);
                }
            }
        }
        MultipleFailureException.assertEmpty(errors);
    }
}

第七步：处理@BeforeClass注解。由于当前的测试案例中有@BeforeClass注解，所以RunAfters持有的下一个节点的实例是RunBefores，上一步中的next.evaluate方法，实际上是调用的RunBefores中的方法

public class RunBefores extends Statement {
    private final Statement next;

    private final Object target;

    private final List<FrameworkMethod> befores;

    public RunBefores(Statement next, List<FrameworkMethod> befores, Object target) {
        this.next = next;
        this.befores = befores;
        this.target = target;
    }

    @Override
    public void evaluate() throws Throwable {
        // 处理@BeforeClass注解
        for (FrameworkMethod before : befores) {
            before.invokeExplosively(target);
        }
        // 调用下一个节点
        next.evaluate();
    }
}

处理@BeforeClass注解的具体步骤：上一步中的invokeExplosively方法，可以看到，通过反射，直接调用被@BeforeClass标注的方法

public Object invokeExplosively(final Object target, final Object... params)
        throws Throwable {
    return new ReflectiveCallable() {
        @Override
        protected Object runReflectiveCall() throws Throwable {
            return method.invoke(target, params);
        }
    }.run();
}

第八步：处理@Test注解，第七步中的next.evaluate方法，实际上是调用这里的匿名内部类重写的evaluate方法

protected Statement childrenInvoker(final RunNotifier notifier) {
    return new Statement() {
        @Override
        public void evaluate() {
            runChildren(notifier);
        }
    };
}

最终调用BlockJunit4ClassRunner中的runChild方法

@Override
protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
    Description description = describeChild(method);
    // 判断方法有没有被@Ingore注解标注
    if (isIgnored(method)) {
        notifier.fireTestIgnored(description);
    } else {
        // 方法没有被@Ignore标注的情况
        runLeaf(methodBlock(method), description, notifier);
    }
}

第九步：第八步中的methodBlock(method)方法，编排测试用例的执行流程

protected Statement methodBlock(FrameworkMethod method) {
    Object test;
    try {
        test = new ReflectiveCallable() {
            @Override
            protected Object runReflectiveCall() throws Throwable {
                // 创建测试类的实例
                return createTest();
            }
        }.run(); // 匿名内部类，重写了runReflectiveCall方法，这里的run方法中会调用runReflectiveCall方法
    } catch (Throwable e) {
        return new Fail(e);
    }
    // 封装了测试用例对应的Method对象
    Statement statement = methodInvoker(method, test);
    // 处理@Test注解中的expected属性
    statement = possiblyExpectingExceptions(method, test, statement);
    // 处理@Test注解中的timeout属性
    statement = withPotentialTimeout(method, test, statement);
    // 处理@Before注解
    statement = withBefores(method, test, statement);
    // 处理@After注解
    statement = withAfters(method, test, statement);
    // 处理@Rule注解
    statement = withRules(method, test, statement);
    // 这里实际上是一个链表，链表中的第一个节点处理@After注解，然后依次向后调用
    return statement;
}

// createTest方法会获取测试类的唯一的构造方法，然后构造出一个测试类的实例
protected Object createTest() throws Exception {
    return getTestClass().getOnlyConstructor().newInstance();
}

第十步：第八步中的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();
    }
}

第十一步：执行测试用例的详细流程。在第十步中，调用statement的evaluate方法，启动测试用例的执行流程。statement的底层，实际上是一个链表，链表中的每个节点，都对应一个功能，例如，如果测试类中有@Before注解，在这里，链表上就会有一个节点，来处理@Before注解。有一点要注意，@Before和@BeforeClass，@After和@AfterClass，它们内部使用的处理方式是相同的。在这里，重点学习@Test注解中timeout属性和expect属性的处理方式。

处理timeout属性：FailOnTimeout继承了Statement实例，在内部，它负责处理timeout属性

public class FailOnTimeout extends Statement {
    private final Statement originalStatement;   // 下一个节点的实例
    private final TimeUnit timeUnit;
    private final long timeout;
    private final boolean lookForStuckThread;
    private volatile ThreadGroup threadGroup = null;

    @Override
    public void evaluate() throws Throwable {
        // 启动一个新的线程来执行测试用例，同时指定超时时间，如果超时，报错
        CallableStatement callable = new CallableStatement();
        FutureTask<Throwable> task = new FutureTask<Throwable>(callable);
        threadGroup = new ThreadGroup("FailOnTimeoutGroup");
        Thread thread = new Thread(threadGroup, task, "Time-limited test");
        thread.setDaemon(true);
        // 启动新线程
        thread.start();
        callable.awaitStarted();  // 等待倒计时锁为0
        // 在这里，阻塞地等待
        Throwable throwable = getResult(task, thread);
        if (throwable != null) {
            throw throwable;
        }
    }

    private Throwable getResult(FutureTask<Throwable> task, Thread thread) {
        try {
            // 指定超时时间，如果超过指定时间任务还没有执行完成，报错
            if (timeout > 0) {
                return task.get(timeout, timeUnit);
            } else {
                return task.get();
            }
        } catch (InterruptedException e) {
            return e; // caller will re-throw; no need to call Thread.interrupt()
        } catch (ExecutionException e) {
            // test failed; have caller re-throw the exception thrown by the test
            return e.getCause();
        } catch (TimeoutException e) {
            return createTimeoutException(thread);
        }
    }  
  
    // 待异步执行的任务
    private class CallableStatement implements Callable<Throwable> {
        private final CountDownLatch startLatch = new CountDownLatch(1);

        public Throwable call() throws Exception {
            try {
                // 倒计时锁，在这里计数器减1，释放在主线程等待的倒计时锁，主线程和子线程同时向下执行，
                // 从而在主线程得到子线程准确的执行时间
                startLatch.countDown(); 
                originalStatement.evaluate();
            } catch (Exception e) {
                throw e;
            } catch (Throwable e) {
                return e;
            }
            return null;
        }

        public void awaitStarted() throws InterruptedException {
            startLatch.await();  // 等待倒计时锁为0
        }
    }
}

这里总结一下基本流程：junit使用了一个倒计时锁和守护线程，在执行测试用例前，主线程在倒计时锁上等待，新线程启动后，将倒计时锁的值减1，此时倒计时锁的值变为0，然后，主线程和子线程同时向下运行，主线程阻塞地等待指定时间，获取结果，如果获取不到，报错

处理expect属性：使用ExpectException类来处理expect属性

public class ExpectException extends Statement {
    private final Statement next;
    private final Class<? extends Throwable> expected;

    public ExpectException(Statement next, Class<? extends Throwable> expected) {
        this.next = next;
        this.expected = expected;
    }

    @Override
    public void evaluate() throws Exception {
        boolean complete = false;
        try {
            // 执行下一个节点的实例，如果有指定的异常抛出，算正确。
            next.evaluate();
            complete = true;
        } catch (AssumptionViolatedException e) {
            throw e;
        } catch (Throwable e) {
            if (!expected.isAssignableFrom(e.getClass())) {
                String message = "Unexpected exception, expected<"
                        + expected.getName() + "> but was<"
                        + e.getClass().getName() + ">";
                throw new Exception(message, e);
            }
        }
        if (complete) {
            throw new AssertionError("Expected exception: "
                    + expected.getName());
        }
    }
}

第十二步：上一步中的evaluate方法就是测试用例的执行详细流程，执行完之后，依次退出方法栈，测试用例就执行完成了。

通过main方法来启动测试

之前的测试用例是通过IDEA启动的，有些源码debug不到，无法了解junit的整体流程，这里通过main方法来启动junit，了解junit的全部流程。

测试案例：

public class LearnJunit6Test {
    public static void main(String[] args) {
        // 创建request实例
        Request request = Request.aClass(LearnJunit6Test.class);
        // 创建一个运行器
        Runner runner = request.getRunner();

        // 创建JunitCore，执行运行器，获取结果信息
        JUnitCore jUnitCore = new JUnitCore();
        Result result = jUnitCore.run(runner);
        // 统计执行信息
        System.out.println("result.getRunCount() = " + result.getRunCount());
        System.out.println("result.getRunTime() = " + result.getRunTime() + "ms");
        System.out.println("result.getFailureCount() = " + result.getFailureCount());
        System.out.println("result.getFailures() = " + result.getFailures());
    }

    @BeforeClass
    public static void beforeClass(){
        Utils.println("beforeClass");
    }

    @AfterClass
    public static void afterClass(){
        Utils.println("afterClass");
    }

    @Before
    public void before() {
        Utils.println("before");
    }

    @After
    public void after() {
        Utils.println("after");
    }

    @Test(expected = ArithmeticException.class, timeout = 2000L)
    public void test() {
        Utils.println("test");
        int i = 1 / 0; // 除零异常。java.lang.ArithmeticException: / by zero
    }

    @Test
    public void test2() {
        throw new RuntimeException("aaa");
    }
}

源码流程：这里，主要了解junit如何创建运行器实例，创建完运行器之后，就是通过run方法来执行运行器，这在之前的流程中已经学习了。

第一步：Request.aClass(LearnJunit6Test.class);，创建request实例，这里创建的是ClassRequest

public static Request aClass(Class<?> clazz) {
    return new ClassRequest(clazz);
}

第二步：request.getRunner方法，从request实例中获取运行器

@Override
public Runner getRunner() {
    if (runner == null) {
        synchronized (runnerLock) {
            if (runner == null) {
                // 创建构造器实例，然后使用构造器来创建运行器
                runner = new AllDefaultPossibilitiesBuilder(canUseSuiteMethod)
                    .safeRunnerForClass(fTestClass);
            }
        }
    }
    return runner;
}

上面创建构造器实例的语句，最终调用AllDefaultPossibilitiesBuilder中的runnerForClass方法，根据类对象来初始化一个运行器，

@Override
public Runner runnerForClass(Class<?> testClass) throws Throwable {
    // 实例化所有的构造器，处理每一种可能出现的情况：类被@Ignore注解标注、类被@RunWith注解标注、
    // 类中有suite方法、当前junit的版本是3.x、当前junit的版本是4.x
    List<RunnerBuilder> builders = Arrays.asList(
            ignoredBuilder(),
            annotatedBuilder(),
            suiteMethodBuilder(),
            junit3Builder(),
            junit4Builder());

    // 遍历构造器列表，如果可以返回runner，则退出循环
    for (RunnerBuilder each : builders) {
        Runner runner = each.safeRunnerForClass(testClass);
        if (runner != null) {
            return runner;
        }
    }
    return null;
}

下面是一系列的构造器的执行逻辑：

IgnoredBuilder：如果类被@Ignore注解标注，使用IgoredClassRunner

public class IgnoredBuilder extends RunnerBuilder {
    @Override
    public Runner runnerForClass(Class<?> testClass) {
        if (testClass.getAnnotation(Ignore.class) != null) {
            return new IgnoredClassRunner(testClass);
        }
        return null;
    }
}

AnnotatedBuilder：如果类被@RunWith注解标注

public class AnnotatedBuilder extends RunnerBuilder {
    private static final String CONSTRUCTOR_ERROR_FORMAT = "Custom runner class %s should have a public constructor with signature %s(Class testClass)";

    private final RunnerBuilder suiteBuilder;

    public AnnotatedBuilder(RunnerBuilder suiteBuilder) {
        this.suiteBuilder = suiteBuilder;
    }

    @Override
    public Runner runnerForClass(Class<?> testClass) throws Exception {
        // 这里的getEnclosingClassForNonStaticMemberClass方法，是获取成员内部类的外部类，
        // 当前测试类和它的外部类，如果有被@RunWith注解标注，使用@RunWith注解指定的运行器，没有
        // 外部类则不查看
        for (Class<?> currentTestClass = testClass; currentTestClass != null;
             currentTestClass = getEnclosingClassForNonStaticMemberClass(currentTestClass)) {
            RunWith annotation = currentTestClass.getAnnotation(RunWith.class);
            if (annotation != null) {
                return buildRunner(annotation.value(), testClass);
            }
        }

        return null;
    }

    // 获取一个类的外部类
    private Class<?> getEnclosingClassForNonStaticMemberClass(Class<?> currentTestClass) {
        // 当前类是内部类并且不是静态的
        if (currentTestClass.isMemberClass() && !Modifier.isStatic(currentTestClass.getModifiers())) {
            return currentTestClass.getEnclosingClass();
        } else {
            return null;
        }
    }

    // 根据@RunWith注解指定的运行器，创建运行器实例
    public Runner buildRunner(Class<? extends Runner> runnerClass,
            Class<?> testClass) throws Exception {
        try {
            return runnerClass.getConstructor(Class.class).newInstance(testClass);
        } catch (NoSuchMethodException e) {
            try {
                return runnerClass.getConstructor(Class.class,
                        RunnerBuilder.class).newInstance(testClass, suiteBuilder);
            } catch (NoSuchMethodException e2) {
                String simpleName = runnerClass.getSimpleName();
                throw new InitializationError(String.format(
                        CONSTRUCTOR_ERROR_FORMAT, simpleName, simpleName));
            }
        }
    }
}

SuiteMethodBuilder：如果类中有名为suite的方法

public class SuiteMethodBuilder extends RunnerBuilder {
    @Override
    public Runner runnerForClass(Class<?> each) throws Throwable {
        if (hasSuiteMethod(each)) {
            return new SuiteMethod(each);
        }
        return null;
    }

    public boolean hasSuiteMethod(Class<?> testClass) {
        try {
            testClass.getMethod("suite");
        } catch (NoSuchMethodException e) {
            return false;
        }
        return true;
    }
}

JUnit3Builder：如果当前测试类继承了TestCase

public class JUnit3Builder extends RunnerBuilder {
    @Override
    public Runner runnerForClass(Class<?> testClass) throws Throwable {
        if (isPre4Test(testClass)) {
            return new JUnit38ClassRunner(testClass);
        }
        return null;
    }

    boolean isPre4Test(Class<?> testClass) {
        return junit.framework.TestCase.class.isAssignableFrom(testClass);
    }
}

JUnit4Builder：这个构造器会在最后执行，如果前面的条件都不符合，使用BlockJUnit4ClassRunner。

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

第四步：上面的逻辑是根据测试类，调用构造器来选择创建哪种运行器，如果没有特殊配置，最终使用JUnit4Builder实例化一个BlockJUnit4ClassRunner来作为运行器

实例化BlockJUnit4ClassRunner：BlockJUnit4ClassRunner继承了ParentRunner，在它的构造器中，会调用ParentRunner的构造器。

protected ParentRunner(Class<?> testClass) throws InitializationError {
    // 扫描测试类中的注解，创建TestClass的实例
    this.testClass = createTestClass(testClass);
    // 验证
    validate();
}

ParentRunner的构造器中会做两件事：扫描测试类中的注解并且创建TestClass的实例、验证测试案例是否符合规范

扫描测试类中的注解并且创建TestClass的实例：这里直接看TestClass的构造方法，主要逻辑都在这里面

public TestClass(Class<?> clazz) {
    this.clazz = clazz;
    if (clazz != null && clazz.getConstructors().length > 1) {
        throw new IllegalArgumentException(
                "Test class can only have one constructor");
    }

    Map<Class<? extends Annotation>, List<FrameworkMethod>> methodsForAnnotations =
            new LinkedHashMap<Class<? extends Annotation>, List<FrameworkMethod>>();
    Map<Class<? extends Annotation>, List<FrameworkField>> fieldsForAnnotations =
            new LinkedHashMap<Class<? extends Annotation>, List<FrameworkField>>();

  	// 扫描类中有注解的方法，将方法存入map中，键是注解，值是方法。类中的字段也一样
    scanAnnotatedMembers(methodsForAnnotations, fieldsForAnnotations);

    this.methodsForAnnotations = makeDeeplyUnmodifiable(methodsForAnnotations);
    this.fieldsForAnnotations = makeDeeplyUnmodifiable(fieldsForAnnotations);
}

扫描方法和字段的逻辑：scanAnnotatedMembers方法

protected void scanAnnotatedMembers(
        Map<Class<? extends Annotation>, List<FrameworkMethod>> methodsForAnnotations, 
        Map<Class<? extends Annotation>, List<FrameworkField>> fieldsForAnnotations) {
  
    // 获取当前类的所有父类
    for (Class<?> eachClass : getSuperClasses(clazz)) {
        // 获取类中的所有方法
        for (Method eachMethod : MethodSorter.getDeclaredMethods(eachClass)) {
            // 添加方法到结果集中
            addToAnnotationLists(new FrameworkMethod(eachMethod), methodsForAnnotations);
        }
        // ensuring fields are sorted to make sure that entries are inserted
        // and read from fieldForAnnotations in a deterministic order
        // 获取类中所有字段
        for (Field eachField : getSortedDeclaredFields(eachClass)) {
            addToAnnotationLists(new FrameworkField(eachField), fieldsForAnnotations);
        }
    }
}

添加方法到结果集中的逻辑：

protected static <T extends FrameworkMember<T>> void addToAnnotationLists(T member,
        Map<Class<? extends Annotation>, List<T>> map) {
    // 获取方法上的注解，如果没有，就不处理了
    for (Annotation each : member.getAnnotations()) {
        // 获取注解的类对象，它将作为map中的键
        Class<? extends Annotation> type = each.annotationType();
        // 根据键取值
        List<T> members = getAnnotatedMembers(map, type, true);
        // 如果当前方法又被子类中的方法覆盖掉，则不处理，因为是从子类中开始处理的，所以之前处理的方法都是子类
        // 和当前类中的方法
        if (member.isShadowedBy(members)) {
            return;
        }
        // 这里对@Before和@BeforeClass注解特殊处理，把它们放到最前面
        if (runsTopToBottom(type)) {
            members.add(0, member);
        } else {
            members.add(member);
        }
    }
}

验证：validate方法，校验测试类中的方法是否符合规范：

@Override
protected void collectInitializationErrors(List<Throwable> errors) {
    super.collectInitializationErrors(errors);

    validateNoNonStaticInnerClass(errors);   // 校验没有静态内部类
    validateConstructor(errors);             // 校验测试类只有一个构造器
    validateInstanceMethods(errors);         // 校验方法必须是public void类型，并且没有参数
    validateFields(errors);
    validateMethods(errors);
}

在创建完运行器后，接下来就是JUnitCore中的run方法了，这个在上一节已经学过了

public Result run(Runner runner) {
    // 创建result实例：用于封装测试结果，包括测试案例的运行时间、成功或失败的个数等。
    Result result = new Result();
    // 创建监听器：调用Result实例创建一个监听器
    RunListener listener = result.createListener();
    // 通知器：把监听器添加到通知器中
    notifier.addFirstListener(listener);
    try {
        // 调用通知器：记录测试案例启动时间
        notifier.fireTestRunStarted(runner.getDescription());
        // 运行测试案例，这里的runner，是BlockJUnit4ClassRunner类型的实例
        runner.run(notifier);
        // 调用通知器：记录测试案例结束时间
        notifier.fireTestRunFinished(result);
    } finally {
        // 移除监视器
        removeListener(listener);
    }
    // 返回测试结果
    return result;
}

流程总结

基本流程：

在IDEA中启动测试用例，IDEA中的junit插件会把测试用例的类对象和方法对象传递给junit
在junit中，创建监听器、通知器，用于记录测试用例执行过程中的事件，
创建result实例，用于记录测试结果
编排测试用例的执行过程，这里采用责任链模式，责任链中的每一个节点都负责执行一个功能，外界只需要调用责任链的头结点即可，剩下的交给责任链来处理。
执行过程中，会调用通知器，记录执行过程中的事件，通知器调用监听器，记录事件信息
执行完成后，统计监听器中的事件信息，记录结果

组件和设计模式

从之前的源码中，了解了junit的基本执行流程，接下来详细学习junit中的组件和设计模式。

junit中的组件：

Request：代表一个请求，从请求中获取Runner
RunnerBuilder：负责构造Runner
Runner：运行器，负责执行测试用例
Statement：封装了要执行的方法，例如被@Before标注的方法、被@Test标注的方法，采用责任链模式，一个节点处理一个方法
Notifer、Listener：通知器和监听器，通知器持有监听器的实例，负责记录测试过程中的事件，包括启动时间、结束时间、成功个数、失败个数
Result：封装测试结果

Request

代表一个请求，request是junit4.x中新增的抽象，目的是为了增加排序和过滤的功能。

Request组件本身是一个抽象类，它有三个实现：ClassRequest、FilterRequest、SortingRequest。ClassRequest是普通的请求，FilterRequest包含过滤功能，SortingRequest包含排序功能

Request：

public abstract class Request {
    // 获取运行器，这是一个抽象方法，具体实现交给子类
    public abstract Runner getRunner();
  
    // 创建一个ClassRequest
    public static Request aClass(Class<?> clazz) {
        return new ClassRequest(clazz);
    }

    // 创建一个FilterRequest，提供过滤功能
    public Request filterWith(Filter filter) {
        return new FilterRequest(this, filter);
    }

    // 创建一个SortingRequest，提供排序功能
    public Request sortWith(Comparator<Description> comparator) {
        return new SortingRequest(this, comparator);
    }
}

ClassRequest：普通的Request，不包含任何特殊功能

public class ClassRequest extends Request {
    private final Object runnerLock = new Object();

    // 持有测试类的类对象
    private final Class<?> fTestClass;
    private final boolean canUseSuiteMethod;
    private volatile Runner runner;

    public ClassRequest(Class<?> testClass, boolean canUseSuiteMethod) {
        this.fTestClass = testClass;
        this.canUseSuiteMethod = canUseSuiteMethod;
    }

    // 实现父类的getRunner方法，创建运行器
    @Override
    public Runner getRunner() {
        if (runner == null) {
            synchronized (runnerLock) {
                if (runner == null) {
                    runner = new AllDefaultPossibilitiesBuilder(canUseSuiteMethod)
                        .safeRunnerForClass(fTestClass);
                }
            }
        }
        return runner;
    }
}

Runner和RunnerBuilder

Runner是运行器，RunnerBuilder是运行器的构造器，junit使用建造者模式来建造运行器。

RunnerBuilder：

public abstract class RunnerBuilder {
    private final Set<Class<?>> parents = new HashSet<Class<?>>();

    // 从一个类对象中构建runner
    public abstract Runner runnerForClass(Class<?> testClass) throws Throwable;
}

处理@RunWith注解的RunnerBuilder：

public class AnnotatedBuilder extends RunnerBuilder {

    // 重写了父类中的抽象方法，处理@RunWith注解
    @Override
    public Runner runnerForClass(Class<?> testClass) throws Exception {
        for (Class<?> currentTestClass = testClass; currentTestClass != null;
             currentTestClass = getEnclosingClassForNonStaticMemberClass(currentTestClass)) {
            RunWith annotation = currentTestClass.getAnnotation(RunWith.class);
            if (annotation != null) {
                return buildRunner(annotation.value(), testClass);
            }
        }

        return null;
    }
}

Runner：

public abstract class Runner implements Describable {
    // 获取描述信息
    public abstract Description getDescription();

    // 接受一个通知器作为参数，执行测试流程
    public abstract void run(RunNotifier notifier);
}

ParentRunner：

public abstract class ParentRunner<T> extends Runner implements Filterable,
        Sortable {
          
          
    // 实现了父类中的抽象方法，获取描述信息和运行测试案例
    @Override
    public Description getDescription() {
        Description description = Description.createSuiteDescription(getName(),
                getRunnerAnnotations());
        for (T child : getFilteredChildren()) {
            description.addChild(describeChild(child));
        }
        return description;
    }

    @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);
        }
    }
          
    // 需要子类来实现的抽象方法：获取子节点、描述子节点、运行子节点
    protected abstract List<T> getChildren();

    protected abstract Description describeChild(T child);

    protected abstract void runChild(T child, RunNotifier notifier);
}

BlockJunit4ClassRunner：

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 {
            runLeaf(methodBlock(method), description, notifier);
        }
    }
    
    @Override
    protected boolean isIgnored(FrameworkMethod child) {
        return child.getAnnotation(Ignore.class) != null;
    }

    @Override
    protected Description describeChild(FrameworkMethod method) {
        Description description = methodDescriptions.get(method);

        if (description == null) {
            description = Description.createTestDescription(getTestClass().getJavaClass(),
                    testName(method), method.getAnnotations());
            methodDescriptions.putIfAbsent(method, description);
        }

        return description;
    }

    @Override
    protected List<FrameworkMethod> getChildren() {
        return computeTestMethods();  // getTestClass().getAnnotatedMethods(Test.class);
    }
}

Statement

Statement：可以简单理解为对可执行方法的封装和抽象，如RunBefores就是一个Statement，它封装了所有标记了@BeforeClass注解的方法，在运行单例类的用例之前会执行这些方法，运行完后RunBefores还会通过next.evaluate()运行后续的Statement。

public abstract class Statement {
    public abstract void evaluate() throws Throwable;
}

执行测试方法的Statement：

public class InvokeMethod extends Statement {
    private final FrameworkMethod testMethod;
    private final Object target;

    public InvokeMethod(FrameworkMethod testMethod, Object target) {
        this.testMethod = testMethod;
        this.target = target;
    }

    @Override
    public void evaluate() throws Throwable {
        testMethod.invokeExplosively(target);
    }
}

通知器和监听器

RunNotifier：

public class RunNotifier {
  
    // 持有监听器的实例
    private final List<RunListener> listeners = new CopyOnWriteArrayList<RunListener>();
  
    public void addListener(RunListener listener) {
        if (listener == null) {
            throw new NullPointerException("Cannot add a null listener");
        }
        listeners.add(wrapIfNotThreadSafe(listener));
    }

    public void removeListener(RunListener listener) {
        if (listener == null) {
            throw new NullPointerException("Cannot remove a null listener");
        }
        listeners.remove(wrapIfNotThreadSafe(listener));
    }
}

RunListener：这个类实际上可以理解为是一个抽象类，具体的实现在子类

public class RunListener {

    public void testRunStarted(Description description) throws Exception {
    }

    public void testRunFinished(Result result) throws Exception {
    }
}

Result中对于RunListener的匿名实现：

    @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)
        }
    }