val connect = server.takeRequest()
    assertThat(connect.requestLine, "Connect line failure on proxy")
      .isEqualTo("CONNECT android.com:443 HTTP/1.1")
    assertThat(connect.headers["Host"]).isEqualTo("android.com:443")
    val get = server.takeRequest()
    assertThat(get.requestLine).isEqualTo("GET /foo HTTP/1.1")
    assertThat(get.headers["Host"]).isEqualTo("android.com")

  }

  @Test
  fun changingSchemeChangesDefaultPort() {
    assertThat(
      parse("http://example.com")
        .newBuilder()
        .scheme("https")
        .build().port,
    ).isEqualTo(443)
    assertThat(
      parse("https://example.com")
        .newBuilder()
        .scheme("http")
        .build().port,
    ).isEqualTo(80)
    assertThat(
      parse("https://example.com:1234")

        QuicOptions.Builder()
          .addAllowedQuicHost("google.com")
          .addAllowedQuicHost("www.google.com")
          .build(),
      )
      .addQuicHint("google.com", 443, 443)
      .addQuicHint("www.google.com", 443, 443)
      .build()

  @After
  fun tearDown() {
    engine.shutdown()
    cacheDir.deleteRecursively()
  }

  @Test
  fun get() {

 *
 *  * Server Name Indication (SNI) enables one IP address to negotiate secure connections for
 *    multiple domain names.
 *
 *  * Application Layer Protocol Negotiation (ALPN) enables the HTTPS port (443) to be used to
 *    negotiate HTTP/2.
 *
 * Unfortunately, older HTTPS servers refuse to connect when such options are presented. Rather than

httpa://foo:80/  s:httpa p://foo:80/
http://foo:-80/
https://foo:443/  s:https h:foo p:/
https://foo:80/  s:https h:foo port:80 p:/
ftp://foo:21/  s:ftp h:foo p:/
ftp://foo:80/  s:ftp h:foo port:80 p:/
gopher://foo:70/  s:gopher h:foo p:/
gopher://foo:443/  s:gopher h:foo port:443 p:/
ws://foo:80/  s:ws h:foo p:/
ws://foo:81/  s:ws h:foo port:81 p:/
ws://foo:443/  s:ws h:foo port:443 p:/
ws://foo:815/  s:ws h:foo port:815 p:/

            "CommentURL=\"http://google.com/\"; " +
            "Discard; " +
            "Domain=${urlWithIpAddress.host}; " +
            "Max-Age=60; " +
            "Path=\"/path\"; " +
            "Port=\"80,443,${server.port}\"; " +
            "Secure; " +
            "Version=\"1\"",
        )
        .build(),
    )
    get(urlWithIpAddress)
    val cookies = cookieManager.cookieStore.cookies

    return result
  }

  /**
   * Returns a string with the URL hostname, socket IP address, and socket port, like one of these:
   *
   *  * `example.com:80 at 1.2.3.4:8888`
   *  * `example.com:443 via proxy [::1]:8888`
   *
   * This omits duplicate information when possible.
   */
  override fun toString(): String {
    return buildString {

Content-Type: text/html
Content-Length: 193
Connection: keep-alive
Location: https://publicobject.com/helloworld.txt

INFO: Sending request https://publicobject.com/helloworld.txt on Connection{publicobject.com:443, proxy=DIRECT hostAddress=54.187.32.157 cipherSuite=TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA protocol=http/1.1}
User-Agent: OkHttp Example
Host: publicobject.com
Connection: Keep-Alive
Accept-Encoding: gzip

   * For example, this returns 8443 for `https://square.com:8443/` and 443 for
   * `https://square.com/`. The result is in `[1..65535]`.
   *
   * | URL                 | `port()` |
   * | :------------------ | :------- |
   * | `http://host/`      | `80`     |
   * | `http://host:8000/` | `8000`   |
   * | `https://host/`     | `443`    |
   */
  @get:JvmName("port") val port: Int,
  /**

    val connect1 = server.takeRequest()
    assertThat(connect1.requestLine).isEqualTo("CONNECT android.com:443 HTTP/1.1")
    assertThat(connect1.headers["Proxy-Authorization"]).isNull()
    val connect2 = server.takeRequest()
    assertThat(connect2.requestLine).isEqualTo("CONNECT android.com:443 HTTP/1.1")
    assertThat(connect2.headers["Proxy-Authorization"]).isEqualTo("password")
    val get = server.takeRequest()