JUnit 4中如何判断当前测试是否为最后一个及解决监听器冲突问题

一、判断当前测试是否为执行流程中的最后一个测试 #

你可以通过自定义TestWatcher结合测试计数来实现：

1. 在自定义TestWatcher中维护计数器和当前测试类的总测试数：
   • 在starting方法里，通过反射获取当前测试类中带@Test注解的方法总数，作为总测试数；
   • 每次测试完成（成功/失败）后递增计数器，当计数器等于总测试数时，即可判定为当前类的最后一个测试。

示例代码：

public class LastTestWatcher extends TestWatcher {
    private int testCount = 0;
    private int totalTests;

    @Override
    protected void starting(Description description) {
        // 仅第一次初始化当前类的总测试数
        if (totalTests == 0) {
            totalTests = (int) Arrays.stream(description.getTestClass().getMethods())
                    .filter(method -> method.isAnnotationPresent(Test.class))
                    .count();
        }
    }

    @Override
    protected void succeeded(Description description) {
        checkIfLastTest();
    }

    @Override
    protected void failed(Throwable e, Description description) {
        checkIfLastTest();
    }

    private void checkIfLastTest() {
        testCount++;
        if (testCount == totalTests) {
            // 这里编写最后一个测试完成后的逻辑
            System.out.println("当前测试类的最后一个测试已执行完成");
        }
    }
}

在测试类中通过@Rule引入该监听器：

public class SampleTest {
    @Rule
    public LastTestWatcher lastTestWatcher = new LastTestWatcher();

    @Test
    public void testCase1() {}

    @Test
    public void testCase2() {}
}

二、所有测试类执行完毕后调用特定方法（解决监听器冲突问题） #

你不需要同时使用TestWatcher和RunListener——直接自定义RunListener就能同时实现单个测试的结果监听（替代TestWatcher的功能），以及全局测试完成后的收尾处理，从根源避免冲突。

方案：自定义RunListener覆盖全生命周期 #

1. 编写自定义RunListener，实现单个测试的成功/失败监听，同时重写testRunFinished处理全局收尾：

public class GlobalTestListener extends RunListener {
    // 替代TestWatcher的succeeded方法：测试成功时触发
    @Override
    public void testSucceeded(Description description) throws Exception {
        super.testSucceeded(description);
        // 写入原TestWatcher中succeeded方法的逻辑
        System.out.println("测试 " + description.getMethodName() + " 执行成功");
    }

    // 替代TestWatcher的failed方法：测试失败时触发
    @Override
    public void testFailure(Failure failure) throws Exception {
        super.testFailure(failure);
        // 写入原TestWatcher中failed方法的逻辑
        System.out.println("测试 " + failure.getDescription().getMethodName() + " 执行失败：" + failure.getException());
    }

    // 所有测试类的全部测试执行完毕后触发
    @Override
    public void testRunFinished(Result result) throws Exception {
        super.testRunFinished(result);
        // 调用你的特定方法
        executeGlobalPostMethod();
    }

    private void executeGlobalPostMethod() {
        System.out.println("所有测试全部完成，执行全局后置处理方法");
    }
}

2. 注册RunListener的两种方式：

   • 方式1：自定义Runner注册
     编写自定义Runner，在其中添加监听器：

     public class CustomTestRunner extends BlockJUnit4ClassRunner {
         public CustomTestRunner(Class<?> klass) throws InitializationError {
             super(klass);
         }
     
         @Override
         protected void runChild(FrameworkMethod method, RunNotifier notifier) {
             notifier.addListener(new GlobalTestListener());
             super.runChild(method, notifier);
         }
     }
     

     在测试类上添加@RunWith(CustomTestRunner.class)即可生效。

   • 方式2：通过构建工具配置
     以Maven Surefire插件为例，在pom.xml中配置监听器：

     <plugin>
         <groupId>org.apache.maven.plugins</groupId>
         <artifactId>maven-surefire-plugin</artifactId>
         <version>2.22.2</version>
         <configuration>
             <properties>
                 <property>
                     <name>listener</name>
                     <value>com.yourpackage.GlobalTestListener</value>
                 </property>
             </properties>
         </configuration>
     </plugin>
     

补充：若需保留TestWatcher的兼容方案 #

如果必须保留TestWatcher，可以通过全局共享计数器配合RunListener实现全局收尾：

• 定义静态原子类计数器，在TestWatcher的成功/失败方法中递增计数；
• 在RunListener的testRunFinished方法中，确认计数器等于总测试数后调用特定方法（注意多线程测试场景下的线程安全）：

public class TestCounter {
    public static final AtomicInteger totalExecutedTests = new AtomicInteger(0);
}

内容的提问来源于stack exchange，提问作者Vadym