JUnit 5

class JUnit5Test {

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

}

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

@BeforeEach
void beforeEach() { ... }

@AfterEach
void afterEach() { ... }

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

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

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

@Test
void someTest() {
	...
	assertEquals(
		expected,
		actual,
		"Should be equal.");
}

@Test
void someTest() {
	...
	assertEquals(
		expected,
		actual,
		() -> "Should " + "be " + "equal.");
}

@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)

void methodUnderTest() {
	throw new IllegalStateException();
}

@Test
void assertExceptions() {
	Exception ex = assertThrows(
		Exception.class,
		this::methodUnderTest);
	assertEquals("Msg", ex.getMessage());
}

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

@DisplayName("A count")
class CountTest {
	@Nested
	@DisplayName("when greater zero")
	class CountGreaterZero {
		@Test
		@DisplayName("is positive")
		void isPositive() { ... }
	}
}

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

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

void pointTest(Point p) { /*...*/ }

@TestFactory
Stream<DynamicText> testingPoints() {
	return Stream.of(
			/* create points */)
		.map(p ->
			dynamicTest(
				"Testing " + p,
				() -> pointTest(p)));
}

void pointTest(Point p) { /*...*/ }

@TestFactory
Stream<DynamicText> testingPoints() {
	List<Point> points = asList(
		/* create points */);
	return DynamicTest.stream(
		points,
		p -> "Testing " + p,
		p -> pointTest(p));
}

void pointTest(Point p) { /*...*/ }

@TestFactory
Stream<DynamicText> testingPoints() {
	return Files
		.lines(pathToPointFile)
		.map(Point::parse)
		.map(p -> dynamicTest(
			"Testing " + p,
			() -> pointTest(p)));
}

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 */
	});

}}

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

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

public interface BeforeEachCallback
		extends Extension {

	void beforeEach(
		TestExtensionContext context);
}

public class BenchmarkExtension implements
		BeforeTestExecutionCallback,
		AfterTestExecutionCallback {

	private long launchTime;

	// ...
}

@Override
public void beforeTestExecution(
		TestExtensionContext context) {
	launchTime = currentTimeMillis();
}

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

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

public class DisabledOnFridayCondition
		implements TestExecutionCondition {
	@Override
	public ConditionEval.Result evaluate(
			TestExtensionCtx. context) {
		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 supports(
			ParameterContext p, ...) {
		return MyServer.class
			== p.getParameter().getType();
	}
	@Override
	public Object resolve( ... ) {
		return new MyServer();
	}
}

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

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

// don't use System.out !
void publishReportEntry(
	Map<String, String> map);

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

// use the store to safe extension state
// (extensions should be stateless;
//  did I mention that?)
Store getStore();
Store getStore(Namespace namespace);

// forwards with a default namespace
Store getStore();
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 JUnit5Test {
	...
}

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

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

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

org.junit.jupiter
junit-jupiter-api
5.0.0-M3

# run all tests
junit-platform-console \
	-cp ${path_to_compiled_test_classes} \
	--scan-class-path
# run a specific test
junit-platform-console \
	-cp ${path_to_compiled_test_classes} \
	--select-class ${fully_qualified_test_class_name}