public fun requestHeadersStart (Lokhttp3/Call;)V
	public fun responseBodyEnd (Lokhttp3/Call;J)V
	public fun responseBodyStart (Lokhttp3/Call;)V
	public fun responseFailed (Lokhttp3/Call;Ljava/io/IOException;)V
	public fun responseHeadersEnd (Lokhttp3/Call;Lokhttp3/Response;)V
	public fun responseHeadersStart (Lokhttp3/Call;)V
	public fun satisfactionFailure (Lokhttp3/Call;Lokhttp3/Response;)V

 */
internal abstract class ConnectionListener {
  /**
   * Invoked as soon as a call causes a connection to be started.
   */
  open fun connectStart(
    route: Route,
    call: Call,
  ) {}

  /**
   * Invoked when a connection fails to be established.
   */
  open fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) {}

  /**

        .trailersDelay(1, TimeUnit.SECONDS)
        .build(),
    )

    val call = client.newCall(Request(server.url("/")))
    call.execute().use { response ->
      val source = response.body.source()
      assertThat(response.header("h1")).isEqualTo("v1")
      assertThat(source.readUtf8(5)).isEqualTo("Hello")
      call.cancelLater(500.milliseconds)
      val trailersDelay =
        measureTime {

    override val timestampNs: Long,
    val route: Route,
    val call: Call,
  ) : ConnectionEvent()

  data class ConnectFailed(
    override val timestampNs: Long,
    val route: Route,
    val call: Call,
    val exception: IOException,
  ) : ConnectionEvent() {
    override fun closes(event: ConnectionEvent): Boolean = event is ConnectStart && call == event.call && route == event.route
  }

  data class ConnectEnd(

        override fun requestHeadersEnd(
          call: Call,
          request: Request,
        ) = TODO()

        override fun requestBodyStart(call: Call) = TODO()

        override fun requestBodyEnd(
          call: Call,
          byteCount: Long,
        ) = TODO()

        override fun requestFailed(
          call: Call,
          ioe: IOException,

    check(rawSocket == null) { "TCP already connected" }

    var success = false

    // Tell the call about the connecting call so async cancels work.
    call.plansToCancel += this
    try {
      call.eventListener.connectStart(call, route.socketAddress, route.proxy)
      connectionPool.connectionListener.connectStart(route, call)

      connectSocket()
      success = true
      return ConnectResult(plan = this)

      if (e != null) {
        call.eventListener.requestFailed(call, e)
      } else {
        call.eventListener.requestBodyEnd(call, bytesRead)
      }
    }
    if (responseDone) {
      if (e != null) {
        call.eventListener.responseFailed(call, e)
      } else {
        call.eventListener.responseBodyEnd(call, bytesRead)
      }
    }
    return call.messageDone(
      exchange = this,

    var shouldClose: Boolean = false
    var lastSocket: Socket? = null

    override fun connectionAcquired(
      call: Call,
      connection: Connection,
    ) {
      lastSocket = connection.socket()
    }

    override fun requestHeadersStart(call: Call) {
      if (shouldClose) {
        lastSocket!!.close()
      }
    }
  }

  @Test
  fun socketFailureOnLargeRequestHeaders() {

        .build()

    val startNanos = System.nanoTime()
    val call = client.newCall(request)

    // Schedule a job to cancel the call in 1 second.
    executor.schedule({
      System.out.printf("%.2f Canceling call.%n", (System.nanoTime() - startNanos) / 1e9f)
      call.cancel()
      System.out.printf("%.2f Canceled call.%n", (System.nanoTime() - startNanos) / 1e9f)
    }, 1, TimeUnit.SECONDS)

    }
  }

  override fun connectStart(
    route: Route,
    call: Call,
  ) = logEvent(ConnectionEvent.ConnectStart(System.nanoTime(), route, call))

  override fun connectFailed(
    route: Route,
    call: Call,
    failure: IOException,
  ) = logEvent(
    ConnectionEvent.ConnectFailed(System.nanoTime(), route, call, failure),
  )

  override fun connectEnd(
    connection: Connection,