More progress.

dweiss · dweiss · commit 2f1b8fbb2358 · 2026-03-10T14:48:07.000+01:00
diff --git a/randomizedtesting-jupiter/src/main/java/com/carrotsearch/randomizedtesting/jupiter/DetectThreadLeaks.java b/randomizedtesting-jupiter/src/main/java/com/carrotsearch/randomizedtesting/jupiter/DetectThreadLeaks.java
@@ -30,4 +30,18 @@ enum Scope {
     /** Check for leaked threads after each individual test method. */
     TEST
   }
+
+  /**
+   * Milliseconds to wait for leaked threads to self-terminate before declaring a failure. If all
+   * leaked threads terminate within this window, the test passes. Default is 0 (no lingering).
+   *
+   * <p>Place this annotation on the same class as {@link DetectThreadLeaks}.
+   */
+  @Target({ElementType.TYPE, ElementType.METHOD})
+  @Retention(RetentionPolicy.RUNTIME)
+  @Documented
+  @Inherited
+  @interface LingerTime {
+    int millis();
+  }
 }
diff --git a/randomizedtesting-jupiter/src/main/java/com/carrotsearch/randomizedtesting/jupiter/DetectThreadLeaksExtension.java b/randomizedtesting-jupiter/src/main/java/com/carrotsearch/randomizedtesting/jupiter/DetectThreadLeaksExtension.java
@@ -1,6 +1,8 @@
 package com.carrotsearch.randomizedtesting.jupiter;
 
 import java.util.HashSet;
+import java.util.Map;
+import java.util.concurrent.TimeUnit;
 import java.util.logging.Logger;
 import java.util.stream.Collectors;
 import org.junit.jupiter.api.extension.AfterAllCallback;
@@ -20,6 +22,9 @@ public class DetectThreadLeaksExtension
   private static final String SNAPSHOT_KEY = "snapshot";
   private static final String CONCURRENT_KEY = "concurrent";
 
+  /** Total time budget (ms) to join interrupted threads before giving up. */
+  private static final long INTERRUPT_JOIN_MS = 2_000L;
+
   @Override
   public void beforeAll(ExtensionContext context) {
     if (context.getExecutionMode() != ExecutionMode.SAME_THREAD) {
@@ -40,7 +45,10 @@ public void afterAll(ExtensionContext context) {
     if (isConcurrentMode(context) || scope(context) != DetectThreadLeaks.Scope.SUITE) {
       return;
     }
-    checkLeaks(context.getStore(EXTENSION_NAMESPACE), "suite [" + context.getDisplayName() + "]");
+    checkLeaks(
+        context.getStore(EXTENSION_NAMESPACE),
+        "suite [" + context.getDisplayName() + "]",
+        linger(context));
   }
 
   @Override
@@ -56,13 +64,29 @@ public void afterEach(ExtensionContext context) {
     if (isConcurrentMode(context) || scope(context) != DetectThreadLeaks.Scope.TEST) {
       return;
     }
-    checkLeaks(context.getStore(EXTENSION_NAMESPACE), "test [" + context.getDisplayName() + "]");
+    checkLeaks(
+        context.getStore(EXTENSION_NAMESPACE),
+        "test [" + context.getDisplayName() + "]",
+        linger(context));
   }
 
   private static DetectThreadLeaks.Scope scope(ExtensionContext context) {
     return context.getRequiredTestClass().getAnnotation(DetectThreadLeaks.class).scope();
   }
 
+  private static int linger(ExtensionContext context) {
+    // Method-level annotation takes precedence over class-level.
+    var methodAnn =
+        context
+            .getTestMethod()
+            .map(m -> m.getAnnotation(DetectThreadLeaks.LingerTime.class))
+            .orElse(null);
+    if (methodAnn != null) return methodAnn.millis();
+
+    var classAnn = context.getRequiredTestClass().getAnnotation(DetectThreadLeaks.LingerTime.class);
+    return classAnn == null ? 0 : classAnn.millis();
+  }
+
   private static boolean isConcurrentMode(ExtensionContext context) {
     // Check the concurrent flag stored in beforeAll (class-level context = parent of method ctx).
     return context
@@ -74,26 +98,70 @@ private static boolean isConcurrentMode(ExtensionContext context) {
         .orElse(false);
   }
 
-  private static void checkLeaks(ExtensionContext.Store store, String description) {
+  private static void checkLeaks(ExtensionContext.Store store, String description, int lingerMs) {
     var snapshot = store.get(SNAPSHOT_KEY, HashSet.class);
     if (snapshot == null) return;
 
-    var leaked = liveThreads();
-    leaked.removeAll(snapshot);
-    leaked.removeIf(t -> !t.isAlive());
+    var leaked = leakedSince(snapshot);
+    if (leaked.isEmpty()) return;
+
+    // Linger: poll until threads self-terminate or the window expires.
+    if (lingerMs > 0) {
+      long deadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(lingerMs);
+      while (!leaked.isEmpty() && System.nanoTime() < deadline) {
+        try {
+          long remainingMs = TimeUnit.NANOSECONDS.toMillis(deadline - System.nanoTime());
+          Thread.sleep(Math.max(1L, Math.min(100L, remainingMs)));
+        } catch (InterruptedException e) {
+          Thread.currentThread().interrupt();
+          break;
+        }
+        leaked = leakedSince(snapshot);
+      }
+      if (leaked.isEmpty()) return;
+    }
+
+    // Interrupt leaked threads for cleanup, then wait briefly for them to terminate.
+    leaked.keySet().forEach(Thread::interrupt);
+    long joinDeadline = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(INTERRUPT_JOIN_MS);
+    for (Thread t : leaked.keySet()) {
+      long remaining = TimeUnit.NANOSECONDS.toMillis(joinDeadline - System.nanoTime());
+      if (remaining <= 0) break;
+      try {
+        t.join(remaining);
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+        break;
+      }
+    }
 
-    if (!leaked.isEmpty()) {
-      var sb = new StringBuilder(leaked.size() + " thread(s) leaked from " + description + ":");
-      leaked.forEach(t -> sb.append("\n  ").append(Threads.threadName(t)));
-      throw new AssertionError(sb.toString());
+    // Report failure with stack traces captured before the interrupt.
+    var sb = new StringBuilder(leaked.size() + " thread(s) leaked from " + description + ":");
+    int cnt = 1;
+    for (var entry : leaked.entrySet()) {
+      sb.append(String.format("%n  %2d) %s", cnt++, Threads.threadName(entry.getKey())));
+      for (var ste : entry.getValue()) {
+        sb.append(String.format("%n        at %s", ste));
+      }
     }
+    throw new AssertionError(sb.toString());
+  }
+
+  private static Map<Thread, StackTraceElement[]> leakedSince(HashSet<?> snapshot) {
+    var current = liveThreadsWithStacks();
+    current.keySet().removeAll(snapshot);
+    return current;
   }
 
   private static HashSet<Thread> liveThreads() {
-    return Thread.getAllStackTraces().keySet().stream()
-        .filter(Thread::isAlive)
-        .filter(t -> !isKnownSystemThread(t))
-        .collect(Collectors.toCollection(HashSet::new));
+    return new HashSet<>(liveThreadsWithStacks().keySet());
+  }
+
+  private static Map<Thread, StackTraceElement[]> liveThreadsWithStacks() {
+    return Thread.getAllStackTraces().entrySet().stream()
+        .filter(e -> e.getKey().isAlive())
+        .filter(e -> !isKnownSystemThread(e.getKey()))
+        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));
   }
 
   private static boolean isKnownSystemThread(Thread t) {
diff --git a/randomizedtesting-jupiter/src/test/java/com/carrotsearch/randomizedtesting/jupiter/F005_ThreadLeaks.java b/randomizedtesting-jupiter/src/test/java/com/carrotsearch/randomizedtesting/jupiter/F005_ThreadLeaks.java
@@ -7,6 +7,7 @@
 import com.carrotsearch.randomizedtesting.jupiter.infra.IgnoreInStandaloneRuns;
 import java.util.concurrent.TimeUnit;
 import java.util.stream.Stream;
+import org.assertj.core.api.Condition;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.DynamicTest;
@@ -70,6 +71,33 @@ static void beforeAll() {
     }
   }
 
+  @Nested
+  class TestStackTracesInMessage {
+    @Test
+    void leakErrorMessageContainsStackTrace() {
+      collectExecutionResults(testKitBuilder(SuiteScopeWithLeak.class))
+          .results()
+          .allEvents()
+          .finished()
+          .failed()
+          .assertEventsMatchExactly(
+              event(
+                  finishedWithFailure(
+                      instanceOf(AssertionError.class),
+                      new Condition<>(
+                          t -> t.getMessage().contains(getClass().getPackageName()),
+                          "error message contains stack frames"))));
+    }
+
+    @DetectThreadLeaks(scope = DetectThreadLeaks.Scope.SUITE)
+    static class SuiteScopeWithLeak extends IgnoreInStandaloneRuns {
+      @Test
+      void testMethod() {
+        startSleepingThread();
+      }
+    }
+  }
+
   @Nested
   class TestTestScope {
     @Test
@@ -91,6 +119,114 @@ void testMethod() {
     }
   }
 
+  @Nested
+  class TestLinger {
+    @Test
+    void threadTerminatingWithinLingerWindowPasses() {
+      collectExecutionResults(testKitBuilder(ShortLivedLeak.class))
+          .results()
+          .allEvents()
+          .assertThatEvents()
+          .doNotHave(event(finishedWithFailure()));
+    }
+
+    @Test
+    void methodLingerTakesPrecedenceOverAbsentClassLinger() {
+      collectExecutionResults(testKitBuilder(MethodLingerOverridesAbsentClassLinger.class))
+          .results()
+          .allEvents()
+          .assertThatEvents()
+          .doNotHave(event(finishedWithFailure()));
+    }
+
+    @Test
+    void methodLingerTakesPrecedenceOverClassLinger() {
+      collectExecutionResults(testKitBuilder(MethodLingerOverridesClassLinger.class))
+          .results()
+          .allEvents()
+          .assertThatEvents()
+          .doNotHave(event(finishedWithFailure()));
+    }
+
+    @Test
+    void threadOutlastingLingerWindowFails() {
+      collectExecutionResults(testKitBuilder(LongLivedLeak.class))
+          .results()
+          .allEvents()
+          .finished()
+          .failed()
+          .assertEventsMatchExactly(event(finishedWithFailure(instanceOf(AssertionError.class))));
+    }
+
+    // Class linger 10s; thread sleeps 100ms → terminates before linger expires → pass.
+    @DetectThreadLeaks(scope = DetectThreadLeaks.Scope.SUITE)
+    @DetectThreadLeaks.LingerTime(millis = 10_000)
+    static class ShortLivedLeak extends IgnoreInStandaloneRuns {
+      @Test
+      void testMethod() {
+        var t =
+            new Thread(
+                () -> {
+                  try {
+                    Thread.sleep(100);
+                  } catch (InterruptedException ignored) {
+                  }
+                });
+        t.setDaemon(true);
+        t.start();
+      }
+    }
+
+    // Class linger 50ms; thread sleeps 1 min → outlasts linger → fail.
+    @DetectThreadLeaks(scope = DetectThreadLeaks.Scope.SUITE)
+    @DetectThreadLeaks.LingerTime(millis = 50)
+    static class LongLivedLeak extends IgnoreInStandaloneRuns {
+      @Test
+      void testMethod() {
+        startSleepingThread();
+      }
+    }
+
+    // Method linger 10s overrides absent class linger; thread sleeps 100ms → pass.
+    @DetectThreadLeaks(scope = DetectThreadLeaks.Scope.TEST)
+    static class MethodLingerOverridesAbsentClassLinger extends IgnoreInStandaloneRuns {
+      @Test
+      @DetectThreadLeaks.LingerTime(millis = 10_000)
+      void testMethod() {
+        var t =
+            new Thread(
+                () -> {
+                  try {
+                    Thread.sleep(100);
+                  } catch (InterruptedException ignored) {
+                  }
+                });
+        t.setDaemon(true);
+        t.start();
+      }
+    }
+
+    // Method linger 10s overrides class linger 50ms; thread sleeps 100ms → pass.
+    @DetectThreadLeaks(scope = DetectThreadLeaks.Scope.TEST)
+    @DetectThreadLeaks.LingerTime(millis = 50)
+    static class MethodLingerOverridesClassLinger extends IgnoreInStandaloneRuns {
+      @Test
+      @DetectThreadLeaks.LingerTime(millis = 10_000)
+      void testMethod() {
+        var t =
+            new Thread(
+                () -> {
+                  try {
+                    Thread.sleep(100);
+                  } catch (InterruptedException ignored) {
+                  }
+                });
+        t.setDaemon(true);
+        t.start();
+      }
+    }
+  }
+
   @Nested
   class TestConcurrentMode {
     @Test
diff --git a/randomizedtesting-jupiter/src/test/java/com/carrotsearch/randomizedtesting/jupiter/F005_ThreadLeaks.md b/randomizedtesting-jupiter/src/test/java/com/carrotsearch/randomizedtesting/jupiter/F005_ThreadLeaks.md
@@ -3,7 +3,7 @@
 ## Functionality
 
 * It should be possible to add a `@DetectThreadLeaks` extension which detects new threads forked within the test 
-container. This extension takes a single parameter - the scope of detection. Either we care about threads leaked
+container. This extension takes a parameter - the scope of detection. Either we care about threads leaked
 from the entire container or from each individual test. Here is an example of use:
 
 ```java
@@ -22,6 +22,22 @@ public class TestClass {
 * The extension is only functional in sequential mode. It should emit a warning and do nothing if tests are
 run in concurrent mode.
 
+* Occasionally there will be threads that cannot be joined but will eventually terminate. One can specify an additional
+"linger" time before the thread leak is reported, for example one second, below:
+  
+```java
+@DetectThreadLeaks(scope = DetectThreadLeaks.Scope.SUITE)
+@DetectThreadLeaks.LingerTime(millis = 1_000)
+public class TestClass {
+    @Test
+    public void testMethod() {
+        new Thread(() -> {
+            try { Thread.sleep(1000); } catch (Exception e) {}
+        }).start();
+    }
+}
+```
+
 ## Migration notes (from randomizedtesting for junit4)
 
 * 
