Implement parallel executor service without ForkJoinPool

documentation/src/test/resources/junit-platform.properties

@@ -1,4 +1,5 @@
 junit.jupiter.execution.parallel.enabled=true
+junit.jupiter.execution.parallel.executor=org.junit.platform.engine.support.hierarchical.ConcurrentHierarchicalTestExecutorService
 junit.jupiter.execution.parallel.mode.default=concurrent
 junit.jupiter.execution.parallel.config.strategy=fixed
 junit.jupiter.execution.parallel.config.fixed.parallelism=6

documentation/src/test/resources/log4j2-test.xml

@@ -5,7 +5,7 @@
 			   xsi:schemaLocation="https://logging.apache.org/xml/ns https://logging.apache.org/xml/ns/log4j-config-2.xsd">
 	<Appenders>
 		<Console name="Console" target="SYSTEM_OUT">
-			<PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n"/>
+			<PatternLayout pattern="%d{HH:mm:ss.SSSSSS} [%-18t] %-5level %logger{1.} - %msg%n"/>
 		</Console>
 	</Appenders>
 	<Loggers>

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/Constants.java

@@ -13,6 +13,7 @@
 import static org.apiguardian.api.API.Status.EXPERIMENTAL;
 import static org.apiguardian.api.API.Status.MAINTAINED;
 import static org.apiguardian.api.API.Status.STABLE;
+import static org.junit.jupiter.engine.config.JupiterConfiguration.PARALLEL_CONFIG_PREFIX;
 import static org.junit.platform.engine.support.hierarchical.DefaultParallelExecutionConfigurationStrategy.CONFIG_CUSTOM_CLASS_PROPERTY_NAME;
 import static org.junit.platform.engine.support.hierarchical.DefaultParallelExecutionConfigurationStrategy.CONFIG_DYNAMIC_FACTOR_PROPERTY_NAME;
 import static org.junit.platform.engine.support.hierarchical.DefaultParallelExecutionConfigurationStrategy.CONFIG_FIXED_MAX_POOL_SIZE_PROPERTY_NAME;
@@ -38,6 +39,8 @@
 import org.junit.jupiter.api.parallel.Execution;
 import org.junit.jupiter.engine.config.JupiterConfiguration;
 import org.junit.platform.commons.util.ClassNamePatternFilterUtils;
+import org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService;
+import org.junit.platform.engine.support.hierarchical.HierarchicalTestExecutorService;
 import org.junit.platform.engine.support.hierarchical.ParallelExecutionConfigurationStrategy;
 
 /**
@@ -210,6 +213,21 @@ public final class Constants {
 	@API(status = STABLE, since = "5.10")
 	public static final String PARALLEL_EXECUTION_ENABLED_PROPERTY_NAME = JupiterConfiguration.PARALLEL_EXECUTION_ENABLED_PROPERTY_NAME;
 
+	/**
+	 * Property name used to configure the fully qualified class name
+	 * {@link HierarchicalTestExecutorService} implementation to use if parallel
+	 * test execution is
+	 * {@linkplain #PARALLEL_EXECUTION_ENABLED_PROPERTY_NAME enabled}: {@value}
+	 *
+	 * <p>The implementation class must provide a parameter of type
+	 *
+	 * <p>By default, {@link ForkJoinPoolHierarchicalTestExecutorService} is used.
+	 *
+	 * @since 6.1
+	 */
+	@API(status = EXPERIMENTAL, since = "6.1")
+	public static final String PARALLEL_EXECUTION_EXECUTOR_PROPERTY_NAME = JupiterConfiguration.PARALLEL_EXECUTION_EXECUTOR_PROPERTY_NAME;
+
 	/**
 	 * Property name used to enable auto-closing of {@link AutoCloseable} instances
 	 *
@@ -237,8 +255,6 @@ public final class Constants {
 	@API(status = STABLE, since = "5.10")
 	public static final String DEFAULT_CLASSES_EXECUTION_MODE_PROPERTY_NAME = Execution.DEFAULT_CLASSES_EXECUTION_MODE_PROPERTY_NAME;
 
-	static final String PARALLEL_CONFIG_PREFIX = "junit.jupiter.execution.parallel.config.";
-
 	/**
 	 * Property name used to select the
 	 * {@link ParallelExecutionConfigurationStrategy}: {@value}

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/JupiterTestEngine.java

@@ -27,9 +27,7 @@
 import org.junit.platform.engine.ExecutionRequest;
 import org.junit.platform.engine.TestDescriptor;
 import org.junit.platform.engine.UniqueId;
-import org.junit.platform.engine.support.config.PrefixedConfigurationParameters;
 import org.junit.platform.engine.support.discovery.DiscoveryIssueReporter;
-import org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService;
 import org.junit.platform.engine.support.hierarchical.HierarchicalTestEngine;
 import org.junit.platform.engine.support.hierarchical.HierarchicalTestExecutorService;
 import org.junit.platform.engine.support.hierarchical.ThrowableCollector;
@@ -79,8 +77,7 @@ public TestDescriptor discover(EngineDiscoveryRequest discoveryRequest, UniqueId
 	protected HierarchicalTestExecutorService createExecutorService(ExecutionRequest request) {
 		JupiterConfiguration configuration = getJupiterConfiguration(request);
 		if (configuration.isParallelExecutionEnabled()) {
-			return new ForkJoinPoolHierarchicalTestExecutorService(new PrefixedConfigurationParameters(
-				request.getConfigurationParameters(), Constants.PARALLEL_CONFIG_PREFIX));
+			return configuration.createParallelExecutorService();
 		}
 		return super.createExecutorService(request);
 	}

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/config/CachingJupiterConfiguration.java

@@ -32,6 +32,7 @@
 import org.junit.jupiter.api.io.TempDirFactory;
 import org.junit.jupiter.api.parallel.ExecutionMode;
 import org.junit.platform.engine.OutputDirectoryCreator;
+import org.junit.platform.engine.support.hierarchical.HierarchicalTestExecutorService;
 
 /**
  * Caching implementation of the {@link JupiterConfiguration} API.
@@ -69,6 +70,11 @@ public boolean isParallelExecutionEnabled() {
 			__ -> delegate.isParallelExecutionEnabled());
 	}
 
+	@Override
+	public HierarchicalTestExecutorService createParallelExecutorService() {
+		return delegate.createParallelExecutorService();
+	}
+
 	@Override
 	public boolean isClosingStoredAutoCloseablesEnabled() {
 		return (boolean) cache.computeIfAbsent(CLOSING_STORED_AUTO_CLOSEABLE_ENABLED_PROPERTY_NAME,

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/config/DefaultJupiterConfiguration.java

@@ -34,13 +34,17 @@
 import org.junit.jupiter.api.io.CleanupMode;
 import org.junit.jupiter.api.io.TempDirFactory;
 import org.junit.jupiter.api.parallel.ExecutionMode;
+import org.junit.jupiter.engine.config.InstantiatingConfigurationParameterConverter.Strictness;
 import org.junit.platform.commons.util.ClassNamePatternFilterUtils;
 import org.junit.platform.commons.util.Preconditions;
 import org.junit.platform.engine.ConfigurationParameters;
 import org.junit.platform.engine.DiscoveryIssue;
 import org.junit.platform.engine.DiscoveryIssue.Severity;
 import org.junit.platform.engine.OutputDirectoryCreator;
+import org.junit.platform.engine.support.config.PrefixedConfigurationParameters;
 import org.junit.platform.engine.support.discovery.DiscoveryIssueReporter;
+import org.junit.platform.engine.support.hierarchical.ForkJoinPoolHierarchicalTestExecutorService;
+import org.junit.platform.engine.support.hierarchical.HierarchicalTestExecutorService;
 
 /**
  * Default implementation of the {@link JupiterConfiguration} API.
@@ -81,6 +85,10 @@ public class DefaultJupiterConfiguration implements JupiterConfiguration {
 	private static final ConfigurationParameterConverter<ExtensionContextScope> extensionContextScopeConverter = //
 		new EnumConfigurationParameterConverter<>(ExtensionContextScope.class, "extension context scope");
 
+	private static final ConfigurationParameterConverter<HierarchicalTestExecutorService> parallelExecutorServiceConverter = //
+		new InstantiatingConfigurationParameterConverter<>(HierarchicalTestExecutorService.class,
+			"parallel executor service", Strictness.FAIL, parameters -> new Object[] { parallelConfig(parameters) });
+
 	private final ConfigurationParameters configurationParameters;
 	private final OutputDirectoryCreator outputDirectoryCreator;
 
@@ -136,6 +144,13 @@ public boolean isParallelExecutionEnabled() {
 		return configurationParameters.getBoolean(PARALLEL_EXECUTION_ENABLED_PROPERTY_NAME).orElse(false);
 	}
 
+	@Override
+	public HierarchicalTestExecutorService createParallelExecutorService() {
+		return parallelExecutorServiceConverter.get(configurationParameters, PARALLEL_EXECUTION_EXECUTOR_PROPERTY_NAME) //
+				.orElseGet(
+					() -> new ForkJoinPoolHierarchicalTestExecutorService(parallelConfig(configurationParameters)));
+	}
+
 	@Override
 	public boolean isClosingStoredAutoCloseablesEnabled() {
 		return configurationParameters.getBoolean(CLOSING_STORED_AUTO_CLOSEABLE_ENABLED_PROPERTY_NAME).orElse(true);
@@ -214,4 +229,9 @@ public ExtensionContextScope getDefaultTestInstantiationExtensionContextScope()
 	public OutputDirectoryCreator getOutputDirectoryCreator() {
 		return outputDirectoryCreator;
 	}
+
+	private static PrefixedConfigurationParameters parallelConfig(ConfigurationParameters configurationParameters) {
+		return new PrefixedConfigurationParameters(configurationParameters, PARALLEL_CONFIG_PREFIX);
+	}
+
 }

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/config/InstantiatingConfigurationParameterConverter.java

@@ -10,28 +10,43 @@
 
 package org.junit.jupiter.engine.config;
 
+import java.lang.reflect.Constructor;
 import java.util.Optional;
+import java.util.function.Function;
 import java.util.function.Supplier;
+import java.util.stream.IntStream;
 
+import org.junit.platform.commons.JUnitException;
 import org.junit.platform.commons.function.Try;
 import org.junit.platform.commons.logging.Logger;
 import org.junit.platform.commons.logging.LoggerFactory;
 import org.junit.platform.commons.support.ReflectionSupport;
+import org.junit.platform.commons.util.Preconditions;
+import org.junit.platform.commons.util.ReflectionUtils;
 import org.junit.platform.engine.ConfigurationParameters;
 
 /**
  * @since 5.5
  */
-class InstantiatingConfigurationParameterConverter<T> implements ConfigurationParameterConverter<T> {
+final class InstantiatingConfigurationParameterConverter<T> implements ConfigurationParameterConverter<T> {
 
 	private static final Logger logger = LoggerFactory.getLogger(InstantiatingConfigurationParameterConverter.class);
 
 	private final Class<T> clazz;
 	private final String name;
+	private final Strictness strictness;
+	private final Function<ConfigurationParameters, Object[]> argumentResolver;
 
 	InstantiatingConfigurationParameterConverter(Class<T> clazz, String name) {
+		this(clazz, name, Strictness.WARN, __ -> new Object[0]);
+	}
+
+	InstantiatingConfigurationParameterConverter(Class<T> clazz, String name, Strictness strictness,
+			Function<ConfigurationParameters, Object[]> argumentResolver) {
 		this.clazz = clazz;
 		this.name = name;
+		this.strictness = strictness;
+		this.argumentResolver = argumentResolver;
 	}
 
 	@Override
@@ -44,31 +59,62 @@ Supplier<Optional<T>> supply(ConfigurationParameters configurationParameters, St
 		return configurationParameters.get(key)
 				.map(String::strip)
 				.filter(className -> !className.isEmpty())
-				.map(className -> newInstanceSupplier(className, key))
+				.map(className -> newInstanceSupplier(className, key, configurationParameters))
 				.orElse(Optional::empty);
 		// @formatter:on
 	}
 
-	private Supplier<Optional<T>> newInstanceSupplier(String className, String key) {
+	private Supplier<Optional<T>> newInstanceSupplier(String className, String key,
+			ConfigurationParameters configurationParameters) {
 		Try<Class<?>> clazz = ReflectionSupport.tryToLoadClass(className);
 		// @formatter:off
-		return () -> clazz.andThenTry(ReflectionSupport::newInstance)
+		return () -> clazz.andThenTry(it -> instantiate(it, configurationParameters))
 				.andThenTry(this.clazz::cast)
 				.ifSuccess(generator -> logSuccessMessage(className, key))
 				.ifFailure(cause -> logFailureMessage(className, key, cause))
 				.toOptional();
 		// @formatter:on
 	}
 
+	@SuppressWarnings("unchecked")
+	private <V> V instantiate(Class<V> clazz, ConfigurationParameters configurationParameters) {
+		var arguments = argumentResolver.apply(configurationParameters);
+		if (arguments.length == 0) {
+			return ReflectionSupport.newInstance(clazz);
+		}
+		var constructors = ReflectionUtils.findConstructors(clazz, it -> {
+			if (it.getParameterCount() != arguments.length) {
+				return false;
+			}
+			var parameters = it.getParameters();
+			return IntStream.range(0, parameters.length) //
+					.allMatch(i -> parameters[i].getType().isAssignableFrom(arguments[i].getClass()));
+		});
+		Preconditions.condition(constructors.size() == 1,
+			() -> "Failed to find unambiguous constructor for %s. Candidates: %s".formatted(clazz.getName(),
+				constructors));
+		return ReflectionUtils.newInstance((Constructor<V>) constructors.get(0), arguments);
+	}
+
 	private void logFailureMessage(String className, String key, Exception cause) {
-		logger.warn(cause, () -> """
-				Failed to load default %s class '%s' set via the '%s' configuration parameter. \
-				Falling back to default behavior.""".formatted(this.name, className, key));
+		switch (strictness) {
+			case WARN -> logger.warn(cause, () -> """
+					Failed to load default %s class '%s' set via the '%s' configuration parameter. \
+					Falling back to default behavior.""".formatted(this.name, className, key));
+			case FAIL -> throw new JUnitException(
+				"Failed to load default %s class '%s' set via the '%s' configuration parameter.".formatted(this.name,
+					className, key),
+				cause);
+		}
 	}
 
 	private void logSuccessMessage(String className, String key) {
 		logger.config(() -> "Using default %s '%s' set via the '%s' configuration parameter.".formatted(this.name,
 			className, key));
 	}
 
+	enum Strictness {
+		FAIL, WARN
+	}
+
 }

junit-jupiter-engine/src/main/java/org/junit/jupiter/engine/config/JupiterConfiguration.java

@@ -31,6 +31,7 @@
 import org.junit.jupiter.api.parallel.Execution;
 import org.junit.jupiter.api.parallel.ExecutionMode;
 import org.junit.platform.engine.OutputDirectoryCreator;
+import org.junit.platform.engine.support.hierarchical.HierarchicalTestExecutorService;
 
 /**
  * @since 5.4
@@ -42,6 +43,8 @@ public interface JupiterConfiguration {
 	String EXTENSIONS_AUTODETECTION_EXCLUDE_PROPERTY_NAME = "junit.jupiter.extensions.autodetection.exclude";
 	String DEACTIVATE_CONDITIONS_PATTERN_PROPERTY_NAME = "junit.jupiter.conditions.deactivate";
 	String PARALLEL_EXECUTION_ENABLED_PROPERTY_NAME = "junit.jupiter.execution.parallel.enabled";
+	String PARALLEL_EXECUTION_EXECUTOR_PROPERTY_NAME = "junit.jupiter.execution.parallel.executor";
+	String PARALLEL_CONFIG_PREFIX = "junit.jupiter.execution.parallel.config.";
 	String CLOSING_STORED_AUTO_CLOSEABLE_ENABLED_PROPERTY_NAME = "junit.jupiter.extensions.store.close.autocloseable.enabled";
 	String DEFAULT_EXECUTION_MODE_PROPERTY_NAME = Execution.DEFAULT_EXECUTION_MODE_PROPERTY_NAME;
 	String DEFAULT_CLASSES_EXECUTION_MODE_PROPERTY_NAME = Execution.DEFAULT_CLASSES_EXECUTION_MODE_PROPERTY_NAME;
@@ -61,6 +64,8 @@ public interface JupiterConfiguration {
 
 	boolean isParallelExecutionEnabled();
 
+	HierarchicalTestExecutorService createParallelExecutorService();
+
 	boolean isClosingStoredAutoCloseablesEnabled();
 
 	boolean isExtensionAutoDetectionEnabled();

junit-platform-engine/src/main/java/org/junit/platform/engine/support/hierarchical/BlockingAwareFuture.java

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2015-2025 the original author or authors.
+ *
+ * All rights reserved. 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-v20.html
+ */
+
+package org.junit.platform.engine.support.hierarchical;
+
+import static org.junit.platform.commons.util.ExceptionUtils.throwAsUncheckedException;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.jspecify.annotations.Nullable;
+
+abstract class BlockingAwareFuture<T extends @Nullable Object> extends DelegatingFuture<T> {
+
+	BlockingAwareFuture(Future<T> delegate) {
+		super(delegate);
+	}
+
+	@Override
+	public T get() throws InterruptedException, ExecutionException {
+		if (delegate.isDone()) {
+			return delegate.get();
+		}
+		return handleSafely(delegate::get);
+	}
+
+	@Override
+	public T get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
+		if (delegate.isDone()) {
+			return delegate.get();
+		}
+		return handleSafely(() -> delegate.get(timeout, unit));
+	}
+
+	private T handleSafely(Callable<T> callable) {
+		try {
+			return handle(callable);
+		}
+		catch (Exception e) {
+			throw throwAsUncheckedException(e);
+		}
+	}
+
+	protected abstract T handle(Callable<T> callable) throws Exception;
+
+}

junit-platform-engine/src/main/java/org/junit/platform/engine/support/hierarchical/CompositeLock.java

@@ -45,6 +45,26 @@ List<Lock> getLocks() {
 		return this.locks;
 	}
 
+	@Override
+	public boolean tryAcquire() {
+		List<Lock> acquiredLocks = new ArrayList<>(this.locks.size());
+		for (Lock lock : this.locks) {
+			if (lock.tryLock()) {
+				acquiredLocks.add(lock);
+			}
+			else {
+				break;
+			}
+		}
+		if (acquiredLocks.size() == this.locks.size()) {
+			return true;
+		}
+		else {
+			release(acquiredLocks);
+			return false;
+		}
+	}
+
 	@Override
 	public ResourceLock acquire() throws InterruptedException {
 		ForkJoinPool.managedBlock(new CompositeLockManagedBlocker());