fun newTestConnection(
      taskRunner: TaskRunner,
      connectionPool: RealConnectionPool,
      route: Route,
      socket: Socket,
      idleAtNs: Long,
    ): RealConnection {
      val result =
        RealConnection(
          taskRunner = taskRunner,
          connectionPool = connectionPool,
          route = route,
          rawSocket = null,
          socket = socket,

  fun acquireConnectionNoEvents(connection: RealConnection)

  fun releaseConnectionNoEvents(): Socket?

  fun connectionReleased(connection: Connection)

  fun connectionConnectionAcquired(connection: RealConnection)

  fun connectionConnectionReleased(connection: RealConnection)

  fun connectionConnectionClosed(connection: RealConnection)

  fun noNewExchanges(connection: RealConnection)

  fun doExtensiveHealthChecks(): Boolean

  }

  override fun acquireConnectionNoEvents(connection: RealConnection) {
  }

  override fun releaseConnectionNoEvents(): Socket? {
    return null
  }

  override fun connectionReleased(connection: Connection) {
  }

  override fun connectionConnectionAcquired(connection: RealConnection) {
  }

  override fun connectionConnectionReleased(connection: RealConnection) {
  }

  }

  override fun connectionConnectionAcquired(connection: RealConnection) {
    connection.connectionListener.connectionAcquired(connection, call)
  }

  override fun connectionConnectionReleased(connection: RealConnection) {
    connection.connectionListener.connectionReleased(connection, call)
  }

  override fun connectionConnectionClosed(connection: RealConnection) {
    connection.connectionListener.connectionClosed(connection)

import okhttp3.internal.connection.RealCall
import okhttp3.internal.connection.RealConnection
import okio.FileSystem
import okio.Path

internal fun buildCache(
  file: Path,
  maxSize: Long,
  fileSystem: FileSystem,
): Cache {
  return Cache(fileSystem, file, maxSize)
}

internal var RealConnection.idleAtNsAccessor: Long
  get() = idleAtNs
  set(value) {
    idleAtNs = value
  }

    )
  }

  /**
   * Holding the lock of the connection being added or removed when mutating this, and check its
   * [RealConnection.noNewExchanges] property. This defends against races where a connection is
   * simultaneously adopted and removed.
   */
  private val connections = ConcurrentLinkedQueue<RealConnection>()

  init {
    // Put a floor on the keep alive duration, otherwise cleanup will spin loop.

 *
 *  2. If there is a connection in the pool that can satisfy the request it is used. Note that it is
 *     possible for shared exchanges to make requests to different host names! See
 *     [RealConnection.isEligible] for details.
 *
 *  3. Attempt plans from prior connect attempts for this call. These occur as either follow-ups to
 *     failed connect attempts (such as trying the next [ConnectionSpec]), or as attempts that lost

import okhttp3.RequestBody.Companion.toRequestBody
import okhttp3.TestUtil.assertSuppressed
import okhttp3.internal.DoubleInetAddressDns
import okhttp3.internal.connection.RealConnection
import okhttp3.internal.connection.RealConnection.Companion.IDLE_CONNECTION_HEALTHY_NS
import okhttp3.internal.http.RecordingProxySelector
import okhttp3.testing.Flaky
import okhttp3.testing.PlatformRule
import okio.BufferedSink

import okhttp3.MediaType.Companion.toMediaTypeOrNull
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.Response
import okhttp3.internal.concurrent.TaskRunner
import okhttp3.internal.connection.RealConnection

internal fun parseCookie(
  currentTimeMillis: Long,
  url: HttpUrl,
  setCookie: String,
): Cookie? = Cookie.parse(currentTimeMillis, url, setCookie)

internal fun cookieToString(
  cookie: Cookie,

    private set

  /** True if there was an exception on the connection to the peer. */
  internal var hasFailure: Boolean = false
    private set

  internal val connection: RealConnection
    get() = codec.carrier as? RealConnection ?: error("no connection for CONNECT tunnels")

  internal val isCoalescedConnection: Boolean
    get() = finder.routePlanner.address.url.host != codec.carrier.route.address.url.host