如何让TestNG将重试方法合并为单次测试运行而非多次？

我之前也遇到过这个困扰！TestNG自带的IRetryAnalyzer确实会把每一次重试都当成独立的测试用例来记录，导致报告里出现多条重复的失败/成功记录。要实现「合并重试记录为单次结果」的需求，得结合TestNG的扩展接口来做，下面给你两个实用的方案：

这个方案的核心是在TestNG生成最终报告前，手动合并同一个测试方法的所有重试记录：如果有成功记录就保留最后一次成功的，否则保留最后一次失败的，再替换掉TestNG原有的结果集。

步骤1：实现自定义IReporter #

import org.testng.IReporter;
import org.testng.ISuite;
import org.testng.ISuiteResult;
import org.testng.ITestContext;
import org.testng.ITestResult;
import org.testng.xml.XmlSuite;

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class MergedRetryReporter implements IReporter {
    // 最大重试次数，要和你的RetryAnalyzer保持一致
    private static final int MAX_RETRY = 3;

    @Override
    public void generateReport(List<XmlSuite> xmlSuites, List<ISuite> suites, String outputDirectory) {
        for (ISuite suite : suites) {
            Map<String, ISuiteResult> suiteResults = suite.getResults();
            for (ISuiteResult suiteResult : suiteResults.values()) {
                ITestContext testContext = suiteResult.getTestContext();
                // 用线程安全的Map存储合并后的结果，适配并行测试场景
                Map<String, ITestResult> mergedResults = new ConcurrentHashMap<>();

                // 处理所有测试结果（成功、失败、跳过）
                processTestResults(testContext.getPassedTests().getAllResults(), mergedResults);
                processTestResults(testContext.getFailedTests().getAllResults(), mergedResults);
                processTestResults(testContext.getSkippedTests().getAllResults(), mergedResults);

                // 清空原有结果，替换为合并后的结果
                clearTestContextResults(testContext);
                populateMergedResults(testContext, mergedResults);
            }
        }
    }

    private void processTestResults(List<ITestResult> results, Map<String, ITestResult> mergedResults) {
        for (ITestResult result : results) {
            // 用「类名+方法名」作为唯一标识，区分不同测试方法
            String methodKey = result.getTestClass().getName() + "." + result.getMethod().getMethodName();
            
            if (mergedResults.containsKey(methodKey)) {
                ITestResult existingResult = mergedResults.get(methodKey);
                // 保留最新的测试结果（通过时间戳判断）
                if (result.getEndMillis() > existingResult.getEndMillis()) {
                    mergedResults.put(methodKey, result);
                }
            } else {
                mergedResults.put(methodKey, result);
            }
        }
    }

    private void clearTestContextResults(ITestContext testContext) {
        testContext.getPassedTests().clear();
        testContext.getFailedTests().clear();
        testContext.getSkippedTests().clear();
    }

    private void populateMergedResults(ITestContext testContext, Map<String, ITestResult> mergedResults) {
        for (ITestResult result : mergedResults.values()) {
            switch (result.getStatus()) {
                case ITestResult.SUCCESS:
                    testContext.getPassedTests().addResult(result);
                    break;
                case ITestResult.FAILURE:
                    testContext.getFailedTests().addResult(result);
                    break;
                case ITestResult.SKIP:
                    testContext.getSkippedTests().addResult(result);
                    break;
            }
        }
    }
}

步骤2：在TestNG配置中启用自定义Reporter #

修改你的testng.xml，添加这个自定义Reporter的监听器配置：

<suite name="YourTestSuite">
    <listeners>
        <!-- 你的重试分析器 -->
        <listener class-name="com.yourpackage.YourRetryAnalyzer"/>
        <!-- 自定义合并报告的Reporter -->
        <listener class-name="com.yourpackage.MergedRetryReporter"/>
    </listeners>

    <test name="YourTest">
        <classes>
            <class name="com.yourpackage.YourTestClass"/>
        </classes>
    </test>
</suite>

这个方案是在测试执行过程中实时处理结果：重试中的失败先标记为「跳过」，等最终重试结束后，再保留最终的成功/失败状态，同时移除之前的中间记录。

步骤1：改造你的IRetryAnalyzer，添加重试次数跟踪 #

import org.testng.IRetryAnalyzer;
import org.testng.ITestResult;

import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class TrackedRetryAnalyzer implements IRetryAnalyzer {
    private static final int MAX_RETRY = 3;
    // 线程安全的Map，存储每个测试方法的重试次数
    private ConcurrentMap<String, Integer> retryCountMap = new ConcurrentHashMap<>();

    @Override
    public boolean retry(ITestResult result) {
        String methodKey = result.getTestClass().getName() + "." + result.getMethod().getMethodName();
        int currentCount = retryCountMap.getOrDefault(methodKey, 0);
        
        if (currentCount < MAX_RETRY) {
            retryCountMap.put(methodKey, currentCount + 1);
            return true;
        }
        retryCountMap.remove(methodKey);
        return false;
    }

    // 对外提供获取重试次数的方法，供Listener调用
    public int getCurrentRetryCount(String methodKey) {
        return retryCountMap.getOrDefault(methodKey, 0);
    }
}

步骤2：实现自定义ITestListener #

import org.testng.ITestContext;
import org.testng.ITestListener;
import org.testng.ITestResult;

public class RetryMergeListener implements ITestListener {

    @Override
    public void onTestSuccess(ITestResult result) {
        // 如果是重试后成功，移除该方法之前的失败记录
        ITestContext context = result.getTestContext();
        String methodKey = getMethodKey(result);
        
        // 从失败结果集中删除该方法的所有旧记录
        context.getFailedTests().getAllResults().removeIf(r -> getMethodKey(r).equals(methodKey));
    }

    @Override
    public void onTestFailure(ITestResult result) {
        TrackedRetryAnalyzer retryAnalyzer = (TrackedRetryAnalyzer) result.getMethod().getRetryAnalyzer();
        String methodKey = getMethodKey(result);
        int currentRetryCount = retryAnalyzer.getCurrentRetryCount(methodKey);

        // 如果还没到最大重试次数，暂时标记为跳过，避免报告提前显示失败
        if (currentRetryCount < 3) {
            result.setStatus(ITestResult.SKIP);
        }
    }

    private String getMethodKey(ITestResult result) {
        return result.getTestClass().getName() + "." + result.getMethod().getMethodName();
    }
}

步骤3：配置监听器 #

同样在testng.xml中添加这两个监听器：

<suite name="YourTestSuite">
    <listeners>
        <listener class-name="com.yourpackage.TrackedRetryAnalyzer"/>
        <listener class-name="com.yourpackage.RetryMergeListener"/>
    </listeners>

    <test name="YourTest">
        <classes>
            <class name="com.yourpackage.YourTestClass"/>
        </classes>
    </test>
</suite>

• 并行测试适配：如果你的测试是并行执行的，一定要用线程安全的集合（比如ConcurrentHashMap）来存储重试次数和结果，避免多线程冲突。
• 第三方报告工具适配：如果用了ExtentReports之类的第三方报告框架，需要在对应的自定义监听器中添加类似的合并逻辑，不能只依赖TestNG的默认报告。
• 重试次数一致性：确保IRetryAnalyzer和Reporter/Listener中的最大重试次数保持一致，避免逻辑冲突。

这样处理后，TestNG的报告就会把同一个测试方法的多次重试合并为单条记录：如果在最大重试次数内成功，就显示为单次成功；如果全部重试都失败，就显示为单次失败，不会再出现多条重复记录啦！

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