public fun headers(headers: Headers): Builder =
      apply {
        this.headers_ = headers.newBuilder()
      }

    /** Sets the trailers and returns this. */
    public fun trailers(trailers: Headers): Builder =
      apply {
        this.trailers_ = trailers.newBuilder()
      }

    /** Don't trust the client during the SSL handshake. */
    public fun failHandshake(): Builder =
      apply {

    if (flushHeaders) {
      connection.flush()
    }
  }

  fun enqueueTrailers(trailers: Headers) {
    withLock {
      check(!sink.finished) { "already finished" }
      require(trailers.size != 0) { "trailers.size() == 0" }
      this.sink.trailers = trailers
    }
  }

  fun readTimeout(): Timeout = readTimeout

  fun writeTimeout(): Timeout = writeTimeout

  /**

func newSignV4ChunkedReader(req *http.Request, trailer bool) (io.ReadCloser, APIErrorCode) {
	cred, seedSignature, region, seedDate, errCode := calculateSeedSignature(req, trailer)
	if errCode != ErrNone {
		return nil, errCode
	}

	if trailer {
		// Discard anything unsigned.
		req.Trailer = make(http.Header)
		trailers := req.Header.Values(awsTrailerHeader)
		for _, key := range trailers {
			req.Trailer.Add(key, "")
		}

      .build()

  @Test
  fun trailersHttp1() {
    trailers(Protocol.HTTP_1_1)
  }

  @Test
  fun trailersHttp2() {
    trailers(Protocol.HTTP_2)
  }

  private fun trailers(protocol: Protocol) {
    enableProtocol(protocol)

    server.enqueue(
      MockResponse
        .Builder()
        .addHeader("h1", "v1")
        .trailers(headersOf("t1", "v2"))
        .body(protocol, "Hello")

     */
    fun responseBodyComplete(trailers: Headers) {
      if (state == STATE_CLOSED) return
      if (state != STATE_READING_RESPONSE_BODY) throw IllegalStateException("state: $state")

      detachTimeout(timeout)

      this@Http1ExchangeCodec.trailers = trailers
      state = STATE_CLOSED
      if (trailers.size > 0) {
        client?.cookieJar?.receiveHeaders(url, trailers)
      }
    }
  }

   * @throws IOException if the trailers cannot be loaded, such as if the network connection is
   *     dropped.
   */
  @Throws(IOException::class)
  fun trailers(): Headers = trailersSource.get()

  /**
   * Returns the trailers after the HTTP response, if they are available to read immediately. Unlike
   * [trailers], this doesn't block if the trailers are not immediately available, and instead

      }

      socket.sleepWhileOpen(response.headersDelayNanos)
      stream.writeHeaders(response.toHttp2Headers(), outFinished, flushHeaders)

      if (trailers.size > 0) {
        stream.enqueueTrailers(trailers)
      }
      pushPromises(stream, request, response.pushPromises)
      if (body != null) {
        socket.sleepWhileOpen(bodyDelayNanos)
        val responseBodySink =

    throwing in 5.0.0, we inadvertently removed the ability for callers to peek the trailers
    (by catching the `IllegalStateException` if they weren't available). This new API restores that
    capability.

 *  Fix: Don't crash on `trailers()` if the response doesn't have a body. We broke [Retrofit] users

        .exhaustResponse()
    server.enqueue(
      MockResponse
        .Builder()
        .clearHeaders()
        .addHeader("h1", "v1")
        .addHeader("h2", "v2")
        .trailers(headersOf("trailers", "boom"))
        .socketHandler(body)
        .build(),
    )
    val call =
      client.newCall(
        Request
          .Builder()
          .url(server.url("/"))
          .build(),

    var trailers: Headers = mockResponse.trailers
    mockResponse = mockResponse.clearHeaders()
    mockResponse = mockResponse.addHeader("")
    mockResponse = mockResponse.addHeader("", "")
    mockResponse = mockResponse.addHeaderLenient("", Any())
    mockResponse = mockResponse.setHeader("", Any())
    mockResponse.headers = headersOf()
    mockResponse.trailers = headersOf()