() -> {
              computationStarted.countDown();
              cache.getUnchecked("b");
              computationComplete.countDown();
            })
        .start();

    // wait for the computingEntry to be created
    computationStarted.await();
    cache.invalidateAll();
    // let the computation proceed
    computingLatch.countDown();

      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;

        if (executeCallbacks.size() > 0) {
            try {
                executeCallbacks.stream().forEach(callback -> callback.accept(response));
            } catch (final Exception ignore) {}
        }
        latch.countDown();
    }

    /**
     * Rejects the deferred computation with the given throwable.
     * @param t The throwable.
     */
    public void reject(final Throwable t) {

    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)
  }

    Object unused =
        new Object() {
          @SuppressWarnings({"removal", "Finalize"}) // b/487687332
          @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() {

            synchronized(failures) {
              failures.add(e)
            }
            latch.countDown()
          }

          override fun onResponse(
            call: Call,
            response: Response,
          ) {
            processResponse(response, hostname, responses, failures)
            latch.countDown()
          }
        },
      )
    }

    try {
      latch.await()

    Object unused =
        new Object() {
          @SuppressWarnings({"removal", "Finalize"}) // b/487687332
          @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() {

    public @Nullable Void call() throws InterruptedException {
      running = true;
      startLatch.countDown();
      stopLatch.await();
      running = false;
      return null;
    }

    void waitForStart() throws InterruptedException {
      startLatch.await();
    }

    void stop() {
      stopLatch.countDown();
    }

    boolean isRunning() {
      return running;
    }
  }

            // Verify that our custom thread was captured
            assertTrue("Should find custom thread in dump", customThreadFound.get() > 0);

        } finally {
            latch.countDown();
            customThread.join(1000); // Wait up to 1 second for thread to finish
        }
    }

    @Test
    public void test_writeThreadDump_fileContent() throws IOException {

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