*
       * Example:
       * ```
       * --> POST /greeting http/1.1 (3-byte body)
       *
       * <-- 200 OK (22ms, 6-byte body)
       * ```
       */
      BASIC,

      /**
       * Logs request and response lines and their respective headers.
       *
       * Example:
       * ```
       * --> POST /greeting http/1.1
       * Host: example.com
       * Content-Type: plain/text

    detecting the TLS capabilities of the host platform.

 *  Fix: Don't crash in `HttpUrl.topPrivateDomain()` when the hostname is malformed.

 *  Fix: Don't attempt Brotli decompression if the response body is empty.


## Version 4.7.2

_2020-05-20_

 *  Fix: Don't crash inspecting whether the host platform is JVM or Android. With 4.7.0 and 4.7.1 we

    if (calls.size >= allocationLimit || noNewExchanges) return false

    // If the non-host fields of the address don't overlap, we're done.
    if (!this.route.address.equalsNonHost(address)) return false

    // If the host exactly matches, we're done: this connection can carry the address.
    if (address.url.host == this.route().address.url.host) {
      return true // This connection is a perfect match.
    }

  @Container
  val socks5Proxy =
    GenericContainer(SOCKS5_PROXY)
      .withNetwork(network)
      .withExposedPorts(1080)

  @Test
  fun testLocal() {
    MockServerClient(mockServer.host, mockServer.serverPort).use { mockServerClient ->
      mockServerClient
        .`when`(
          request().withPath("/person")
            .withQueryStringParameter("name", "peter"),
        )

        value = value.substring(1, value.length - 1)
      }

      result.add(
        Cookie.Builder()
          .name(name)
          .value(value)
          .domain(url.host)
          .build(),
      )
      pos = pairEnd + 1
    }
    return result
  }

    @Volatile var callsPerHost = AtomicInteger(0)
      private set

    fun reuseCallsPerHostFrom(other: AsyncCall) {
      this.callsPerHost = other.callsPerHost
    }

    val host: String
      get() = originalRequest.url.host

    val request: Request
      get() = originalRequest

    val call: RealCall
      get() = this@RealCall

    /**

      this.associatedStreamId = associatedStreamId
      this.headerBlock = headerBlock
    }

    override fun alternateService(
      streamId: Int,
      origin: String,
      protocol: ByteString,
      host: String,
      port: Int,
      maxAge: Long,
    ) {
      throw UnsupportedOperationException()
    }
  }

  companion object {

 * This class contains a Kotlin implementation of the pseudocode specified by RFC 3492. It includes
 * direct translation of the pseudocode presented there.
 *
 * Partner this class with [UTS #46] to implement IDNA2008 [RFC 5890] like most browsers do.
 *
 * [RFC 3492]: https://datatracker.ietf.org/doc/html/rfc3492
 * [RFC 5890]: https://datatracker.ietf.org/doc/html/rfc5890
 * [UTS #46]: https://www.unicode.org/reports/tr46/
 */
object Punycode {

  fun requestMethodPostIsNotCached() {
    // We could support this but choose not to for implementation simplicity
    testRequestMethod("POST", false)
  }

  @Test
  fun requestMethodPostIsNotCachedUnlessOverridden() {
    // Supported via cacheUrlOverride
    testRequestMethod("POST", true, withOverride = true)
  }

  @Test
  fun requestMethodPutIsNotCached() {
    testRequestMethod("PUT", false)
  }

    // Adapt the request and response into our Request and Response domain model.
    val scheme = if (request.handshake != null) "https" else "http"
    val authority = request.headers["Host"] // Has host and port.
    val fancyRequest =
      Request.Builder()
        .url("$scheme://$authority/")
        .headers(request.headers)
        .build()
    val fancyResponse =
      Response.Builder()