body: Buffer,
      maxChunkSize: Int,
    ) = apply {
      removeHeader("Content-Length")
      headers.add(CHUNKED_BODY_HEADER)

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

      }

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

        )
      routeSelector = newRouteSelector
    }

    // List available IP addresses for the current proxy. This may block in Dns.lookup().
    if (!newRouteSelector.hasNext()) throw IOException("exhausted all routes")
    val newRouteSelection = newRouteSelector.next()
    routeSelection = newRouteSelection

    if (isCanceled()) throw IOException("Canceled")

          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) {

    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!!)

internal inline fun ignoreIoExceptions(block: () -> Unit) {
  try {
    block()
  } catch (_: IOException) {
  }
}

internal fun Buffer.skipAll(b: Byte): Int {
  var count = 0
  while (!exhausted() && this[0] == b) {
    count++
    readByte()
  }
  return count
}

/**
 * Returns the index of the next non-whitespace character in this. Result is undefined if input

  return result
}

internal fun idnToAscii(host: String): String? {
  val bufferA = Buffer().writeUtf8(host)
  val bufferB = Buffer()

  // 1. Map, from bufferA to bufferB.
  while (!bufferA.exhausted()) {
    val codePoint = bufferA.readUtf8CodePoint()
    if (!IDNA_MAPPING_TABLE.map(codePoint, bufferB)) return null
  }

  // 2. Normalize, from bufferB to bufferA.

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

    limiter.acquire(1); // R0.00, from capacity
    limiter.acquire(3); // R0.00, from capacity
    limiter.acquire(1); // R0.00, concluding a burst of 5 permits

    limiter.acquire(); // R0.20, capacity exhausted
    assertEvents(
        "U1.00", "U1.00", "R0.00", "R0.00", "R0.00", "R0.00", // first request and burst
        "R0.20");
  }

  public void testCreateWarmupParameterValidation() {
    RateLimiter unused;

    limiter.acquire(1); // R0.00, from capacity
    limiter.acquire(3); // R0.00, from capacity
    limiter.acquire(1); // R0.00, concluding a burst of 5 permits

    limiter.acquire(); // R0.20, capacity exhausted
    assertEvents(
        "U1.00", "U1.00", "R0.00", "R0.00", "R0.00", "R0.00", // first request and burst
        "R0.20");
  }

  public void testCreateWarmupParameterValidation() {
    RateLimiter unused;