JUnit Platform Launcher API

import static org.junit.platform.engine.discovery.ClassNameFilter.includeClassNamePatterns;
import static org.junit.platform.engine.discovery.DiscoverySelectors.selectClass;
import static org.junit.platform.engine.discovery.DiscoverySelectors.selectPackage;
import static org.junit.platform.launcher.core.LauncherDiscoveryRequestBuilder.discoveryRequest;

import org.junit.platform.launcher.LauncherDiscoveryRequest;
import org.junit.platform.launcher.LauncherSession;
import org.junit.platform.launcher.TestPlan;
import org.junit.platform.launcher.core.LauncherFactory;

LauncherDiscoveryRequest discoveryRequest = discoveryRequest()
	.selectors(
		selectPackage("com.example.mytests"),
		selectClass(MyTestClass.class)
	)
	.filters(
		includeClassNamePatterns(".*Tests")
	)
	.build();

try (LauncherSession session = LauncherFactory.openSession()) {
	TestPlan testPlan = session.getLauncher().discover(discoveryRequest);

	// ... discover additional test plans or execute tests
}

LauncherDiscoveryRequest discoveryRequest = LauncherDiscoveryRequestBuilder.request()
	.selectors(
		selectPackage("com.example.mytests"),
		selectClass(MyTestClass.class)
	)
	.filters(
		includeClassNamePatterns(".*Tests")
	)
	.build();

SummaryGeneratingListener listener = new SummaryGeneratingListener();

try (LauncherSession session = LauncherFactory.openSession()) {
	Launcher launcher = session.getLauncher();
	// Register one ore more listeners of your choice.
	launcher.registerTestExecutionListeners(listener);
	// Discover tests and build a test plan.
	TestPlan testPlan = launcher.discover(discoveryRequest);
	// Execute the test plan.
	launcher.execute(testPlan);
	// Alternatively, execute the discovery request directly.
	launcher.execute(discoveryRequest);
}

TestExecutionSummary summary = listener.getSummary();
// Do something with the summary...

import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.URI;
import java.net.URL;
import java.net.URLClassLoader;

import org.junit.platform.launcher.LauncherInterceptor;

public class CustomLauncherInterceptor implements LauncherInterceptor {

	private final URLClassLoader customClassLoader;

	public CustomLauncherInterceptor() throws Exception {
		ClassLoader parent = Thread.currentThread().getContextClassLoader();
		customClassLoader = new URLClassLoader(new URL[] { URI.create("some.jar").toURL() }, parent);
	}

	@Override
	public <T> T intercept(Invocation<T> invocation) {
		Thread currentThread = Thread.currentThread();
		ClassLoader originalClassLoader = currentThread.getContextClassLoader();
		currentThread.setContextClassLoader(customClassLoader);
		try {
			return invocation.proceed();
		}
		finally {
			currentThread.setContextClassLoader(originalClassLoader);
		}
	}

	@Override
	public void close() {
		try {
			customClassLoader.close();
		}
		catch (IOException e) {
			throw new UncheckedIOException("Failed to close custom class loader", e);
		}
	}
}

LauncherConfig launcherConfig = LauncherConfig.builder()
	.enableTestEngineAutoRegistration(false)
	.enableLauncherSessionListenerAutoRegistration(false)
	.enableLauncherDiscoveryListenerAutoRegistration(false)
	.enablePostDiscoveryFilterAutoRegistration(false)
	.enableTestExecutionListenerAutoRegistration(false)
	.addTestEngines(new CustomTestEngine())
	.addLauncherSessionListeners(new CustomLauncherSessionListener())
	.addLauncherDiscoveryListeners(new CustomLauncherDiscoveryListener())
	.addPostDiscoveryFilters(new CustomPostDiscoveryFilter())
	.addTestExecutionListeners(new LegacyXmlReportGeneratingListener(reportsDir, out))
	.addTestExecutionListeners(new CustomTestExecutionListener())
	.build();

LauncherDiscoveryRequest discoveryRequest = LauncherDiscoveryRequestBuilder.request()
	.selectors(selectPackage("com.example.mytests"))
	.build();

try (LauncherSession session = LauncherFactory.openSession(launcherConfig)) {
	session.getLauncher().execute(discoveryRequest);
}

import static java.net.InetAddress.getLoopbackAddress;
import static org.junit.platform.engine.TestExecutionResult.successful;

import java.io.IOException;
import java.io.UncheckedIOException;
import java.net.ServerSocket;

import org.jspecify.annotations.Nullable;
import org.junit.platform.engine.EngineDiscoveryRequest;
import org.junit.platform.engine.ExecutionRequest;
import org.junit.platform.engine.TestDescriptor;
import org.junit.platform.engine.TestEngine;
import org.junit.platform.engine.UniqueId;
import org.junit.platform.engine.support.descriptor.EngineDescriptor;
import org.junit.platform.engine.support.store.Namespace;
import org.junit.platform.engine.support.store.NamespacedHierarchicalStore;

/**
 * First custom test engine implementation.
 */
public class FirstCustomEngine implements TestEngine {

	public ServerSocket socket;

	@Override
	public String getId() {
		return "first-custom-test-engine";
	}

	public ServerSocket getSocket() {
		return this.socket;
	}

	@Override
	public TestDescriptor discover(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId) {
		return new EngineDescriptor(uniqueId, "First Custom Test Engine");
	}

	@Override
	public void execute(ExecutionRequest request) {
		request.getEngineExecutionListener()
				.executionStarted(request.getRootTestDescriptor());

		NamespacedHierarchicalStore<Namespace> store = request.getStore();
		socket = store.computeIfAbsent(Namespace.GLOBAL, "serverSocket", key -> {
			try {
				return new ServerSocket(0, 50, getLoopbackAddress());
			}
			catch (IOException e) {
				throw new UncheckedIOException("Failed to start ServerSocket", e);
			}
		}, ServerSocket.class);

		request.getEngineExecutionListener()
				.executionFinished(request.getRootTestDescriptor(), successful());
	}

}

/**
 * Second custom test engine implementation.
 */
public class SecondCustomEngine implements TestEngine {

	public ServerSocket socket;

	@Override
	public String getId() {
		return "second-custom-test-engine";
	}

	public ServerSocket getSocket() {
		return this.socket;
	}

	@Override
	public TestDescriptor discover(EngineDiscoveryRequest discoveryRequest, UniqueId uniqueId) {
		return new EngineDescriptor(uniqueId, "Second Custom Test Engine");
	}

	@Override
	public void execute(ExecutionRequest request) {
		request.getEngineExecutionListener()
				.executionStarted(request.getRootTestDescriptor());

		NamespacedHierarchicalStore<Namespace> store = request.getStore();
		socket = store.computeIfAbsent(Namespace.GLOBAL, "serverSocket", key -> {
			try {
				return new ServerSocket(0, 50, getLoopbackAddress());
			}
			catch (IOException e) {
				throw new UncheckedIOException("Failed to start ServerSocket", e);
			}
		}, ServerSocket.class);

		request.getEngineExecutionListener()
				.executionFinished(request.getRootTestDescriptor(), successful());
	}

}

@Test
void runBothCustomEnginesTest() {
	FirstCustomEngine firstCustomEngine = new FirstCustomEngine();
	SecondCustomEngine secondCustomEngine = new SecondCustomEngine();

	LauncherConfig launcherConfig = LauncherConfig.builder()
			.addTestEngines(firstCustomEngine, secondCustomEngine)
			.enableTestEngineAutoRegistration(false)
			.build();

	LauncherDiscoveryRequest discoveryRequest = discoveryRequest()
			.selectors(selectPackage("com.example.mytests"))
			.build();

	Launcher launcher = LauncherFactory.create(launcherConfig);
	launcher.execute(discoveryRequest);

	assertSame(firstCustomEngine.getSocket(), secondCustomEngine.getSocket());
	assertTrue(firstCustomEngine.getSocket().isClosed(), "socket should be closed");
}

CancellationToken cancellationToken = CancellationToken.create(); (1)

TestExecutionListener failFastListener = new TestExecutionListener() {
	@Override
	public void executionFinished(TestIdentifier identifier, TestExecutionResult result) {
		if (result.getStatus() == FAILED) {
			cancellationToken.cancel(); (2)
		}
	}
};

LauncherExecutionRequest executionRequest = LauncherDiscoveryRequestBuilder.request()
		.selectors(selectClass(MyTestClass.class))
		.forExecution()
		.cancellationToken(cancellationToken) (3)
		.listeners(failFastListener) (4)
		.build();

try (LauncherSession session = LauncherFactory.openSession()) {
	session.getLauncher().execute(executionRequest); (5)
}