frame.writeByte(paddingLength)
    frame.write(expectedData)
    frame.write(padding)
    reader.nextFrame(requireSettings = false, assertData())
    // Padding was skipped.
    assertThat(frame.exhausted()).isTrue()
  }

  @Test fun readPaddedDataFrameZeroPadding() {
    val dataLength = 1123
    val expectedData = ByteArray(dataLength)
    Arrays.fill(expectedData, 2.toByte())

          currentLabelByteIndex++
          if (publicSuffixByteIndex == publicSuffixLength) break

          if (labels[currentLabelIndex].size == currentLabelByteIndex) {
            // We've exhausted our current label. Either there are more labels to compare, in which
            // case we expect a dot as the next character. Otherwise, we've checked all our labels.
            if (currentLabelIndex == labels.size - 1) {

      override fun fromDer(reader: DerReader): Long {
        val peekHeader =
          reader.peekHeader()
            ?: throw ProtocolException("expected time but was exhausted at $reader")

        return when {
          peekHeader.tagClass == Adapters.UTC_TIME.tagClass &&
            peekHeader.tag == Adapters.UTC_TIME.tag -> {
            Adapters.UTC_TIME.fromDer(reader)
          }

  private val Request.isChunked: Boolean
    get() = "chunked".equals(header("Transfer-Encoding"), ignoreCase = true)

  /**
   * Trailers received when the response body became exhausted.
   *
   * If the response body was successfully read until the end, this is the headers that followed,
   * or empty headers if there were none that followed.
   *

    )

    val call = client.newCall(Request(server.url("/")))
    call.execute().use { response ->
      assertThat(response.trailers()).isEqualTo(headersOf("t1", "v2"))
      assertThat(response.body.source().exhausted()).isTrue()
    }
  }

  @Test
  @Disabled
  fun trailersAndCacheHttp1() {
    trailersAndCache(Protocol.HTTP_1_1)
  }

  @Test
  @Disabled
  fun trailersAndCacheHttp2() {

     * on the socket.
     */
    @Throws(IOException::class, InterruptedException::class)
    private fun processOneRequest(socket: MockWebServerSocket): Boolean {
      if (socket.source.exhausted()) {
        return false // No more requests on this socket.
      }

      val request =
        readRequest(
          socket = socket,
          connectionIndex = connectionIndex,

       * propagate the never indexed flag of a header.
       */
      @Throws(IOException::class)
      fun readHeaders() {
        while (!source.exhausted()) {
          val b = source.readByte() and 0xff
          when {
            b == 0x80 -> {
              // 10000000
              throw IOException("index == 0")
            }

    ): Builder =
      apply {
        removeHeader("Content-Length")
        headers_.add("Transfer-encoding: chunked")

        val bytesOut = Buffer()
        while (!body.exhausted()) {
          val chunkSize = minOf(body.size, maxChunkSize.toLong())
          bytesOut.writeHexadecimalUnsignedLong(chunkSize)
          bytesOut.writeUtf8("\r\n")
          bytesOut.write(body, chunkSize)

    data.write("880203ee".decodeHex()) // Close with code 1006
    for (i in 1015..2999) {
      data.write(("8802" + format("%04X", i)).decodeHex()) // Close with code 'i'
    }
    var count = 0
    while (!data.exhausted()) {
      assertFailsWith<ProtocolException> {
        clientReader.processNextFrame()
      }.also { expected ->
        assertThat(expected.message!!)

  /**
   * Returns the least of the specified values according to this ordering. If there are multiple
   * least values, the first of those is returned. The iterator will be left exhausted: its {@code
   * hasNext()} method will return {@code false}.
   *
   * <p><b>Java 8+ users:</b> Use {@code Streams.stream(iterator).min(thisComparator).get()} instead