@JvmName("-deprecated_getTrailers")
  @Deprecated(
    message = "moved to var",
    replaceWith = ReplaceWith(expression = "trailers"),
    level = DeprecationLevel.ERROR,
  )
  fun getTrailers(): Headers = trailers

  fun setTrailers(trailers: Headers) = apply { this.trailers = trailers }

  @JvmName("-deprecated_getSocketPolicy")
  @Deprecated(
    message = "moved to var",

    val request =
      Request
        .Builder()
        .url("http://square.com/")
        .header("TE", "trailers")
        .build()
    val expected =
      headerEntries(
        ":method",
        "GET",
        ":path",
        "/",
        ":scheme",
        "http",
        "te",
        "trailers",
      )
    assertThat(http2HeadersList(request)).isEqualTo(expected)
  }

			req.Trailer.Add(key, "")
		}
	} else {
		req.Trailer = nil
	}
	return &s3UnsignedChunkedReader{
		trailers: req.Trailer,
		reader:   bufio.NewReader(req.Body),
		buffer:   make([]byte, 64*1024),
	}, ErrNone
}

// Represents the overall state that is required for decoding a
// AWS Signature V4 chunked reader.
type s3UnsignedChunkedReader struct {
	reader   *bufio.Reader
	trailers http.Header

	buffer []byte

  for (pushPromise in pushPromises) {
    result.addPush(pushPromise.wrap())
  }

  result.settings(settings)
  result.status(status)
  result.headers(headers)
  result.trailers(trailers)

  when (socketPolicy) {
    SocketPolicy.EXPECT_CONTINUE, SocketPolicy.CONTINUE_ALWAYS -> {
      result.add100Continue()
    }

    SocketPolicy.UPGRADE_TO_SSL_AT_END -> {
      result.inTunnel()
    }

interface ExchangeCodec {
  /** The connection or CONNECT tunnel that owns this codec. */
  val carrier: Carrier

  /** Returns true if the response body and (possibly empty) trailers have been received. */
  val isResponseComplete: Boolean

  /** The socket that carries this exchange. */
  val socket: Socket

  /** Returns an output stream where the request body can be streamed. */

          else -> {
            val responseBody = exchange.openResponseBody(response)
            response
              .newBuilder()
              .body(responseBody)
              .trailers(
                object : TrailersSource {
                  override fun peek() = exchange.peekTrailers()

                  override fun get(): Headers {
                    val source = responseBody.source()

  fun readLine(): String {
    val line = source.readUtf8LineStrict(headerLimit)
    headerLimit -= line.length.toLong()
    return line
  }

  /** Reads headers or trailers. */
  fun readHeaders(): Headers {
    val result = Headers.Builder()
    while (true) {
      val line = readLine()
      if (line.isEmpty()) break
      result.addLenient(line)
    }
    return result.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()

        // header names must be lowercase.
        val name = headers.name(i).lowercase(Locale.US)
        if (name !in HTTP_2_SKIPPED_REQUEST_HEADERS ||
          name == TE &&
          headers.value(i) == "trailers"
        ) {
          result.add(Header(name, headers.value(i)))
        }
      }
      return result
    }

    /** Returns headers for a name value block containing an HTTP/2 response. */

   *
   * Note that this method may be called a second time for a single HTTP response if the response
   * includes a trailer. For this obscure HTTP feature, [cookies] contains only the trailer's
   * cookies.
   */
  fun saveFromResponse(
    url: HttpUrl,
    cookies: List<Cookie>,
  )

  /**