1  public  class CoreJUnit4SampleTest {  2     @BeforeClass  3      public  static  void beforeClass() {  4         System.out.println("beforeClass() method executed.");  5         System.out.println();  6     }  7     @BeforeClass  8      public  static  void beforeClass2() {  9         System.out.println("beforeClass2() method executed."); 10         System.out.println(); 11     } 12     @AfterClass 13      public  static  void afterClass() { 14         System.out.println("afterClass() method executed."); 15         System.out.println(); 16     } 17     @Before 18      public  void before() { 19         System.out.println("before() method executed."); 20     } 21     @After 22      public  void after() { 23         System.out.println("after() method executed"); 24     } 25     @Test 26      public  void testSucceeded() { 27         System.out.println("testSucceeded() method executed."); 28     } 29     @Test 30     @Ignore 31      public  void testIgnore() { 32         System.out.println("testIgnore() method executed."); 33     } 34     @Test 35      public  void testFailed() { 36         System.out.println("testFailed() method executed."); 37          throw  new RuntimeException("Throw delibrately "); 38     } 39     @Test 40      public  void testAssumptionFailed() { 41         System.out.println("testAssumptionFailed() method executed."); 42         Assume.assumeThat(0, Is.is(1)); 43     } 44     @Test 45      public  void testFilteredOut() { 46         System.out.println("testFilteredOut() method executed."); 47     } 48 }

 1  public   class  BlockJUnit4ClassRunnerExecutor {

 2       public   static   void  main(String[] args) {

 3          RunNotifier notifier  =   new  RunNotifier();            

 4          Result result  =   new  Result();

 5          notifier.addFirstListener(result.createListener());

 6          notifier.addListener( new  LogRunListener());

 7          

 8          Runner runner  =   null ;

 9           try  {

10              runner  =   new  BlockJUnit4ClassRunner(CoreJUnit4SampleTest. class );

11               try  {

12                  ((BlockJUnit4ClassRunner)runner).filter( new  MethodNameFilter( " testFilteredOut " ));

13              }  catch  (NoTestsRemainException e) {

14                  System.out.println( " All methods are been filtered out " );

15                   return ;

16              }

17              ((BlockJUnit4ClassRunner)runner).sort( new  Sorter( new  AlphabetComparator()));

18          }  catch  (Throwable e) {

19              runner  =   new  ErrorReportingRunner(CoreJUnit4SampleTest. class , e);

20          }

21          notifier.fireTestRunStarted(runner.getDescription());

22          runner.run(notifier);

23          notifier.fireTestRunFinished(result);

24      }

25  } 

1  private   final  ArrayList < Description >  fChildren;

2  private   final  String fDisplayName;    

3  private   final Annotation[] fAnnotations;

对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 的成员如下：

并且这些成员在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 }

用ParentRunner命名这个Runner是想表达这是一个在测试方法树中具有子节点的节点，它的子节点可以是测试方法（BlockJUnit4ClassRunner）或者Runner（Suite）。ParentRunner以测试类Class实例作为构造函数的参数，在构造函数内部用TestClass对测试类进行封装，并对一些那些规定的方法做验证：

1.       @BeforeClass和@AfterClass注解的方法必须是public，void，static，无参

 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 }

 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 }