Question

有没有办法参数化两个测试类（就像你可以在JUnit 4中使用Parameterized和@Parameters）和测试方法（就像你可以在JUnit 4中使用JUnitParams或使用{{ 1}}在JUnit 5）？我需要最终获得参数的笛卡尔积。

在TestNG中，我执行以下操作：

@ParameterizedTest

它产生：

public class ExampleTest {

    private final String classParameter;

    @Factory(dataProvider = "classParameters")
    public ExampleTest(String classParameter) {
        this.classParameter = classParameter;
    }

    @DataProvider
    public static Object[][] classParameters() {
        return new Object[][] {
                {"classParam1"},
                {"classParam2"},
        };
    }

    @Test(dataProvider = "testParameters")
    public void test(String testParameter) {
        System.out.println(classParameter + " " + testParameter);
    }

    @DataProvider
    public static Object[][] testParameters() {
        return new Object[][] {
                {"testParam1"},
                {"testParam2"},
        };
    }

}

我们正考虑从TestNG迁移到JUnit 5，但我们经常使用这种东西。一个值得注意的例子是测试各种二进制数据处理器，其中测试构造函数将采用字节/位顺序参数，并且我们为Big Endian和Little Endian运行每个测试。

我正在考虑为此创建扩展程序，然后使用classParam1 testParam1 classParam1 testParam2 classParam2 testParam1 classParam2 testParam2，但是可能存在现有的扩展程序或者我已经错过的开箱即用的东西？

Answer 1

您可以合并多个来源，例如@MethodSource。根据您的TestNG示例：

class ExampleTest {

    @ParameterizedTest
    @MethodSource("args")
    void test(String classParameter, String testParameter) {
        System.out.println(classParameter + " " + testParameter);
    }

    static Stream<Arguments> args() {
        return classParameters().flatMap(
                classParameter -> testParameters().map(
                        testParameter -> Arguments.of(classParameter, testParameter)));
    }

    static Stream<String> classParameters() {
        return Stream.of("classParam1", "classParam2");
    }

    static Stream<String> testParameters() {
        return Stream.of("testParam1", "testParam2");
    }

}

这将产生：

classParam1 testParam1
classParam1 testParam2
classParam2 testParam1
classParam2 testParam2

编辑：“ OP asked”示例“具有至少两个具有不同参数集的测试方法的示例”：

class ExampleTest {

    static Stream<String> classParams() {
        return Stream.of("classParam1", "classParam2", "classParam3");
    }

    static Stream<Arguments> withClassParams(List<?> methodParams) {
        return classParams().flatMap(
                classParam -> methodParams.stream().map(
                        methodParam -> Arguments.of(classParam, methodParam)));
    }

    @ParameterizedTest
    @MethodSource
    void booleanParams(String classParam, boolean booleanParam) {
        System.out.println(classParam + " " + booleanParam);
    }

    static Stream<Arguments> booleanParams() {
        return withClassParams(List.of(false, true));
    }

    @ParameterizedTest
    @MethodSource
    void integerParams(String classParam, int integerParam) {
        System.out.println(classParam + " " + integerParam);
    }

    static Stream<Arguments> integerParams() {
        return withClassParams(List.of(1, 2, 3, 4, 5, 6));
    }

    @ParameterizedTest
    @MethodSource
    void objectParams(String classParam, Object objectParam) {
        System.out.println(classParam + " " + objectParam);
    }

    static Stream<Arguments> objectParams() {
        return withClassParams(List.of(new Object()));
    }

}

3个类参数以及3个具有不同类型和大小的不同方法参数，产生以下输出：

classParam1 java.lang.Object@35cabb2a
classParam2 java.lang.Object@35cabb2a
classParam3 java.lang.Object@35cabb2a
classParam1 1
classParam1 2
classParam1 3
classParam1 4
classParam1 5
classParam1 6
classParam2 1
classParam2 2
classParam2 3
classParam2 4
classParam2 5
classParam2 6
classParam3 1
classParam3 2
classParam3 3
classParam3 4
classParam3 5
classParam3 6
classParam1 false
classParam1 true
classParam2 false
classParam2 true
classParam3 false
classParam3 true

在JUnit 5中参数化类和测试

1 个答案: