Test all supported Java versions (#167)

And fix a bit of test flakiness

.github/workflows/maven.yml

@@ -6,17 +6,33 @@ on:
   pull_request:
     branches: [ "main" ]
 
+env:
+  MAVEN_OPTS: -Dhttp.keepAlive=false -Dmaven.wagon.http.pool=false -Dmaven.wagon.http.retryhandler.count=5 -Dmaven.wagon.httpconnectionManager.ttlSeconds=240 -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn
+
 jobs:
   build:
-
+    strategy:
+      fail-fast: false
+      matrix:
+        java-version: [11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22]
     runs-on: ubuntu-latest
-
     steps:
     - uses: actions/checkout@v2
-    - name: Set up JDK 11
+    - name: Set up Java
       uses: actions/setup-java@v2
       with:
-        java-version: '11'
-        distribution: 'adopt'
+        java-version: ${{ matrix.java-version }}
+        distribution: 'zulu'
     - name: Build with Maven
-      run: ./mvnw -Dorg.slf4j.simpleLogger.log.org.apache.maven.cli.transfer.Slf4jMavenTransferListener=warn verify -B
+      run: ./mvnw -Dmaven.javadoc.skip=true verify -B
+  site:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - name: Set up Java
+        uses: actions/setup-java@v2
+        with:
+          java-version: '11'
+          distribution: 'zulu'
+      - name: Build with Maven
+        run: ./mvnw verify package site -B

src/test/java/blackbox/ThreadBasedPoolTest.java

@@ -720,4 +720,10 @@ void tryClaimMustReturnIfPoolIsNotEmpty(Taps taps) throws Exception {
     noBackgroundExpirationChecking();
     super.tryClaimMustReturnIfPoolIsNotEmpty(taps);
   }
+
+  @Override
+  void managedPoolMustGiveNumberOfAllocatedAndInUseObjects() throws Exception {
+    noBackgroundExpirationChecking();
+    super.managedPoolMustGiveNumberOfAllocatedAndInUseObjects();
+  }
 }

src/test/java/blackbox/slow/PoolIT.java

@@ -20,6 +20,7 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.TestInfo;
 import org.junit.jupiter.api.extension.ExtendWith;
 import org.junit.jupiter.api.extension.RegisterExtension;
 import stormpot.Completion;
@@ -88,8 +89,9 @@ void setUp() {
   protected abstract PoolBuilder<GenericPoolable> createPoolBuilder(CountingAllocator allocator);
 
   @AfterEach
-  void verifyObjectsAreNeverDeallocatedMoreThanOnce() throws InterruptedException {
-    assertTrue(pool.shutdown().await(shortTimeout), "pool should have been shut down by the test");
+  void verifyObjectsAreNeverDeallocatedMoreThanOnce(TestInfo info) throws InterruptedException {
+    assertTrue(pool.shutdown().await(shortTimeout),
+            "pool should have been shut down by the test: " + info.getDisplayName());
     pool = null;
 
     List<GenericPoolable> deallocated = allocator.getDeallocations();

src/test/java/extensions/ExecutorExtension.java

@@ -20,12 +20,11 @@
 import org.junit.jupiter.api.extension.Extension;
 import org.junit.jupiter.api.extension.ExtensionContext;
 
-import java.util.ArrayList;
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.StringJoiner;
+import java.lang.management.LockInfo;
+import java.lang.management.ManagementFactory;
+import java.lang.management.MonitorInfo;
+import java.lang.management.ThreadInfo;
+import java.util.*;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
@@ -161,12 +160,19 @@ void verifyAllThreadsTerminatedSuccessfully() {
     }
 
     void dumpAllThreads() {
+      ThreadInfo[] threadInfos = ManagementFactory.getThreadMXBean().dumpAllThreads(true, true);
+      Map<Long, ThreadInfo> infos = new HashMap<>();
+      for (ThreadInfo threadInfo : threadInfos) {
+        infos.put(threadInfo.getThreadId(), threadInfo);
+      }
       synchronized (threads) {
         System.err.println(
             "\n===[ Dumping stack traces for all created threads ]===\n");
+        Set<Long> createdThreads = new HashSet<>();
         for (Thread thread : threads) {
+          createdThreads.add(thread.getId());
           StackTraceElement[] stackTrace = thread.getStackTrace();
-          printStackTrace(thread, stackTrace);
+          printStackTrace(thread, infos.get(thread.getId()), stackTrace);
         }
         System.err.println(
             "\n===[ End stack traces for all created threads ]===\n");
@@ -176,21 +182,42 @@ void dumpAllThreads() {
         Set<Map.Entry<Thread, StackTraceElement[]>> entries =
             Thread.getAllStackTraces().entrySet();
         for (Map.Entry<Thread,StackTraceElement[]> entry : entries) {
-          printStackTrace(entry.getKey(), entry.getValue());
+          Thread thread = entry.getKey();
+          if (!createdThreads.contains(thread.getId())) {
+            printStackTrace(thread, infos.get(thread.getId()), entry.getValue());
+          }
         }
         System.err.println(
             "\n===[ End stack traces for all other threads ]===\n");
       }
     }
 
     private void printStackTrace(
-        Thread thread,
-        StackTraceElement[] stackTrace) {
-      Exception printer = new Exception(
-          "Stack trace for " + thread + " (id " + thread.getId() +
-              "), state = " + thread.getState());
-      printer.setStackTrace(stackTrace);
-      printer.printStackTrace();
+            Thread thread,
+            ThreadInfo info,
+            StackTraceElement[] stackTrace) {
+      Thread.State state = thread.getState();
+      LockInfo lockInfo = info.getLockInfo();
+      MonitorInfo[] monitors = info.getLockedMonitors();
+      Map<StackTraceElement, MonitorInfo> locks = new HashMap<>();
+      for (MonitorInfo monitor : monitors) {
+        locks.put(monitor.getLockedStackFrame(), monitor);
+      }
+      System.err.printf("\"%s\" #%s prio=%s daemon=%s tid=0 nid=0 %s%n   java.lang.Thread.State: %s%n",
+              thread.getName(), thread.getId(), thread.getPriority(), thread.isDaemon(),
+              state.toString().toLowerCase(), state);
+      for (StackTraceElement ste : stackTrace) {
+        System.err.printf("\tat %s%n", ste);
+        if (lockInfo != null) {
+          System.err.printf("\t- waiting on %s%n", lockInfo);
+          lockInfo = null;
+        }
+        MonitorInfo monitor = locks.get(ste);
+        if (monitor != null) {
+          System.err.printf("\t- locked %s%n", monitor);
+        }
+      }
+      System.err.println();
     }
   }
 }