看完类结构图，那么我们再来看一下源码吧。由于Description在JUnit中应用广泛，又是相对独立于功能的，因而将从Description开始：
如上文所说，Description是JUnit中对Runner和测试方法的描述，它包含三个字段：
1 private final ArrayList<Description> fChildren;
2 private final String fDisplayName;
3 private final Annotation[] fAnnotations;
displayName对测试方法的格式为：<methodName>(<className>)，如：
testFailed(levin.blog.junit.sample.simple.CoreJUnit4SampleTest)
对Runner来说，displayName一般为Runner所封装的测试类，然而对没有根类的Suite，该值为”null”。annotations字段为测试方法或测试类上所具有的所有注解类。children对测试方法来说为空，对Runner来说，表达Runner内部所有的测试方法的Description或Runner的Description。作为JUnit的用户，除非自定义Runner，其他的，我们一般都是通过注册自己的RunListener来实现自己想要的统计和信息提示工作，而在Listener中并没有直接暴露给我们Runner或者是测试类的实例，它是通过提供Description实例的方式来获取我们需要的信息。Description提供以下的接口供我们使用：
1 public String getDisplayName();
2 public ArrayList<Description> getChildren();
3 public boolean isSuite();
4 public boolean isTest();
5 public int testCount();
6 public <T extends Annotation> T getAnnotation(Class<T> annotationType);
7 public Collection<Annotation> getAnnotations();
8 public Class<?> getTestClass();
9 public String getClassName();
10 public String getMethodName();
Runner实现了Disacribable接口，该接口只包含一个方法：
1 public interface Describable {
2 public abstract Description getDescription();
3 }
该方法在ParentRunner中创建一个Description，并遍历当前Runner下的Children，并将这些child的Description添加到Description中最后返回：
1 @Override
2 public Description getDescription() {
3 Description description= Description.createSuiteDescription(
4 getName(), getRunnerAnnotations());
5 for (T child : getFilteredChildren())
6 description.addChild(describeChild(child));
7 return description;
8 }
9 BlockJUnit4ClassRunner：
10 @Override
11 protected Description describeChild(FrameworkMethod method) {
12 return Description.createTestDescription(
13 getTestClass().getJavaClass(),
14 testName(method), method.getAnnotations());
15 }
16 Suite：
17 @Override
18 protected Description describeChild(Runner child) {
19 return child.getDescription();
20 }
21
RunNotifier类和RunListener类对测试方法运行事件的发布
RunListener是JUnit提供的自定义对测试运行方法统计的接口，JUnit用户可以继承RunListener类，在JUnit运行开始、结束以及每一个测试方法的运行开始、结束、测试失败以及假设出错等情况下加入一些自己的逻辑，如统计整个JUnit运行的时间（这个在Result中已经实现了）、每个运行方法的时间、运行最后有多少方法成功，多少失败等，如上例中的LogRunListener。RunListener定义了如下接口：
1 public class RunListener {
2 public void testRunStarted(Description description) throws Exception {
4 }
5 public void testRunFinished(Result result) throws Exception {
6 }
7 public void testStarted(Description description) throws Exception {
8 }
9 public void testFinished(Description description) throws Exception {
11 }
12 public void testFailure(Failure failure) throws Exception {
13 }
14 public void testAssumptionFailure(Failure failure) {
15 }
16 public void testIgnored(Description description) throws Exception {
17 }
18 }
这个类需要注意的是：1. testFinished()不管测试方法是成功还是失败，这个方法总是会被调用；2. 在测试方法中跑出AssumptionViolatedException并不认为是测试失败，一般在测试方法中调用Assume类中的方法而失败，会跑该异常，在JUnit的默认实现中，对这些方法只是简单的忽略，并发布testAssumptionFailure()事件，并不认为该方法测试失败，自定义的Runner可以改变这个行为；3. 当我们需要自己操作Runner实例是，Result的信息需要自己手动的注册Result中定义的Listener，不然Result中的信息并不会填写正确，如上例中的做法：
1 Result result = new Result();
2 notifier.addFirstListener(result.createListener());
在实现时，所有事件响应函数提供给我们有三种信息：Description、Result和Failure。其中Description已经在上一小节中介绍过了它所具有的信息，这里不再重复。对于Result，前段提到过只有它提供的Listener后才会取到正确的信息，它包含的信息有：总共执行的测试方法数、忽略的测试方法数、以及所有在测试过程中抛出的异常列表、整个测试过程的执行时间等，Result实例在JUnit运行结束时传入testRunFinished()事件方法中，以帮助我们做一些测试方法执行结果的统计信息，事实上，我感觉这些信息很多时候还是不够的，需要我们在自己的RunListener中自己做一些信息记录。Failure类则记录了测试方法在测试失败时抛出的异常以及该测试方法对应的Description实例，当在构建Runner过程中出现异常，Failure也会用于描述测试类，如上例中，如果beforeClass()方法不是静态的话，在初始化Runner时就会出错，此时的运行结果如下：
==>JUnit4 started with description:
levin.blog.junit.sample.simple.CoreJUnit4SampleTest
==>Test method started with description: initializationError(levin.blog.junit.sample.simple.CoreJUnit4SampleTest)
==>Test method failed with failure: initializationError(levin.blog.junit.sample.simple.CoreJUnit4SampleTest): Method beforeClass() should be static
==>Test method finished with description: initializationError(levin.blog.junit.sample.simple.CoreJUnit4SampleTest)
==>JUnit4 finished with result:
FailureCount: 1
IgnoreCount: 0
RunCount: 1
RunTime: 3
Failures: [initializationError(levin.blog.junit.sample.simple.CoreJUnit4SampleTest): Method beforeClass() should be static]
Runner中的run()方法需要传入RunNotifier实例，它是对RunListener的封装，我们可以向其注册多个RunListener，当Runner需要发布某个事件时，就会通过它来代理，它则会遍历所有已注册的RunListener，并运行相应的事件。当运行某个RunListener抛异常时，它会首先将这个RunListener移除，并发布测试失败事件，在该事件中的Description为一个名为“Test mechanism”的Description，因为此时是注册的事件处理器失败，无法获知一个Description实例：
1 private abstract class SafeNotifier {
2 void run() {
3 synchronized (fListeners) {
4 for (Iterator<RunListener> all= fListeners.iterator();
5 all.hasNext();)
6 try {
7 notifyListener(all.next());
8 } catch (Exception e) {
9 all.remove(); // Remove the offending listener first to avoid an infinite loop
11 fireTestFailure(new Failure(
12 Description.TEST_MECHANISM, e));
13 }
14 }
15 }
16 abstract protected void notifyListener(RunListener each) throws Exception;
18 }
在RunNotifier类中还有一个pleaseStop()方法从而可以在测试中途停止整个测试过程，其实现时在发布testStarted事件时，如果发现pleaseStop字段已经为true，则抛出StoppedByUserException，当Runner接收到该异常后，将该异常直接抛出。
事实上，ParentRunner在发布事件时，并不直接和RunNotifier打交道，而是会用EachTestNotifier类对其进行封装，该类只是对MultipleFailureException做了处理，其他只是一个简单的代理。在遇到MultipleFailureException，它会遍历内部每个Exception，并对每个Exception发布testFailure事件。当在运行@After注解的方法时抛出多个异常类（比如测试方法已经抛出异常了，@After注解方法中又抛出异常或者存在多个@After注解方法，并多个@After注解方法抛出了多个异常），此时就会构造一个MultipleFailureException，这种设计可能是出于对防止测试方法中的Exception被@After注解方法中的Exception覆盖的问题引入的。
FrameworkMethod与FrameworkField类
FrameworkMethod是对Java反射中Method的封装，它提供了对方法的验证、调用以及处理子类方法隐藏父类方法问题，其主要提供的接口如下：
1 public Method getMethod();
2 public Object invokeExplosively(final Object target, final Object
params);
3 public String getName();
4 public void validatePublicVoidNoArg(boolean isStatic, List<Throwable> errors);
5 public void validatePublicVoid(boolean isStatic, List<Throwable> errors)
6 public void validateNoTypeParametersOnArgs(List<Throwable> errors);
7 @Override
8 public boolean isShadowedBy(FrameworkMethod other);
9 @Override
10 public Annotation[] getAnnotations();
11 public <T extends Annotation> T getAnnotation(Class<T> annotationType);
其中isShadowedBy()方法用于处理子类方法隐藏父类方法的问题，JUnit支持测试类存在继承关系，并且会遍历所有父类的测试方法，但是如果子类的方法隐藏了父类的方法，则父类的方法不会被执行。这里的隐藏是指当子类的方法名、所有参数类型相同时，不管是静态方法还是非静态方法，都会被隐藏。其实现如下：
1 public boolean isShadowedBy(FrameworkMethod other) {
2 if (!other.getName().equals(getName()))
3 return false;
4 if (other.getParameterTypes().length != getParameterTypes().length)
5 return false;
6 for (int i= 0; i < other.getParameterTypes().length; i++)
7 if (!other.getParameterTypes()[i].equals(getParameterTypes()[i]))
9 return false;
10 return true;
11 }
类似FrameworkMethod，FrameworkField是对Java反射中的Field的封装，它提供了对字段取值、处理隐藏父类字段的问题，其主要提供的接口如下：
1 public String getName();
2 @Override
3 public Annotation[] getAnnotations();
4 public boolean isPublic();
5 @Override
6 public boolean isShadowedBy(FrameworkField otherMember) {
7 return otherMember.getName().equals(getName());
8 }
9 public boolean isStatic();
10 public Field getField();
11 public Class<?> getType();
12 public Object get(Object target)
13 throws IllegalArgumentException, IllegalAccessException;
在处理隐藏问题是，它只是判断如果父类中某个字段的名和子类中某个字段的名字相同，则父类中的字段不会被JUnit处理，即被隐藏。事实上，关于隐藏的问题，只是对JUnit识别的方法和字段有效，即有JUnit相关注解的方法字段，其他方法并不受影响（事实上也是不可能受到影响）。
TestClass类
TestClass是对Java中Class类的封装，在TestClass构造过程中，它会收集所有传入Class实例中具有注释的字段和方法，它会搜索类的所有继承结构。因而TestClass的成员如下：
1 private final Class<?> fClass;
2 private Map<Class<?>, List<FrameworkMethod>> fMethodsForAnnotations;
3 private Map<Class<?>, List<FrameworkField>> fFieldsForAnnotations;
并且这些成员在TestClass
构造完后即已经初始化完成。在所有注解的收集过程中，它对@Before
和@BeforeClass
有一个特殊的处理，即父类中@Before
和@BeforeClass
的注解方法总是在之类之前，从而保证父类的@Before
和@BeforeClass
的注解方法会在子类的这些注解方法之前执行。而对@After
和@AfterClass
的注解方法没有做处理，因而保持了之类的@After
和@AfterClass
注解方法会在父类的这些注解方法之前执行。这段特殊逻辑是通过以下代码实现的（在addToAnnotationLists()
方法中，其中runsTopToBottom()
方法形象的表达了这个意思）：1 if (runsTopToBottom(type))
2 members.add(0, member);
3 else
4 members.add(member);
在获得测试类中所有注解的方法和字段的Map后，TestClass提供了对Annotation对应的方法和字段的查询接口：
1 public List<FrameworkMethod> getAnnotatedMethods(
2 Class<? extends Annotation> annotationClass);
3 public List<FrameworkField> getAnnotatedFields(
4 Class<? extends Annotation> annotationClass);
5 public <T> List<T> getAnnotatedFieldValues(Object test,
6 Class<? extends Annotation> annotationClass,
7 Class<T> valueClass);
以及测试类相关的信息，如Class实例、名字、测试类中具有的Annotation等：
1 public Class<?> getJavaClass();
2 public String getName();
3 public Constructor<?> getOnlyConstructor();
4 public Annotation[] getAnnotations();
5 public boolean isANonStaticInnerClass();
Runner、ParentRunner与BlockJUnit4ClassRunner类
Runner是JUnit中对所有Runner的抽象，它只包括三个方法：
1 public abstract class Runner implements Describable {
2 public abstract Description getDescription();
3 public abstract void run(RunNotifier notifier);
4 public int testCount() {
5 return getDescription().testCount();
6 }
7 }
其中getDescription()的实现已经在Description相关的小节中做过计算了，不在重复，testCount()方法很简单，也已经实现了，因而本节主要介绍run()方法的运行过程，而该方法的实现则是在ParentRunner中。
用ParentRunner命名这个Runner是想表达这是一个在测试方法树中具有子节点的节点，它的子节点可以是测试方法（BlockJUnit4ClassRunner）或者Runner（Suite）。ParentRunner以测试类Class实例作为构造函数的参数，在构造函数内部用TestClass对测试类进行封装，并对一些那些规定的方法做验证：
1. @BeforeClass和@AfterClass注解的方法必须是public，void，static，无参
1 validatePublicVoidNoArgMethods(BeforeClass.class, true, errors);
2 validatePublicVoidNoArgMethods(AfterClass.class, true, errors);
2. 对有@ClassRule修饰的字段，必须是public，static，并且该字段的实例必须是实现了TestRule接口的。为了兼容性，也可以实现MethodRule接口。
在验证过程中，ParentRunner通过一个List<Throwable>收集所有的验证错误信息，如果存在错误信息，则验证不通过，ParentRunner将抛出一个InitializationError的Exception，该Exception中包含了所有的错误信息，一般在这种情况下，会创建一个ErrorReportingRunner返回以处理验证出错的问题，该Runner将在下面的小节中详细介绍。
在Runner构造完成后，就可以调用run()方法运行该Runner了：
1 @Override
2 public void run(final RunNotifier notifier) {
3 EachTestNotifier testNotifier= new EachTestNotifier(notifier, getDescription());
5 try {
6 Statement statement= classBlock(notifier);
7 statement.evaluate();
8 } catch (AssumptionViolatedException e) {
9 testNotifier.fireTestIgnored();
10 } catch (StoppedByUserException e) {
11 throw e;
12 } catch (Throwable e) {
13 testNotifier.addFailure(e);
14 }
15 }
该方法的核心是构造一个Statement实例，然后调用该实例的evaluate()方法。在JUnit中，Statement是一个类链表，一个Runner的执行过程就是这个Statement类链表的执行过程。ParentRunner对Statement类链表的构造主要是对测试类级别的构造，如@BeforeClass、@AfterClass、@ClassRule等执行Statement：
1 protected Statement classBlock(final RunNotifier notifier) {
2 Statement statement= childrenInvoker(notifier);
3 statement= withBeforeClasses(statement);
4 statement= withAfterClasses(statement);
5 statement= withClassRules(statement);
6 return statement;
7 }
8 protected Statement childrenInvoker(final RunNotifier notifier) {
9 return new Statement() {
10 @Override
11 public void evaluate() {
12 runChildren(notifier);
13 }
14 };
15 }
16 private void runChildren(final RunNotifier notifier) {
17 for (final T each : getFilteredChildren())
18 fScheduler.schedule(new Runnable() {
19 public void run() {
20 ParentRunner.this.runChild(each, notifier);
21 }
22 });
23 fScheduler.finished();
24 }
25 private List<T> getFilteredChildren() {
26 if (fFilteredChildren == null)
27 fFilteredChildren = new ArrayList<T>(getChildren());
28 return fFilteredChildren;
29 }
30 protected abstract List<T> getChildren();
31 protected abstract void runChild(T child, RunNotifier notifier);
其中getChildren()、runChild()方法由子类实现。
1 protected Statement withBeforeClasses(Statement statement) {
2 List<FrameworkMethod> befores= fTestClass
3 .getAnnotatedMethods(BeforeClass.class);
4 return befores.isEmpty() ? statement :
5 new RunBefores(statement, befores, null);
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 private Statement withClassRules(Statement statement) {
14 List<TestRule> classRules= classRules();
15 return classRules.isEmpty() ? statement :
16 new RunRules(statement, classRules, getDescription());
17 }
18 protected List<TestRule> classRules() {
19 return fTestClass.getAnnotatedFieldValues(null,
20 ClassRule.class, TestRule.class);
21 }
关于Statement将在下一节中详细讲，不过这里从Statement的构造过程可以看出Rule的执行要先于@BeforeClass注解方法或晚于@AfterClass注解方法。
在ParentRunner关于执行方法的实现中，还有一个对每个测试方法Statement链的执行框架的实现，其主要功能是加入事件发布和对异常的处理逻辑，从这里的Statement实例是一个测试方法的运行整体，它包括了@Before注解方法、@After注解方法以及@Rule注解字段的TestRule实例的运行过程，因而testStarted事件的发布是在@Before方法运行之前，而testFinished事件的发布是在@After方法运行之后：
1 protected final void runLeaf(Statement statement, Description description, RunNotifier notifier) {
3 EachTestNotifier eachNotifier= new EachTestNotifier(notifier, description);
5 eachNotifier.fireTestStarted();
6 try {
7 statement.evaluate();
8 } catch (AssumptionViolatedException e) {
9 eachNotifier.addFailedAssumption(e);
10 } catch (Throwable e) {
11 eachNotifier.addFailure(e);
12 } finally {
13 eachNotifier.fireTestFinished();
14 }
15 }
ParentRunner还实现Filterable接口和Sortable接口，不过这里很奇怪的实现时为什么sorter要保存成字段，感觉这个完全可以通过方法参数实现，而filteredChildren字段的实现方式在多线程环境中运行的话貌似也会出问题。Filter类主要提供一个shouldRun()接口以判断传入的Description是否可以运行，若否，则将该Description从ParentRunner中移除；否则，将该Filter应用到该child中，以处理child可能是Filterable实例（ParentRunner）的问题，从而以递归、先根遍历的方式遍历测试实例树上的所有节点，若一个父节点的所有子节点都被过滤了，则抛出NoTestRemainException：
1 public void filter(Filter filter) throws NoTestsRemainException {
2 for (Iterator<T> iter = getFilteredChildren().iterator();
3 iter.hasNext(); ) {
4 T each = iter.next();
5 if (shouldRun(filter, each))
6 try {
7 filter.apply(each);
8 } catch (NoTestsRemainException e) {
9 iter.remove();
10 }
11 else
12 iter.remove();
13 }
14 if (getFilteredChildren().isEmpty()) {
15 throw new NoTestsRemainException();
16 }
17 }
18 private boolean shouldRun(Filter filter, T each) {
19 return filter.shouldRun(describeChild(each));
20 }
JUnit中提供几种默认实现的Filter：1. ALL不做任何过滤；2. matchMethodDescription只保留某个指定的测试方法。
1 public static Filter ALL= new Filter() {
2 @Override
3 public boolean shouldRun(Description description) {
4 return true;
5 }
6 @Override
7 public String describe() {
8 return "all tests";
9 }
10 @Override
11 public void apply(Object child) throws NoTestsRemainException {
12 // 因为不会做任何过滤行为，因而不需要应用到子节点中
13 }
14 @Override
15 public Filter intersect(Filter second) {
16 return second; // 因为本身没有任何过滤行为，所以可以直接返回传入的Filter
17 }
18 };
19 public static Filter matchMethodDescription(final Description desiredDescription) {
21 return new Filter() {
22 @Override
23 public boolean shouldRun(Description description) {
24 if (description.isTest())
25 return desiredDescription.equals(description);
26 // explicitly check if any children want to run
27 for (Description each : description.getChildren())
28 if (shouldRun(each))
29 return true;
30 return false;
31 }
32 @Override
33 public String describe() {
34 return String.format("Method %s", desiredDescription.getDisplayName());
36 }
37 };
38 }
Sorter类实现Comparator接口，ParentRunner通过其compare()方法构造和ParentRunner子节点相关的Comparator实例，并采用后根递归遍历的方式对测试方法树中的所有测试方法进行排序，因而这里只会排序同一个节点下的所有子节点，而节点之间的顺序不会受影响。
1 public void sort(Sorter sorter) {
2 fSorter= sorter;
3 for (T each : getFilteredChildren())
4 sortChild(each);
5 Collections.sort(getFilteredChildren(), comparator());
6 }
7 private Comparator<? super T> comparator() {
8 return new Comparator<T>() {
9 public int compare(T o1, T o2) {
10 return fSorter.compare(describeChild(o1), describeChild(o2));
12 }
13 };
14 }
最后ParentRunner还提供了一个RunnerScheduler的接口字段，以控制JUnit测试方法的执行过程，我们可以注入一个使用多线程方式运行每个测试方法的RunnerScheduler，不过从代码上看，貌似JUnit对多线程的支持并不好，所以这个接口的扩展目前来看我还找不到什么用途：
1 public interface RunnerScheduler {
2 void schedule(Runnable childStatement);
3 void finished();
4 }
BlockJUnit4ClassRunner节点下所有的子节点都是测试方法，它是JUnit中运行测试方法的核心Runner，它实现了ParentRunner中没有实现的几个方法：
1 @Override
2 protected List<FrameworkMethod> getChildren() {
3 return computeTestMethods();
4 }
5 protected List<FrameworkMethod> computeTestMethods() {
6 return getTestClass().getAnnotatedMethods(Test.class);
7 }
8 @Override
9 protected void runChild(final FrameworkMethod method, RunNotifier notifier) {
11 Description description= describeChild(method);
12 if (method.getAnnotation(Ignore.class) != null) {
13 notifier.fireTestIgnored(description);
14 } else {
15 runLeaf(methodBlock(method), description, notifier);
16 }
17 }
18 protected Statement methodBlock(FrameworkMethod method) {
19 Object test;
20 try {
21 test= new ReflectiveCallable() {
22 @Override
23 protected Object runReflectiveCall() throws Throwable {
24 return createTest();
25 }
26 }.run();
27 } catch (Throwable e) {
28 return new Fail(e);
29 }
30 Statement statement= methodInvoker(method, test);
31 statement= possiblyExpectingExceptions(method, test, statement);
32 statement= withPotentialTimeout(method, test, statement);
33 statement= withBefores(method, test, statement);
34 statement= withAfters(method, test, statement);
35 statement= withRules(method, test, statement);
36 return statement;
37 } //这个方法的实现可以看出每个测试方法运行时都会重新创建一个新的测试类实例，这也可能是@BeforeClass、AfterClass、@ClassRule需要静态的原因吧，因为静态的话，每次类实例的重新创建对其结果都不会有影响。
38 另，从这里对Statement的构建顺序，JUnit对TestRule的运行也要在@Before注解方法之前或@After注解方法之后
39 protected Object createTest() throws Exception {
40 return getTestClass().getOnlyConstructor().newInstance();
41 }
42 protected Statement methodInvoker(FrameworkMethod method, Object test) {
43 return new InvokeMethod(method, test);
44 }
45 protected Statement possiblyExpectingExceptions(FrameworkMethod method, object test, Statement next) {
47 Test annotation= method.getAnnotation(Test.class);
48 return expectsException(annotation) ? new ExpectException(next,
49 getExpectedException(annotation)) : next;
50 }
51 private Class<? extends Throwable> getExpectedException(Test annotation) {
52 if (annotation == null || annotation.expected() == None.class)
53 return null;
54 else
55 return annotation.expected();
56 }
57 private boolean expectsException(Test annotation) {
58 return getExpectedException(annotation) != null;
59 }
60 protected Statement withPotentialTimeout(FrameworkMethod method,
61 Object test, Statement next) {
62 long timeout= getTimeout(method.getAnnotation(Test.class));
63 return timeout > 0 ? new FailOnTimeout(next, timeout) : next;
64 }
65 private long getTimeout(Test annotation) {
66 if (annotation == null)
67 return 0;
68 return annotation.timeout();
69 }
70 protected Statement withBefores(FrameworkMethod method, Object target,
71 Statement statement) {
72 List<FrameworkMethod> befores= getTestClass().getAnnotatedMethods(
73 Before.class);
74 return befores.isEmpty() ? statement : new RunBefores(statement,
75 befores, target);
76 }
77 protected Statement withAfters(FrameworkMethod method, Object target,
78 Statement statement) {
79 List<FrameworkMethod> afters= getTestClass().getAnnotatedMethods(
80 After.class);
81 return afters.isEmpty() ? statement : new RunAfters(statement,
82 afters, target);
83 }
84 private Statement withRules(FrameworkMethod method, Object target,
85 Statement statement) {
86 Statement result= statement;
87 result= withMethodRules(method, target, result);
88 result= withTestRules(method, target, result);
89 return result;
90 }
91 private Statement withMethodRules(FrameworkMethod method, Object target,
92 Statement result) {
93 List<TestRule> testRules= getTestRules(target);
94 for (org.junit.rules.MethodRule each : getMethodRules(target))
95 if (! testRules.contains(each))
96 result= each.apply(result, method, target);
97 return result;
98 }
99 private List<org.junit.rules.MethodRule> getMethodRules(Object target) {
100 return rules(target);
101 }
102 protected List<org.junit.rules.MethodRule> rules(Object target) {
103 return getTestClass().getAnnotatedFieldValues(target, Rule.class,
104 org.junit.rules.MethodRule.class);
105 }
106 private Statement withTestRules(FrameworkMethod method, Object target,
107 Statement statement) {
108 List<TestRule> testRules= getTestRules(target);
109 return testRules.isEmpty() ? statement :
110 new RunRules(statement, testRules, describeChild(method));
111 }
112 protected List<TestRule> getTestRules(Object target) {
113 return getTestClass().getAnnotatedFieldValues(target,
114 Rule.class, TestRule.class);
115 }
在验证方面，BlockJUnit4ClassRunner也加入了一些和自己相关的验证：
1 @Override
2 protected void collectInitializationErrors(List<Throwable> errors) {
3 super.collectInitializationErrors(errors);
4 validateNoNonStaticInnerClass(errors);
5 validateConstructor(errors);
6 validateInstanceMethods(errors);
7 validateFields(errors);
8 }
1. 如果测试类是一个类的内部类，那么该测试类必须是静态的：
1 protected void validateNoNonStaticInnerClass(List<Throwable> errors) {
2 if (getTestClass().isANonStaticInnerClass()) {
3 String gripe= "The inner class " + getTestClass().getName()
4 + " is not static.";
5 errors.add(new Exception(gripe));
6 }
7 }
2. 测试类的构造函数必须有且仅有一个无参的构造函数（事实上关于只有一个构造函数的验证在构造TestClass实例的时候已经做了，因而这里真正起作用的知识对无参的验证）：
1 protected void validateConstructor(List<Throwable> errors) {
2 validateOnlyOneConstructor(errors);
3 validateZeroArgConstructor(errors);
4 }
5 protected void validateOnlyOneConstructor(List<Throwable> errors) {
6 if (!hasOneConstructor()) {
7 String gripe= "Test class should have exactly one public constructor";
8 errors.add(new Exception(gripe));
9 }
10 }
11 protected void validateZeroArgConstructor(List<Throwable> errors) {
12 if (!getTestClass().isANonStaticInnerClass()
13 && hasOneConstructor()
14 && (getTestClass().getOnlyConstructor().getParameterTypes().length != 0)) {
16 String gripe= "Test class should have exactly one public zero-argument constructor";
17 errors.add(new Exception(gripe));
18 }
19 }
20 private boolean hasOneConstructor() {
21 return getTestClass().getJavaClass().getConstructors().length == 1;
22 }
3. @Before、@After、@Test注解的方法必须是public，void，非静态，不带参数：
1 protected void validateInstanceMethods(List<Throwable> errors) {
2 validatePublicVoidNoArgMethods(After.class, false, errors);
3 validatePublicVoidNoArgMethods(Before.class, false, errors);
4 validateTestMethods(errors);
5 if (computeTestMethods().size() == 0)
6 errors.add(new Exception("No runnable methods"));
7 }
8 protected void validateTestMethods(List<Throwable> errors) {
9 validatePublicVoidNoArgMethods(Test.class, false, errors);
10 }
4. 带有@Rule注解的字段必须是public，非静态，实现了TestRule接口或MethodRule接口。
1 private void validateFields(List<Throwable> errors) {
2 RULE_VALIDATOR.validate(getTestClass(), errors);
3 }
JUnit核心执行的序列图
写了好几天，终于把JUnit核心的执行所有代码分析完了，不过发现写的那么细，很多东西其实很难表达，因而贴了很多代码，感觉写的挺乱的，所以画一张序列图吧，感觉很多时候还是图的表达效果更好一些，要我看那么一大段的问题，也感觉挺烦的。
Suite与Parameterized
Suite是其子节点是Runner的Runner，其内部保存了一个Runner的List。Suite的功能实现很简单，因为它将大部分的方法代理给了其内部Runner实例：
1 private final List<Runner> fRunners;
2 @Override
3 protected List<Runner> getChildren() {
4 return fRunners;
5 }
6 @Override
7 protected Description describeChild(Runner child) {
8 return child.getDescription();
9 }
10 @Override
11 protected void runChild(Runner runner, final RunNotifier notifier) {
12 runner.run(notifier);
13 }
Suite重点在于如何构建一个Suite，Suite提供两个构造函数：
1. 提供一个带SuiteClasses注解的类，所有测试类由SuiteClasses指定，而klass类作为这个Suite的根类。此时一般所有的测试类是klass的内部类，因而可以通过@RunWith指定运行klass类的Runner是Suite，然后用SuiteClasses注解指定可以作为测试类的类。
1 public Suite(Class<?> klass, RunnerBuilder builder) throws InitializationError {
3 this(builder, klass, getAnnotatedClasses(klass));
4 }
5 protected Suite(RunnerBuilder builder, Class<?> klass, Class<?>[] suiteClasses) throws InitializationError {
7 this(klass, builder.runners(klass, suiteClasses));
8 }
9 @Retention(RetentionPolicy.RUNTIME)
10 @Target(ElementType.TYPE)
11 @Inherited
12 public @interface SuiteClasses {
13 public Class<?>[] value();
14 }
15 private static Class<?>[] getAnnotatedClasses(Class<?> klass) throws InitializationError {
17 SuiteClasses annotation= klass.getAnnotation(SuiteClasses.class);
18 if (annotation == null)
19 throw new InitializationError(String.format("class '%s' must have a SuiteClasses annotation", klass.getName()));
22 return annotation.value();
23 }
2. 在有些情况下，我们需要运行多个没有相关的测试类，此时这些测试类没有一个公共的根类的Suite，则需要使用一下的构造函数（此时Suite的getName()返回”null”，即其Description的displayName的值为”null”，关于RunnerBuilder将会在后面的文章中介绍）：
1 public Suite(RunnerBuilder builder, Class<?>[] classes) throws InitializationError {
3 this(null, builder.runners(null, classes));
4 }
5 protected Suite(Class<?> klass, List<Runner> runners) throws InitializationError {
7 super(klass);
8 fRunners = runners;
9 }
Parameterized继承自Suite，它类似BlockJUnit4ClassRunner是对一个测试类的运行过程的封装，但是它支持在测试类中定义一个获得参数数组的一个列表，从而可以为构造该测试类提供不同的参数值以进行多次测试。因而Parameterized这个Runner其实就是根据参数数组列表的个数创建多个基于该测试类的Runner，并运行所有这些Runner中测试方法。
由于这个测试类的构造函数是带参的，而BlockJUnit4ClassRunner则限制其测试类必须是不带参的，因而Parameterized需要创建自己的Runner，它集成自BlockJUnit4ClassRunner，除了构造函数的差别，Parameterized的根节点是该测试类本身，它处理@BeforeClass、@AfterClass、@ClassRule的注解问题，因而其子节点的Runner不需要重新对其做处理了，因而在集成的Runner中应该避免这些方法、字段重复执行。
1 private class TestClassRunnerForParameters extends BlockJUnit4ClassRunner {
3 private final int fParameterSetNumber;
4 private final List<Object[]> fParameterList;
5 TestClassRunnerForParameters(Class<?> type, List<Object[]> parameterList, int i) throws InitializationError {
8 super(type);
9 fParameterList= parameterList;
10 fParameterSetNumber= i; //参数数组列表中的位置
11 }
12 @Override
13 public Object createTest() throws Exception {
14 return getTestClass().getOnlyConstructor().newInstance(
15 computeParams());//带参创建测试类实例
16 }
17 private Object[] computeParams() throws Exception {
18 try {
19 return fParameterList.get(fParameterSetNumber);
20 } catch (ClassCastException e) {
21 throw new Exception(String.format(
22 "%s.%s() must return a Collection of arrays.",
23 getTestClass().getName(), getParametersMethod(
24 getTestClass()).getName()));
25 }
26 }
27 @Override
28 protected String getName() {
29 return String.format("[%s]", fParameterSetNumber);
30 }
31 @Override
32 protected String testName(final FrameworkMethod method) {
33 return String.format("%s[%s]", method.getName(),
34 fParameterSetNumber);
35 }
36 @Override
37 protected void validateConstructor(List<Throwable> errors) {
38 validateOnlyOneConstructor(errors);//去除不带参构造函数验证
39 }
40 @Override
41 protected Statement classBlock(RunNotifier notifier) {
42 return childrenInvoker(notifier);//不处理@BeforeClass、
43 //@AfterClass、@ClassRule等注解
44 }
45 @Override
46 protected Annotation[] getRunnerAnnotations() {
47 return new Annotation[0];//去除测试类的Annotation，这些应该在Parameterized中处理
49 }
50 }
Parameterized对Suite的行为改变只是在创建Runner集合的过程，Parameterized通过类中查找@Parameters注解的静态方法获得参数数组列表，并更具这个参数数组列表创建TestClassRunnerForParameters的集合：
1 @Retention(RetentionPolicy.RUNTIME)
2 @Target(ElementType.METHOD)
3 public static @interface Parameters {
4 }
5 public Parameterized(Class<?> klass) throws Throwable {
6 super(klass, Collections.<Runner>emptyList());
7 List<Object[]> parametersList= getParametersList(getTestClass());
8 for (int i= 0; i < parametersList.size(); i++)
9 runners.add(new TestClassRunnerForParameters(getTestClass().getJavaClass(), parametersList, i));
11 }
12 private List<Object[]> getParametersList(TestClass klass)
13 throws Throwable {
14 return (List<Object[]>) getParametersMethod(klass).invokeExplosively(null);
16 }
17 private FrameworkMethod getParametersMethod(TestClass testClass)
18 throws Exception {
19 List<FrameworkMethod> methods= testClass.getAnnotatedMethods(Parameters.class);
21 for (FrameworkMethod each : methods) {
22 int modifiers= each.getMethod().getModifiers();
23 if (Modifier.isStatic(modifiers) &&
24 Modifier.isPublic(modifiers))
25 return each;
26 }
27 throw new Exception("No public static parameters method on class " + testClass.getName());
29 }
一个简单的Parameterized测试类如下，不过如果在Eclipse中单独的运行testEqual()测试方法会出错，因为Eclipse在Filter传入的方法名为testEqual，而在Parameterized中这个方法名已经被改写成testEqual[i]了，因而在Filter过程中，所有的测试方法都被过滤掉了，此时会抛NoTestRemainException，而在Eclipse中出现的则是InitializationError的Exception，这里也是Eclipse中JUnit的插件没有做好，它并没有给出Failure类的详细信息：
1 public class ParameterizedTest {
2 @Parameters
3 public static List<Object[]> data() {
4 return Arrays.asList(new Object[][] {
5 { 0, 0 }, { 1, 1 }, { 2, 1 }, { 3, 2 },
6 { 4, 3 }, { 5, 5 }, { 6, 8 }
7 });
8 }
9 @BeforeClass
10 public static void beforeClass() {
11 System.out.println(".testing.");
12 }
13 private final int input;
14 private final int expected;
15 public ParameterizedTest(int input, int expected) {
16 this.input = input;
17 this.expected = expected;
18 }
19 @Test
20 public void testEqual() {
21 Assert.assertEquals(expected, compute(input));
22 }
23 public int compute(int input) {
24 if(input == 0 || input == 1) {
25 return input;
26 }
27 if(input == 2) {
28 return 1;
29 }
30 return compute(input -1) + compute(input - 2);
31 }
32 }
ErrorReportingRunner和IgnoredClassRunner
关于JUnit4，还剩下最后两个Runner，分别是ErrorReportingRunner和IgnoredClassRunner，为了编程模型的统一（这是一个非常好的设计想法，将各种变化都封装在Runner中），JUnit中即使一个Runner实例创建失败或是该测试类有@Ignored的注解，在这两种情况中，JUnit分别通过ErrorReportingRunner和IgnoredClassRunner去表达。在ErrorReportingRunner中，为每个Exception发布测试失败的信息；IgnoredClassRunner则只是发布testIgnored事件：
1 public class ErrorReportingRunner extends Runner {
2 private final List<Throwable> fCauses;
3 private final Class<?> fTestClass;
4 public ErrorReportingRunner(Class<?> testClass, Throwable cause) {
5 fTestClass= testClass;
6 fCauses= getCauses(cause);
7 }
8 @Override
9 public Description getDescription() {
10 Description description= Description.createSuiteDescription(fTestClass);
12 for (Throwable each : fCauses)
13 description.addChild(describeCause(each));
14 return description;
15 }
16 @Override
17 public void run(RunNotifier notifier) {
18 for (Throwable each : fCauses)
19 runCause(each, notifier);
20 }
21 @SuppressWarnings("deprecation")
22 private List<Throwable> getCauses(Throwable cause) {
23 if (cause instanceof InvocationTargetException)
24 return getCauses(cause.getCause());
25 if (cause instanceof InitializationError)
26 return ((InitializationError) cause).getCauses();
27 if (cause instanceof org.junit.internal.runners.InitializationError)
28 return ((org.junit.internal.runners.InitializationError) cause)
29 .getCauses();
30 return Arrays.asList(cause);
31 }
32 private Description describeCause(Throwable child) {
33 return Description.createTestDescription(fTestClass,
34 "initializationError");
35 }
36 private void runCause(Throwable child, RunNotifier notifier) {
37 Description description= describeCause(child);
38 notifier.fireTestStarted(description);
39 notifier.fireTestFailure(new Failure(description, child));
40 notifier.fireTestFinished(description);
41 }
42 }
43 public class IgnoredClassRunner extends Runner {
44 private final Class<?> fTestClass;
45 public IgnoredClassRunner(Class<?> testClass) {
46 fTestClass= testClass;
47 }
48 @Override
49 public void run(RunNotifier notifier) {
50 notifier.fireTestIgnored(getDescription());
51 }
52 @Override
53 public Description getDescription() {
54 return Description.createSuiteDescription(fTestClass);
55 }
56 }
写在最后的话
写了一个周末了，这一篇终于是写完了，初次尝试将阅读框架源码以文字的形式表达出来，确实不好写，感觉自己写的太详细了，也贴了太多源码，因为有些时候感觉源码比文字更有表达能力，不过太多的源码就把很多实质的东西掩盖了，然后文章看起来也没有什么大的价值干，而且太长了，看到那么多的东西，要我自己看到也就有不想看的感觉，1万多字啊，呵呵。总之以后慢慢改进吧，这一篇就当是练习了，不想复工了，也没那么多的时间重写。。。。。。