org.apache.lucene.search.TimeLimitingCollector#getGlobalTimerThread()
org.apache.lucene.search.TimeLimitingCollector#getGlobalCounter()

@defaultMessage Don't interrupt threads use FutureUtils#cancel(Future<T>) instead
java.util.concurrent.Future#cancel(boolean)

@defaultMessage Don't try reading from paths that are not configured in Environment, resolve from Environment instead

        Thread customThread = new Thread(() -> {
            try {
                latch.await();
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }, "CustomTestThread");

        customThread.start();

        try {
            Consumer<String> searchConsumer = line -> {

#   destroys some temporary bazel data and causes longer builds.
#
#   You will need the NVIDIA Container Toolkit for GPU testing:
#   https://github.com/NVIDIA/nvidia-container-toolkit
#
#   Note: if you interrupt a bazel command on docker (ctrl-c), you
#   will need to run `docker exec tf pkill bazel` to quit bazel.
#
#   Note: new files created from the container are owned by "root".

    @Override
    protected void tearDown(TestInfo testInfo) throws Exception {
        if (indexUpdater != null && indexUpdater.isAlive()) {
            indexUpdater.setFinishCrawling(true);
            indexUpdater.interrupt();
            indexUpdater.join(1000);
        }
        super.tearDown(testInfo);
    }

    // Test initialization
    @Test
    public void test_init() {
        indexUpdater.init();

            }

            @Override
            public void destroy() {
                // Override to avoid null pointer issues with thread
                generating = false;
                // Don't need to interrupt thread since we never start it in tests
            }
        };
        manager.init();
        assertTrue(manager.baseDir.exists());
        manager.destroy();
    }

    // Test initialization failure

                            }
                        });
                        successCount.incrementAndGet();
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } catch (CIFSException e) {
                        if (e.getMessage().contains("backpressure")) {
                            rejectedCount.incrementAndGet();
                        }

            if (!channelExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                channelExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // Private helper methods

    private int getMaxChannelsFromConfig(Configuration config) {
        // In a real implementation, this would read from configuration

                        assertTrue(pwd == null || pwd.equals("ConcurrentPass123!"));
                    }
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            });
        }

        // Start all threads
        for (Thread t : threads) {
            t.start();
        }

        // Wait for all threads to complete

                            completedOps.incrementAndGet();
                        }
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                    } finally {
                        endLatch.countDown();
                    }
                });
            }

            startLatch.countDown(); // Start all threads

                    cleanupExecutor.shutdownNow();
                }
            } catch (InterruptedException e) {
                cleanupExecutor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }

        // Clean up expired weak references
        cleanupExpiredReferences();

        // Release all leases
        releaseAll();

        // Clear file cache