dispatcher.maxRequestsPerHost = 4
    executor.assertJobs("http://a/1", "http://a/2", "http://a/3", "http://a/4")
  }

  @Test
  fun oldJobFinishesNewJobCanRunDifferentHost() {
    dispatcher.maxRequests = 1
    client.newCall(newRequest("http://a/1")).enqueue(callback)
    client.newCall(newRequest("http://b/1")).enqueue(callback)
    executor.finishJob("http://a/1")
    executor.assertJobs("http://b/1")
  }

  @Test

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Executor;
import java.util.concurrent.ExecutorService;

/**
 * Tests for {@link ClosingFuture} that exercise {@link
 * ClosingFuture#finishToValueAndCloser(ValueAndCloserConsumer, Executor)}.
 */
public class ClosingFutureFinishToValueAndCloserTest extends AbstractClosingFutureTest {

   *     returned future.
   * @param executor Executor to run the function in.
   * @return A future that holds result of the transformation.
   */
  public final <T extends @Nullable Object> FluentFuture<T> transform(
      Function<? super V, T> function, Executor executor) {
    return (FluentFuture<T>) Futures.transform(this, function, executor);
  }

  /**

  }

  public void testNoOpScheduledExecutorShutdown() {
    ListeningScheduledExecutorService executor = TestingExecutors.noOpScheduledExecutor();
    assertFalse(executor.isShutdown());
    assertFalse(executor.isTerminated());
    executor.shutdown();
    assertTrue(executor.isShutdown());
    assertTrue(executor.isTerminated());
  }

  /**
   * Returns the {@link Executor} that will be used to run this service. Subclasses may override
   * this method to use a custom {@link Executor}, which may configure its worker thread with a
   * specific name, thread group or priority. The returned executor's {@link
   * Executor#execute(Runnable) execute()} method is called when this service is started and

      .build()

  @After
  fun tearDown() {
    engine.shutdown()
    cacheDir.deleteRecursively()
  }

  @Test
  fun get() {
    val executor = Executors.newCachedThreadPool()

    val completableFuture = execute(engine, executor, "https://google.com/robots.txt")

    try {
      val response = completableFuture.get(10, TimeUnit.SECONDS)

      assertEquals(200, response.code)

   */
  protected void triggerShutdown() {}

  /**
   * Returns the {@link Executor} that will be used to run this service. Subclasses may override
   * this method to use a custom {@link Executor}, which may configure its worker thread with a
   * specific name, thread group or priority. The returned executor's {@link
   * Executor#execute(Runnable) execute()} method is called when this service is started, and should
   * return promptly.
   *

   * @param executor the executor in which the listeners callback methods will be run. For fast,
   *     lightweight listeners that would be safe to execute in any thread, consider {@link
   *     MoreExecutors#directExecutor}.
   * @since 13.0
   */
  void addListener(Listener listener, Executor executor);

  /**
   * The lifecycle states of a service.
   *

    executor.execute(task);
    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) {

   */
  public <T extends @Nullable Object> ListenableFuture<T> submitAsync(
      AsyncCallable<T> callable, Executor executor) {
    checkNotNull(callable);
    checkNotNull(executor);
    TaskNonReentrantExecutor taskExecutor = new TaskNonReentrantExecutor(executor, this);
    AsyncCallable<T> task =
        new AsyncCallable<T>() {
          @Override