reason: String,
        ) {
          webSocket.close(1000, null)
          latch.countDown()
        }

        override fun onFailure(
          webSocket: WebSocket,
          t: Throwable,
          response: Response?,
        ) {
          t.printStackTrace(System.out)
          latch.countDown()
        }
      },
    )

          latch2.countDown()
        }
      }
    val request2Listener: EventListener =
      object : EventListener() {
        override fun connectStart(
          call: Call,
          inetSocketAddress: InetSocketAddress,
          proxy: Proxy,
        ) {
          // Let request1 proceed to make a connection.
          latch1.countDown()
          try {

              successLatch.countDown();
            })
        .start();

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());

    future.cancel(true);

    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertTrue(successLatch.await(200, MILLISECONDS));

    latch.countDown();
  }

  protected final ListenableFutureTask<Integer> task =
      ListenableFutureTask.create(
          new Callable<Integer>() {
            @Override
            public Integer call() throws Exception {
              runLatch.countDown();
              taskLatch.await();
              if (throwException) {
                throw new IllegalStateException("Fail");
              }
              return 25;
            }
          });

    service.expectedShutdownState = Service.State.RUNNING;

    service.startAsync().awaitRunning();
    assertTrue(service.startUpCalled);
    assertEquals(Service.State.RUNNING, service.state());

    exitRun.countDown(); // the service will exit voluntarily
    executionThread.join();

    assertTrue(service.shutDownCalled);
    assertEquals(Service.State.TERMINATED, service.state());

        TrustedListenableFutureTask.create(
            new Callable<Integer>() {
              @Override
              public Integer call() throws Exception {
                enterLatch.countDown();
                try {
                  new CountDownLatch(1).await(); // wait forever
                  throw new AssertionError();
                } catch (InterruptedException e) {

              successLatch.countDown();
            })
        .start();

    assertFalse(future.isDone());
    assertFalse(future.isCancelled());

    future.cancel(true);

    assertTrue(future.isDone());
    assertTrue(future.isCancelled());

    assertTrue(successLatch.await(200, MILLISECONDS));

    latch.countDown();
  }

                } catch (final Exception e) {
                    logger.warn("Could not close a process input stream.", e);
                } finally {
                    latch.countDown();
                }
            }, "ProcessCloser-input-" + sessionId).start();
            new Thread(() -> {
                try {
                    CloseableUtil.closeQuietly(process.getErrorStream());

          @Override
          @Nullable Void runInterruptibly() throws Exception {
            BrokenChannel bc = new BrokenChannel();
            bc.doBegin();
            isInterruptibleRegistered.countDown();
            new CountDownLatch(1).await(); // the interrupt will wake us up
            return null;
          }

          @Override
          boolean isDone() {
            return false;
          }

                }
                latch.countDown()
              }

              override fun onFailure(
                hostname: String,
                e: IOException,
              ) {
                synchronized(allExceptions) {
                  allExceptions.add(e)
                }
                latch.countDown()
              }
            },
          )
        }