Fix fallback to ForkJoinPools Java 7 constructor on Java 9 and higher

When an invalid ParallelExecutionConfiguration is provided on Java 9+ the
`ForkJoinPoolHierarchicalTestExecutorService` will fall back to using the
since Java 7 constructor. As a result misconfiguration goes unnoticed.

Separated the exceptions thrown by finding the Java 9+ constructor from those
thrown by invoking the constructor with an invalid configuration. The former
can be ignored, the latter should not be.

Fixes #3045.

Author: mpkorstanje

documentation/src/docs/asciidoc/release-notes/index.adoc

@@ -16,6 +16,8 @@ authors as well as build tool and IDE vendors.
 
 include::{includedir}/link-attributes.adoc[]
 
+include::{basedir}/release-notes-5.10.0-M1.adoc[]
+
 include::{basedir}/release-notes-5.9.1.adoc[]
 
 include::{basedir}/release-notes-5.9.0.adoc[]

documentation/src/docs/asciidoc/release-notes/release-notes-5.10.0-M1.adoc

@@ -0,0 +1,58 @@
+[[release-notes-5.10.0-M1️]]
+== 5.10.0-M1️
+
+*Date of Release:* ❓
+
+*Scope:* ❓
+
+For a complete list of all _closed_ issues and pull requests for this release, consult the
+link:{junit5-repo}+/milestone/5.10.0-M1️?closed=1+[5.10.0-M1️] milestone page in the JUnit repository on
+GitHub.
+
+
+[[release-notes-5.10.0-M1️-junit-platform]]
+=== JUnit Platform
+
+==== Bug Fixes
+
+* Fixed fallback to ForkJoinPools Java 7 constructor on Java 9 and higher
+
+==== Deprecations and Breaking Changes
+
+* ❓
+
+==== New Features and Improvements
+
+* ❓
+
+
+[[release-notes-5.10.0-M1️-junit-jupiter]]
+=== JUnit Jupiter
+
+==== Bug Fixes
+
+* ❓
+
+==== Deprecations and Breaking Changes
+
+* ❓
+
+==== New Features and Improvements
+
+* ❓
+
+
+[[release-notes-5.10.0-M1️-junit-vintage]]
+=== JUnit Vintage
+
+==== Bug Fixes
+
+* ❓
+
+==== Deprecations and Breaking Changes
+
+* ❓
+
+==== New Features and Improvements
+
+* ❓

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

@@ -19,13 +19,16 @@
 import java.util.Deque;
 import java.util.LinkedList;
 import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.Callable;
 import java.util.concurrent.ForkJoinPool;
 import java.util.concurrent.ForkJoinPool.ForkJoinWorkerThreadFactory;
 import java.util.concurrent.ForkJoinTask;
 import java.util.concurrent.ForkJoinWorkerThread;
 import java.util.concurrent.Future;
 import java.util.concurrent.RecursiveAction;
 import java.util.concurrent.TimeUnit;
+import java.util.function.Function;
 import java.util.function.Predicate;
 
 import org.apiguardian.api.API;
@@ -81,18 +84,32 @@ private static ParallelExecutionConfiguration createConfiguration(ConfigurationP
 
 	private ForkJoinPool createForkJoinPool(ParallelExecutionConfiguration configuration) {
 		ForkJoinWorkerThreadFactory threadFactory = new WorkerThreadFactory();
-		return Try.call(() -> {
-			// Try to use constructor available in Java >= 9
-			Constructor<ForkJoinPool> constructor = ForkJoinPool.class.getDeclaredConstructor(Integer.TYPE,
-				ForkJoinWorkerThreadFactory.class, UncaughtExceptionHandler.class, Boolean.TYPE, Integer.TYPE,
-				Integer.TYPE, Integer.TYPE, Predicate.class, Long.TYPE, TimeUnit.class);
-			return constructor.newInstance(configuration.getParallelism(), threadFactory, null, false,
-				configuration.getCorePoolSize(), configuration.getMaxPoolSize(), configuration.getMinimumRunnable(),
-				configuration.getSaturatePredicate(), configuration.getKeepAliveSeconds(), TimeUnit.SECONDS);
-		}).orElseTry(() -> {
-			// Fallback for Java 8
-			return new ForkJoinPool(configuration.getParallelism(), threadFactory, null, false);
-		}).getOrThrow(cause -> new JUnitException("Failed to create ForkJoinPool", cause));
+		// Try to use constructor available in Java >= 9
+		Callable<ForkJoinPool> constructorInvocation = sinceJava9Constructor() //
+				.map(sinceJava9ConstructorInvocation(configuration, threadFactory))
+				// Fallback for Java 8
+				.orElse(sinceJava7ConstructorInvocation(configuration, threadFactory));
+		return Try.call(constructorInvocation) //
+				.getOrThrow(cause -> new JUnitException("Failed to create ForkJoinPool", cause));
+	}
+
+	private static Optional<Constructor<ForkJoinPool>> sinceJava9Constructor() {
+		return Try.call(() -> ForkJoinPool.class.getDeclaredConstructor(Integer.TYPE, ForkJoinWorkerThreadFactory.class,
+			UncaughtExceptionHandler.class, Boolean.TYPE, Integer.TYPE, Integer.TYPE, Integer.TYPE, Predicate.class,
+			Long.TYPE, TimeUnit.class)) //
+				.toOptional();
+	}
+
+	private static Function<Constructor<ForkJoinPool>, Callable<ForkJoinPool>> sinceJava9ConstructorInvocation(
+			ParallelExecutionConfiguration configuration, ForkJoinWorkerThreadFactory threadFactory) {
+		return constructor -> () -> constructor.newInstance(configuration.getParallelism(), threadFactory, null, false,
+			configuration.getCorePoolSize(), configuration.getMaxPoolSize(), configuration.getMinimumRunnable(),
+			configuration.getSaturatePredicate(), configuration.getKeepAliveSeconds(), TimeUnit.SECONDS);
+	}
+
+	private static Callable<ForkJoinPool> sinceJava7ConstructorInvocation(ParallelExecutionConfiguration configuration,
+			ForkJoinWorkerThreadFactory threadFactory) {
+		return () -> new ForkJoinPool(configuration.getParallelism(), threadFactory, null, false);
 	}
 
 	@Override
@@ -199,6 +216,7 @@ static class WorkerThreadFactory implements ForkJoinPool.ForkJoinWorkerThreadFac
 		public ForkJoinWorkerThread newThread(ForkJoinPool pool) {
 			return new WorkerThread(pool, contextClassLoader);
 		}
+
 	}
 
 	static class WorkerThread extends ForkJoinWorkerThread {
@@ -207,6 +225,7 @@ static class WorkerThread extends ForkJoinWorkerThread {
 			super(pool);
 			setContextClassLoader(contextClassLoader);
 		}
+
 	}
 
 }

platform-tests/src/test/java/org/junit/platform/engine/support/hierarchical/ForkJoinPoolHierarchicalTestExecutorServiceTests.java

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2015-2022 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.assertj.core.api.Assertions.assertThat;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.mockito.Mockito.when;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.junit.platform.commons.JUnitException;
+import org.mockito.Mock;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+@ExtendWith(MockitoExtension.class)
+class ForkJoinPoolHierarchicalTestExecutorServiceTests {
+
+	@Mock
+	ParallelExecutionConfiguration configuration;
+
+	@Test
+	void exceptionsFromInvalidConfigurationAreNotSwallowed() {
+		when(configuration.getParallelism()).thenReturn(2);
+		when(configuration.getMaxPoolSize()).thenReturn(1); // invalid, should be > parallelism
+		when(configuration.getCorePoolSize()).thenReturn(1);
+		when(configuration.getMinimumRunnable()).thenReturn(1);
+		when(configuration.getSaturatePredicate()).thenReturn(__ -> true);
+		when(configuration.getKeepAliveSeconds()).thenReturn(0);
+
+		JUnitException exception = assertThrows(JUnitException.class,
+			() -> new ForkJoinPoolHierarchicalTestExecutorService(configuration));
+		assertThat(exception).hasMessage("Failed to create ForkJoinPool");
+		assertThat(exception).rootCause().isInstanceOf(IllegalArgumentException.class);
+	}
+
+}