.connectionPool(
          buildConnectionPool(
            connectionListener = connectionListener,
            taskRunner = taskRunner,
          ),
        ).dispatcher(Dispatcher(backend.executor))
        .taskRunnerInternal(taskRunner)
    } else {
      OkHttpClient
        .Builder()
        .connectionPool(ConnectionPool(connectionListener = connectionListener))
    }

  public final Throwable failureCause() {
    return snapshot.failureCause();
  }

  /**
   * @since 13.0
   */
  @Override
  public final void addListener(Listener listener, Executor executor) {
    listeners.addListener(listener, executor);
  }

  @Override
  public String toString() {
    return getClass().getSimpleName() + " [" + state() + "]";
  }

  /**

// `struct_size` is used for struct member compatibility check between core TF
// and plug-ins with the same C API minor version. More info here:
// https://github.com/tensorflow/community/blob/master/rfcs/20200612-stream-executor-c-api/C_API_versioning_strategy.md
#define TF_VALIDATE_STRUCT_SIZE(STRUCT_NAME, STRUCT_OBJ, SIZE_VALUE_NAME) \
  do {                                                                    \

        new Service() {
          final NoOpService delegate = new NoOpService();

          @Override
          public final void addListener(Listener listener, Executor executor) {
            service1.startAsync();
            delegate.addListener(listener, executor);
          }

          // Delegates from here on down
          @Override
          public final Service startAsync() {

                new LifecyclePluginResolver(new PluginVersionResolverStub()));
    }

    @Override
    protected String getProjectsDirectory() {
        return "src/test/projects/lifecycle-executor";
    }

    @Inject
    private ExceptionHandler exceptionHandler;

    protected String getProjectsDirectory() {
        return "src/test/projects/lifecycle-executor";
    }

    @Test
    void testCreation() throws Exception {
        assertNotNull(defaultLifeCycles);
        assertNotNull(mojoExecutor);
        assertNotNull(lifeCycleBuilder);

import okhttp3.internal.unmodifiable

/**
 * Policy on when async requests are executed.
 *
 * Each dispatcher uses an [ExecutorService] to run calls internally. If you supply your own
 * executor, it should be able to run [the configured maximum][maxRequests] number of calls
 * concurrently.
 */
class Dispatcher() {
  /**

        final AtomicInteger successCount = new AtomicInteger(0);

        ExecutorService executor = Executors.newFixedThreadPool(threadCount);

        for (int i = 0; i < threadCount; i++) {
            final int threadId = i;
            executor.submit(new Runnable() {
                @Override
                public void run() {
                    try {

      run = true;
    }
  }

  private static class TestCallable implements Callable<String> {
    @Override
    public String call() {
      return "foo";
    }
  }

  /** Simple same thread listening executor service that doesn't handle shutdown. */
  private static class TestListeningExecutorService extends AbstractListeningExecutorService {

    @Override
    public void execute(Runnable runnable) {

        this.pathToLease = new ConcurrentHashMap<>();
        this.fileCache = new ConcurrentHashMap<>();
        this.lock = new ReentrantReadWriteLock();

        // Start cleanup executor for expired leases
        this.cleanupExecutor = Executors.newSingleThreadScheduledExecutor(r -> {
            Thread t = new Thread(r, "LeaseManager-Cleanup");
            t.setDaemon(true);
            return t;
        });