Question

我正在尝试为接口Foo编写参数化测试，该接口声明了方法getFooEventInt（int，int）。我编写了一个参数化测试，该测试适用于单个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），然后每次迭代使用提供的种子/ 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));
  }

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

2 个答案: