JUnit 5

class JUnit5Test {

    @Test
    void someTest() {
        assertTrue(true);
    }

}

@BeforeAll
static void beforeAll() { ... }

@BeforeEach
void beforeEach() { ... }

@AfterEach
void afterEach() { ... }

@AfterAll
static void afterAll() { ... }

@Test
void assertAllProperties() {
    Address ad = new Address("City", "Street", "42");

    assertAll("address",
      () -> assertEquals("C", ad.city),
      () -> assertEquals("Str", ad.street),
      () -> assertEquals("63", ad.number)
    );
}

org.opentest4j.MultipleFailuresError:
	address (3 failures)
	expected: <C> but was: <City>
	expected: <Str> but was: <Street>
	expected: <63> but was: (42)

@Test
@Disabled("Y U No Pass?!")
void failingTest() {
    assertTrue(false);
}

@Test
@EnabledOnOs(OS.LINUX)
void runsOnLinux() {
    assertTrue(IS_FREE_SOFTWARE);
}

@Test
@DisabledOnFriday
void failingTest() {
    assertTrue(false);
}

@DisplayName("A stack")
class StackTest {

    @Test
    @DisplayName("when new, is empty")
    void isEmpty() { /*...*/ }

    @Test
    @DisplayName("when new and popped, "
            + "throws EmptyStackException")
    void throwsExceptionWhenPopped() { /*...*/ }

}

class CountTest {
    // lifecycle and tests
    @Nested
    class CountGreaterZero {
        // lifecycle and tests
        @Nested
        class CountMuchGreaterZero {
            // lifecycle and tests
        }
    }
}

@Test
void someTest(MyServer server) {
    // do something with `server`
}

@ParameterizedTest
@MethodSource("createWords")
void testWordLengths(String word, int length) {
    assertEquals(length, word.length());
}

static Stream<Arguments> createWords() {
    return Stream.of(
        Arguments.of("Hello", 5),
        Arguments.of("Parameterized", 13));
}

@Test
@Execution(CONCURRENT)
class {

    // [...]

}

org.junit.jupiter
junit-jupiter-api
5.5.2

org.junit.jupiter
junit-jupiter-engine
5.5.2

# run all tests
java -jar junit-platform-console-standalone.jar
    --class-path ${path_to_compiled_test_classes}
    --scan-class-path
# run a specific test
java -jar junit-platform-console-standalone.jar
    --class-path ${path_to_compiled_test_classes}
    --select-class ${fully_qualified_test_class_name}

@Test
@EnabledOnOs(OS.LINUX)
void runsOnLinux() { /*...*/ }

@EnabledOnOs(LINUX)
@EnabledOnOs({ WINDOWS, MAC })
@DisabledOnOs(LINUX)
@DisabledOnOs({ WINDOWS, MAC })

@EnabledOnJre(JAVA_8)
@EnabledOnJre({ JAVA_9, JAVA_10 })
@DisabledOnJre(JAVA_8)
@DisabledOnJre({ JAVA_9, JAVA_10 })

@EnabledIfSystemProperty(
    named = "os.arch", matches = ".*64.*")
@DisabledIfSystemProperty(
    named = "ci-server", matches = "true")

@EnabledIfEnvironmentVariable(
    named = "ENV", matches = "staging-server")
@DisabledIfEnvironmentVariable(
    named = "ENV", matches = ".*development.*")

@Test
@EnabledIf({
    "load('nashorn:mozilla_compat.js')",
    "importPackage(java.time)",
    "var today = LocalDate.now()",
    "var tomorrow = today.plusDays(1)",
    "tomorrow.isAfter(today)" })
void theDayAfterTomorrow() { /*...*/ }

@Test
@EnabledIf(
    value = /*...*/,
    engine = /*...*/ )
void theDayAfterTomorrow() { /*...*/ }

@Test
@EnabledOnOs(OS.LINUX)
@DisabledOnJre(JRE.JAVA_10)
void moreConditions() { /*...*/ }

junit.jupiter.conditions.deactivate=*

@Tag("unit")
class UserTest { }

@Tag("db")
class UserRepositoryTest { }

@Tag("integration")
class UserServiceTest { }

<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <version>2.22.0</version>
    <configuration>
        <groups>unit</groups>
        <!-- <excludedGroups>db</excludedGroups> -->
    </configuration>
</plugin>

test {
    useJUnitPlatform {
        includeTags 'unit'
        // excludeTags 'db'
    }
}

@Test
@ExtendWith(TempDirectory.class)
void test(@TempDir Path tempDir) { /*...*/ }

// just to demo - irl use @SpringJUnitConfig
@ExtendWith(SpringExtension.class)
public class ApiControllerTest {
    private final ApiController controller;

    public ApiControllerTest(
            @Autowired ApiController controller) {
        this.controller = controller;
    }

    @Test
    public testController() { /*...*/ }
}

@TestInstance(Lifecycle.PER_CLASS)
class ClassTestInstanceTest {
    private static int CLASS_TEST_COUNT = 0;
    private int instanceTestCount = 0;

    @Test void test_1() { incAndCheckCounts(); }
    @Test void test_2() { incAndCheckCounts(); }

    private void incAndCheckCounts() {
        CLASS_TEST_COUNT++;
        instanceTestCount++;
        // fails with instance per test
        assertEquals(
            CLASS_TEST_COUNT, instanceTestCount);
    }
}

junit.jupiter.testinstance.lifecycle.default=per_class

junit.jupiter.conditions.deactivate = *

<plugin>
    <artifactId>maven-surefire-plugin</artifactId>
    <configuration>
        <properties>
            <configurationParameters>
                junit.jupiter.conditions.deactivate=*
            </configurationParameters>
        </properties>
    </configuration>
    <dependencies>
        ...
    </dependencies>
</plugin>

test {
    useJUnitPlatform()
    systemProperties = [
        'junit.jupiter.conditions.deactivate': '*'
    ]
}

-Djunit.jupiter.conditions.deactivate=*

junit.jupiter.conditions.deactivate=*

class StackTest {

    @Nested
    class WhenNew {

        @Nested
        class AfterPushing {

            @Nested
            class AfterPopping { }

        }
    }
}

class StackTest {
    Stack<Object> stack;

    @Nested
    class WhenNew {

        @BeforeEach
        void createNewStack() {
            stack = new Stack<>();
        }

        // continued

    }
}

class StackTest {
    @Nested
    class WhenNew {
        @Nested
        class AfterPushing {

            @BeforeEach
            void pushAnElement() {
                stack.push("element");
            }

        }
    }
}

// in StackTest.WhenNew
//     ⇝ called first
@BeforeEach
void createNewStack() {
    stack = new Stack<>();
}

// in StackTest.WhenNew.AfterPushing
//     ⇝ called second
@BeforeEach
void pushAnElement() {
    stack.push(anElement);
}

@DisplayName("A stack")
class StackTest {

    @Nested @DisplayName("when new")
    class WhenNew {

        @Test @DisplayName("is empty")
        void isEmpty() { /* ... */ }

        @Nested
        @DisplayName("after pushing an element")
        class AfterPushing { /*...*/ }

    }
}

class RepeatedInvocationTest {
    private static int REPS = 0;

    @RepeatedTest(5)
    void repeated(RepetitionInfo reps) {
        REPS++;
        // getCurrentRepetition starts with 1
        assertEquals(REPS, reps.getCurrentRepetition());
        assertEquals(5, reps.getTotalRepetitions());
    }

}

class RepeatedInvocationTest {

    @DisplayName("Calling repeated...")
    @RepeatedTest(value = 5,
        name = "... {currentRepetition}th"
            "of {totalRepetitions} times")
    void repeated(RepetitionInfo reps) { /*...*/ }

}

org.junit.jupiter
junit-jupiter-params
5.5.2

@ParameterizedTest
@ValueSource(strings = { " Hello", "JUnit" })
void testValues(String word) { /*...*/ }

@ParameterizedTest
@EnumSource(TimeUnit.class)
void testAllEnumValues(TimeUnit unit) { /*...*/ }

@ParameterizedTest
@EnumSource(
    value = TimeUnit.class,
    names = {"NANOSECONDS", "MICROSECONDS"})
void testSomeEnumValues(TimeUnit unit) { /*...*/ }

@ParameterizedTest
@MethodSource("createWords")
void testWords(String word) { /*...*/ }

static Stream<String> createWords() {
    return Stream.of("Hello", "JUnit");
}

@ParameterizedTest
@MethodSource("createWords")
void testWordLengths(String word, int length) {
    /*...*/
}

static Stream<Arguments> createWords() {
    return Stream.of(
        Arguments.of("Hello", 5),
        Arguments.of("Parameterized", 13));
}

@ParameterizedTest
@CsvSource({ "(0/0), 0", "(0/1), 1" })
void testPointNorm(
    String point, double norm) { /*...*/ }

@ParameterizedTest
@CsvFileSource(resources = "/point-norms.csv")
void testPointNorm(
    String point, double norm) { /*...*/ }

class RandomIntegerProvider
        implements ArgumentsProvider {

    @Override
    public Stream<Arguments> arguments( /*...*/ ) {
        return new Random().ints(0, 10)
            .mapToObj(Arguments::of)
            .limit(3);
    }

}

@ParameterizedTest
@ArgumentsSource(RandomIntegerProvider.class)
void testRandomIntegers(Integer argument) { /*...*/ }

@ParameterizedTest
@CsvSource({ "(0/0), 0", "(0/1), 1" })
void testPointNorm(
    Point point, double norm) { /*...*/ }

class Point {

    /** Creates a point from an '(x/y)' string */
    static Point from(String xy) { /*...*/ }

}

class PointConverter
        implements ArgumentConverter {

    @Override
    public Object convert(
            Object input, /*...*/ )
            throws ArgumentConversionException {
        if (input instanceof String)
            return Point.from((String) input);
        throw new ArgumentConversionException(
            input + " is no valid point");
    }

}

@ParameterizedTest
@CsvSource({ "(0/0), 0", "(0/1), 1" })
void testPointNorm(
    @ConvertWith(PointConverter.class)
    Point point,
    double norm) { /*...*/ }

@ParameterizedTest
@CsvSource({ "0, 0, 0", "1.414, 1, 1" })
void testPointNorm(
        double norm, ArgumentsAccessor args) {
    Point point = Point.from(
        args.getDouble(1), args.getDouble(2));
    assertEquals(norm, point.norm(), 0.01);
}

class PointAggregator
        implements ArgumentsAggregator {

    @Override
    public Object aggregateArguments(
            ArgumentsAccessor args, /*...*/ )
            throws ArgumentsAggregationException {
        return Point.from(
            args.getDouble(1), args.getDouble(2));
    }

}

@ParameterizedTest
@CsvSource({ "0, 0, 0", "1.414, 1, 1" })
void testPointNorm(
        double norm,
        @AggregateWith(PointAggregator.class)
        Point point) {
    assertEquals(norm, point.norm(), 0.01);
}

@DisplayName("Roman numeral")
@ParameterizedTest(name = "\"{0}\" should be {1}")
@CsvSource({ "I, 1", "II, 2", "V, 5" })
void numeral(String word, int number) { /*...*/ }

    @Test
    @ResourceLock(value = "props", mode = READ)
    void customPropertyIsNotSetByDefault() {
        assertNull(System.getProperty("my.prop"));
    }

    @Test
    @ResourceLock(value = "props", mode = READ_WRITE)
    void canSetCustomPropertyToApple() {
        System.setProperty("my.prop", "apple");
        assertEquals(
            "apple",
            System.getProperty("my.prop"));
    }

@TestFactory
List<DynamicTest> createPointTests() {
    return List.of(
        dynamicTest(
            "A Great Test For Point",
            () -> { /* test code */ } ),
        dynamicTest(
            "Another Great Test For Point",
            () -> { /* test code */ } )
    );
}

    @TestFactory
    List<DynamicContainer> registeredTests() {
        return asList(
            dynamicContainer(
                "Dynamic Container #1",
                asList( /* dynamic tests */ )),
            dynamicContainer(
                "Dynamic Container #2",
                asList( /* dynamic tests */ ))
        );
    }
}

class PointTest {

    "A great test for point" -> {
        /* test code */
    }

}

public class LambdaTest {

    private List<DynamicTest> tests;

    protected void λ(
            String name, Executable test) {
        tests.add(dynamicTest(name, test));
    }

    @TestFactory
    List<DynamicTest> tests() {
        return tests;
    }
}

class PointTest extends LambdaTest {{

    λ("A Great Test For Point", () -> {
        /* test code goes here */
    });

}}

class PointTest extends LambdaTest {{

    λ(a_great_test_for_point -> {
        /* test code goes here */
    });

}}

@EnableRuleMigrationSupport
class JUnit4RuleInJupiterTest {

    @Rule
    public ExpectedException thrown =
        ExpectedException.none();

    @Test
    void useExpectedExceptionRule() {
        List<Object> list = List.of();
        thrown.expect(
            IndexOutOfBoundsException.class);
        list.get(0);
    }
}

@ExtendWith(MockitoExtension.class)
class MockitoTest {

    @InjectMocks private Circle circle;
    @Mock private Point center;

    @Test
    void shouldInjectMocks() {
        assertNotNull(center);
        assertNotNull(circle);
        assertSame(center, circle.center());
    }
}

package org.junitpioneer.vintage;
public @interface Test {
    Class<? extends Throwable> expected()
        default None.class;
    long timeout() default 0L;
}

@RunWith(MockitoJUnitRunner.class)
public class MyTest { ... }

public class MyTest {
    @Rule
    public MockitoRule rule =
        MockitoJUnit.rule();
}

public interface BeforeEachCallback
        extends Extension {

    void beforeEach(ExtensionContext context);
}

public class BenchmarkExtension implements
        BeforeTestExecutionCallback,
        AfterTestExecutionCallback {

    private long launchTime;

    // ...
}

@Override
public void beforeTestExecution( /*...*/ ) {
    launchTime = currentTimeMillis();
}

@Override
public void afterTestExecution( /*...*/ ) {
    printf("Test '%s' took %d ms.%n",
        context.getDisplayName(),
        currentTimeMillis() - launchTime);
}

@Test
@DisabledOnFriday
void failingTest() {
    assertTrue(false);
}

public class DisabledOnFridayCondition
        implements ExecutionCondition {

    @Override
    public ConditionEvaluationResult evaluate( /*...*/ ) {
        if (isFriday())
            return disabled("Weekend!");
        else
            return enabled("Fix it!");
    }

}

@Test
void someTest(MyServer server) {
    // do something with `server`
}

public class MyServerParameterResolver
        implements ParameterResolver {

    @Override
    public boolean supportsParameter(
            ParameterContext pCtx, /*...*/) {
        return MyServer.class
            == pCtx.getParameter().getType();
    }

    @Override
    public Object resolveParameter(
            ParameterContext pCtx, /*...*/) {
        return new MyServer();
    }

}

// every node has its own context
Optional<ExtensionContext> getParent();
ExtensionContext getRoot();

// some node-related info
String getUniqueId();
String getDisplayName();
Set<String> getTags();

// don't use System.out!
void publishReportEntry(String key, String value);

// configure your extension with system properties
Optional<String> getConfigurationParameter(String key)

// to reflect over the test class/method
Optional<AnnotatedElement> getElement();
Optional<Class<?>> getTestClass();
Optional<Method> getTestMethod();
Optional<Lifecycle> getTestInstanceLifecycle();

// use the store for extension state
Store getStore(Namespace namespace);

Store getStore(Namespace namespace);

Object getObject(Object key);
Object getOrComputeIfAbsent(
        K key, Function creator);

void put(Object key, Object value)

Object remove(Object key)

void storeNowAsLaunchTime(
        ExtensionContext context) {
    long now = currentTimeMillis();
    context.getStore(NAMESPACE)
            .put(KEY, now);
}

long loadLaunchTime(
        ExtensionContext context) {
    return context.getStore(NAMESPACE)
            .get(KEY, long.class);
}

@ExtendWith(DisabledOnFridayCondition.class)
class SomeTest {
    ...
}

@ExtendWith(DisabledOnFridayCondition.class)
public @interface DisabledOnFriday { }

@Test
@Tag("integration")
@ExtendWith(BenchmarkExtension.class)
@ExtendWith(MyServerParameterResolver.class)
public @interface IntegrationTest { }

@IntegrationTest
@DisabledOnFriday
void testLogin(MyServer server) { ... }

@DisabledByFormula(
    "After Mayan b'ak'tun 13",
    // Nope 😩
    now().isAfter(MAYAN_B_AK_TUN_13))
class DisabledByFormulaTest {

    private static final LocalDateTime
        MAYAN_B_AK_TUN_13 = of(2012, 12, 21, 0, 0);
}

class DisabledByFormulaTest {

    private static final LocalDateTime
        MAYAN_B_AK_TUN_13 = of(2012, 12, 21, 0, 0);

    @RegisterExtension
    static DisabledByFormula FORMULA = disabledWhen(
            "After Mayan b'ak'tun 13",
            now().isAfter(MAYAN_B_AK_TUN_13));
}