workingOnly = true,
        getOnly = true,
      )
    runBatch(dnsProviders, names)
  } finally {
    bootstrapClient.connectionPool.evictAll()
    bootstrapClient.dispatcher.executorService.shutdownNow()
    bootstrapClient.cache?.close()
  }

            try {
                if (!cleanupExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                    cleanupExecutor.shutdownNow();
                }
            } catch (InterruptedException e) {
                cleanupExecutor.shutdownNow();
                Thread.currentThread().interrupt();
            }
        }

        // Clean up expired weak references

            consumer.consumeResult(shards.get(i), () -> latch.countDown());
        }
        latch.await();
        SearchPhaseController.ReducedQueryPhase phase = consumer.reduce();
        executor.shutdownNow();
        return phase;
    }

      Future<Boolean> getResult = executor.submit(() -> future.get());

      // Release the future value.
      latch.countDown();

      assertTrue(getResult.get(10, SECONDS));
    } finally {
      executor.shutdownNow();
    }

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

  /** Tests that the {@link Future#get(long, TimeUnit)} method times out correctly. */

  }

  fun close() {
    val okHttpClient = client as OkHttpClient
    okHttpClient.connectionPool.evictAll() // Close any persistent connections.
    okHttpClient.dispatcher.executorService.shutdownNow()
  }

  companion object {
    internal const val NAME = "okcurl"
    internal const val DEFAULT_TIMEOUT = -1

    private fun versionString(): String? {
      val prop = Properties()

        healthCheckExecutor.shutdown();
        try {
            if (!healthCheckExecutor.awaitTermination(5, TimeUnit.SECONDS)) {
                healthCheckExecutor.shutdownNow();
            }
        } catch (InterruptedException e) {
            healthCheckExecutor.shutdownNow();
            Thread.currentThread().interrupt();
        }

        // Close all connections without synchronization - concurrent collections are thread-safe

                assertEquals(10, searchCount.get());
                assertEquals(10, registerCount.get());

            } finally {
                if (!executor.isTerminated()) {
                    executor.shutdownNow();
                }
            }
        }
    }

    /**
     * Test that setSearcher and register can be called concurrently.
     */
    @Test

  }

  /** Returns true if no tasks have been scheduled. This runs the coordinator for confirmation. */
  fun isIdle() = taskRunner.activeQueues().isEmpty()

  override fun close() {
    tasksExecutor.shutdownNow()
  }

  companion object {
    var instance = 0
  }

        } catch (final InterruptedException e) {
            if (logger.isDebugEnabled()) {
                logger.debug("Interrupted.", e);
            }
        } finally {
            executorService.shutdownNow();
        }
        return totalCount;
    }

     * run. We want to see what happens when it's interrupted, not when it's
     * rejected.
     */
    submitSuccessful.await();
    executorService.shutdownNow();
    abstractFuture.set(DATA1);
    assertThat(listenableFuture.get()).isEqualTo(DATA1);
    singleCallListener.waitForCall();

    assertTrue(singleCallListener.wasCalled());