val request =
      Request.Builder()
        .url("http://square.com/")
        .header("Connection", "upgrade")
        .header("Upgrade", "websocket")
        .header("Host", "square.com")
        .header("TE", "gzip")
        .build()
    val expected =
      headerEntries(
        ":method",
        "GET",
        ":path",
        "/",
        ":authority",

    val client =
      clientTestRule.newClientBuilder()
        .proxy(socksProxy.proxy())
        .build()
    val url =
      server.url("/")
        .newBuilder()
        .host(SocksProxy.HOSTNAME_THAT_ONLY_THE_PROXY_KNOWS)
        .build()
    val request = Request.Builder().url(url).build()
    val response1 = client.newCall(request).execute()

    calls++

    if (exchange != null) {
      check(exchange.finder.routePlanner.sameHostAndPort(request.url)) {
        "network interceptor ${interceptors[index - 1]} must retain the same host and port"
      }
      check(calls == 1) {
        "network interceptor ${interceptors[index - 1]} must call proceed() exactly once"
      }
    }

    // Call the next interceptor in the chain.

    val username: String = httpUrl.username()
    val encodedPassword: String = httpUrl.encodedPassword()
    val password: String = httpUrl.password()
    val host: String = httpUrl.host()
    val port: Int = httpUrl.port()
    val pathSize: Int = httpUrl.pathSize()
    val encodedPath: String = httpUrl.encodedPath()
    val encodedPathSegments: List<String> = httpUrl.encodedPathSegments()

     * @param origin when present, the [origin](http://tools.ietf.org/html/rfc6454) is typically
     *     represented as a combination of scheme, host and port. When empty, the origin is that of
     *     the `streamId`.
     * @param protocol an ALPN protocol, such as `h2`.
     * @param host an IP address or hostname.
     * @param port the IP port associated with the service.

http://%30%78%63%30%2e%30%32%35%30.01%2e  s:http p:/ h:0xc0.0250.01.
http://192.168.0.257

# Invalid escaping should trigger the regular host error handling.
http://%3g%78%63%30%2e%30%32%35%30%2E.01

# Something that isn't exactly an IP should get treated as a host and
# spaces escaped.
http://192.168.0.1\shello

# Fullwidth and escaped UTF-8 fullwidth should still be treated as IP.

    )
    val session = FakeSSLSession(certificate)
    assertThat(verifier.verify("localhost", session)).isTrue()
    assertThat(verifier.verify("localhost.localdomain", session)).isTrue()
    assertThat(verifier.verify("local.host", session)).isFalse()
    assertThat(verifier.verify("127.0.0.1", session)).isTrue()
    assertThat(verifier.verify("127.0.0.2", session)).isFalse()
  }

  @Test fun wildcardsCannotMatchIpAddresses() {

    val proxySelector = RecordingProxySelector()
    proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, InetSocketAddress("myproxy", 8008)))

    // Define two host names for the DNS routing of fake proxy servers
    val proxyServer1 = InetAddress.getByAddress("proxyServer1", byteArrayOf(127, 0, 0, 2))
    val proxyServer2 = InetAddress.getByAddress("proxyServer2", byteArrayOf(127, 0, 0, 3))

      client.newBuilder()
        .addNetworkInterceptor(
          Interceptor { chain: Interceptor.Chain? ->
            val request =
              chain!!.request().newBuilder()
                .header("Host", "privateobject.com")
                .build()
            chain.proceed(request)
          },
        )
        .build()
    server.enqueue(MockResponse())

      .assertLogMatch(Regex("""dnsStart: ${url.host}"""))
      .assertLogMatch(Regex("""dnsEnd: \[.+]"""))
      .assertLogMatch(Regex("""connectStart: ${url.host}/.+ DIRECT"""))
      .assertLogMatch(Regex("""connectEnd: http/1.1"""))
      .assertLogMatch(
        Regex(
          """connectionAcquired: Connection\{${url.host}:\d+, proxy=DIRECT hostAddress=${url.host}/.+ cipherSuite=none protocol=http/1\.1\}""",
        ),
      )