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

 * {@link #runOneIteration} that will be executed periodically as specified by its {@link
 * Scheduler}. When this service is asked to stop via {@link #stopAsync} it will cancel the periodic
 * task (but not interrupt it) and wait for it to stop before running the {@link #shutDown} method.
 *
 * <p>Subclasses are guaranteed that the life cycle methods ({@link #runOneIteration}, {@link

        new Runnable() {
          @Override
          public void run() {
            try {
              okayToRun.await();
            } catch (InterruptedException e) {
              Thread.currentThread().interrupt();
              throw new RuntimeException(e);
            }
            runCalled.getAndIncrement();
          }
        },
        directExecutor());
    Runnable execute =
        new Runnable() {

            context.addInHeader("");

            context.terminal.handle(
                    Terminal.Signal.INT, signal -> Thread.currentThread().interrupt());

            context.reader =
                    LineReaderBuilder.builder().terminal(context.terminal).build();

            if (context.options().goals().isEmpty()

            context.addInHeader("");

            context.terminal.handle(
                    Terminal.Signal.INT, signal -> Thread.currentThread().interrupt());

            context.reader =
                    LineReaderBuilder.builder().terminal(context.terminal).build();

            if (context.options().goals().isEmpty()) {

        updater.setDaemon(true);
        updater.start();
    }

    @Override
    public void close() {
        if (closed.compareAndSet(false, true)) {
            updater.interrupt();
        }
    }

    public TransferListener getDelegate() {
        return delegate;
    }

    private void feedConsumer() {
        final ArrayList<Exchange> batch = new ArrayList<>(batchMaxSize);

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

   * <p>The implementation deviates from the {@code ExecutorService} specification with regards to
   * the {@code shutdownNow} method. First, "best-effort" with regards to canceling running tasks is
   * implemented as "no-effort". No interrupts or other attempts are made to stop threads executing
   * tasks. Second, the returned list will always be empty, as any submitted task is considered to

#   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".

                            failure.set(e);
                        }
                    });
                    context.terminal.handle(Terminal.Signal.INT, signal -> commandThread.interrupt());
                    commandThread.start();
                    commandThread.join();
                    if (failure.get() != null) {
                        throw failure.get();
                    }