一个通用的单元测试框架的思考和设计03-实现篇-核心类源码

第二节里我们介绍了iunit整体的设计思路以及核心类之间的关系，这篇将以源码+解释的方式来演示核心类的实现方式

1.IUnitRunner 类

这个类是测试的入口类，直接继承自junit4.8的BlockJunit4ClassRunner，在构造函数里，我们把iunit框架的扩展功能添加了进来，因为整个框架呃设计都是基于Listener的，所以只需要把监听器在框架运行的时候加载进来即可--见构造函数，listener的注册是通过注解来进行的，因为测试类本身可能会有继承关系，因此需要遍历父类中的Listener，把子类+所有父类中的Listener合并起来，当然还要注意剔除掉重复注册的Listener，否则很可能导致一个Listener被执行多次(既在子类中注册过了又在父类中注册过了)

package com.crazycoder2010.iunit;

import java.util.ArrayList;
import java.util.List;

import org.junit.Ignore;
import org.junit.internal.AssumptionViolatedException;
import org.junit.internal.runners.model.EachTestNotifier;
import org.junit.runner.Description;
import org.junit.runner.notification.RunNotifier;
import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.Statement;

import com.crazycoder2010.iunit.annotation.IUnitTestExecuteListeners;

public class IUnitRunner extends BlockJUnit4ClassRunner {
/**
* 监听器
*/
private List<IUnitTestExecuteListener> executeListeners = new ArrayList<IUnitTestExecuteListener>();
private Class<?> clazz;
private TestContext testContext;
public IUnitRunner(Class<?> klass) throws InitializationError {
super(klass);

//这个构造函数是junt的调用入口，这里我们把扩展功能的初始化写到其后
this.clazz = klass;
this.testContext = new TestContext();
initListeners();
}

private void initListeners(){
this.executeListeners.addAll(findListeners());
}

/**
* 解析为当前测试类注册的监听器
* @return
*/
@SuppressWarnings("rawtypes")
private List<IUnitTestExecuteListener> findListeners(){
List<IUnitTestExecuteListener> result = new ArrayList<IUnitTestExecuteListener>();
List<Class> listeners = new ArrayList<Class>();
Class<?> c = this.clazz;
while(c != null){
IUnitTestExecuteListeners listener = c.getAnnotation(IUnitTestExecuteListeners.class);
if(listener != null){
for(Class<? extends IUnitTestExecuteListener> l : listener.value()){
if(!listeners.contains(l)){
listeners.add(l);
}
}
}
c = c.getSuperclass();
}
for(Class clazz:listeners){
try {
result.add((IUnitTestExecuteListener) clazz.newInstance());
} catch (InstantiationException e) {
e.printStackTrace();
} catch (IllegalAccessException e) {
e.printStackTrace();
}
}
return result;
}

@Override
protected Object createTest() throws Exception {
Object testInstance = super.createTest();
//加上我们框架的扩展功能
this.testContext.setTestInstance(testInstance);
for(IUnitTestExecuteListener executeListener : this.executeListeners){
executeListener.prepareTestInstance(testContext);
}
return testInstance;
}

@Override
protected void runChild(FrameworkMethod method, RunNotifier notifier) {
EachTestNotifier eachNotifier= makeNotifier(method, notifier);
if (method.getAnnotation(Ignore.class) != null) {
runIgnored(eachNotifier);
} else {
runNotIgnored(method, eachNotifier);
}
}

private EachTestNotifier makeNotifier(FrameworkMethod method,
RunNotifier notifier) {
Description description= describeChild(method);
return new EachTestNotifier(notifier, description);
}

private void runIgnored(EachTestNotifier eachNotifier) {
eachNotifier.fireTestIgnored();
}

private void runNotIgnored(FrameworkMethod method,
EachTestNotifier eachNotifier) {
eachNotifier.fireTestStarted();
try {
Statement statement = methodBlock(method);
doBefore();
statement.evaluate();
doAfter();
} catch (AssumptionViolatedException e) {
eachNotifier.addFailedAssumption(e);
} catch (Throwable e) {
eachNotifier.addFailure(e);
testContext.setThrowable(e);
doAfterThrowable();
} finally {
eachNotifier.fireTestFinished();
}
}

private void doBefore()throws Exception{
for(IUnitTestExecuteListener executeListener : this.executeListeners){
executeListener.beforeTest(testContext);
}
}

private void doAfter() throws Exception{
for(IUnitTestExecuteListener executeListener : this.executeListeners){
executeListener.afterTest(testContext);
}
}

private void doAfterThrowable(){
for(IUnitTestExecuteListener executeListener : this.executeListeners){
try {
executeListener.afterThrowable(testContext);
} catch (Exception e) {
e.printStackTrace();
}
}
}
}

2.IUnitTestExecuteListener接口

这个接口定义了测试用例执行生命周期的几个关键点

package com.crazycoder2010.iunit;

/**
* 框架执行监听器
* @author Kevin
*
*/
public interface IUnitTestExecuteListener {
/**
* TestCase对象被加载后执行的操作，每个TestCase只会执行一次
* @param testContext
*/
public void prepareTestInstance(TestContext testContext) throws Exception;

/**
* 在每执行一个单元测试方法之前运行
* @param testContext
* @throws Exception
*/
public void beforeTest(TestContext testContext) throws Exception;

/**
* 每个单元测试方法执行完时执行
* @param testContext
* @throws Exception
*/
public void afterTest(TestContext testContext) throws Exception;

/**
* 发生异常时做的处理
* @param testContext
*/
public void afterThrowable(TestContext testContext) throws Exception;
}

3.IUnitTestExecuteListeners注解

这个用来给测试类注册监听器的注解，一个IUnitTestExecuteListeners可以注册多个Listener

package com.crazycoder2010.iunit.annotation;

import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Inherited;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

import com.crazycoder2010.iunit.IUnitTestExecuteListener;

/**
* 为TestCase注册监听器
*
* @author Kevin
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
@Documented
public @interface IUnitTestExecuteListeners {
/**
* 实际用到的监听器类
*
* @return
*/
Class<? extends IUnitTestExecuteListener>[] value() default {};
}

4.AbstractIUnitTestCase测试基类

这个类是为了便于测试定义了一个TestCase的基类，可以在此注册一些通用的监听器，注意@Runwith(IUnitRunner.class)这个是关键，否则我们写在runner中扩展的功能是不会被junit4执行到的

package com.crazycoder2010.iunit;

import org.junit.runner.RunWith;

import com.crazycoder2010.iunit.annotation.IUnitTestExecuteListeners;

@RunWith(IUnitRunner.class)
@IUnitTestExecuteListeners({DatasetProviderListener.class})
public class AbstractIUnitTestCase {

}