动态测试

注解中描述的JUnit Jupiter中的标准@Test注解与JUnit 4中的@Test注解非常相似。两者都描述了实现测试用例的方法。这些测试用例是静态的，因为它们是在编译时完全指定的，而且它们的行为不能由运行时发生的任何事情来改变。Assumption提供了一种基本的动态行为形式，但是刻意在表达方面受到限制。

除了这些标准测试外，JUnit Jupiter还引入了一种全新的测试编程模型。这种新的测试是动态测试，它是由@TestFactory注解的工厂方法在运行时生成的。

与@Test方法相比，@TestFactory方法本身不是测试用例，而是测试用例的工厂。因此，动态测试是工厂的产物。从技术上讲，@TestFactory方法必须返回DynamicNode实例的Stream，Collection，Iterable或Iterator。 DynamicNode的可实例化的子类是DynamicContainer和DynamicTest。 DynamicContainer实例由一个显示名称和一个动态子节点列表组成，可以创建任意嵌套的动态节点层次结构。然后，DynamicTest实例将被延迟执行，从而实现测试用例的动态甚至非确定性生成。

任何由@TestFactory返回的Stream都要通过调用stream.close()来正确关闭，使得使用诸如Files.lines()之类的资源变得安全。

与@Test方法一样，@TestFactory方法不能是private或static，并且可以选择声明参数，以便通过ParameterResolvers解析。

DynamicTest是运行时生成的测试用例。它由显示名称和Executable组成。 Executable是@FunctionalInterface，这意味着动态测试的实现可以作为lambda表达式或方法引用来提供。

动态生命周期

动态测试的执行生命周期与标准的@Test情况完全不同。具体而言，个别动态测试没有生命周期回调。这意味着@BeforeEach和@AfterEach方法及其相应的扩展回调函数是为@TestFactory方法执行，而不是对每个动态测试执行。换句话说，如果您从一个lambda表达式的测试实例中访问动态测试的字段，这些字段将不会由同一个@TestFactory方法生成的各个动态测试之间的回调方法或扩展重置。

从JUnit Jupiter 5.0.2开始，动态测试必须始终由工厂方法创建; 不过，在稍后的发行版中，这可以通过注册设施来补充。

动态测试目前是实验性功能。有关详细信息，请参阅实验性API中的表格。

动态测试示例

下面的DynamicTestsDemo类演示了测试工厂和动态测试的几个示例。

第一种方法返回无效的返回类型。由于在编译时无法检测到无效的返回类型，因此在运行时检测并抛出JUnitException异常。

接下来的五个方法是非常简单的例子，演示了Collection，Iterable，Iterator或者DynamicTest实例的生成。这些例子中的大多数并不真正表现出动态行为，而只是在原则上展示了支持的返回类型。而dynamicTestsFromStream()和dynamicTestsFromIntStream()演示了如何为给定的一组字符串或一组输入数字生成动态测试是何等的简单。

下一个方法本质上是真正动态的。 generateRandomNumberOfTests()实现了一个生成随机数的Iterator，一个显示名称生成器和一个测试执行器，然后将这三者全部提供给DynamicTest.stream()。尽管generateRandomNumberOfTests()的非确定性行为理所当然的会与测试的可重复性相冲突，应谨慎使用，它可以演示动态测试的表现力和力量。

最后一个方法使用DynamicContainer生成动态测试的嵌套层次结构。

  1. import static org.junit.jupiter.api.Assertions.assertEquals;
  2. import static org.junit.jupiter.api.Assertions.assertFalse;
  3. import static org.junit.jupiter.api.Assertions.assertNotNull;
  4. import static org.junit.jupiter.api.Assertions.assertTrue;
  5. import static org.junit.jupiter.api.DynamicContainer.dynamicContainer;
  6. import static org.junit.jupiter.api.DynamicTest.dynamicTest;
  8. import java.util.Arrays;
  9. import java.util.Collection;
  10. import java.util.Iterator;
  11. import java.util.List;
  12. import java.util.Random;
  13. import java.util.function.Function;
  14. import java.util.stream.IntStream;
  15. import java.util.stream.Stream;
  17. import org.junit.jupiter.api.DynamicNode;
  18. import org.junit.jupiter.api.DynamicTest;
  19. import org.junit.jupiter.api.Tag;
  20. import org.junit.jupiter.api.TestFactory;
  21. import org.junit.jupiter.api.function.ThrowingConsumer;
  23. class DynamicTestsDemo {
  25.     // This will result in a JUnitException!
  26.     @TestFactory
  27.     List<String> dynamicTestsWithInvalidReturnType() {
  28.         return Arrays.asList("Hello");
  29.     }
  31.     @TestFactory
  32.     Collection<DynamicTest> dynamicTestsFromCollection() {
  33.         return Arrays.asList(
  34.             dynamicTest("1st dynamic test", () -> assertTrue(true)),
  35.             dynamicTest("2nd dynamic test", () -> assertEquals(4, 2 * 2))
  36.         );
  37.     }
  39.     @TestFactory
  40.     Iterable<DynamicTest> dynamicTestsFromIterable() {
  41.         return Arrays.asList(
  42.             dynamicTest("3rd dynamic test", () -> assertTrue(true)),
  43.             dynamicTest("4th dynamic test", () -> assertEquals(4, 2 * 2))
  44.         );
  45.     }
  47.     @TestFactory
  48.     Iterator<DynamicTest> dynamicTestsFromIterator() {
  49.         return Arrays.asList(
  50.             dynamicTest("5th dynamic test", () -> assertTrue(true)),
  51.             dynamicTest("6th dynamic test", () -> assertEquals(4, 2 * 2))
  52.         ).iterator();
  53.     }
  55.     @TestFactory
  56.     Stream<DynamicTest> dynamicTestsFromStream() {
  57.         return Stream.of("A", "B", "C")
  58.             .map(str -> dynamicTest("test" + str, () -> { /* ... */ }));
  59.     }
  61.     @TestFactory
  62.     Stream<DynamicTest> dynamicTestsFromIntStream() {
  63.         // Generates tests for the first 10 even integers.
  64.         return IntStream.iterate(0, n -> n + 2).limit(10)
  65.             .mapToObj(n -> dynamicTest("test" + n, () -> assertTrue(n % 2 == 0)));
  66.     }
  68.     @TestFactory
  69.     Stream<DynamicTest> generateRandomNumberOfTests() {
  71.         // Generates random positive integers between 0 and 100 until
  72.         // a number evenly divisible by 7 is encountered.
  73.         Iterator<Integer> inputGenerator = new Iterator<Integer>() {
  75.             Random random = new Random();
  76.             int current;
  78.             @Override
  79.             public boolean hasNext() {
  80.                 current = random.nextInt(100);
  81.                 return current % 7 != 0;
  82.             }
  84.             @Override
  85.             public Integer next() {
  86.                 return current;
  87.             }
  88.         };
  90.         // Generates display names like: input:5, input:37, input:85, etc.
  91.         Function<Integer, String> displayNameGenerator = (input) -> "input:" + input;
  93.         // Executes tests based on the current input value.
  94.         ThrowingConsumer<Integer> testExecutor = (input) -> assertTrue(input % 7 != 0);
  96.         // Returns a stream of dynamic tests.
  97.         return DynamicTest.stream(inputGenerator, displayNameGenerator, testExecutor);
  98.     }
  100.     @TestFactory
  101.     Stream<DynamicNode> dynamicTestsWithContainers() {
  102.         return Stream.of("A", "B", "C")
  103.             .map(input -> dynamicContainer("Container " + input, Stream.of(
  104.                 dynamicTest("not null", () -> assertNotNull(input)),
  105.                 dynamicContainer("properties", Stream.of(
  106.                     dynamicTest("length > 0", () -> assertTrue(input.length() > 0)),
  107.                     dynamicTest("not empty", () -> assertFalse(input.isEmpty()))
  108.                 ))
  109.             )));
  110.     }
  112. }