Beispiel: konditionale Testausführung

      public class ExternalSystemAvailabilityExtension
        implements ContainerExecutionCondition {

        @Override
        public ConditionEvaluationResult
          evaluate(TestExtensionContext ctx) {
          if (externalSystemAvailable())
            return enabled(“External system is available“);
          else
            return disabled(“External system isn‘t available!“)
        }
        // ...
      }
    

Beispiel: Anwendung einer Erweiterung

      @ExtendWith(ExternalSystemAvailabilityExtension.class)
      class HelloWorldTests {
        // ...
      }
    

      @ExtendWith(ExternalSystemAvailabilityExtension.class)
      public @interface ExternalSystemAvailable {}

      @ExternalSystemAvailable
      class ExternalTests {
        // ...
      }

    

JUnit 5 - Jupiter

      assertTrue(service.isEnabled(), "Expected to be true");

      assertEquals(expected, actual, () -> "Expected value didn't match");

      assertAll("Addresstests",
        () -> assertEquals("Nürnberg", addresse.getOrt()),
        () -> assertEquals("90425", addresse.getPlz())
      );

      Exception ex = assertThrows(Exception.class, service::invoke);

      assertTimeout(Duration.parse("PT0.500S"), service::invoke);
      assertTimeoutPreemptivly(
        Duration.parse("PT0.500S"), service::invoke);
    

JUnit 5 - Jupiter

      assumeTrue(service.isEnabled(), "Service should be enabled!");

      assumeFalse(service.isEnabled(), () -> "That didn‘t work!");

      assumingThat(service.isEnabled(), () -> { /* do something */ };
    

JUnit 5 - Jupiter

class TestWrapper {
  @BeforeEach
  void setup() { /* .... */ }

  @Nested
  class WrappedTest1 {
    @Test
    void test() { /* ... */ }
  }

  @Nested
  class WrappedTest2 {
    @Test
    void test() { /* ... */ }
  }
}

JUnit 5 - Jupiter

      @DisplayName("Eine Adresse sollte")
      class AddressTests {

        @Test
        @DisplayName("einen gültigen Ort besitzen")
        void shouldHaveValidCity() {
          assertNotNull(adresse.getOrt());
        }

        @Test
        @DisplayName("eine gültige Postleitzahl besitzen")
        void shouldHaveValidCity() {
          assertNotNull(adresse.getOrt());
        }
      }
    

JUnit 5 - Jupiter

      @RunWith(Parameterized.class)
      public class FibonacciTest {
        @Parameters public static Collection<Object[]> data() {
          return Arrays.asList(new Object[][] {
            {0,0},{1,1},{2,1},{3,2} })};

        private int input, expected;

        public FibonacciTest(int input, int expected) {
          this.input = input; this.expected = expected;
        }

        @Test
        public void test() {
          assertEquals(expected, Fibonacci.compute(input));
        }
      }
    

JUnit 5 - Jupiter

      class DynamicTests {

        @TestFactory
        List<DynamicTest> createSomeTests() {

          return Arrays.asList(
            DynamicTest.dynamicTest("First dynamically created test",
              () -> assertEquals(/* ... */)),

            DynamicTest.dynamicTest("Second dynamically created test",
              () -> assertEquals(/* ... */))
          );
        }
      }
    

JUnit 5 - Jupiter

      class ParameterizedTests {

        @ParameterizedTest
        @ValueSource(ints = {1,2,3,4,5})
        void valueSourceTest(int param){ /* ... */ }

        @ParameterizedTest
        @CsvFileSource(resources = "/file.csv")
        void csvSourceTest(String token1, String token2){ /* ... */ }

        @ParameterizedTest
        @MethodSource("paramMethod")
        void methodSourceTest(String param){ /* ... */ }

        static Iterable<String> paramMethod() { /* ... */ }
      }
    

JUnit 5 - Jupiter

• Repeatable Tests

      class RepeatableTests {

        @RepeatableTest(10)
        void repeatableTest(RepetitionInfo repetitionInfo) {
          /* ... */
        }
      }
    

JUnit 5 - Jupiter

      class DisabledTests {

        @Test
        @Disabled
        void breakingTest() {
          fail("This never works!");
        }

        @Test
        @DisabledOnWeekends
        void breaksOnWeekends() {
          fail("Meeh, it's weekend again!");
        }
      }
    

JUnit 5 - Jupiter

      import static org.junit.jupiter.api.extension.ConditionEvaluationResult.*;
      class DisabledOnWeekendsCondition implements TestExecutionCondition {

        @Override
        public ConditionEvaluationResult evaluate(TestExtensionContext context) {
          if (isWeekend())
            return disabled("Should not be run on weekends!");
          else
            return enabled("Should be run on weekdays!");
        }

        // ...
      }