}
  }

  interface Backend {
    fun nanoTime(): Long

    fun coordinatorNotify(taskRunner: TaskRunner)

    fun coordinatorWait(
      taskRunner: TaskRunner,
      nanos: Long,
    )

    fun <T> decorate(queue: BlockingQueue<T>): BlockingQueue<T>

    fun execute(
      taskRunner: TaskRunner,
      runnable: Runnable,
    )
  }

  class RealBackend(

  /** A task runner that posts tasks to this fake. Tasks won't be executed until requested. */
  val taskRunner: TaskRunner =
    TaskRunner(
      object : TaskRunner.Backend {
        override fun execute(
          taskRunner: TaskRunner,
          runnable: Runnable,
        ) {
          taskRunner.assertLockHeld()

          val queuedTask = RunnableSerialTask(runnable)
          serialTaskQueue += queuedTask

 *
 * Each step may fail. If a retry is possible, a new instance is created with the next plan, which
 * will be configured differently.
 */
class ConnectPlan internal constructor(
  private val taskRunner: TaskRunner,
  private val connectionPool: RealConnectionPool,
  private val readTimeoutMillis: Int,
  private val writeTimeoutMillis: Int,
  private val socketConnectTimeoutMillis: Int,

import okhttp3.internal.concurrent.TaskQueue
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.concurrent.assertLockHeld
import okhttp3.internal.concurrent.withLock
import okhttp3.internal.connection.RealCall.CallReference
import okhttp3.internal.okHttpName
import okhttp3.internal.platform.Platform

class RealConnectionPool internal constructor(
  taskRunner: TaskRunner,
  /** The maximum number of idle connections across all addresses. */

  var uriPort: Int = 1

  fun newConnection(
    pool: RealConnectionPool,
    route: Route,
    idleAtNanos: Long = Long.MAX_VALUE,
    taskRunner: TaskRunner = this.taskRunner,
  ): RealConnection {
    val result =
      RealConnection.newTestConnection(
        taskRunner = taskRunner,
        connectionPool = pool,
        route = route,
        socket = Socket(),
        idleAtNs = idleAtNanos,
      )

internal fun OkHttpClient.Builder.taskRunnerInternal(taskRunner: TaskRunner) = this.taskRunner(taskRunner)

internal fun buildConnectionPool(
  connectionListener: ConnectionListener,
  taskRunner: TaskRunner,
): ConnectionPool =
  ConnectionPool(
    connectionListener = connectionListener,
    taskRunner = taskRunner,

    maxIdleConnections: Int = 5,
    keepAliveDuration: Long = 5,
    timeUnit: TimeUnit = TimeUnit.MINUTES,
    taskRunner: TaskRunner = TaskRunner.INSTANCE,
    connectionListener: ConnectionListener = ConnectionListener.NONE,
  ) : this(
    RealConnectionPool(
      taskRunner = taskRunner,
      maxIdleConnections = maxIdleConnections,
      keepAliveDuration = keepAliveDuration,
      timeUnit = timeUnit,

   */
  fun cancelAll() {
    taskRunner.assertLockNotHeld()

    taskRunner.withLock {
      if (cancelAllAndDecide()) {
        taskRunner.kickCoordinator(this)
      }
    }
  }

  fun shutdown() {
    taskRunner.assertLockNotHeld()

    taskRunner.withLock {
      shutdown = true
      if (cancelAllAndDecide()) {
        taskRunner.kickCoordinator(this)
      }
    }
  }

    if (isLoom()) {
      val backend = TaskRunner.RealBackend(loomThreadFactory())
      val taskRunner = TaskRunner(backend)

      OkHttpClient
        .Builder()
        .connectionPool(
          buildConnectionPool(
            connectionListener = connectionListener,
            taskRunner = taskRunner,
          ),
        ).dispatcher(Dispatcher(backend.executor))

    fun cache(cache: Cache?) =
      apply {
        this.cache = cache
      }

    internal fun taskRunner(taskRunner: TaskRunner) =
      apply {
        this.taskRunner = taskRunner
      }

    /**
     * Sets the DNS service used to lookup IP addresses for hostnames.
     *
     * If unset, the [system-wide default][Dns.SYSTEM] DNS will be used.