object : EventListener() {
        var socket: SSLSocket? = null
        var closed = false

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

        override fun requestHeadersStart(call: Call) {
          if (closed) {
            throw IOException("fake socket failure")
          }
        }

    return writer
  }

  /**
   * Shortens the last frame from its original length to `length`. This will cause the peer to
   * close the socket as soon as this frame has been written; otherwise the peer stays open until
   * explicitly closed.
   */
  fun truncateLastFrame(length: Int): Http2Writer {
    val lastFrame = outFrames.removeAt(outFrames.size - 1)
    require(length < bytesOut.size - lastFrame.start)

  fun request(): Request

  /**
   * Immediately and violently release resources held by this event source. This does nothing if
   * the event source has already been closed or canceled.
   */
  fun cancel()

  fun interface Factory {
    /**
     * Creates a new event source and immediately returns it. Creating an event source initiates an

  /**
   * Called when the HTTP response was successfully returned by the remote server. The callback may
   * proceed to read the response body with [Response.body]. The response is still live until its
   * response body is [closed][ResponseBody]. The recipient of the callback may consume the response
   * body on another thread.
   *
   * Note that transport-layer success (receiving a HTTP response code, headers and body) does not

    /**
     * How many concurrent calls should be possible to make at any time.
     * The pool will routinely try to pre-emptively open connections to satisfy this minimum.
     * Connections will still be closed if they idle beyond the keep-alive but will be replaced.
     */
    @JvmField val minimumConcurrentCalls: Int = 0,
    /** How long to wait to retry pre-emptive connection attempts that fail. */

        else -> minOf(maxResult, delimiterIndex)
      }
    }

    @Throws(IOException::class)
    override fun close() {
      if (closed) return
      closed = true
      currentPart = null
      source.close()
    }

    /** A single part in a multipart body. */
    class Part(
      @get:JvmName("headers") val headers: Headers,

 * and [ShutdownOutputAtEnd] that close a socket after a response, and where there are
 * follow-up requests. The client is unblocked and free to continue as soon as it has received the
 * entire response body. If and when the client makes a subsequent request using a pooled socket the
 * server may not have had time to close the socket. The socket will be closed at an indeterminate

  ) {
    get().log("[ES] onEvent", Platform.INFO, null)
    events.add(Event(id, type, data))
    drainCancelQueue(eventSource)
  }

  override fun onClosed(eventSource: EventSource) {
    get().log("[ES] onClosed", Platform.INFO, null)
    events.add(Closed)
    drainCancelQueue(eventSource)
  }

  override fun onFailure(
    eventSource: EventSource,
    t: Throwable?,
    response: Response?,
  ) {

   * most [BufferedSource] instances, but not of [Buffer].
   */
  private fun responseBody(content: String): ResponseBody {
    val data = Buffer().writeUtf8(content)
    val source: Source =
      object : Source {
        var closed = false

        override fun close() {
          closed = true
        }

        override fun read(

    }
  }

  override fun onClosed(
    webSocket: WebSocket,
    code: Int,
    reason: String,
  ) {
    Platform.get().log("[WS $name] onClosed $code", Platform.INFO, null)
    val delegate = delegate
    if (delegate != null) {
      this.delegate = null
      delegate.onClosed(webSocket, code, reason)
    } else {
      events.add(Closed(code, reason))
    }
  }