junit5 动态测试

JUnit @TestFactory annotation coupled with DynamicTest can be used to create a test factory method.

可以将JUnit @TestFactory批注与DynamicTest结合使用，以创建测试工厂方法。

JUnit动态测试 (JUnit Dynamic Tests)

JUnit @TestFactory methods must not be private or static. These methods must return a Stream, Collection, Iterable, or Iterator of DynamicNode instances.

JUnit @TestFactory方法不得为私有或静态。 这些方法必须返回DynamicNode实例的Stream ， Collection ，Iterable或Iterator 。

Any Stream returned by a @TestFactory will be properly closed by calling stream.close(), making it safe to use a resource such as Files.lines() as the initial source of the stream.

@TestFactory返回的任何Stream都可以通过调用stream.close()来正确关闭，从而可以安全地使用诸如Files.lines()类的资源作为流的初始源。

DynamicTest is one of the implementation of DynamicNode. Note that dynamic tests are different from @Test cases since callback methods such as @BeforeEach and @AfterEach are not executed for dynamic tests.

DynamicTest是DynamicNode的实现之一。 请注意，动态测试与@Test情况不同，因为动态测试不会执行@BeforeEach和@AfterEach之类的回调方法。

JUnit @TestFactory DynamicTest示例 (JUnit @TestFactory DynamicTest Example)

Let’s look at a simple example of using @TestFactory and DynamicTest to create test factory of dynamic tests.

让我们看一个使用@TestFactory和DynamicTest创建动态测试的测试工厂的简单示例。

package com.journaldev.dynamictests;import static org.junit.jupiter.api.Assertions.assertTrue;
import static org.junit.jupiter.api.DynamicTest.dynamicTest;import java.util.Arrays;
import java.util.Collection;import org.junit.jupiter.api.DynamicTest;
import org.junit.jupiter.api.TestFactory;
import org.junit.jupiter.api.function.Executable;public class JUnit5DynamicTests {@TestFactoryCollection<DynamicTest> dynamicTests() {return Arrays.asList(dynamicTest("simple dynamic test", () -> assertTrue(true)),dynamicTest("My Executable Class", new MyExecutable()),dynamicTest("Exception Executable", () -> {throw new Exception("Exception Example");}),dynamicTest("simple dynamic test-2", () -> assertTrue(true)));}}class MyExecutable implements Executable {@Overridepublic void execute() throws Throwable {System.out.println("Hello World!");}}

Below image shows the output of the JUnit test execution.

下图显示了JUnit测试执行的输出。

Above example is very simple one, let’s create Dynamic tests for a custom class method. Let’s say we have a utility class defined as:

上面的例子很简单，让我们为自定义类方法创建动态测试。 假设我们有一个定义为的实用程序类：

public class MyUtils {public static int add(int x, int y) {return x+y;}
}

Here is the test factory method for above function.

这是上述功能的测试工厂方法。

@TestFactory
Stream<DynamicTest> dynamicTestsExample() {List<Integer> input1List = Arrays.asList(1,2,3);List<Integer> input2List = Arrays.asList(10,20,30);List<DynamicTest> dynamicTests = new ArrayList<>();for(int i=0; i < input1List.size(); i++) {int x = input1List.get(i);int y = input2List.get(i);DynamicTest dynamicTest = dynamicTest("Dynamic Test for MyUtils.add("+x+","+y+")", () ->{assertEquals(x+y,MyUtils.add(x,y));});dynamicTests.add(dynamicTest);}return dynamicTests.stream();
}

Below image shows the execution output of above test method.

下图显示了上述测试方法的执行输出。

Notice that our add method is simple, so in assertEquals() we are using input variables to derive the expected output. If it’s a complex method, we can define a List for expected output and use that in the assertions. We can also define a custom Executable class if we want to have complex testing logic.

请注意，我们的add方法很简单，因此在assertEquals()我们使用输入变量来得出预期的输出。 如果这是一个复杂的方法，我们可以为预期的输出定义一个List并将其用于断言中。 如果我们想要复杂的测试逻辑，我们还可以定义一个自定义的Executable类。

摘要 (Summary)

JUnit 5 Dynamic tests functionality can be achieved by parameterized tests. Also, Parameterized tests follow the standard JUnit test lifecycle and @BeforeEach and @AfterEach methods are executed for them. Whereas dynamic tests lifecycle is totally different and they don’t have access to @BeforeEach and @AfterEach methods.

JUnit 5动态测试功能可以通过参数化测试来实现。 同样，参数化测试遵循标准的JUnit测试生命周期，并对其执行@BeforeEach和@AfterEach方法。 动态测试的生命周期完全不同，并且无法访问@BeforeEach和@AfterEach方法。

翻译自: https://www.journaldev.com/21715/junit-dynamic-tests-testfactory-dynamictest

junit5 动态测试