junit4X系列--Statement

原文出处：http://www.blogjava.net/DLevin/archive/2012/05/11/377954.html。感谢作者的无私分享。

初次用文字的方式记录读源码的过程，不知道怎么写，感觉有点贴代码的嫌疑。不过中间还是加入了一些自己的理解和心得，希望以后能够慢慢的改进，感兴趣的童鞋凑合着看吧，感觉JUnit这个框架还是值得看的，里面有许多不错的设计思想在，更何况它是Kent Beck和Erich Gamma这样的大师写的。。。。。

深入JUnit源码之Statement

看JUnit源码最大的收获就是看到这个Statement的设计，它也是我看到过的所有源码中最喜欢的设计之一。JUnit中Runner的运行过程就是Statement链的运行过程，Statement是对一个单元运行的封装，每个Statement都只是执行它本身所表达的逻辑，而将其他逻辑交给下一个Statement处理，而且基本上的Statement都存在对下一个节点的引用，从而由此构成一条Statement的链，从设计模式的角度上来看，这是一个职责连模式（Chain Of Responsibility Pattern）。JUnit中对@BeforeClass、@AfterClass、@Before、@After、@ClassRule、@Rule等逻辑就是通过Statement来实现的。首先来看一下Statement的类结构。

Statement的类结构还是比较简单的，首先Statement是所有类的父类，它只定义了一个抽象的evaluate()方法，由其他子类实现该方法；而且除了Fail和InvokeMethod类，其他类都有一个对Statement本身的引用。其实从实现上，每个Statement也是比较简单的，这个接下来就可以看到了。每个Statement都只实现它自己的逻辑，而将其他逻辑代理给另一个Statement执行，这样可以在编写每个Statement的时候只关注自己的逻辑，从而保持Statement本身的简单，并且易于扩展，当一条Statement执行完后，整个逻辑也就执行完了。不过Statement这条链也不是凭空产生的，它也是要根据一定的逻辑构造起来的，关于Statement链的构造在JUnit中由Runner负责，为了保持本文的完整性，本文会首先会讲解上述几个Statement的源码，同时简单回顾Statement链的构造过程，最后将通过一个简单的例子，将Statement的执行过程用序列图的方式表达出来，以更加清晰的表达Statement的执行过程。不过本文不会详细介绍Rules相关的代码，这部分的代码将会在下一节详细介绍。

RunBefores和RunAfters

这两个Statement是针对JUnit中@BeforeClass、@Before的实现的，其中@BeforeClass是在测试类运行时，所有测试方法运行之前运行，并且对每个测试类只运行一次，这个注解修饰的方法必须是静态的（在Runner一节中有谈过它为什么要被设计成一定是要静态方法，因为在运行每个测试方法是，测试类都会从新初始化一遍，如果不是静态类，它只运行一次的话，它运行的结果无法保存下来）；@Before是在每个测试方法运行之前都要运行。

在Statement的设计中，@BeforeClass注解的方法抽象成一个Statement叫RunBefores，而测试类中其他要运行的测试方法的运行过程是另一个Statement叫next，在RunBefores中调用完所有这些方法，而将其他逻辑交给next； @Before注解的方法也是一样的逻辑，它把接下来的测试方法看成是一个Statement叫next，它调用完所有@Before注解的方法后，将接下来的事情交给next，因而他们共享RunBefores的Statement，唯一不同的是@BeforeClass的RunBefores可以直接调用测试类中的方法，因为他们是静态的，而@Before的RunBefores需要传入测试类的实例。

 1 public class RunBefores extends Statement {
 2     private final Statement fNext;
 3     private final Object fTarget;
 4     private final List<FrameworkMethod> fBefores;
 5     public RunBefores(Statement next, List<FrameworkMethod> befores, Object target) {
 6        fNext= next;
 7        fBefores= befores;
 8        fTarget= target;
 9     }
10     @Override
11     public void evaluate() throws Throwable {
12        for (FrameworkMethod before : fBefores)
13            before.invokeExplosively(fTarget);
14        fNext.evaluate();
15     }
16 }

从源码中可以看到，构造RunBefores时传入下一个Statement、所有@BeforeClass或@Before注解的方法以及测试类的实例，对@BeforeClass来说，传入null即可。在运行evaluate()方法时，它依次调用@BeforeClass或@Before注解的方法，后将接下来的逻辑交给next。从这段逻辑也可以看出如果有一个@BeforeClass或@Before注解的方法抛异常，接下来的这些方法就都不会执行了，包括测试方法。不过此时@AfterClass或@After注解的方法还会执行，这个在下一小节中即可知道。

关于RunBefores的构造要，其实最重要的是要关注它的next Statement是什么，对于@BeforeClass对应的RunBefores来说，它的next Statement那些所有的测试方法运行而组成的Statement，而对于@Before对应的RunBefores来说，它的next Statement是测试方法的Statement：

 1 protected Statement classBlock(final RunNotifier notifier) {
 2     Statement statement= childrenInvoker(notifier);
 3     statement= withBeforeClasses(statement);
 4     
 5 }
 6 protected Statement withBeforeClasses(Statement statement) {
 7     List<FrameworkMethod> befores= fTestClass
 8            .getAnnotatedMethods(BeforeClass.class);
 9     return befores.isEmpty() ? statement :
10        new RunBefores(statement, befores, null);
11 }
12 protected Statement methodBlock(FrameworkMethod method) {
13     
14     Statement statement= methodInvoker(method, test);
15     
16     statement= withBefores(method, test, statement);
17     
18 }
19 protected Statement withBefores(FrameworkMethod method, Object target,
20        Statement statement) {
21     List<FrameworkMethod> befores= getTestClass().getAnnotatedMethods(
22            Before.class);
23     return befores.isEmpty() ? statement : new RunBefores(statement,
24            befores, target);
25 }

@AfterClass和@After

这两个Statement是针对JUnit中@AfterClass、@After的实现的，其中@AfterClass是在测试类运行时，所有测试方法结束之后运行，不管之前的方法是否有抛异常，并且对每个测试类只运行一次，这个注解修饰的方法必须是静态的；@After是在每个测试方法运行结束后都要运行的，不管测试方法是否测试失败。

在Statement的设计中，@AfterClass注解的方法抽象成一个Statement叫Afters，而测试类中之前要运行的过程是另一个Statement叫next（其实这个叫before更好一些），在RunAfters中等所有之前的运行过程调用完后，再调用@AfterClass注解的方法； @After注解的方法也是一样的逻辑，它把之前的测试方法包括@Before注解的方法看成是一个Statement叫next（before？），它等测试方法或@Before注解的方法调用完后，调用@After注解的方法，因而他们共享RunAfters的Statement，唯一不同的是@AfterClass的RunAfters可以直接调用测试类中的方法，因为他们是静态的，而@After的RunAfters需要传入测试类的实例。

 1 public class RunAfters extends Statement {
 2     private final Statement fNext;
 3     private final Object fTarget;
 4     private final List<FrameworkMethod> fAfters;
 5     public RunAfters(Statement next, List<FrameworkMethod> afters, Object target) {
 6        fNext= next;
 7        fAfters= afters;
 8        fTarget= target;
 9     }
10     @Override
11     public void evaluate() throws Throwable {
12        List<Throwable> errors = new ArrayList<Throwable>();
13        try {
14            fNext.evaluate();
15        } catch (Throwable e) {
16            errors.add(e);
17        } finally {
18            for (FrameworkMethod each : fAfters)
19               try {
20                   each.invokeExplosively(fTarget);
21               } catch (Throwable e) {
22                   errors.add(e);
23               }
24        }
25        MultipleFailureException.assertEmpty(errors);
26     }
27 }

从源码中可以看到，构造RunAfters时传入下一个Statement、所有@AfterClass或@After注解的方法以及测试类的实例，对@AfterClass来说，传入null即可。在运行evaluate()方法时，它会等之前的Statement执行结束后，再依次调用@AfterClass或@After注解的方法。从这段逻辑也可以看出无论之前Statement执行是否抛异常，@AfterClass或@After注解的方法都是会被执行的，为了避免在执行@AfterClass或@After注解的方法抛出的异常覆盖之前在运行@BeforeClass、@Before或@Test注解方法抛出的异常，这里所有的异常都会触发一次testFailure的事件，这个实现可以查看Runner小节的EachTestNotifier类的实现。

对于RunAfters的构造，可能要注意的一点是传入RunAfters的Statement是RunBefores的实例，这个其实还是好理解的，因为RunAfters是在传入的Statement运行结束后运行，而RunBefores又是要在测试方法之前运行的，因而需要将RunAfters放在Statement链的最头端，而后是RunAfters，最后才是测试方法调用的Statement（InvokeMethod）。

 1 protected Statement classBlock(final RunNotifier notifier) {
 2     
 3     statement= withBeforeClasses(statement);
 4     statement= withBeforeClasses(statement);
 5     
 6 }
 7 protected Statement withAfterClasses(Statement statement) {
 8     List<FrameworkMethod> afters= fTestClass
 9            .getAnnotatedMethods(AfterClass.class);
10     return afters.isEmpty() ? statement :
11        new RunAfters(statement, afters, null);
12 }
13 protected Statement methodBlock(FrameworkMethod method) {
14     
15     statement= withBefores(method, test, statement);
16     statement= withAfters(method, test, statement);
17     
18 }
19 protected Statement withAfters(FrameworkMethod method, Object target,
20        Statement statement) {
21     List<FrameworkMethod> afters= getTestClass().getAnnotatedMethods(
22            After.class);
23     return afters.isEmpty() ? statement : new RunAfters(statement, afters,
24            target);
25 }  

InvokeMethod、ExpectedException和FailOnTimeout

之所有要把这三个Statement放在一起是因为他们都是和@Test注解相关的：

1 @Retention(RetentionPolicy.RUNTIME)
2 @Target({ElementType.METHOD})
3 public @interface Test {
4     Class<? extends Throwable> expected() default None.class;
5     long timeout() default 0L;
6 }

@Test注解定义了两个成员：expected指定当前测试方法如果抛出指定的异常则表明测试成功；而timeout指定当前测试方法如果超出指定的时间（以毫秒为单位），则测试失败。在Statement设计中，这些逻辑都抽象成了一个Statement。而@Test注解的方法则被认为是真正要运行的测试方法，它的执行过程也被抽象成了一个Statement。

@Test注解的方法抽象出的Statement命名为InvokeMethod，它是一个非常简单的Statement：

 1 public class InvokeMethod extends Statement {
 2     private final FrameworkMethod fTestMethod;
 3     private Object fTarget;
 4     public InvokeMethod(FrameworkMethod testMethod, Object target) {
 5        fTestMethod= testMethod;
 6        fTarget= target;
 7     }
 8     @Override
 9     public void evaluate() throws Throwable {
10        fTestMethod.invokeExplosively(fTarget);
11     }
12 }

使用一个方法实例和测试类的实例构造InvokeMethod，在运行时直接调用该方法。并且InvokeMethod并没有对其他Statement的引用，因而它是Statement链上的最后一个节点。

 1 protected Statement methodBlock(FrameworkMethod method) {
 2     
 3     Statement statement= methodInvoker(method, test);
 4     statement= possiblyExpectingExceptions(method, test, statement);
 5     statement= withPotentialTimeout(method, test, statement);
 6     
 7 }
 8 protected Statement methodInvoker(FrameworkMethod method, Object test) {
 9     return new InvokeMethod(method, test);
10 }

ExpectException用于处理当在@Test注解中定义了expected字段时，该注解所在的方法是否在运行过程中真的抛出了指定的异常，如果没有，则表明测试失败，因而它需要该测试方法对应的Statement（InvokeMethod）的引用：

 1 public class ExpectException extends Statement {
 2     private Statement fNext;
 3     private final Class<? extends Throwable> fExpected;
 4     public ExpectException(Statement next, Class<? extends Throwable> expected) {
 5        fNext= next;
 6        fExpected= expected;
 7     }
 8     @Override
 9     public void evaluate() throws Exception {
10        boolean complete = false;
11        try {
12            fNext.evaluate();
13            complete = true;
14        } catch (AssumptionViolatedException e) {
15            throw e;
16        } catch (Throwable e) {
17            if (!fExpected.isAssignableFrom(e.getClass())) {
18               String message= "Unexpected exception, expected<"
19                          + fExpected.getName() + "> but was<"
20                          + e.getClass().getName() + ">";
21               throw new Exception(message, e);
22            }
23        }
24        if (complete)
25            throw new AssertionError("Expected exception: "
26                   + fExpected.getName());
27     }
28 }

使用InvokeMethod实例和一个expected的Throwable Class实例作为参数构造ExpectException，当InvokeMethod实例执行后，判断其抛出的异常是否为指定的异常或者该测试方法没有抛出异常，在这两种情况下，测试都会失败，因而需要它抛出异常以处理这种情况。

 1 protected Statement methodBlock(FrameworkMethod method) {
 2     
 3     Statement statement= methodInvoker(method, test);
 4     statement= possiblyExpectingExceptions(method, test, statement);
 5     
 6 }
 7 protected Statement possiblyExpectingExceptions(FrameworkMethod method,
 8        Object test, Statement next) {
 9     Test annotation= method.getAnnotation(Test.class);
10     return expectsException(annotation) ? new ExpectException(next,
11            getExpectedException(annotation)) : next;
12 }

FailOnTimeout是在@Test注解中指定了timeout值时，用于控制@Test注解所在方法的执行时间是否超出了timeout的值，若是，则抛出异常，表明测试失败。在JUnit4当前的实现中，它引用的Statement实例是ExpectException（如果expected字段定义了的话）或InvokeMethod。它通过将引用的Statement实例的执行放到另一个线程中，然后通过控制线程的执行时间以控制内部引用的Statement实例的执行时间，如果测试方法因内部抛出异常而没有完成，则抛出内部抛出的异常实例，否则抛出执行时间超时相关的异常。

 1 public class FailOnTimeout extends Statement {
 2     private final Statement fOriginalStatement;
 3     private final long fTimeout;
 4     public FailOnTimeout(Statement originalStatement, long timeout) {
 5        fOriginalStatement= originalStatement;
 6        fTimeout= timeout;
 7     }
 8     @Override
 9     public void evaluate() throws Throwable {
10        StatementThread thread= evaluateStatement();
11        if (!thread.fFinished)
12            throwExceptionForUnfinishedThread(thread);
13     }
14     private StatementThread evaluateStatement() throws InterruptedException {
15        StatementThread thread= new StatementThread(fOriginalStatement);
16        thread.start();
17        thread.join(fTimeout);
18        thread.interrupt();
19        return thread;
20     }
21     private void throwExceptionForUnfinishedThread(StatementThread thread)
22            throws Throwable {
23        if (thread.fExceptionThrownByOriginalStatement != null)
24            throw thread.fExceptionThrownByOriginalStatement;
25        else
26            throwTimeoutException(thread);
27     }
28     private void throwTimeoutException(StatementThread thread) throws Exception {
29        Exception exception= new Exception(String.format(
30               "test timed out after %d milliseconds", fTimeout));
31        exception.setStackTrace(thread.getStackTrace());
32        throw exception;
33     }
34     private static class StatementThread extends Thread {
35        private final Statement fStatement;
36        private boolean fFinished= false;
37        private Throwable fExceptionThrownByOriginalStatement= null;
38        public StatementThread(Statement statement) {
39            fStatement= statement;
40        }
41        @Override
42        public void run() {
43            try {
44               fStatement.evaluate();
45               fFinished= true;
46            } catch (InterruptedException e) {
47               //don't log the InterruptedException
48            } catch (Throwable e) {
49               fExceptionThrownByOriginalStatement= e;
50            }
51        }
52     }
53 }

FailOnTimeout的构造过程如同上述的其他Statement类似：

 1 protected Statement methodBlock(FrameworkMethod method) {
 2     
 3     Statement statement= methodInvoker(method, test);
 4     statement= possiblyExpectingExceptions(method, test, statement);
 5     statement= withPotentialTimeout(method, test, statement);
 6     
 7 }
 8 protected Statement withPotentialTimeout(FrameworkMethod method,
 9        Object test, Statement next) {
10     long timeout= getTimeout(method.getAnnotation(Test.class));
11     return timeout > 0 ? new FailOnTimeout(next, timeout) : next;
12 }

Fail与RunRules

Fail这个Statement是在创建测试类出错时构造的Statement，这个设计思想有点类似Null Object模式，即保持编程模型的统一，即使在出错的时候也用一个Statement去封装，这也正是Runner中ErrorReportingRunner的设计思想。

Fail这个Statement很简单，它在运行时重新抛出之前记录的异常，其构造过程也是在创建测试类实例出错时构造：

 1 protected Statement methodBlock(FrameworkMethod method) {
 2     Object test;
 3     try {
 4        test= new ReflectiveCallable() {
 5            @Override
 6            protected Object runReflectiveCall() throws Throwable {
 7               return createTest();
 8            }
 9        }.run();
10     } catch (Throwable e) {
11        return new Fail(e);
12     }
13     
14 }
15 public class Fail extends Statement {
16     private final Throwable fError;
17     public Fail(Throwable e) {
18        fError= e;
19     }
20     @Override
21     public void evaluate() throws Throwable {
22        throw fError;
23     }
24 }

RunRules这个Statement是对@ClassRule和@Rule运行的封装，它会将定义的所有Rule应用到传入的Statement引用后返回，由于它内部还有一些比较复杂的逻辑，关于Rule将有一个单独的小节讲解。这里主要关注RunRules这个Statement的实现和构造：

 1 public class RunRules extends Statement {
 2     private final Statement statement;
 3     public RunRules(Statement base, Iterable<TestRule> rules, Description description) {
 4        statement= applyAll(base, rules, description);
 5     }
 6     @Override
 7     public void evaluate() throws Throwable {
 8        statement.evaluate();
 9     }
10     private static Statement applyAll(Statement result, Iterable<TestRule> rules,
11            Description description) {
12        for (TestRule each : rules)
13            result= each.apply(result, description);
14        return result;
15     }
16 }
17 protected Statement classBlock(final RunNotifier notifier) {
18     
19     statement= withAfterClasses(statement);
20     statement= withClassRules(statement);
21     return statement;
22 }
23 private Statement withClassRules(Statement statement) {
24     List<TestRule> classRules= classRules();
25     return classRules.isEmpty() ? statement :
26         new RunRules(statement, classRules, getDescription());
27 }
28 protected Statement methodBlock(FrameworkMethod method) {
29     
30     statement= withRules(method, test, statement);
31     return statement;
32 }
33 private Statement withRules(FrameworkMethod method, Object target,
34        Statement statement) {
35     List<TestRule> testRules= getTestClass().getAnnotatedFieldValues(
36         target, Rule.class, TestRule.class);
37     return testRules.isEmpty() ? statement :
38        new RunRules(statement, testRules, describeChild(method));
39 }

Rule分为@ClassRule和@Rule，@ClassRule是测试类级别的，它对一个测试类只运行一次，而@Rule是测试方法级别的，它在每个测试方法运行时都会运行。RunRules的构造过程中，我们可以发现RunRules才是最外层的Statement，TestRule中要执行的逻辑要么比@BeforeClass、@Before注解的方法要早，要么比@AfterClass、@After注解的方法要迟。

Statement执行序列图

假设在一个测试类中存在多个@BeforeClass、@AfterClass、@Before、@After注解的方法，并且有两个测试方法testMethod1()和testMethod2()，那么他们的运行序列图如下所示（这里没有考虑Rule，对@ClassRule的RunRules，它的链在最前端，而@Rule的RunRules则是在RunAfters的前面，关于Rule将会在下一节中详细讲解）：