是否可以嵌套JUnit 5参数化测试？

Question

我试图为接口Foo编写一个参数化测试，它声明了一个方法getFooEventInt（int，int）。我编写了一个paramterized测试，适用于Foo（FooImpl对象）的单个实例。

public class FooTest {

    @ParameterizedTest
    @MethodSource("getFooEvenIntProvider")
    public void getFooEvenIntTest(int seed, int expectedResult) {
        Foo foo = new FooImpl();

        Assertions.assertEquals(expectedResult, foo.getFooEvenInt(seed));
    }

    private static Stream getFooEvenIntProvider() {
        return Stream.of(
            Arguments.of(-2,  0),
            Arguments.of(-1,  0),
            Arguments.of( 0,  2),
            Arguments.of( 1,  2),
        );
    }
}

但是，我希望能够针对提供的Foo实现实例列表调用getFooEvenIntTest（int，int），然后每次迭代使用seed / expectedResult值的提供列表。

我意识到我能做到这一点......

public class FooTest {

    @ParameterizedTest
    @MethodSource("getFooProvider")
    public void getFooImplEvenIntTest(Foo foo) {
        int[] expectedResult = {  0,  0, 2, 2 };
        int[] seed           = { -2, -1, 0, 1 };

        for(int i=0; i<seed.length; i++) {
            Assertions.assertEquals(expectedResult[i],
                                    foo.getFooEvenInt(seed[i]));
        }
     }

    private static Stream getFooProvider() {
        return Stream.of(
                Arguments.of(new FooImpl()),
                Arguments.of(new FooImpl2())
        );
    }
}

有任何想法吗？如果我搞清楚，我会发布，但我想我会检查这是否可行，或者是否有不同的方法。

Answer 1

BLUF：我会将蟋蟀解释为“即使你可以，你也不应该嵌套参数化测试”，在这种情况下，我运行下面概述的方法。

对于一个界面Foo ...

public interface Foo {
    public char getFirstChar(String strValue);
    public int  getNextEvenInt(int seed);
}

对Foo实现的参数化测试的“最佳”使用将是......

public class FooTest {

    @ParameterizedTest
    @MethodSource("getFooProvider")
    public void getFirstCharTest(Foo foo) {
        char[]   expectedResult = { 'a', 'b', 'c', 'd' };
        String[] seed           = { "alpha", "bravo", "charlie", "delta" };

        for(int i=0; i<seed.length; i++) {
            Assertions.assertEquals(expectedResult[i],
                                    foo.getFirstChar(seed[i]));
        }
    }

    @ParameterizedTest
    @MethodSource("getFooProvider")
    public void getNextEvenIntTest(Foo foo) {
        int[] expectedResult = {  0,  0, 2, 2 };
        int[] seed           = { -2, -1, 0, 1 };

        for(int i=0; i<seed.length; i++) {
            Assertions.assertEquals(expectedResult[i],
                                    foo.getFooEvenInt(seed[i]));
        }
    }

    private static Stream getFooProvider() {
        return Stream.of(
                Arguments.of(new FooImplOne()),
                Arguments.of(new FooImplTwo())
                // extend as need for implementations of Foo
        );
    }
}

虽然我不会在各种测试中看到每个值对的传递结果的“温暖模糊”，但它将实现我在接口级别进行测试的目标，我可以轻松扩展以验证/验证接口的实现。

Answer 2

我想你想到结合两个参数流。您可以通过创建两个参数列表的笛卡尔积来实现此目的。

我已经在https://github.com/joerg-pfruender/junit-goodies/blob/master/src/main/java/com/github/joergpfruender/junitgoodies/ParameterizedTestHelper.java上实现了这一点

public static Stream<Arguments> cartesian(Stream a, Stream b) {
  List argumentsA = (List) a.collect(Collectors.toList());
  List argumentsB = (List) b.collect(Collectors.toList());

  List<Arguments> result = new ArrayList();
  for (Object o : argumentsA) {
    Object[] objects = asArray(o);
    for (Object o1 : argumentsB) {
      Object[] objects1 = asArray(o1);
      Object[] arguments = ArrayUtils.addAll(objects, objects1);
      result.add(Arguments.of(arguments));
    }
  }
  return result.stream();
}

private static Object[] asArray(Object o) {
  Object[] objects;
  if (o instanceof Arguments) {
    objects = ((Arguments) o).get();
  } else {
    objects = new Object[]{o};
  }
  return objects;
}

然后你的测试代码将是：

  public static Stream<Arguments> fooIntsAndFooProvider() {
    return ParameterizedTestHelper.cartesian(getFooEvenIntProvider(), getFooProvider());
  }

  @ParameterizedTest
  @MethodSource("fooIntsAndFooProvider")
  public void getFooImplEvenIntTest(Integer seed, Integer expectedResult, Foo foo) {
        Assertions.assertEquals(expectedResult,
                                foo.getFooEvenInt(seed));
  }