fun Request.Builder.commonGet(): Request.Builder = method("GET", null)

fun Request.Builder.commonHead(): Request.Builder = method("HEAD", null)

fun Request.Builder.commonPost(body: RequestBody): Request.Builder = method("POST", body)

fun Request.Builder.commonDelete(body: RequestBody?): Request.Builder = method("DELETE", body)

fun Request.Builder.commonPut(body: RequestBody): Request.Builder = method("PUT", body)

 */
package okhttp3

import java.net.InetAddress
import java.net.UnknownHostException
import okhttp3.Dns.Companion.SYSTEM

/**
 * A domain name service that resolves IP addresses for host names. Most applications will use the
 * [system DNS service][SYSTEM], which is the default. Some applications may provide their own
 * implementation to use a different DNS server, to prefer IPv6 addresses, to prefer IPv4 addresses,

import org.junit.jupiter.api.Assertions.assertTrue
import org.junit.jupiter.api.Test

@Suppress("DEPRECATION_ERROR")
class PublicInternalApiTest {
  @Test
  fun permitsRequestBody() {
    assertTrue(permitsRequestBody("POST"))
    assertFalse(permitsRequestBody("GET"))
  }

  @Test
  fun requiresRequestBody() {
    assertTrue(requiresRequestBody("PUT"))
    assertFalse(requiresRequestBody("GET"))
  }

  @Test

    assertThat("http://host/a\u0000b".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%00b"))
    assertThat("http://host/a\u0080b".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%C2%80b"))
    assertThat("http://host/a\u009fb".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/a%C2%9Fb"))
    // Percent-encoded in the query.
    assertThat("http://host/?a\u0000b".toHttpUrl().toUri())
      .isEqualTo(URI("http://host/?a%00b"))

      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:\\\\host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:///host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:\\//host/path"))
      .isEqualTo(parse("http://host/path"))
    assertThat(parse("http:/\\/host/path"))
      .isEqualTo(parse("http://host/path"))

        Request(
          url = "https://url-host.com:${server.port}/".toHttpUrl(),
          headers = headersOf("Host", "header-host"),
        ),
      )
    val response = call.execute()
    assertThat(response.isSuccessful).isTrue()

    val recordedRequest = server.takeRequest()
    assertThat(recordedRequest.requestUrl!!.host).isEqualTo("header-host")

      (
        if (host.startsWith("[") && host.endsWith("]")) {
          decodeIpv6(host, 1, host.length - 1)
        } else {
          decodeIpv6(host, 0, host.length)
        }
      ) ?: return null

    val address = canonicalizeInetAddress(inetAddressByteArray)
    if (address.size == 16) return inet6AddressToAscii(address)
    if (address.size == 4) return inet4AddressToAscii(address) // An IPv4-mapped IPv6 address.

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

    }
  }
}

private fun Request.requestForCache(): Request {
  val cacheUrlOverride = cacheUrlOverride

  return if (cacheUrlOverride != null && (method == "GET" || method == "POST")) {
    newBuilder()
      .get()
      .url(cacheUrlOverride)
      .cacheUrlOverride(null)
      .build()
  } else {
    this
  }

  @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"),
        )