Junit源码分析

Junit是非常短小精悍的单元测试框架，里面用到了大量的设计模式和设计原则，当然本文不是去分析这些模式，只是从头看代码分析一下它的执行过程：


1.Junit38ClassRunner的构造方法

        public JUnit38ClassRunner(Class<?> klass) {
                this(new TestSuite(klass.asSubclass(TestCase.class)));
        }

2.TestSuite的构造方法

  

public TestSuite(final Class<?> theClass) {
         addTestsFromTestCase(theClass);
   }

   下面看一下addTestsFromTestCase(theClass)方法的源码

  

private void addTestsFromTestCase(final Class<?> theClass) {
                fName= theClass.getName();
                try {
                        getTestConstructor(theClass); // Avoid generating multiple error messages
                } catch (NoSuchMethodException e) {
                        addTest(warning("Class "+theClass.getName()+" has no public constructor TestCase(String name) or TestCase()"));
                        return;
                }

                if (!Modifier.isPublic(theClass.getModifiers())) {
                        addTest(warning("Class "+theClass.getName()+" is not public"));
                        return;
                }

                Class<?> superClass= theClass;
                List<String> names= new ArrayList<String>();
                while (Test.class.isAssignableFrom(superClass)) {
                        for (Method each : superClass.getDeclaredMethods())
                                addTestMethod(each, names, theClass);
                        superClass= superClass.getSuperclass();
                }
                if (fTests.size() == 0)
                        addTest(warning("No tests found in "+theClass.getName()));
        }

然后我们再来看看addTestMethod方法

       

private void addTestMethod(Method m, List<String> names, Class<?> theClass) {
                String name= m.getName();
                if (names.contains(name))
                        return;
                if (! isPublicTestMethod(m)) {
                        if (isTestMethod(m))
                                addTest(warning("Test method isn't public: "+ m.getName() + "(" + theClass.getCanonicalName() + ")"));
                        return;
                }
                names.add(name);
                addTest(createTest(theClass, name));
        }

isTestMethod(Method m)方法判断该方法是否为测试方法，即以test开头或者有相关注解的方法
addTest(createTest(theClass, name));这里将创建出TestCase的实例，并添加到fTests（Vector）中
这里创建的出的TestCase的fname属性将保存实际要测试的方法名


3.TestSuite的createTest方法

       

static public Test createTest(Class<?> theClass, String name) {
                Constructor<?> constructor;
                try {
                        constructor= getTestConstructor(theClass);
                } catch (NoSuchMethodException e) {
                        return warning("Class "+theClass.getName()+" has no public constructor TestCase(String name) or TestCase()");
                }
                Object test;
                try {
                        if (constructor.getParameterTypes().length == 0) {
                                test= constructor.newInstance(new Object[0]);
                                if (test instanceof TestCase)
                                        ((TestCase) test).setName(name);
                        } else {
                                test= constructor.newInstance(new Object[]{name});
                        }
                } catch (InstantiationException e) {
                        return(warning("Cannot instantiate test case: "+name+" ("+exceptionToString(e)+")"));
                } catch (InvocationTargetException e) {
                        return(warning("Exception in constructor: "+name+" ("+exceptionToString(e.getTargetException())+")"));
                } catch (IllegalAccessException e) {
                        return(warning("Cannot access test case: "+name+" ("+exceptionToString(e)+")"));
                }
                return (Test) test;
        }

下面我们进入Test的执行过程：

4.Junit38ClassRunner的run方法

  

public void run(RunNotifier notifier) {
         TestResult result= new TestResult();
         result.addListener(createAdaptingListener(notifier));
         getTest().run(result);
   }

   这里getTest()的得到的是TestSuite，上面的代码我们已经知道TestSuite中包含了多个TestCase实例，当然这里说的比较局限TestSuite也可以包含其他的TestSuite去执行一组测试，它们都保存在fTests中，这其实是组合模式,那接着我们就应该看看TestSuite的run方法

   5.TestSuite的run方法

       

public void run(TestResult result) {
                for (Test each : fTests) {
                          if (result.shouldStop() )
                                  break;
                        runTest(each, result);
                }
        }

  不出所料，在这里是遍历fTests去执行每一个TestCase实例的run方法,那我们就继续去看TestCase的run方法

  6.TestCase的run方法

       

public void run(TestResult result) {
                result.run(this);
        }

  这里TestCase把自己作为参数传给TestResult的run方法去执行，这里为什么要这样做呢，为什么不直接执行呢？这个问题先留在这里，接着看

  7.TestResult的run方法

       

protected void run(final TestCase test) {
                startTest(test);
                Protectable p= new Protectable() {
                        public void protect() throws Throwable {
                                test.runBare();
                        }
                };
                runProtected(test, p);

                endTest(test);
        }

  startTest、endTest方法无非就是做一些初始化和销毁的工作，就不进入每个方法去看了，TestResult顾名思义是用来收集测试结果的，它在Runner、TestSuite、TestCase之间一直传递，保存所有测试方法的执行结果
  这里创建了一个受保护的Protectable类，在里面执行TestCase的runBare方法，runProtected()会去调用p.protect()方法.这说明测试方法实际上还是在TestCase中执行的，那为什么要传给TestResult，再在TestResult类中调用TestCase的runBare方法呢，我们来看一下runProtected()的具体过程吧
 
  8.TestResult的runProtected方法

       

public void runProtected(final Test test, Protectable p) {
                try {
                        p.protect();
                } 
                catch (AssertionFailedError e) {
                        addFailure(test, e);
                }
                catch (ThreadDeath e) { // don't catch ThreadDeath by accident
                        throw e;
                }
                catch (Throwable e) {
                        addError(test, e);
                }
        }

  很明显，这个过程是为了收集执行结果的，如果catch到AssertionFailureError表示测试结果不正确，如果catch到其他异常表示测试出现错误,addFailure和addError方法其实就是往TestResult的fFailures和fErrors列表中添加对象，并通知相应的观察者。

  我们回到主过程中，来接着看测试方法是如何被调用的:

  9.TestCase的runBare()方法

       

public void runBare() throws Throwable {
                Throwable exception= null;
                setUp();
                try {
                        runTest();
                } catch (Throwable running) {
                        exception= running;
                }
                finally {
                        try {
                                tearDown();
                        } catch (Throwable tearingDown) {
                                if (exception == null) exception= tearingDown;
                        }
                }
                if (exception != null) throw exception;
        }

 
  这里我们就会发现为什么junit在对每个方法进行测试时都要先后执行setUp()、实际要测试的方法和tearDown()方法，这里用的模板方法模式，setUp和tearDown如果在测试类中有进行复写，那实际执行的是测试类中的setUp和tearDown,而且测试每个类的前后都会执行这两个方法，而实际执行要测试的方法是在runTest()中实现的，下面就来看看runTest()方法吧

  10.TestCase的runTest()方法

       

protected void runTest() throws Throwable {
                assertNotNull("TestCase.fName cannot be null", fName); // Some VMs crash when calling getMethod(null,null);
                Method runMethod= null;
                try {
                        // use getMethod to get all public inherited
                        // methods. getDeclaredMethods returns all
                        // methods of this class but excludes the
                        // inherited ones.
                        runMethod= getClass().getMethod(fName, (Class[])null);
                } catch (NoSuchMethodException e) {
                        fail("Method \""+fName+"\" not found");
                }
                if (!Modifier.isPublic(runMethod.getModifiers())) {
                        fail("Method \""+fName+"\" should be public");
                }

                try {
                        runMethod.invoke(this);
                }
                catch (InvocationTargetException e) {
                        e.fillInStackTrace();
                        throw e.getTargetException();
                }
                catch (IllegalAccessException e) {
                        e.fillInStackTrace();
                        throw e;
                }
        }

   这里就可以发现Junit实际上就是把我们要测试的方法反射出来去invoke,以上这些就是Junit进行测试的全过程了，下面我们再来看分析前面的过程中遗留的问题：
   为什么在TestCase的run方法中不直接执行测试方法，而要将自身传给TestResult的run方法中去执行？
   这个问题通过后面的执行过程，大家应该也看明白了，这其实是Junit的设计上非常值得我们学习的地方，就是类的单一职责特点，TestCase里的方法应该都是测试相关的，而TestResult里的方法都是为了结果服务的，这个交织的过程就是为了获取测试结果