Merge branch 'main' into renovate/jackson-monorepo

Author: MarkusPaulsen

src/main/java/de/tum/cit/ase/ares/api/internal/TimeoutUtils.java

@@ -85,17 +85,20 @@ private static <T> T executeWithTimeout(Duration timeout, Callable<T> action, Te
 		}
 	}
 
-	private static void terminateTimedOutExecution(Future<?> future, ExecutorService executorService,
+	static void terminateTimedOutExecution(Future<?> future, ExecutorService executorService,
 			Duration terminationGracePeriod, IntConsumer fatalProcessTerminator) {
+		executorService.shutdown();
 		future.cancel(true);
-		executorService.shutdownNow();
 		/*
-		 * Give interruption-aware code time to finish before the owning thread
-		 * continues. If it ignores interruption, the fork is already contaminated:
-		 * returning would let untrusted code outlive its security, IO and reporting
-		 * lifecycle and affect later tests in a reused JVM. Thread.stop() cannot repair
-		 * that safely or reliably, so fail closed by terminating the complete worker
-		 * process and let Maven, Gradle or the IDE report the crashed test fork.
+		 * Future.cancel(true) delivers the single interruption that asks the timed-out
+		 * execution to stop. Calling shutdownNow() here would interrupt the worker a
+		 * second time; that interruption can race with interruption-aware code leaving
+		 * its body. Give it time to finish before the owning thread continues. If it
+		 * ignores interruption, the fork is already contaminated: returning would let
+		 * untrusted code outlive its security, IO and reporting lifecycle and affect
+		 * later tests in a reused JVM. Thread.stop() cannot repair that safely or
+		 * reliably, so fail closed by terminating the complete worker process and let
+		 * Maven, Gradle or the IDE report the crashed test fork.
 		 */
 		if (!awaitTermination(executorService, terminationGracePeriod.toMillis())) {
 			fatalProcessTerminator.accept(UNRESPONSIVE_TIMEOUT_EXIT_CODE);

src/main/java/de/tum/cit/ase/ares/api/jqwik/JqwikContext.java

@@ -6,15 +6,15 @@
 import org.apiguardian.api.API;
 import org.apiguardian.api.API.Status;
 
-import net.jqwik.api.lifecycle.PropertyLifecycleContext;
+import net.jqwik.api.lifecycle.*;
 
 import de.tum.cit.ase.ares.api.context.*;
 
 @API(status = Status.INTERNAL)
 public class JqwikContext extends TestContext {
-	private final PropertyLifecycleContext lifecycleContext;
+	private final MethodLifecycleContext lifecycleContext;
 
-	JqwikContext(PropertyLifecycleContext lifecycleContext) {
+	JqwikContext(MethodLifecycleContext lifecycleContext) {
 		this.lifecycleContext = lifecycleContext;
 	}
 
@@ -44,13 +44,20 @@ public Optional<String> displayName() {
 	}
 
 	public PropertyLifecycleContext getPropertyLifecycleContext() {
-		return lifecycleContext;
+		if (lifecycleContext instanceof PropertyLifecycleContext propertyLifecycleContext) {
+			return propertyLifecycleContext;
+		}
+		throw new IllegalStateException("This context represents a jqwik try, not a property"); //$NON-NLS-1$
 	}
 
 	public static JqwikContext of(PropertyLifecycleContext lifecycleContext) {
 		return new JqwikContext(lifecycleContext);
 	}
 
+	public static JqwikContext of(TryLifecycleContext lifecycleContext) {
+		return new JqwikContext(lifecycleContext);
+	}
+
 	@Override
 	public Optional<TestType> findTestType() {
 		return TestContextUtils.findAnnotationIn(this, JqwikAresTest.class).map(JqwikAresTest::value);

src/main/java/de/tum/cit/ase/ares/api/jqwik/JqwikStrictTimeoutExtension.java

@@ -1,6 +1,7 @@
 package de.tum.cit.ase.ares.api.jqwik;
 
 import java.time.Duration;
+import java.util.List;
 
 import org.apiguardian.api.API;
 import org.apiguardian.api.API.Status;
@@ -29,27 +30,28 @@
  * @author Christian Femers
  */
 @API(status = Status.MAINTAINED)
-public class JqwikStrictTimeoutExtension implements AroundPropertyHook {
+public class JqwikStrictTimeoutExtension implements AroundTryHook {
 	private static final Duration TERMINATION_GRACE_PERIOD = Duration.ofSeconds(1);
 
 	@Override
-	public int aroundPropertyProximity() {
+	public int aroundTryProximity() {
 		/*
-		 * Keep the timeout inside Ares's security, IO and reporting hooks. Their setup
-		 * and cleanup mutate engine-wide state and must remain on jqwik's owning
-		 * thread; only the actual property execution belongs on the timeout worker.
+		 * Keep the timeout inside jqwik's try lifecycle and Ares's security, IO and
+		 * reporting hooks. Their setup and cleanup mutate engine-wide state and must
+		 * remain on jqwik's owning thread; only one invocation of the property method
+		 * belongs on the timeout worker.
 		 */
 		return 40;
 	}
 
 	@Override
-	public PropertyExecutionResult aroundProperty(PropertyLifecycleContext context, PropertyExecutor property)
+	public TryExecutionResult aroundTry(TryLifecycleContext context, TryExecutor aTry, List<Object> parameters)
 			throws Throwable {
 		DomainContext domainContext = CurrentDomainContext.get();
 		TestDescriptor desc = CurrentTestDescriptor.get();
 		return TimeoutUtils.performTimeoutExecution(
 				() -> CurrentDomainContext.runWithContext(domainContext,
-						() -> CurrentTestDescriptor.runWithDescriptor(desc, property::execute)),
+						() -> CurrentTestDescriptor.runWithDescriptor(desc, () -> aTry.execute(parameters))),
 				JqwikContext.of(context), TERMINATION_GRACE_PERIOD);
 	}
 }

src/test/java/de/tum/cit/ase/ares/api/internal/TimeoutUtilsTest.java

@@ -2,22 +2,41 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.fail;
 import static org.mockito.Mockito.*;
 
 import java.lang.reflect.Method;
 import java.nio.file.Path;
+import java.time.Duration;
 import java.util.Optional;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Future;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicInteger;
 
 import org.junit.jupiter.api.Test;
+import org.mockito.InOrder;
 import org.opentest4j.AssertionFailedError;
 
 import de.tum.cit.ase.ares.api.StrictTimeout;
 import de.tum.cit.ase.ares.api.context.TestContext;
 
 class TimeoutUtilsTest {
+	@Test
+	void timedOutExecutionUsesOneCancellationInterrupt() {
+		Future<?> future = mock(Future.class);
+		ExecutorService executorService = mock(ExecutorService.class);
+		when(executorService.isTerminated()).thenReturn(true);
+
+		TimeoutUtils.terminateTimedOutExecution(future, executorService, Duration.ofSeconds(1),
+				exitCode -> fail("Interruption-aware execution must not request fatal termination")); //$NON-NLS-1$
+
+		InOrder cancellationOrder = inOrder(executorService, future);
+		cancellationOrder.verify(executorService).shutdown();
+		cancellationOrder.verify(future).cancel(true);
+		verify(executorService, never()).shutdownNow();
+	}
 
 	@Test
 	void interruptionAwareExecutionFinishesBeforeControlReturns() throws Exception {

src/test/java/de/tum/cit/ase/ares/integration/JqwickTest.java

@@ -36,6 +36,7 @@ class JqwickTest {
 	private final String provokeTimeoutSleepExample = "provokeTimeoutSleepExample";
 	private final String provokeTimeoutSleepProperty = "provokeTimeoutSleepProperty";
 	private final String provokeTimeoutSleepTries = "provokeTimeoutSleepTries";
+	private final String strictTimeoutAppliesPerTry = "strictTimeoutAppliesPerTry";
 	private final String testHiddenIncomplete = "testHiddenIncomplete";
 	private final String testLocaleDe = "testLocaleDe";
 	private final String testPublicIncomplete = "testPublicIncomplete";
@@ -125,6 +126,11 @@ void test_provokeTimeoutSleepTries() {
 		tests.assertThatEvents().haveExactly(1, testFailedWith(provokeTimeoutSleepTries, AssertionFailedError.class));
 	}
 
+	@TestTest
+	void test_strictTimeoutAppliesPerTry() {
+		tests.assertThatEvents().haveExactly(1, finishedSuccessfully(strictTimeoutAppliesPerTry));
+	}
+
 	@TestTest
 	void test_testHiddenIncomplete() {
 		tests.assertThatEvents().doNotHave(event(test(testHiddenIncomplete)));

src/test/java/de/tum/cit/ase/ares/integration/testuser/JqwickUser.java

@@ -138,6 +138,13 @@ void provokeTimeoutSleepTries(@SuppressWarnings("unused") @ForAll @Positive int
 		sleepUntilInterrupted();
 	}
 
+	@Public
+	@Property(tries = 5)
+	@StrictTimeout(value = 250, unit = TimeUnit.MILLISECONDS)
+	void strictTimeoutAppliesPerTry(@SuppressWarnings("unused") @ForAll int x) throws InterruptedException {
+		Thread.sleep(100);
+	}
+
 	private void sleepUntilInterrupted() throws InterruptedException {
 		try {
 			Thread.sleep(300);