能否让DataProvider驱动的测试方法仅执行一次迭代后终止？

当然可以实现！针对你的需求，我分享几种TestNG的解决方案，其中包括你提到的Test Listeners方法，还有更灵活的替代方案：

方法一：自定义Test Listener（推荐，不修改现有DataProvider） #

这种方法通过TestNG的ITestListener接口拦截测试执行，标记并跳过目标方法的后续迭代，同时保证后续依赖测试能正常获取到变量。

步骤1：实现自定义Listener #

我们用ThreadLocal来记录当前线程是否已经执行过第一次迭代，避免并行测试时的线程干扰：

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

public class StopAfterFirstIterationListener implements ITestListener {
    // 线程本地存储，标记当前方法是否已执行第一次迭代
    private static final ThreadLocal<Boolean> hasExecutedFirst = ThreadLocal.withInitial(() -> false);

    @Override
    public void onTestStart(ITestResult result) {
        // 检查当前测试方法是否是需要控制的目标方法
        // 你可以替换成自己的方法名，或者用自定义注解（见下文优化）
        if ("setupVariableTest".equals(result.getMethod().getMethodName())) {
            if (hasExecutedFirst.get()) {
                // 标记测试为跳过，并终止执行
                result.setStatus(ITestResult.SKIP);
                throw new SkipException("仅执行第一次迭代，后续迭代跳过");
            } else {
                // 标记已执行第一次迭代
                hasExecutedFirst.set(true);
            }
        }
    }

    @Override
    public void onFinish(ITestContext context) {
        // 测试完成后清理ThreadLocal，避免影响其他测试
        hasExecutedFirst.remove();
    }

    // 其他未用到的Listener方法留空实现即可
    @Override
    public void onTestSuccess(ITestResult result) {}
    @Override
    public void onTestFailure(ITestResult result) {}
    @Override
    public void onTestSkipped(ITestResult result) {}
    @Override
    public void onTestFailedButWithinSuccessPercentage(ITestResult result) {}
    @Override
    public void onStart(ITestContext context) {}
}

步骤2：在测试类中使用Listener #

给测试类添加@Listeners注解，并编写你的测试方法：

import org.testng.annotations.DataProvider;
import org.testng.annotations.Listeners;
import org.testng.annotations.Test;

@Listeners(StopAfterFirstIterationListener.class)
public class SetupTest {
    // 存储给后续依赖测试的变量
    public static String targetVariable;

    // 目标设置方法，仅执行第一次迭代
    @Test(dataProvider = "setupData")
    public void setupVariableTest(String data) {
        // 在这里设置变量
        targetVariable = data;
        System.out.println("执行第一次迭代，设置变量为：" + data);
    }

    // 依赖测试，会使用上面设置的变量
    @Test(dependsOnMethods = "setupVariableTest")
    public void dependentTest() {
        System.out.println("依赖测试获取到的变量：" + targetVariable);
    }

    // 模拟30次迭代的DataProvider
    @DataProvider(name = "setupData")
    public Object[][] provideData() {
        Object[][] data = new Object[30][1];
        for (int i = 0; i < 30; i++) {
            data[i][0] = "测试数据" + (i + 1);
        }
        return data;
    }
}

优化：用自定义注解替代硬编码方法名 #

如果需要给多个方法添加这个功能，可以定义一个自定义注解，让Listener更通用：

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

@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RunOnlyFirstIteration {}

然后修改Listener的判断逻辑：

@Override
public void onTestStart(ITestResult result) {
    // 检查方法是否标记了自定义注解
    if (result.getMethod().getConstructorOrMethod().getMethod().isAnnotationPresent(RunOnlyFirstIteration.class)) {
        if (hasExecutedFirst.get()) {
            result.setStatus(ITestResult.SKIP);
            throw new SkipException("仅执行第一次迭代，后续迭代跳过");
        } else {
            hasExecutedFirst.set(true);
        }
    }
}

最后给测试方法添加注解：

@Test(dataProvider = "setupData")
@RunOnlyFirstIteration
public void setupVariableTest(String data) {
    // 设置变量逻辑
}

方法二：直接修改DataProvider返回第一个数据 #

如果这个DataProvider仅用于当前设置方法，最简单的方式就是让它只返回第一个迭代数据：

@DataProvider(name = "setupData")
public Object[][] provideData() {
    // 生成完整的30条数据
    Object[][] fullData = new Object[30][1];
    for (int i = 0; i < 30; i++) {
        fullData[i][0] = "测试数据" + (i + 1);
    }
    // 仅返回第一个数据
    return new Object[][] {fullData[0]};
}

这种方法不需要额外的Listener，但如果该DataProvider还要给其他测试方法使用，就不适用了。

方法三：使用IHookable接口拦截执行 #

TestNG的IHookable接口可以直接拦截测试方法的执行逻辑，实现类似的效果：

import org.testng.IHookCallBack;
import org.testng.IHookable;
import org.testng.ITestResult;

public class StopAfterFirstHook implements IHookable {
    private boolean hasExecutedFirst = false;

    @Override
    public void run(IHookCallBack callBack, ITestResult testResult) {
        if ("setupVariableTest".equals(testResult.getMethod().getMethodName())) {
            if (!hasExecutedFirst) {
                // 执行第一次迭代
                callBack.runTestMethod(testResult);
                hasExecutedFirst = true;
            } else {
                // 跳过后续迭代
                testResult.setStatus(ITestResult.SKIP);
            }
        } else {
            // 其他测试方法正常执行
            callBack.runTestMethod(testResult);
        }
    }
}

然后在测试类添加@Listeners(StopAfterFirstHook.class)即可。

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