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

    private void redistributePendingOperations(ChannelInfo failedChannel) {
        // Get pending operations from failed channel

            for (Thread thread : threads) {
                try {
                    thread.join();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    fail("Thread interrupted");
                }
            }

            // Verify all results are consistent
            for (String result : results) {
                assertEquals("thread-test", result);

                        }
                    }
                    totalPolled.addAndGet(count);
                } catch (final InterruptedException e) {
                    Thread.currentThread().interrupt();
                } finally {
                    doneLatch.countDown();
                }
            }).start();
        }

        startLatch.countDown();
        doneLatch.await();

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

        // Stop all change watchers
        for (String path : directoryCache.keySet()) {
            changeNotifier.stopWatching(path);
        }

        // Clear caches

  /** Unblock a waiting task thread. Used by the test thread only. */
  fun interruptCoordinatorThread() {
    taskRunner.assertLockNotHeld()
    require(currentTask == TestThreadSerialTask)

    // Queue a task to interrupt the waiting coordinator.
    serialTaskQueue +=
      object : SerialTask {
        override fun start() {
          taskRunner.assertLockHeld()
          waitingCoordinatorInterrupted = true

          withLock {
            afterRun(task, -1L, false)
          }
          if (thrown is InterruptedException) {
            Thread.currentThread().interrupt()
          } else {
            throw thrown
          }
        } finally {
          currentThread.name = oldName
        }
      }
    }

  internal fun kickCoordinator(taskQueue: TaskQueue) {

            try {
                return future.get();
            } catch (final InterruptedException e) {
                logger.warn("Search operation was interrupted", e);
                Thread.currentThread().interrupt(); // Restore interrupt status
                return SearchResult.create().build();
            } catch (final ExecutionException e) {

            try {
                Thread.sleep(delayMs);
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            SearchResultBuilder builder = SearchResult.create();
            for (int i = 0; i < 10; i++) {
                Map<String, Object> doc = new HashMap<>();

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

        customThread.start();

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

        cleanupScheduler.shutdownNow();
        try {
            cleanupScheduler.awaitTermination(5, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            log.warn("Interrupted while shutting down cleanup scheduler", e);
        }

        log.info("Authentication rate limiter closed");
    }

    /**
     * Per-account attempt tracking
     */