POOL-425 Add failing tests to reproduce POOL-426

Author: raju.gupta

src/test/java/org/apache/commons/pool2/impl/TestGenericObjectPool.java

@@ -43,6 +43,7 @@
 import java.util.Timer;
 import java.util.TimerTask;
 import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.CyclicBarrier;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.Executors;
 import java.util.concurrent.FutureTask;
@@ -1012,18 +1013,21 @@ void testAddObjectConcurrentCallsRespectsMaxIdle() throws Exception {
             pool.setMaxIdle(maxIdleLimit);
             pool.setMaxTotal(-1);
 
-            final CountDownLatch startLatch = new CountDownLatch(1);
-            List<Runnable> tasks = getRunnables(numThreads, startLatch, pool);
+            final CyclicBarrier barrier = new CyclicBarrier(numThreads);
+            List<Runnable> tasks = getRunnables(numThreads, barrier, pool);
 
             ExecutorService executorService = Executors.newFixedThreadPool(numThreads);
-            tasks.forEach(executorService::submit);
             try {
-                startLatch.countDown(); // Start all threads simultaneously
-            } finally {
+                tasks.forEach(executorService::submit);
                 executorService.shutdown();
-                assertTrue(executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS));
+                assertTrue(executorService.awaitTermination(60, TimeUnit.SECONDS),
+                    "Executor did not terminate in time");
+            } finally {
+                executorService.shutdownNow(); // Ensure cleanup
             }
 
+            assertTrue(executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS));
+
             assertTrue(pool.getNumIdle() <= maxIdleLimit,
                 "Concurrent addObject() calls should not exceed maxIdle limit of " + maxIdleLimit +
                     ", but found " + pool.getNumIdle() + " idle objects");
@@ -1037,22 +1041,23 @@ void testReturnObjectRespectsMaxIdleLimit() throws Exception {
         config.setJmxEnabled(false);
         try (final GenericObjectPool<String> pool = new GenericObjectPool<>(new SimpleFactory(), config)) {
             assertEquals(0, pool.getNumIdle(), "should be zero idle");
-            final int maxIdleLimit = 5;
-            final int numThreads = 100;
+            final int maxIdleLimit = 10;
+            final int numThreads = 200;
 
             pool.setMaxTotal(-1);
             pool.setMaxIdle(maxIdleLimit);
 
-            final CountDownLatch startLatch = new CountDownLatch(1);
-            List<Runnable> tasks = getReturnRunnables(numThreads, startLatch, pool);
+            final CyclicBarrier barrier = new CyclicBarrier(numThreads);
+            List<Runnable> tasks = getReturnRunnables(numThreads, barrier, pool);
 
             ExecutorService executorService = Executors.newFixedThreadPool(numThreads);
-            tasks.forEach(executorService::submit);
             try {
-                startLatch.countDown(); // Start all threads simultaneously
-            } finally {
+                tasks.forEach(executorService::submit);
                 executorService.shutdown();
-                assertTrue(executorService.awaitTermination(Long.MAX_VALUE, TimeUnit.NANOSECONDS));
+                assertTrue(executorService.awaitTermination(60, TimeUnit.SECONDS),
+                    "Executor did not terminate in time");
+            } finally {
+                executorService.shutdownNow(); // Ensure cleanup
             }
 
             assertEquals(maxIdleLimit, pool.getNumIdle(),
@@ -1061,14 +1066,14 @@ void testReturnObjectRespectsMaxIdleLimit() throws Exception {
     }
 
     private List<Runnable> getRunnables(final int numThreads,
-                                        final CountDownLatch startLatch,
+                                        final CyclicBarrier barrier,
                                         final GenericObjectPool<String> pool) {
         List<Runnable> tasks = new ArrayList<>();
 
         for(int i = 0; i < numThreads; i++) {
             tasks.add(() -> {
                 try {
-                    startLatch.await(); // Wait for all threads to be ready
+                    barrier.await(); // Wait for all threads to be ready
                     pool.addObject();
                 } catch (Exception e) {
                     // do nothing
@@ -1079,15 +1084,15 @@ private List<Runnable> getRunnables(final int numThreads,
     }
 
     private List<Runnable> getReturnRunnables(final int numThreads,
-                                              final CountDownLatch startLatch,
+                                              final CyclicBarrier barrier,
                                               final GenericObjectPool<String> pool) {
         List<Runnable> tasks = new ArrayList<>();
 
         for(int i = 0; i < numThreads; i++) {
             tasks.add(() -> {
                 try {
                     String pooledObject = pool.borrowObject();
-                    startLatch.await(); // Wait for all threads to be ready
+                    barrier.await(); // Wait for all threads to be ready
                     pool.returnObject(pooledObject);
                 } catch (Exception e) {
                     // do nothing