JUnit扩展方式（二）-使用Runner对JUnit进行扩展（基础）

在前面的文章中对于如何使用Rule对JUnit进行扩展进行了说明，在Rule之前对于JUnit的扩展使用的方式是通过创建一个继承自BlockJUnit4ClassRunner类的新的Runner类，然后在测试用例中通过@RunWith指定使用新的Runner来运行测试类实现的；
具体步骤如下：
1）创建一个新的Runner类，该类继承自BlockJUnit4ClassRunner；
2）在测试类中通过@RunWith指定使用新的Runner替代默认的Runner；
注：文中描述的只是一个Demo，操作的逻辑判断直接写在Runner中，实际过程中需要将Runner和操作逻辑解耦，实现一个松耦合的Runner；
代码如下：
创建继承自BlockJUnit4ClassRunner的新Runner：

package extension.runner;

import org.junit.runners.BlockJUnit4ClassRunner;
import org.junit.runners.model.FrameworkMethod;
import org.junit.runners.model.InitializationError;
import org.junit.runners.model.Statement;

import extension.rule.AfterMethod;
import extension.rule.BeforeMethod;

@SuppressWarnings("deprecation")
public class ExtensionRunner extends BlockJUnit4ClassRunner {

	private Class<?> clazz;

	public ExtensionRunner(Class<?> klass) throws InitializationError {
		super(klass);
		this.clazz = klass;
	}

	// Extend @BeforeClass, add additional operations to @BeforeClass
	protected Statement withBeforeClasses(final Statement statement) {
		final Statement junitStatement = super.withBeforeClasses(statement);
		return new Statement() {
			@Override
			public void evaluate() throws Throwable {
				System.out.println("Before Class: " + clazz.getName());
				junitStatement.evaluate();
			}

		};
	}

	protected Statement withBefores(final FrameworkMethod method,
			Object target, final Statement statement) {
		final Statement junitStatement = super.withBefores(method, target,
				statement);
		return new Statement() {
			@Override
			public void evaluate() throws Throwable {
				if (method.getAnnotation(BeforeMethod.class) != null) {
					System.out.println(((BeforeMethod) method
							.getAnnotation(BeforeMethod.class)).message());
				}
				junitStatement.evaluate();
			}

		};
	}

	protected Statement withAfters(final FrameworkMethod method, Object target,
			final Statement statement) {
		final Statement junitStatement = super.withAfters(method, target,
				statement);
		return new Statement() {
			@Override
			public void evaluate() throws Throwable {
				junitStatement.evaluate();
				if (method.getAnnotation(AfterMethod.class) != null) {
					System.out.println(((AfterMethod) method
							.getAnnotation(AfterMethod.class)).message());
				}
			}

		};
	}

	protected Statement withAfterClasses(final Statement statement) {
		final Statement junitStatement = super.withAfterClasses(statement);
		return new Statement() {
			@Override
			public void evaluate() throws Throwable {
				junitStatement.evaluate();
				System.out.println("After Class: " + clazz.getName());
			}

		};
	}
}

在测试类中指定新的Runner代替默认Runner：

package test;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import org.junit.runner.RunWith;

import extension.rule.AfterMethod;
import extension.rule.BeforeMethod;
import extension.runner.ExtensionRunner;

@RunWith(ExtensionRunner.class)
public class RunnerTestCase {

	@BeforeClass
	public static void beforeClass() {
		System.out.println("beforeClass");
	}

	@Before
	public void before() {
		System.out.println("before");
	}
	
	@Test
	@BeforeMethod(message="test_1 before method")
	public void test_1() {
		System.out.println("test_1");
	}
	
	@Test
	@AfterMethod(message="test_2 after method")
	public void test_2() {
		System.out.println("test_2");
	}
	
	@Test
	@BeforeMethod(message="test_3 before method")
	@AfterMethod(message="test_3 after method")
	public void test_3() {
		System.out.println("test_3");
	}
	
	@After
	public void after() {
		System.out.println("after");
	}

	@AfterClass
	public static void afterClass() {
		System.out.println("afterClass");
	}
}

运行结果如下：