server.enqueue(MockResponse(body = "abc"))
    server.enqueue(MockResponse(body = "def"))

    val request = Request(server.url("/"))

    val call = client.newCall(request)
    val response1 = call.execute()

    val cloned = call.clone()
    val response2 = cloned.execute()

    assertThat("abc").isEqualTo(response1.body.string())
    assertThat("def").isEqualTo(response2.body.string())
  }

    override fun execute() {
        try {
            val versionToIncubating = mutableMapOf<Version, MutableSet<IncubatingDescription>>()
            val repositoryRoot = parameters.repositoryRoot.get().asFile.toPath()
            parameters.srcDirs.forEach { srcDir ->
                if (srcDir.exists()) {
                    val collector = CompositeVersionsToIncubatingCollector(
                        listOf(

 */
class RealInterceptorChain(
  internal val call: RealCall,
  private val interceptors: List<Interceptor>,
  private val index: Int,
  internal val exchange: Exchange?,
  internal val request: Request,
  internal val connectTimeoutMillis: Int,
  internal val readTimeoutMillis: Int,
  internal val writeTimeoutMillis: Int,
  override val authenticator: Authenticator,
  override val cache: Cache?,

    // Special header names defined in HTTP/2 spec.
    @JvmField val PSEUDO_PREFIX: ByteString = ":".encodeUtf8()

    const val RESPONSE_STATUS_UTF8 = ":status"
    const val TARGET_METHOD_UTF8 = ":method"
    const val TARGET_PATH_UTF8 = ":path"
    const val TARGET_SCHEME_UTF8 = ":scheme"
    const val TARGET_AUTHORITY_UTF8 = ":authority"

    @JvmField val RESPONSE_STATUS: ByteString = RESPONSE_STATUS_UTF8.encodeUtf8()

    const val BUILD_RC_NUMBER = "rcNumber"
    const val BUILD_TIMESTAMP = "buildTimestamp"
    const val BUILD_VCS_NUMBER = "BUILD_VCS_NUMBER"
    const val BUILD_VERSION_QUALIFIER = "versionQualifier"
    const val CI_ENVIRONMENT_VARIABLE = "CI"
    const val DEFAULT_RFN_PERFORMANCE_BASELINES = "defaultRfnPerformanceBaselines"
    const val DEFAULT_RFR_PERFORMANCE_BASELINES = "defaultRfrPerformanceBaselines"

    ) {
      if (random != null) {
        val sslSocket = connection.socket() as SSLSocket
        val session = sslSocket.session

        val masterSecretHex =
          session.masterSecret
            ?.encoded
            ?.toByteString()
            ?.hex()

        if (masterSecretHex != null) {
          val keyLog = "CLIENT_RANDOM $random $masterSecretHex"

          if (verbose) {

  val npnProtocols: List<String>,
  val platform: String?,
  val requiresSha2: Boolean,
  val signatureAlgorithms: List<Int>,
  val suiteIds: List<Int>,
  val suiteNames: List<String>,
  val supportsCompression: Boolean,
  val supportsNpn: Boolean,
  val supportsRi: Boolean,
  val supportsSni: Boolean,
  val supportsStapling: Boolean,
  val supportsTickets: Boolean,
  val userAgent: String?,
  val version: String,

  public val failHandshake: Boolean
  public val onRequestStart: SocketEffect?
  public val doNotReadRequestBody: Boolean
  public val onRequestBody: SocketEffect?
  public val onResponseStart: SocketEffect?
  public val onResponseBody: SocketEffect?
  public val onResponseEnd: SocketEffect?
  public val shutdownServer: Boolean

  public val headersDelayNanos: Long
  public val bodyDelayNanos: Long
  public val trailersDelayNanos: Long

    open val paramName: String
      get() = override.paramName ?: name.replaceFirstChar { it.lowercase(getDefault()) }
  }

  class DelayingSocketFactory(
    val onConnect: Socket.(timeout: Int) -> Unit = {},
    val onRead: Socket.() -> Unit = {},
    val onWrite: Socket.() -> Unit = {},
  ) : DelegatingSocketFactory(getDefault()) {
    override fun createSocket(): Socket {

      )
    }
  }

  @Test
  fun byteStringEmpty() {
    val body = body("")
    assertThat(body.byteString()).isEqualTo(ByteString.EMPTY)
  }

  @Test
  fun byteStringSeesBom() {
    val body = body("efbbbf68656c6c6f")
    val actual = body.byteString()
    val expected: ByteString = "efbbbf68656c6c6f".decodeHex()
    assertThat(actual).isEqualTo(expected)
  }