val peerCertificates = readCertificateList(source)
          val localCertificates = readCertificateList(source)
          val tlsVersion =
            if (!source.exhausted()) {
              TlsVersion.forJavaName(source.readUtf8LineStrict())
            } else {
              TlsVersion.SSL_3_0
            }

              cancel()
            }
          }
        } else if (messageOrClose == null) {
          return false // The queue is exhausted.
        }
      }
    }

    try {
      if (pong != null) {
        writer!!.writePong(pong)
      } else if (messageOrClose is Message) {
        val message = messageOrClose as 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

   *
   * Will only be invoked for requests having a response body e.g. won't be invoked for a web socket
   * upgrade.
   *
   * If the response body is closed before the response body is exhausted, this is invoked at the
   * time it is closed. In such calls [byteCount] is the number of bytes returned to the
   * application. This may be smaller than the resource's byte count if were read to completion.
   *

       * 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")
            }

          break // End of journal.
        }
      }

      redundantOpCount = lineCount - lruEntries.size

      // If we ended on a truncated line, rebuild the journal before appending to it.
      if (!exhausted()) {
        rebuildJournal()
      } else {
        journalWriter?.closeQuietly()
        journalWriter = newJournalWriter()
      }
    }
  }

  @Throws(FileNotFoundException::class)

		if tr < sr {
			tr, sr = sr, tr
		}
		// ASCII only, sr/tr must be upper/lower case
		if 'A' <= sr && sr <= 'Z' && tr == sr+'a'-'A' {
			continue
		}
		return false
	}
	// Check if we've exhausted both strings.
	return len(s) == len(t)

hasUnicode:
	s = s[i:]
	t = t[i:]
	for len(s) != 0 && len(t) != 0 {
		// Extract first rune from each.
		var sr, tr rune
		if s[0] < utf8.RuneSelf {

    assertThat(response.header("h2")).isEqualTo("v2")
    assertThat(source.readUtf8(5)).isEqualTo("Hello")
    assertThat(source.readUtf8(7)).isEqualTo("Bonjour")
    assertThat(source.exhausted()).isTrue()
    assertThat(response.trailers()).isEqualTo(headersOf("trailers", "boom"))
  }

  @Test
  fun clientReadsHeadersDataTrailersHttp2() {
    platform.assumeHttp2Support()
    server.enqueue(

HSPLokio/AsyncTimeout;-><clinit>()V
HSPLokio/AsyncTimeout;-><init>()V
HSPLokio/AsyncTimeout;->enter()V
HSPLokio/AsyncTimeout;->exit()Z
HSPLokio/Buffer;-><init>()V
HSPLokio/Buffer;->exhausted()Z
HSPLokio/Buffer;->getByte(J)B
HSPLokio/Buffer;->indexOfElement(Lokio/ByteString;)J
HSPLokio/Buffer;->rangeEquals(JLokio/ByteString;)Z
HSPLokio/Buffer;->read(Lokio/Buffer;J)J
HSPLokio/Buffer;->read([BII)I

    assertThat(URLConnection.getDefaultRequestProperty("X-setDefaultRequestProperty")).isNull()
  }

  /**
   * Reads `count` characters from the stream. If the stream is exhausted before `count`
   * characters can be read, the remaining characters are returned and the stream is closed.
   */
  private fun readAscii(
    inputStream: InputStream,
    count: Int,
  ): String {