require(millis <= Integer.MAX_VALUE) { "$name too large" }
  require(millis != 0L || duration <= 0L) { "$name too small" }
  return millis.toInt()
}

internal fun checkDuration(
  name: String,
  duration: Duration,
): Int {
  check(!duration.isNegative()) { "$name < 0" }
  val millis = duration.inWholeMilliseconds
  require(millis <= Integer.MAX_VALUE) { "$name too large" }

## Dispatch

For synchronous calls, you bring your own thread and are responsible for managing how many simultaneous requests you make. Too many simultaneous connections wastes resources; too few harms latency.

      if (networkResponse == null && cacheCandidate != null) {
        cacheCandidate.body.closeQuietly()
      }
    }

    // If we have a cache response too, then we're doing a conditional get.
    if (cacheResponse != null) {
      if (networkResponse?.code == HTTP_NOT_MODIFIED) {
        val response =
          cacheResponse.newBuilder()

    bytesIn.writeShort(0xff00) // == Indexed - Add idx = 127
    assertFailsWith<IOException> {
      hpackReader!!.readHeaders()
    }.also { expected ->
      assertThat(expected.message).isEqualTo("Header index too large 127")
    }
  }

  // Example taken from twitter/hpack DecoderTest.testInsidiousIndex
  @Test
  fun readIndexedHeaderFieldInsidiousIndex() {
    bytesIn.writeByte(0xff) // == Indexed - Add ==

    when pooled connections are evicted).

    If you have a configured ping interval, you should confirm that it is long
    enough for a roundtrip from client to server. If your ping interval is too
    short, slow connections may be misinterpreted as failed connections. A ping
    interval of 30 seconds is reasonable for most use cases.

 *  **OkHttp now supports [Conscrypt][conscrypt].** Conscrypt is a Java Security

            "Retry-After",
            "1",
          ),
        body = "You took too long!",
        socketPolicy = DisconnectAtEnd,
      ),
    )
    val request = Request(server.url("/"))
    val response = client.newCall(request).execute()
    assertThat(response.body.string()).isEqualTo("You took too long!")
  }

  @Test
  fun requestBodyRetransmittedOnClientRequestTimeout() {

    }

    // Optimization: check whether hostname is too short to match the pattern. hostName must be at
    // least as long as the pattern because asterisk must match the whole left-most label and
    // hostname starts with a non-empty label. Thus, asterisk has to match one or more characters.
    if (hostname.length < pattern.length) {
      return false // Hostname too short to match the pattern.
    }

    if ("*." == pattern) {

        // that it will almost certainly fail because the proxy has sent unexpected data.
        if (source?.buffer?.exhausted() == false || sink?.buffer?.exhausted() == false) {
          throw IOException("TLS tunnel buffered too many bytes!")
        }

        user.secureConnectStart()

        // Create the wrapper over the connected socket.
        val sslSocket =
          route.address.sslSocketFactory.createSocket(

          newFixedLengthSource(contentLength)
        } else {
          newUnknownLengthSource()
        }
      }
    }
  }

  override fun trailers(): Headers {
    check(state == STATE_CLOSED) { "too early; can't read the trailers yet" }
    return trailers ?: EMPTY_HEADERS
  }

  override fun flushRequest() {
    sink.flush()
  }

  override fun finishRequest() {
    sink.flush()
  }

      if (success && !entry.zombie) {
        if (fileSystem.exists(dirty)) {
          val clean = entry.cleanFiles[i]
          fileSystem.atomicMove(dirty, clean)
          val oldLength = entry.lengths[i]
          // TODO check null behaviour
          val newLength = fileSystem.metadata(clean).size ?: 0
          entry.lengths[i] = newLength
          size = size - oldLength + newLength
        }
      } else {