public void testSetFuture_misbehavingFutureDoesNotThrow() throws Exception {
    ListenableFuture<String> badFuture =
        new ListenableFuture<String>() {
          @Override
          public boolean cancel(boolean interrupt) {
            return false;
          }

          @Override
          public boolean isDone() {
            return true;
          }

          @Override

                null);

        // Wait for expiration
        try {
            Thread.sleep(150);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        HandleInfo info = manager.getHandleForReconnect("/test/file.txt");
        assertNull(info);
    }

    @Test
    public void testCompleteReconnectSuccess() {

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

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

        // Clear caches

                }

            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                throw new RuntimeException("Reconnection interrupted", e);
            } catch (Exception e) {
                log.debug("Reconnection attempt {} failed for {}: {}", attempt + 1, info.getPath(), e.getMessage());

        }

        if (serverThread != null) {
            try {
                serverThread.join(5000); // Wait up to 5 seconds
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }
        }

        registrations.clear();
        log.info("Mock witness service stopped");
    }

    /**
     * Get the address the service is listening on
     *

  /** 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

    }

    /**
     * Stops the crawling process.
     * Sets the crawler status to DONE and interrupts all crawler threads.
     */
    public void stop() {
        crawlerContext.setStatus(CrawlerStatus.DONE);
        try {
            if (crawlerThreadGroup != null) {
                crawlerThreadGroup.interrupt();
            }
        } catch (final Exception e) {
            // ignore
        }
    }

                try {
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                    break;
                }
            }
            assertEquals(CrawlerStatus.RUNNING, crawler.crawlerContext.getStatus());
            crawler.awaitTermination();

  override fun request(): Request = originalRequest

  /**
   * Immediately closes the socket connection if it's currently held. Use this to interrupt an
   * in-flight request from any thread. It's the caller's responsibility to close the request body
   * and response body streams; otherwise resources may be leaked.
   *

            throw new CommandExecutionException("Process terminated.", e);
        } finally {
            if (mt != null) {
                mt.setFinished(true);
                try {
                    mt.interrupt();
                } catch (final Exception e) {
                    // ignore
                }
            }
            if (currentProcess != null) {
                try {