outputFuture.set(RESULT_DATA);
          break;
        case SLOW_OUTPUT_VALID_INPUT_DATA:
          break; // do nothing to the result
        case SLOW_FUNC_VALID_INPUT_DATA:
          funcIsWaitingLatch.countDown();
          awaitUninterruptibly(funcCompletionLatch);
          break;
        case EXCEPTION_DATA:
          throw EXCEPTION;
      }
      return outputFuture;
    }
  }

          outputFuture.set(RESULT_DATA);
          break;
        case SLOW_OUTPUT_VALID_INPUT_DATA:
          break; // do nothing to the result
        case SLOW_FUNC_VALID_INPUT_DATA:
          funcIsWaitingLatch.countDown();
          awaitUninterruptibly(funcCompletionLatch);
          break;
        case EXCEPTION_DATA:
          throw EXCEPTION;
      }
      return outputFuture;
    }
  }

    val waiting = CountDownLatch(1)
    client =
      client
        .newBuilder()
        .addInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            try {
              ready.countDown()
              waiting.await()
            } catch (e: InterruptedException) {
              throw AssertionError()
            }
            throw IOException()
          },
        ).build()

        Thread thread = new Thread(myRunnable);
        thread.start();

        MavenSession m2 = new MavenSession(null, null, mavenExecutionRequest, null);
        defaultLegacySupport.setSession(m2);
        latch.countDown();
        thread.join();
        assertNull(myRunnable.getSession());
    }

    class MyRunnable implements Runnable {

        private volatile MavenSession session;

        @Override

    Object unused =
        new Object() {
          @SuppressWarnings({"removal", "Finalize"}) // b/260137033
          @Override
          protected void finalize() {
            latch.countDown();
          }
        };
    unused = null; // Hint to the JIT that unused is unreachable
    GcFinalization.await(latch);
    assertEquals(0, latch.getCount());
  }

  public void testAwaitDone_future() {

      arguments.add(Duration.ofMillis(timeout.millis));
    }
    try {
      Object result;
      doingCallLatch.countDown();
      try {
        result = method.invoke(monitor, arguments.toArray());
      } finally {
        callCompletedLatch.countDown();
      }
      if (result == null) {
        return Outcome.SUCCESS;
      } else if ((Boolean) result) {
        return Outcome.SUCCESS;

    endsFirst.join()
    // First response is still waiting.
    assertThat(firstResponseCode.get()).isEqualTo(0)
    // Second response is done.
    assertThat(secondResponseCode.get()).isEqualTo(200)
    latch.countDown()
    startsFirst.join()
    // And now it's done!
    assertThat(firstResponseCode.get()).isEqualTo(200)
    // (Still done).
    assertThat(secondResponseCode.get()).isEqualTo(200)
  }

    this.latch = new CountDownLatch(1);
  }

  public void setUp() {
    future.addListener(
        new Runnable() {
          @Override
          public void run() {
            latch.countDown();
          }
        },
        exec);

    assertEquals(1, latch.getCount());
    assertFalse(future.isDone());
    assertFalse(future.isCancelled());
  }

  public void tearDown() {

  fun sendResponse(
    s: String,
    responseSent: CountDownLatch = CountDownLatch(1),
  ) = apply {
    actions += { stream ->
      stream.sink.writeUtf8(s)
      stream.sink.flush()
      responseSent.countDown()
    }
  }

  fun exhaustResponse() =
    apply {
      actions += { stream -> stream.sink.close() }
    }

  fun sleep(
    duration: Long,
    unit: TimeUnit,
  ) = apply {

    this.countDownLatch = new CountDownLatch(1);
    this.future = future;

    future.addListener(this, directExecutor());
  }

  @Override
  public void run() {
    countDownLatch.countDown();
  }

  /**
   * Verify that the listener completes in a reasonable amount of time, and Asserts that the future
   * returns the expected data.
   *