在没有显式测试套件类声明的情况下清理所有JUnit测试

Question

在Intelij和Eclipse IDE(可能还有其他一些IDE)中，可以从一个包中运行所有测试类(甚至是项目中的所有测试类)，而无需将每个测试类显式地放在测试套件类中(这是我想避免的)。只需右键点击->运行所有测试，瞧！

不过，我对这种测试方法有一个问题。我想在所有的测试完成后做一些清理，但无论我做什么，似乎都不起作用。

起初，我尝试使用RunListener及其testRunFinished()方法，但它是在每次原子测试完成后调用的，所以在运行它们时不是我想要的。

然后我想到了终结器和runFinalizersOnExit(true)，不幸的是，它被弃用了，并且只在执行测试的计算机上运行。

我尝试的最后一件事是创建一个"监听器"线程，在给定测试执行开始和结束时间差的情况下，该线程将在测试完成五秒钟后清理干净。我用下面的代码来测试这个解决方案：

import org.junit.Test;
public class Main {
static {
System.out.println("In a static block!");
new Thread(new Runnable() {
public void run() {
System.out.println("Starting static thread!");
try {
while (true) {
Thread.sleep(1000);
System.out.println("Static thread working...");
}
} catch (InterruptedException e) {
System.err.println("Static thread interrupted!");
e.printStackTrace();
} catch (Exception e) {
System.err.println("Static thread catches exception!");
e.printStackTrace();
} finally {
System.err.println("Static thread in finally method.");
Thread.currentThread().interrupt();
}
}
}).start();
System.out.println("Exiting static block!");
}
@Test
public void test() throws Exception {
System.out.println("Running test!");
Thread.sleep(3000);
System.out.println("Stopping test!");
}
}

运气不好。测试完成后，线程被终止。即使是finally块也从未执行。。。

In a static block!
Exiting static block!
Running test!
Starting static thread!
Static thread working...
Static thread working...
Stopping test!
Static thread working...

期望的行为是：

1. 右键单击
2. 运行所有测试
3. TestA正在运行
4. 测试A完成
5. TestB正在运行
6. 测试B完成
7. 。。。更多测试类
8. 清理

Answer 1

不确定我是否完全理解你的问题，但我认为你想要beforeClass、beforeClass和afterClass方法。即

@BeforeClass
public void beforeClass() {
// Do stuff before test class is run
}
@Before
public void before() {
// Do stuff before each test is run
}
@After
public void after() {
// DO stuff after each test is run
}
@AfterClass
public void afterClass() {
// DO stuff after test class is run
}

你可以用一些黑客或其他框架在更全球化的层面上做事。例如，Spring的测试套件。但我会尽量把这些东西放在一个测试类的范围内。

Answer 2

我找到了解决问题的方法。我的同事建议"嘿，你就不能数一下测试班吗？"——我就是这么做的。

这里使用了一点反射魔法，所以代码可能不可移植：

public abstract class CleaningTestRunner extends BlockJUnit4ClassRunner {
protected abstract void cleanupAfterAllTestRuns();
private static long TEST_CLASSES_AMOUNT;
private static long TEST_RUNS_FINISHED = 0;
private static boolean CLASSES_COUNTED = false;
static {
while (!CLASSES_COUNTED) {
try {
Field f = ClassLoader.class.getDeclaredField("classes");
f.setAccessible(true);
Vector<Class> classes = (Vector<Class>) f.get(CleaningTestRunner.class.getClassLoader());
TEST_CLASSES_AMOUNT = 0;
for (Class<?> klass : classes) {
if (klass.isAnnotationPresent(RunWith.class)) {
if (CleaningTestRunner.class.isAssignableFrom(klass.getAnnotation(RunWith.class).value())) {
for (Method method : klass.getMethods()) {
if (method.isAnnotationPresent(Test.class)) {
++TEST_CLASSES_AMOUNT;
break;
}
}
}
}
}
CLASSES_COUNTED = true;
} catch (Exception ignored) {
}
}
}
public CleaningTestRunner(Class<?> klass) throws InitializationError {
super(klass);
}
@Override
public void run(RunNotifier notifier) {
notifier.addListener(new TestCleanupListener());
super.run(notifier);
}
private class TestCleanupListener extends RunListener {
@Override
public void testRunFinished(Result result) throws Exception {
++TEST_RUNS_FINISHED;
if (TEST_RUNS_FINISHED == TEST_CLASSES_AMOUNT) {
cleanupAfterAllTestRuns();
}
}
}
}