}
  }

  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(

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

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

  fun shutdown() {
    taskRunner.assertLockNotHeld()

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

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

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
import okio.IOException

class RealConnectionPool internal constructor(
  private val taskRunner: TaskRunner,
  /**

 *
 * 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(
  private val taskRunner: TaskRunner,
  private val connectionPool: RealConnectionPool,
  private val readTimeoutMillis: Int,
  private val writeTimeoutMillis: Int,
  private val socketConnectTimeoutMillis: Int,

  /** For scheduling everything asynchronous. */
  private val taskRunner = builder.taskRunner

  /** Asynchronously writes frames to the outgoing socket. */
  private val writerQueue = taskRunner.newQueue()

  /** Ensures push promise callbacks events are sent in order per stream. */
  private val pushQueue = taskRunner.newQueue()

  /** Notifies the listener of settings changes. */

          this[packageName] = "OkHttp"
        }

        this[OkHttpClient::class.java.name] = "okhttp.OkHttpClient"
        this[Http2::class.java.name] = "okhttp.Http2"
        this[TaskRunner::class.java.name] = "okhttp.TaskRunner"
        this["okhttp3.mockwebserver.MockWebServer"] = "okhttp.MockWebServer"
      }.toMap()

  internal fun androidLog(
    loggerName: String,
    logLevel: Int,
    message: String,

  @RegisterExtension @JvmField
  val testLogHandler = TestLogHandler(taskFaker.logger)

  private val taskRunner = taskFaker.taskRunner
  private val log = mutableListOf<String>()
  private val redQueue = taskRunner.newQueue()
  private val blueQueue = taskRunner.newQueue()
  private val greenQueue = taskRunner.newQueue()

  @AfterEach
  internal fun tearDown() {
    taskFaker.close()
  }

 * in sequence.
 */
public class MockWebServer : Closeable {
  private val taskRunnerBackend =
    TaskRunner.RealBackend(
      threadFactory("MockWebServer TaskRunner", daemon = false),
    )
  private val taskRunner = TaskRunner(taskRunnerBackend)
  private val requestQueue = LinkedBlockingQueue<RecordedRequest>()
  private val openClientSockets =

    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.