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

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

  stream_executor::StreamExecutor* executor =
      platform->ExecutorForDevice(0).value();
  TF_ASSERT_OK_AND_ASSIGN(auto stream, executor->CreateStream());

  se::DeviceMemoryBase gpu_dst{device_tensor.data(), 4 * sizeof(float)};
  xla::Shape shape;
  TF_ASSERT_OK(TensorShapeToXLAShape(DT_FLOAT, TensorShape({2, 2}), &shape));

  TF_ASSERT_OK_AND_ASSIGN(auto se_event, executor->CreateEvent());

    }
  }

  private static final class Listener {
    final Runnable command;
    final Executor executor;

    Listener(Runnable command, Executor executor) {
      this.command = checkNotNull(command);
      this.executor = checkNotNull(executor);
    }

    void execute() {
      try {
        executor.execute(command);
      } catch (RuntimeException e) {
        log.log(
            Level.SEVERE,

    private final InternalParameterAcceptingConnection executor;

    ParameterizedActionRunner(InternalParameterAcceptingConnection executor, CancellationExceptionTransformer exceptionTransformer, VersionDetails versionDetails) {
        super(null, exceptionTransformer, versionDetails);
        this.executor = executor;
    }

    @Override

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

    private final InternalCancellableConnection executor;
    private final CancellationExceptionTransformer exceptionTransformer;
    private final VersionDetails versionDetails;

    CancellableActionRunner(InternalCancellableConnection executor, CancellationExceptionTransformer exceptionTransformer, VersionDetails versionDetails) {
        this.executor = executor;
        this.exceptionTransformer = exceptionTransformer;

        }

        @Override
        public void stop() {
            ManagedExecutor executor;
            lock.lock();
            try {
                executor = this.executor;
            } finally {
                lock.unlock();
            }
            if (executor != null) {
                executor.stop();
            }
        }

        public void add(C command) {

    abstract TestClassExecutionResult assertFailedToExecute(TestExecutionResult testResult, String testClassName)

    String getStableEnvironmentDependencies() {
        return testFrameworkDependencies
    }

    def "executes tests in the correct environment"() {
        given:
        file('src/test/java/org/gradle/OkTest.java') << """
            package org.gradle;

            import java.io.File;
            import java.io.PrintStream;

import java.util.Collection;
import java.util.concurrent.Executor;
import java.util.concurrent.locks.Lock;

class ExpectAllRequestsThenReleaseAll extends ExpectMaxNConcurrentRequestsThenRelease {
    ExpectAllRequestsThenReleaseAll(Lock lock, int testId, Duration timeout, WaitPrecondition previous, Collection<? extends ResourceExpectation> expectations, Executor executor) {