@Tag("Slow")
class WholeOperationTimeoutTest {
  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()
  private val client = clientTestRule.newClient()

  @StartStop
  private val server = MockWebServer()

  @Test
  fun defaultConfigIsNoTimeout() {
    val request =
      Request
        .Builder()
        .url(server.url("/"))
        .build()
    val call = client.newCall(request)

      request: RecordedRequest,
      response: MockResponse,
    ) {
      val settings = response.settings
      stream.connection.setSettings(settings)

      val bodyDelayNanos = response.bodyDelayNanos
      val trailers = response.trailers
      val body = response.body
      val socketHandler = response.socketHandler
      val outFinished = (
        body == null &&
          response.pushPromises.isEmpty() &&

    // 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()

  }

  companion object {
    private const val CONNECTION = "connection"
    private const val HOST = "host"
    private const val KEEP_ALIVE = "keep-alive"
    private const val PROXY_CONNECTION = "proxy-connection"
    private const val TRANSFER_ENCODING = "transfer-encoding"
    private const val TE = "te"
    private const val ENCODING = "encoding"
    private const val UPGRADE = "upgrade"

    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 {

  }

  private class Entry {
    private val url: HttpUrl
    private val varyHeaders: Headers
    private val requestMethod: String
    private val protocol: Protocol
    private val code: Int
    private val message: String
    private val responseHeaders: Headers
    private val handshake: Handshake?
    private val sentRequestMillis: Long
    private val receivedResponseMillis: Long

    /**

    server.enqueue(MockResponse())
    dns["san.com"] = Dns.SYSTEM.lookup(server.hostName).subList(0, 1)
    val sanUrl = url.newBuilder().host("san.com").build()
    val latch1 = CountDownLatch(1)
    val latch2 = CountDownLatch(1)
    val latch3 = CountDownLatch(1)
    val latch4 = CountDownLatch(1)
    val listener1: EventListener =
      object : EventListener() {
        override fun connectStart(
          call: Call,

import java.net.http.HttpResponse


private
data class GradleServicesVersion(val version: String, val buildTime: String)


@DisableCachingByDefault(because = "Not worth caching")
abstract class PreparePatchRelease : DefaultTask() {

    @get:Internal
    abstract val versionFile: RegularFileProperty

    @get:Internal
    abstract val releasedVersionsFile: RegularFileProperty

    @TaskAction
    fun prepare() {

        .build(),
    )
    val startNanos = System.nanoTime()
    val connection = server.url("/").toUrl().openConnection()
    connection.doOutput = true
    connection.getOutputStream().write("ABCDEF".toByteArray(UTF_8))
    val inputStream = connection.getInputStream()
    assertThat(inputStream.read()).isEqualTo(-1)
    val elapsedNanos = System.nanoTime() - startNanos

  internal data class Message(
    val bytes: ByteString? = null,
    val string: String? = null,
  )

  internal data class Ping(
    val payload: ByteString,
  )

  internal data class Pong(
    val payload: ByteString,
  )

  internal data class Closing(
    val code: Int,
    val reason: String,
  )

  internal data class Closed(
    val code: Int,
    val reason: String,
  )