return 25;
            }
          });

  @Override
  protected void setUp() throws Exception {
    super.setUp();

    exec = newCachedThreadPool();

    task.addListener(
        new Runnable() {
          @Override
          public void run() {
            listenerLatch.countDown();
          }
        },
        directExecutor());
  }

  @Override

  private Thread executionThread;
  private Throwable thrownByExecutionThread;
  private final Executor exceptionCatchingExecutor =
      new Executor() {
        @Override
        public void execute(Runnable command) {
          executionThread = new Thread(command);
          executionThread.setUncaughtExceptionHandler(
              new UncaughtExceptionHandler() {
                @Override

    }
    bloomFilter.put(GOLDEN_PRESENT_KEY);

    int numThreads = 12;
    double safetyFalsePositiveRate = 0.1;
    Stopwatch stopwatch = Stopwatch.createStarted();

    Runnable task =
        new Runnable() {
          @Override
          public void run() {
            do {
              // We can't have a GOLDEN_NOT_PRESENT_KEY because false positives are

    return task;
  }

  /**
   * Executes {@code runnable} on the specified {@code executor}, returning a {@code Future} that
   * will complete after execution.
   *
   * @throws RejectedExecutionException if the task cannot be scheduled for execution
   * @since 28.2
   */
  public static ListenableFuture<@Nullable Void> submit(Runnable runnable, Executor executor) {
    TrustedListenableFutureTask<@Nullable Void> task =

@JvmField
internal val UTC: TimeZone = TimeZone.getTimeZone("GMT")!!

internal fun threadFactory(
  name: String,
  daemon: Boolean,
): ThreadFactory =
  ThreadFactory { runnable ->
    Thread(runnable, name).apply {
      isDaemon = daemon
    }
  }

internal fun HttpUrl.toHostHeader(includeDefaultPort: Boolean = false): String {
  val host =
    if (":" in host) {
      "[$host]"
    } else {

    this.exec = newCachedThreadPool();
    this.future = checkNotNull(future);
    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());

      completed.assertCompletionExpected();
      assertEquals("", queue.peek());
    }

    private static void scheduleEnableWrites(BlockingQueue<String> queue, long countdownInMillis) {
      Runnable toRun = new EnableWrites(queue, countdownInMillis);
      // TODO(cpovirk): automatically fail the test if this thread throws
      Thread enablerThread = new Thread(toRun);
      enablerThread.start();
    }
  }

    }
    bloomFilter.put(GOLDEN_PRESENT_KEY);

    int numThreads = 12;
    double safetyFalsePositiveRate = 0.1;
    Stopwatch stopwatch = Stopwatch.createStarted();

    Runnable task =
        new Runnable() {
          @Override
          public void run() {
            do {
              // We can't have a GOLDEN_NOT_PRESENT_KEY because false positives are

        };
    addCallback(f, callback, directExecutor());
  }

  private class CountingSameThreadExecutor implements Executor {
    int runCount = 0;

    @Override
    public void execute(Runnable command) {
      command.run();
      runCount++;
    }
  }

  private final class MockCallback implements FutureCallback<String> {
    @Nullable private String value = null;

    AtomicInteger actualOccupiedDepth = new AtomicInteger();
    AtomicReference<Throwable> thrown = new AtomicReference<>();
    joinUninterruptibly(
        startThread(
            new Runnable() {
              @Override
              public void run() {
                try {
                  actualIsOccupied.set(monitor.isOccupied());