| /* |
| * Copyright 2015-2022 the original author or authors. |
| * |
| * All rights reserved. This program and the accompanying materials are |
| * made available under the terms of the Eclipse Public License v2.0 which |
| * accompanies this distribution and is available at |
| * |
| * https://www.eclipse.org/legal/epl-v20.html |
| */ |
| |
| package example; |
| |
| // tag::user_guide[] |
| |
| import static example.util.StringUtils.isPalindrome; |
| import static org.junit.jupiter.api.Assertions.assertEquals; |
| import static org.junit.jupiter.api.Assertions.assertFalse; |
| import static org.junit.jupiter.api.Assertions.assertNotNull; |
| import static org.junit.jupiter.api.Assertions.assertTrue; |
| import static org.junit.jupiter.api.DynamicContainer.dynamicContainer; |
| import static org.junit.jupiter.api.DynamicTest.dynamicTest; |
| import static org.junit.jupiter.api.Named.named; |
| |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Random; |
| import java.util.function.Function; |
| import java.util.stream.IntStream; |
| import java.util.stream.Stream; |
| |
| import example.util.Calculator; |
| |
| import org.junit.jupiter.api.DynamicNode; |
| import org.junit.jupiter.api.DynamicTest; |
| import org.junit.jupiter.api.Named; |
| import org.junit.jupiter.api.Tag; |
| import org.junit.jupiter.api.TestFactory; |
| import org.junit.jupiter.api.function.ThrowingConsumer; |
| |
| // end::user_guide[] |
| // @formatter:off |
| // tag::user_guide[] |
| class DynamicTestsDemo { |
| |
| private final Calculator calculator = new Calculator(); |
| |
| // end::user_guide[] |
| @Tag("exclude") |
| // tag::user_guide[] |
| // This will result in a JUnitException! |
| @TestFactory |
| List<String> dynamicTestsWithInvalidReturnType() { |
| return Arrays.asList("Hello"); |
| } |
| |
| @TestFactory |
| Collection<DynamicTest> dynamicTestsFromCollection() { |
| return Arrays.asList( |
| dynamicTest("1st dynamic test", () -> assertTrue(isPalindrome("madam"))), |
| dynamicTest("2nd dynamic test", () -> assertEquals(4, calculator.multiply(2, 2))) |
| ); |
| } |
| |
| @TestFactory |
| Iterable<DynamicTest> dynamicTestsFromIterable() { |
| return Arrays.asList( |
| dynamicTest("3rd dynamic test", () -> assertTrue(isPalindrome("madam"))), |
| dynamicTest("4th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2))) |
| ); |
| } |
| |
| @TestFactory |
| Iterator<DynamicTest> dynamicTestsFromIterator() { |
| return Arrays.asList( |
| dynamicTest("5th dynamic test", () -> assertTrue(isPalindrome("madam"))), |
| dynamicTest("6th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2))) |
| ).iterator(); |
| } |
| |
| @TestFactory |
| DynamicTest[] dynamicTestsFromArray() { |
| return new DynamicTest[] { |
| dynamicTest("7th dynamic test", () -> assertTrue(isPalindrome("madam"))), |
| dynamicTest("8th dynamic test", () -> assertEquals(4, calculator.multiply(2, 2))) |
| }; |
| } |
| |
| @TestFactory |
| Stream<DynamicTest> dynamicTestsFromStream() { |
| return Stream.of("racecar", "radar", "mom", "dad") |
| .map(text -> dynamicTest(text, () -> assertTrue(isPalindrome(text)))); |
| } |
| |
| @TestFactory |
| Stream<DynamicTest> dynamicTestsFromIntStream() { |
| // Generates tests for the first 10 even integers. |
| return IntStream.iterate(0, n -> n + 2).limit(10) |
| .mapToObj(n -> dynamicTest("test" + n, () -> assertTrue(n % 2 == 0))); |
| } |
| |
| @TestFactory |
| Stream<DynamicTest> generateRandomNumberOfTestsFromIterator() { |
| |
| // Generates random positive integers between 0 and 100 until |
| // a number evenly divisible by 7 is encountered. |
| Iterator<Integer> inputGenerator = new Iterator<Integer>() { |
| |
| Random random = new Random(); |
| // end::user_guide[] |
| { |
| // Use fixed seed to always produce the same number of tests for execution on the CI server |
| random = new Random(23); |
| } |
| // tag::user_guide[] |
| int current; |
| |
| @Override |
| public boolean hasNext() { |
| current = random.nextInt(100); |
| return current % 7 != 0; |
| } |
| |
| @Override |
| public Integer next() { |
| return current; |
| } |
| }; |
| |
| // Generates display names like: input:5, input:37, input:85, etc. |
| Function<Integer, String> displayNameGenerator = (input) -> "input:" + input; |
| |
| // Executes tests based on the current input value. |
| ThrowingConsumer<Integer> testExecutor = (input) -> assertTrue(input % 7 != 0); |
| |
| // Returns a stream of dynamic tests. |
| return DynamicTest.stream(inputGenerator, displayNameGenerator, testExecutor); |
| } |
| |
| @TestFactory |
| Stream<DynamicTest> dynamicTestsFromStreamFactoryMethod() { |
| // Stream of palindromes to check |
| Stream<String> inputStream = Stream.of("racecar", "radar", "mom", "dad"); |
| |
| // Generates display names like: racecar is a palindrome |
| Function<String, String> displayNameGenerator = text -> text + " is a palindrome"; |
| |
| // Executes tests based on the current input value. |
| ThrowingConsumer<String> testExecutor = text -> assertTrue(isPalindrome(text)); |
| |
| // Returns a stream of dynamic tests. |
| return DynamicTest.stream(inputStream, displayNameGenerator, testExecutor); |
| } |
| |
| @TestFactory |
| Stream<DynamicTest> dynamicTestsFromStreamFactoryMethodWithNames() { |
| // Stream of palindromes to check |
| Stream<Named<String>> inputStream = Stream.of( |
| named("racecar is a palindrome", "racecar"), |
| named("radar is also a palindrome", "radar"), |
| named("mom also seems to be a palindrome", "mom"), |
| named("dad is yet another palindrome", "dad") |
| ); |
| |
| // Returns a stream of dynamic tests. |
| return DynamicTest.stream(inputStream, |
| text -> assertTrue(isPalindrome(text))); |
| } |
| |
| @TestFactory |
| Stream<DynamicNode> dynamicTestsWithContainers() { |
| return Stream.of("A", "B", "C") |
| .map(input -> dynamicContainer("Container " + input, Stream.of( |
| dynamicTest("not null", () -> assertNotNull(input)), |
| dynamicContainer("properties", Stream.of( |
| dynamicTest("length > 0", () -> assertTrue(input.length() > 0)), |
| dynamicTest("not empty", () -> assertFalse(input.isEmpty())) |
| )) |
| ))); |
| } |
| |
| @TestFactory |
| DynamicNode dynamicNodeSingleTest() { |
| return dynamicTest("'pop' is a palindrome", () -> assertTrue(isPalindrome("pop"))); |
| } |
| |
| @TestFactory |
| DynamicNode dynamicNodeSingleContainer() { |
| return dynamicContainer("palindromes", |
| Stream.of("racecar", "radar", "mom", "dad") |
| .map(text -> dynamicTest(text, () -> assertTrue(isPalindrome(text))) |
| )); |
| } |
| |
| } |
| // end::user_guide[] |