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)

    /**
     * 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. */

      return webSocket!!.processNextFrame()
    }

    override fun close() {
      if (closed) {
        throw AssertionError("Already closed")
      }
      try {
        source.close()
      } catch (ignored: IOException) {
      }
      try {
        sink.close()
      } catch (ignored: IOException) {
      }
      closed = true
    }

    override fun cancel() {
      canceled = true

  }

  @Throws(IOException::class)
  fun flush() {
    this.withLock {
      if (closed) throw IOException("closed")
      sink.flush()
    }
  }

  @Throws(IOException::class)
  fun rstStream(
    streamId: Int,
    errorCode: ErrorCode,
  ) {
    this.withLock {
      if (closed) throw IOException("closed")
      require(errorCode.httpCode != -1)

      frameHeader(

  override fun clone(): Call = RealCall(client, originalRequest, forWebSocket)

  override fun request(): Request = originalRequest

  /**
   * Immediately closes the socket connection if it's currently held. Use this to interrupt an
   * in-flight request from any thread. It's the caller's responsibility to close the request body

    the certificate that follows and the last certificate is signed by a trusted root.

 *  Fix: Don't lose HTTP/2 flow control bytes when incoming data races with a stream close. If this
    happened enough then eventually the connection would stall.

 *  Fix: Acknowledge and apply inbound HTTP/2 settings atomically. Previously we had a race where we

    val source1 = relay.newSource()
    val source2 = relay.newSource()
    source1!!.close()
    source1.close() // Unnecessary. Shouldn't decrement the reference count.
    assertThat(relay.isClosed).isFalse()
    source2!!.close()
    assertThat(relay.isClosed).isTrue()
    assertFile(Relay.PREFIX_DIRTY, -1L, -1, null, null)
  }

  @Test
  fun racingReaders() {

    this.withLock {
      cancel = !source.finished && source.closed && (sink.finished || sink.closed)
      open = isOpen
    }
    if (cancel) {
      // RST this stream to prevent additional data from being sent. This is safe because the input
      // stream is closed (we won't use any further bytes) and the output stream is either finished
      // or closed (so RSTing both streams doesn't cause harm).

          queueSize -= message.data.size.toLong()
        }
      } else if (messageOrClose is Close) {
        val close = messageOrClose as Close
        writer!!.writeClose(close.code, close.reason)

        // We closed the writer: now both reader and writer are closed.
        if (streamsToClose != null) {
          listener.onClosed(this, receivedCloseCode, receivedCloseReason!!)
        }
      } else {

    callback.await(server.url("/a")).assertFailure("Canceled", "Socket closed", "Socket is closed")
  }

  @Test
  fun cancelAll() {
    val call = client.newCall(Request(server.url("/")))
    call.enqueue(callback)
    client.dispatcher.cancelAll()
    callback.await(server.url("/")).assertFailure("Canceled", "Socket closed", "Socket is closed")
  }

  @Test
  fun cancelWhileRequestHeadersAreSent() {