diff --git a/pom.xml b/pom.xml
index cf9b5e87a63..db2df2348d8 100644
--- a/pom.xml
+++ b/pom.xml
@@ -26,6 +26,8 @@
   <properties>
     <tycho.scmUrl>scm:git:https://github.com/eclipse-platform/eclipse.platform.git</tycho.scmUrl>
     <tycho.surefire.testClassesDirectory>${project.build.outputDirectory}</tycho.surefire.testClassesDirectory>
+    <test.includes></test.includes>
+    <test.excludes></test.excludes>
   </properties>
 
   <!-- 
@@ -75,6 +77,12 @@
           <artifactId>tycho-surefire-plugin</artifactId>
           <configuration>
             <testClassesDirectory>${tycho.surefire.testClassesDirectory}</testClassesDirectory>
+            <includes>
+              <include>${test.includes}</include>
+            </includes>
+            <excludes>
+              <exclude>%{test.excludes}</exclude>
+            </excludes>
           </configuration>
         </plugin>
       </plugins>
diff --git a/runtime/tests/org.eclipse.core.tests.harness/META-INF/MANIFEST.MF b/runtime/tests/org.eclipse.core.tests.harness/META-INF/MANIFEST.MF
index 90638e7726c..de41d01d0c3 100644
--- a/runtime/tests/org.eclipse.core.tests.harness/META-INF/MANIFEST.MF
+++ b/runtime/tests/org.eclipse.core.tests.harness/META-INF/MANIFEST.MF
@@ -5,13 +5,22 @@ Bundle-SymbolicName: org.eclipse.core.tests.harness;singleton:=true
 Bundle-Version: 3.15.300.qualifier
 Bundle-Vendor: Eclipse.org
 Export-Package: org.eclipse.core.tests.harness;version="2.0",
+ org.eclipse.core.tests.harness.performance,
+ org.eclipse.core.tests.harness.session,
  org.eclipse.core.tests.session;version="2.0"
 Require-Bundle: org.junit,
  org.eclipse.test.performance,
  org.eclipse.core.runtime;bundle-version="[3.29.0,4.0.0)",
  org.eclipse.jdt.junit.runtime,
  org.eclipse.jdt.junit4.runtime,
- org.eclipse.pde.junit.runtime
+ org.eclipse.jdt.junit5.runtime,
+ org.eclipse.pde.junit.runtime,
+ junit-platform-launcher,
+ junit-platform-engine,
+ junit-jupiter-engine,
+ junit-vintage-engine,
+ junit-platform-suite-commons,
+ junit-platform-suite-engine
 Bundle-ActivationPolicy: lazy
 Bundle-RequiredExecutionEnvironment: JavaSE-17
 Import-Package: javax.xml.parsers,
@@ -19,8 +28,13 @@ Import-Package: javax.xml.parsers,
  org.apiguardian.api,
  org.assertj.core.api,
  org.junit.jupiter.api,
- org.junit.platform.suite.api,
+ org.junit.jupiter.api.condition,
+ org.junit.jupiter.api.extension,
+ org.junit.jupiter.migrationsupport,
+ org.junit.jupiter.params,
  org.junit.platform.commons,
+ org.junit.platform.runner,
+ org.junit.platform.suite.api,
  org.opentest4j,
  org.w3c.dom,
  org.xml.sax
diff --git a/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/harness/session/SessionShouldError.java b/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/harness/session/SessionShouldError.java
new file mode 100644
index 00000000000..a4960c0327e
--- /dev/null
+++ b/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/harness/session/SessionShouldError.java
@@ -0,0 +1,27 @@
+/*******************************************************************************
+ * Copyright (c) 2023 Vector Informatik GmbH and others.
+ *
+ * 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-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.core.tests.harness.session;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Indicates that a session of a test case is expected to terminate with a
+ * failure or error. To be used in combination with a
+ * {@link SessionTestExtension}.
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(ElementType.METHOD)
+public @interface SessionShouldError {
+	// Marker annotation
+}
diff --git a/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/harness/session/SessionTestExtension.java b/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/harness/session/SessionTestExtension.java
new file mode 100644
index 00000000000..0344e8b6cae
--- /dev/null
+++ b/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/harness/session/SessionTestExtension.java
@@ -0,0 +1,350 @@
+/*******************************************************************************
+ * Copyright (c) 2023 Vector Informatik GmbH and others.
+ *
+ * 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-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.core.tests.harness.session;
+
+import static org.eclipse.core.tests.harness.TestHarnessPlugin.PI_HARNESS;
+import static org.eclipse.core.tests.harness.TestHarnessPlugin.log;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.lang.reflect.Method;
+import java.net.ServerSocket;
+import java.net.Socket;
+import java.util.Objects;
+import org.eclipse.core.runtime.Assert;
+import org.eclipse.core.runtime.AssertionFailedException;
+import org.eclipse.core.runtime.CoreException;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Platform;
+import org.eclipse.core.runtime.Status;
+import org.eclipse.core.tests.session.RemoteAssertionFailedError;
+import org.eclipse.core.tests.session.RemoteTestException;
+import org.eclipse.core.tests.session.Setup;
+import org.eclipse.core.tests.session.SetupManager;
+import org.eclipse.core.tests.session.SetupManager.SetupException;
+import org.eclipse.core.tests.session.TestDescriptor;
+import org.junit.jupiter.api.extension.ExtensionContext;
+import org.junit.jupiter.api.extension.InvocationInterceptor;
+import org.junit.jupiter.api.extension.ReflectiveInvocationContext;
+
+/**
+ */
+public class SessionTestExtension implements InvocationInterceptor {
+	public static final String CORE_TEST_APPLICATION = "org.eclipse.pde.junit.runtime.coretestapplication"; //$NON-NLS-1$
+	/**
+	 * Is set to true during remote execution to ensure that the JUnit 5 executor
+	 * does not recursively make a remote call for executing the test
+	 */
+	private static final String REMOTE_EXECUTION_INDICATION_SYSTEM_PROPERY = "org.eclipse.core.tests.session.isRemoteExecution"; //$NON-NLS-1$
+
+	private final String pluginId;
+	private final String applicationId;
+	private final Setup setup;
+
+	private SessionTestExtension(String pluginId, String applicationId) {
+		this.pluginId = pluginId;
+		this.applicationId = applicationId;
+		try {
+			this.setup = SetupManager.getInstance().getDefaultSetup();
+			setup.setSystemProperty("org.eclipse.update.reconcile", "false");
+		} catch (SetupException e) {
+			throw new IllegalStateException("unable to create setup", e);
+		}
+
+	}
+
+	public static SessionTestExtensionBuilder forPlugin(String pluginId) {
+		return new SessionTestExtensionBuilder(pluginId);
+	}
+
+	public static class SessionTestExtensionBuilder {
+		private final String storedPluginId;
+		private String storedApplicationId = CORE_TEST_APPLICATION;
+
+		private SessionTestExtensionBuilder(String pluginId) {
+			Objects.requireNonNull(pluginId);
+			this.storedPluginId = pluginId;
+		}
+
+		public SessionTestExtensionBuilder withApplicationId(String applicationId) {
+			storedApplicationId = applicationId;
+			return this;
+		}
+
+		public SessionTestExtension create() {
+			return new SessionTestExtension(storedPluginId, storedApplicationId);
+		}
+	}
+
+	@Override
+	public void interceptTestMethod(Invocation<Void> invocation, ReflectiveInvocationContext<Method> invocationContext,
+			ExtensionContext extensionContext) throws Throwable {
+		boolean isRemoteExecution = System.getProperty(REMOTE_EXECUTION_INDICATION_SYSTEM_PROPERY, "").equals(Boolean.toString(true));
+		if (isRemoteExecution) {
+			invocation.proceed();
+			return;
+		}
+		String testClass = extensionContext.getTestClass().get().getName();
+		String testMethod = extensionContext.getTestMethod().get().getName();
+
+		boolean shouldFail = extensionContext.getTestMethod().get().getAnnotation(SessionShouldError.class) != null;
+		invocation.skip();
+		executeRemotely(testClass, testMethod, shouldFail);
+	}
+
+	private void executeRemotely(String testClass, String testMethod, boolean shouldFail) throws Throwable {
+		Setup localSetup = createSingleTestSetup(testClass, testMethod);
+		localSetup.setSystemProperty(REMOTE_EXECUTION_INDICATION_SYSTEM_PROPERY, Boolean.toString(true));
+
+		TestDescriptor descriptor = new TestDescriptor(testClass, testMethod);
+		ResultCollector collector = new ResultCollector(getTestId(testClass, testMethod));
+		localSetup.setEclipseArgument("port", Integer.toString(collector.getPort()));
+		new Thread(collector, "Test result collector").start();
+		IStatus status = launch(localSetup);
+		collector.shutdown();
+		if (!shouldFail) {
+			if (!status.isOK()) {
+				log(status);
+				throw new CoreException(status);
+			}
+			if (!collector.didTestFinish()) {
+				throw new Exception("session test did not run: " + descriptor);
+			}
+			if (!collector.wasTestSuccessful()) {
+				throw collector.getError();
+			}
+		} else {
+			if (status.isOK() && collector.wasTestSuccessful()) {
+				throw new AssertionFailedException("test should fail but did not: " + descriptor);
+			}
+		}
+	}
+
+	private static String getTestId(String testClass, String testMethod) {
+		return testMethod + "(" + testClass + ")";
+	}
+
+	private Setup createSingleTestSetup(String testClassName, String testMethodName) {
+		Setup localSetup = (Setup) setup.clone();
+		localSetup.setEclipseArgument(Setup.APPLICATION, applicationId);
+//		localSetup.setEclipseArgument("runasjunit5", "");
+		localSetup.setEclipseArgument("loaderpluginname", pluginId);// "org.eclipse.core.tests.harness");
+		localSetup.setEclipseArgument("testloaderclass", "org.eclipse.jdt.internal.junit5.runner.JUnit5TestLoader");
+		localSetup.setEclipseArgument("testpluginname", pluginId);
+		localSetup.setEclipseArgument("test", testClassName + ":" + testMethodName);
+		return localSetup;
+	}
+
+	/**
+	 * Runs the setup. Returns a status object indicating the outcome of the
+	 * operation.
+	 *
+	 * @return a status object indicating the outcome
+	 */
+	private static IStatus launch(Setup setup) {
+		Assert.isNotNull(setup.getEclipseArgument(Setup.APPLICATION), "test application is not defined");
+		Assert.isNotNull(setup.getEclipseArgument("testpluginname"), "test plug-in id not defined");
+		Assert.isTrue(setup.getEclipseArgument("classname") != null ^ setup.getEclipseArgument("test") != null,
+				"either a test suite or a test case must be provided");
+		// to prevent changes in the protocol from breaking us,
+		// force the version we know we can work with
+		setup.setEclipseArgument("version", "4");
+		IStatus outcome = Status.OK_STATUS;
+		try {
+			int returnCode = setup.run();
+			if (returnCode == 23) {
+				// asked to restart; for now just do this once.
+				// Note that 23 is our magic return code indicating that a restart is required.
+				// This can happen for tests that update framework extensions which requires a
+				// restart.
+				returnCode = setup.run();
+			}
+			if (returnCode != 0) {
+				outcome = new Status(IStatus.WARNING, Platform.PI_RUNTIME, returnCode,
+						"Process returned non-zero code: " + returnCode + "\n\tCommand: " + setup, null);
+			}
+		} catch (Exception e) {
+			outcome = new Status(IStatus.ERROR, Platform.PI_RUNTIME, -1, "Error running process\n\tCommand: " + setup,
+					e);
+		}
+		return outcome;
+	}
+
+	/**
+	 * Partly taken from
+	 * {@code org.eclipse.core.tests.session.SessionTestRunner#ResultCollector}.
+	 */
+	static class ResultCollector implements Runnable {
+		private final String testId;
+		private final ServerSocket serverSocket;
+
+		private volatile boolean shouldRun = true;
+		private volatile boolean executionFinished;
+
+		private static enum STATE {
+			SUCCESS, FAILURE, ERROR;
+		}
+		private STATE state = STATE.SUCCESS;
+		private StringBuilder stackBuilder;
+
+		private String stackTrace;
+		private boolean testFinished;
+		private Throwable error;
+
+		ResultCollector(String testId) throws IOException {
+			this.serverSocket = new ServerSocket(0);
+			this.testId = testId;
+		}
+
+		int getPort() {
+			return serverSocket.getLocalPort();
+		}
+
+		boolean didTestFinish() {
+			return testFinished;
+		}
+
+		boolean wasTestSuccessful() {
+			return testFinished && error == null;
+		}
+
+		Throwable getError() {
+			return error;
+		}
+
+		@Override
+		public void run() {
+			// someone asked us to stop before we could do anything
+			if (!shouldRun) {
+				return;
+			}
+			try (Socket s = serverSocket.accept();
+					BufferedReader messageReader = new BufferedReader(
+							new InputStreamReader(s.getInputStream(), "UTF-8"))) {
+				// main loop
+				while (true) {
+					synchronized (this) {
+						processAvailableMessages(messageReader);
+						if (!shouldRun) {
+							return;
+						}
+						this.wait(150);
+					}
+				}
+			} catch (InterruptedException e) {
+				// not expected
+			} catch (IOException e) {
+				if (!shouldRun) {
+					// we have been finished without ever getting any connections
+					// no need to throw exception
+					return;
+				}
+				log(new Status(IStatus.WARNING, PI_HARNESS, IStatus.ERROR, "Error", e));
+			} finally {
+				executionFinished = true;
+				synchronized (this) {
+					notifyAll();
+				}
+			}
+		}
+
+		/*
+		 * Politely asks the collector thread to stop and wait until it is finished.
+		 */
+		void shutdown() {
+			// ask the collector to stop
+			synchronized (this) {
+				if (executionFinished) {
+					return;
+				}
+				shouldRun = false;
+				try {
+					serverSocket.close();
+				} catch (IOException e) {
+					log(new Status(IStatus.ERROR, PI_HARNESS, IStatus.ERROR, "Error", e));
+				}
+				notifyAll();
+			}
+			// wait until the collector is done
+			synchronized (this) {
+				while (!executionFinished) {
+					try {
+						wait(100);
+					} catch (InterruptedException e) {
+						// we don't care
+					}
+				}
+			}
+		}
+
+		private void processAvailableMessages(BufferedReader messageReader) throws IOException {
+			while (messageReader.ready()) {
+				String message = messageReader.readLine();
+				processMessage(message);
+			}
+		}
+
+		private void processMessage(String message) {
+			if (message.startsWith("%TESTS")) {
+				String receivedTestId = parseTestId(message);
+				if (!testId.equals(receivedTestId)) {
+					throw new IllegalStateException("unknown test id: " + receivedTestId + message);
+				}
+				return;
+			} else if (message.startsWith("%TESTE")) {
+				switch (state) {
+				case FAILURE:
+					error = new RemoteAssertionFailedError("", stackTrace);
+					break;
+				case ERROR:
+					error = new RemoteTestException("", stackTrace);
+				}
+				testFinished = true;
+			} else if (message.startsWith("%ERROR")) {
+				state = STATE.ERROR;
+			} else if (message.startsWith("%FAILED")) {
+				state = STATE.FAILURE;
+			} else if (message.startsWith("%TRACES")) {
+				// just create the string buffer that will hold all the frames of the stack
+				// trace
+				stackBuilder = new StringBuilder();
+			} else if (message.startsWith("%TRACEE")) {
+				// stack trace fully read - fill the slot in the result object and reset the
+				// string buffer
+				stackTrace = stackBuilder.toString();
+				stackBuilder = null;
+			} else if (message.startsWith("%")) {
+				// ignore any other messages
+			} else if (stackBuilder != null) {
+				// build the stack trace line by line
+				stackBuilder.append(message);
+				stackBuilder.append(System.lineSeparator());
+			}
+		}
+
+		private String parseTestId(String message) {
+			if (message.isEmpty() || message.charAt(0) != '%') {
+				return null;
+			}
+			int firstComma = message.indexOf(',');
+			if (firstComma == -1) {
+				return null;
+			}
+			int secondComma = message.indexOf(',', firstComma + 1);
+			if (secondComma == -1) {
+				secondComma = message.length();
+			}
+			return message.substring(firstComma + 1, secondComma);
+		}
+
+	}
+}
diff --git a/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/harness/session/samples/SampleSessionTests.java b/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/harness/session/samples/SampleSessionTests.java
new file mode 100644
index 00000000000..7c978877bf5
--- /dev/null
+++ b/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/harness/session/samples/SampleSessionTests.java
@@ -0,0 +1,82 @@
+/*******************************************************************************
+ * Copyright (c) 2023 Vector Informatik GmbH and others.
+ *
+ * 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-2.0/
+ *
+ * SPDX-License-Identifier: EPL-2.0
+ *******************************************************************************/
+package org.eclipse.core.tests.harness.session.samples;
+
+import static org.eclipse.core.tests.harness.TestHarnessPlugin.PI_HARNESS;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
+import org.eclipse.core.tests.harness.session.SessionShouldError;
+import org.eclipse.core.tests.harness.session.SessionTestExtension;
+import org.junit.jupiter.api.Nested;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.RegisterExtension;
+
+/**
+ * Examples demonstrating the behavior of session tests using the JUnit 5
+ * platform. When executed, the {@code Successful} tests will succeed, while the
+ * {@code Failing} ones will fail.
+ */
+public class SampleSessionTests {
+	@RegisterExtension
+	static SessionTestExtension sessionTestExtension = SessionTestExtension.forPlugin(PI_HARNESS).create();
+
+	@Nested
+	public class Successful {
+		@Test
+		public void asIntended() {
+			assertEquals(1, 1);
+		}
+
+		@Test
+		@SessionShouldError
+		public void withExpectedFailure() {
+			fail("fail");
+		}
+
+		@Test
+		@SessionShouldError
+		public void withExpectedError_viaException() {
+			throw new RuntimeException("error");
+		}
+
+		@Test
+		@SessionShouldError
+		public void withExpectedError_viaExit() {
+			System.exit(1);
+		}
+	}
+
+	@Nested
+	public class Failing {
+		@Test
+		@SessionShouldError
+		public void unexpectedlySuccessful() {
+			assertEquals(1, 1);
+		}
+
+		@Test
+		public void withFailure() {
+			fail("fail");
+		}
+
+		@Test
+		public void withError_viaException() {
+			throw new RuntimeException("error");
+		}
+
+		@Test
+		public void withError_viaExit() {
+			System.exit(1);
+		}
+	}
+
+}
diff --git a/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/session/ConfigurationSessionTestSuite.java b/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/session/ConfigurationSessionTestSuite.java
index 1f1ab78844a..3e610c84988 100644
--- a/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/session/ConfigurationSessionTestSuite.java
+++ b/runtime/tests/org.eclipse.core.tests.harness/src/org/eclipse/core/tests/session/ConfigurationSessionTestSuite.java
@@ -74,6 +74,7 @@ public ConfigurationSessionTestSuite(String pluginId, String name) {
 		super(pluginId, name);
 	}
 
+	@SuppressWarnings("deprecation")
 	public void addMinimalBundleSet() {
 		// Just use any class from the bundles we want to add as minimal bundle set
 
@@ -91,6 +92,7 @@ public void addMinimalBundleSet() {
 
 		addBundle(org.eclipse.jdt.internal.junit.runner.ITestLoader.class); // org.eclipse.jdt.junit.runtime
 		addBundle(org.eclipse.jdt.internal.junit4.runner.JUnit4TestLoader.class); // org.eclipse.jdt.junit4.runtime
+		addBundle(org.eclipse.jdt.internal.junit5.runner.JUnit5TestLoader.class); // org.eclipse.jdt.junit5.runtime
 		addBundle(org.eclipse.pde.internal.junit.runtime.CoreTestApplication.class); // org.eclipse.pde.junit.runtime
 
 		addBundle(net.bytebuddy.ByteBuddy.class); // net.bytebuddy for org.assertj.core.api
@@ -120,8 +122,17 @@ public void addMinimalBundleSet() {
 
 		addBundle(org.junit.Test.class); // org.junit
 		addBundle(org.junit.jupiter.api.Test.class); // junit-jupiter-api
+		addBundle(org.junit.jupiter.engine.JupiterTestEngine.class); // junit-jupiter-engine
+		addBundle(org.junit.jupiter.migrationsupport.EnableJUnit4MigrationSupport.class); // junit-jupiter-migrationsupport
+		addBundle(org.junit.jupiter.params.ParameterizedTest.class); // junit-jupiter-params
+		addBundle(org.junit.vintage.engine.VintageTestEngine.class); // junit-vintage-engine
 		addBundle(org.junit.platform.commons.JUnitException.class); // junit-platform-commons
+		addBundle(org.junit.platform.engine.TestEngine.class); // junit-platform-engine
+		addBundle(org.junit.platform.launcher.Launcher.class); // junit-platform-launcher
+		addBundle(org.junit.platform.runner.JUnitPlatform.class); // junit-platform-runner
 		addBundle(org.junit.platform.suite.api.Suite.class); // junit-platform-suite-api
+		addBundle(org.junit.platform.suite.commons.SuiteLauncherDiscoveryRequestBuilder.class); // junit-platform-suite-commons
+		addBundle(org.junit.platform.suite.engine.SuiteTestEngine.class); // junit-platform-suite-engine
 		addBundle(org.apiguardian.api.API.class); // org.apiguardian.api
 		addBundle(org.opentest4j.AssertionFailedError.class); // org.opentest4j
 	}
diff --git a/runtime/tests/org.eclipse.core.tests.runtime/META-INF/MANIFEST.MF b/runtime/tests/org.eclipse.core.tests.runtime/META-INF/MANIFEST.MF
index e3c5bef1f60..fd1d1ca5f25 100644
--- a/runtime/tests/org.eclipse.core.tests.runtime/META-INF/MANIFEST.MF
+++ b/runtime/tests/org.eclipse.core.tests.runtime/META-INF/MANIFEST.MF
@@ -14,7 +14,10 @@ Require-Bundle: org.junit,
  org.eclipse.test.performance;resolution:=optional,
  org.eclipse.core.runtime;bundle-version="3.29.0",
  org.eclipse.core.tests.harness;bundle-version="3.11.0"
-Import-Package: org.assertj.core.api
+Import-Package: org.assertj.core.api,
+ org.junit.jupiter.api,
+ org.junit.jupiter.api.extension,
+ org.junit.platform.suite.api
 Bundle-ActivationPolicy: lazy
 Bundle-RequiredExecutionEnvironment: JavaSE-17
 Plugin-Class: org.eclipse.core.tests.runtime.RuntimeTestsPlugin
diff --git a/runtime/tests/org.eclipse.core.tests.runtime/build.properties b/runtime/tests/org.eclipse.core.tests.runtime/build.properties
index d2154dcb351..045feb6b26f 100644
--- a/runtime/tests/org.eclipse.core.tests.runtime/build.properties
+++ b/runtime/tests/org.eclipse.core.tests.runtime/build.properties
@@ -28,5 +28,6 @@ javacWarnings..=-unchecked,-raw
 # Maven properties, see https://github.com/eclipse/tycho/wiki/Tycho-Pomless
 # This plug-in's name does not comply with Tycho's naming convention for test-plugins -> packaging type has to be specified explicitly
 pom.model.packaging = eclipse-test-plugin
-pom.model.property.testClass = org.eclipse.core.tests.runtime.AutomatedRuntimeTests
 pom.model.property.defaultSigning-excludeInnerJars = true
+pom.model.property.test.includes = **/Bug_*.java, **/*Test.java
+pom.model.property.test.excludes = **/*.perf/*.java
diff --git a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/internal/preferences/AllPreferenceTests.java b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/internal/preferences/AllPreferenceTests.java
index ae00fe2d2f4..0c687b73313 100644
--- a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/internal/preferences/AllPreferenceTests.java
+++ b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/internal/preferences/AllPreferenceTests.java
@@ -13,12 +13,14 @@
  *******************************************************************************/
 package org.eclipse.core.tests.internal.preferences;
 
-import org.eclipse.core.tests.runtime.*;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
+import org.eclipse.core.tests.runtime.PreferenceExportTest;
+import org.eclipse.core.tests.runtime.PreferenceForwarderTest;
+import org.eclipse.core.tests.runtime.PreferencesTest;
+import org.junit.platform.suite.api.SelectClasses;
+import org.junit.platform.suite.api.Suite;
 
-@RunWith(Suite.class)
-@Suite.SuiteClasses({ EclipsePreferencesTest.class, PreferencesServiceTest.class, IScopeContextTest.class,
+@Suite
+@SelectClasses({ EclipsePreferencesTest.class, PreferencesServiceTest.class, IScopeContextTest.class,
 		TestBug388004.class, TestBug380859.class, PreferenceExportTest.class, PreferenceForwarderTest.class,
 		PreferencesTest.class })
 @SuppressWarnings("deprecation")
diff --git a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/internal/runtime/AllInternalRuntimeTests.java b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/internal/runtime/AllInternalRuntimeTests.java
index c332ba49f56..852e7a5bf73 100644
--- a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/internal/runtime/AllInternalRuntimeTests.java
+++ b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/internal/runtime/AllInternalRuntimeTests.java
@@ -13,10 +13,10 @@
  *******************************************************************************/
 package org.eclipse.core.tests.internal.runtime;
 
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
+import org.junit.platform.suite.api.SelectClasses;
+import org.junit.platform.suite.api.Suite;
 
-@RunWith(Suite.class)
-@Suite.SuiteClasses({ LogSerializationTest.class, PlatformURLLocalTest.class, PlatformURLSessionTest.class })
+@Suite
+@SelectClasses({ LogSerializationTest.class, PlatformURLLocalTest.class, PlatformURLSessionTest.class })
 public class AllInternalRuntimeTests {
 }
diff --git a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/AllRuntimeTests.java b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/AllRuntimeTests.java
index 412acbc93f3..236e5f71a84 100644
--- a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/AllRuntimeTests.java
+++ b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/AllRuntimeTests.java
@@ -13,11 +13,11 @@
  *******************************************************************************/
 package org.eclipse.core.tests.runtime;
 
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
+import org.junit.platform.suite.api.SelectClasses;
+import org.junit.platform.suite.api.Suite;
 
-@RunWith(Suite.class)
-@Suite.SuiteClasses({ PlatformTest.class })
+@Suite
+@SelectClasses({ PlatformTest.class })
 public class AllRuntimeTests {
 
 }
diff --git a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/AutomatedRuntimeTests.java b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/AutomatedRuntimeTests.java
index ec72a718c6d..d803fa43a24 100644
--- a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/AutomatedRuntimeTests.java
+++ b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/AutomatedRuntimeTests.java
@@ -16,15 +16,15 @@
 import org.eclipse.core.tests.internal.preferences.AllPreferenceTests;
 import org.eclipse.core.tests.internal.runtime.AllInternalRuntimeTests;
 import org.eclipse.core.tests.runtime.jobs.AllJobTests;
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
+import org.junit.platform.suite.api.SelectClasses;
+import org.junit.platform.suite.api.Suite;
 
 /**
  * Runs the sniff tests for the build. All tests listed here should be
  * automated.
  */
-@RunWith(Suite.class)
-@Suite.SuiteClasses({
+@Suite
+@SelectClasses({
 		AllInternalRuntimeTests.class,
 
 		AllRuntimeTests.class,
diff --git a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/AllJobTests.java b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/AllJobTests.java
index c3611e9a48f..19c92734a24 100644
--- a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/AllJobTests.java
+++ b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/AllJobTests.java
@@ -14,25 +14,25 @@
  *******************************************************************************/
 package org.eclipse.core.tests.runtime.jobs;
 
-import org.junit.runner.RunWith;
-import org.junit.runners.Suite;
+import org.junit.platform.suite.api.SelectClasses;
+import org.junit.platform.suite.api.Suite;
 
 /**
  * Runs all job tests
  */
-@RunWith(Suite.class)
-@Suite.SuiteClasses({
+@SelectClasses({
 		YieldTest.class, IJobManagerTest.class, JobGroupTest.class, JobQueueTest.class, OrderedLockTest.class,
 		BeginEndRuleTest.class, JobTest.class, DeadlockDetectionTest.class, Bug_129551.class, Bug_211799.class,
 		Bug_307282.class, Bug_307391.class, MultiRuleTest.class, Bug_311756.class, Bug_311863.class, Bug_316839.class,
-		Bug_320329.class, Bug_478634.class, Bug_550738.class, Bug_574883.class, Bug_412138.class,
-		Bug_574883Join.class, GithubBug_193.class,
-		WorkerPoolTest.class,
+		Bug_320329.class, Bug_478634.class, Bug_550738.class, Bug_574883.class,
+		Bug_412138.class,
+		Bug_574883Join.class, GithubBug_193.class, WorkerPoolTest.class,
 		/*
 		 * Intentional the LAST TEST in the list to testNoTimeoutOccured() in the other
 		 * tests:
 		 */
 		JobEventTest.class
 })
+@Suite
 public class AllJobTests {
 }
diff --git a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/Bug_412138.java b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/Bug_412138.java
index 38f7e5ca829..c5dcbdb144a 100644
--- a/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/Bug_412138.java
+++ b/runtime/tests/org.eclipse.core.tests.runtime/src/org/eclipse/core/tests/runtime/jobs/Bug_412138.java
@@ -13,33 +13,42 @@
  *******************************************************************************/
 package org.eclipse.core.tests.runtime.jobs;
 
-import java.io.*;
+import static org.eclipse.core.tests.runtime.RuntimeTestsPlugin.PI_RUNTIME_TESTS;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.io.ObjectOutputStream;
 import java.util.concurrent.atomic.AtomicIntegerArray;
-import junit.framework.*;
-import org.eclipse.core.runtime.*;
+import junit.framework.AssertionFailedError;
+import org.eclipse.core.runtime.IProgressMonitor;
+import org.eclipse.core.runtime.IStatus;
+import org.eclipse.core.runtime.Status;
 import org.eclipse.core.runtime.jobs.Job;
 import org.eclipse.core.tests.harness.FileSystemHelper;
 import org.eclipse.core.tests.harness.TestBarrier2;
-import org.eclipse.core.tests.runtime.RuntimeTestsPlugin;
-import org.eclipse.core.tests.session.SessionTestSuite;
+import org.eclipse.core.tests.harness.session.SessionShouldError;
+import org.eclipse.core.tests.harness.session.SessionTestExtension;
+import org.junit.jupiter.api.MethodOrderer;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestMethodOrder;
+import org.junit.jupiter.api.extension.RegisterExtension;
 
 /**
  * Test for bug 412138.
  */
-public class Bug_412138 extends TestCase {
-	private static final String FILE_NAME = FileSystemHelper.getTempDir().append(Bug_412138.class.getName()).toOSString();
-
-	public static Test suite() {
-		SessionTestSuite suite = new SessionTestSuite(RuntimeTestsPlugin.PI_RUNTIME_TESTS, Bug_412138.class.getName());
-		suite.addCrashTest(new Bug_412138("testRunScenario"));
-		suite.addTest(new Bug_412138("testVerifyResult"));
-		return suite;
-	}
+@TestMethodOrder(MethodOrderer.MethodName.class)
+public class Bug_412138 {
+	@RegisterExtension
+	static SessionTestExtension sessionTestExtension = SessionTestExtension.forPlugin(PI_RUNTIME_TESTS).create();
 
-	public Bug_412138(String name) {
-		super(name);
-	}
+	private static final String FILE_NAME = FileSystemHelper.getTempDir().append(Bug_412138.class.getName()).toOSString();
 
+	@Test
+	@SessionShouldError
 	public void testRunScenario() throws InterruptedException {
 		// delete the file so that we don't report previous results
 		new File(FILE_NAME).delete();
@@ -59,7 +68,7 @@ protected IStatus run(IProgressMonitor monitor) {
 						return Status.OK_STATUS;
 					}
 				} catch (InterruptedException e) {
-					return new Status(IStatus.ERROR, RuntimeTestsPlugin.PI_RUNTIME_TESTS, e.getMessage(), e);
+					return new Status(IStatus.ERROR, PI_RUNTIME_TESTS, e.getMessage(), e);
 				}
 			}
 		};
@@ -72,7 +81,7 @@ protected IStatus run(IProgressMonitor monitor) {
 					status.set(0, TestBarrier2.STATUS_DONE);
 					return Status.OK_STATUS;
 				} catch (InterruptedException e) {
-					return new Status(IStatus.ERROR, RuntimeTestsPlugin.PI_RUNTIME_TESTS, e.getMessage(), e);
+					return new Status(IStatus.ERROR, PI_RUNTIME_TESTS, e.getMessage(), e);
 				}
 			}
 		};
@@ -104,6 +113,7 @@ protected IStatus run(IProgressMonitor monitor) {
 		}
 	}
 
+	@Test
 	public void testVerifyResult() throws IOException, ClassNotFoundException {
 		File file = new File(FILE_NAME);
 		// if the file does not exist, there was no deadlock so the whole test pass