return proxyClass.isInstance(arg)
        // Equal proxy instances should mostly be instance of proxyClass
        // Under some edge cases (such as the proxy of JDK types serialized and then deserialized)
        // the proxy type may not be the same.
        // We first check isProxyClass() so that the common case of comparing with non-proxy objects
        // is efficient.
        || (Proxy.isProxyClass(arg.getClass())

 *   <li>SO_TIMEOUT_PROPERTY: Socket timeout setting.</li>
 *   <li>PROXY_HOST_PROPERTY: Proxy host setting.</li>
 *   <li>PROXY_PORT_PROPERTY: Proxy port setting.</li>
 *   <li>PROXY_AUTH_SCHEME_PROPERTY: Proxy authentication scheme.</li>
 *   <li>PROXY_CREDENTIALS_PROPERTY: Proxy credentials.</li>
 *   <li>USER_AGENT_PROPERTY: User agent string.</li>

package okhttp3

import java.net.InetSocketAddress
import java.net.Proxy
import okhttp3.internal.toCanonicalHost

/**
 * The concrete route used by a connection to reach an abstract origin server. When creating a
 * connection the client has many options:
 *
 *  * **HTTP proxy:** a proxy server may be explicitly configured for the client. Otherwise, the

/**
 * Performs either **preemptive** authentication before connecting to a proxy server, or
 * **reactive** authentication after receiving a challenge from either an origin web server or proxy
 * server.
 *
 * ## Preemptive Authentication
 *
 * To make HTTPS calls using an HTTP proxy server OkHttp must first negotiate a connection with
 * the proxy. This proxy connection is called a "TLS Tunnel" and is specified by

    }
  }

  @Test
  fun testUrlConnectionPlaintextProxied() {
    testRequest {
      val proxy =
        Proxy(
          Proxy.Type.HTTP,
          it.remoteAddress(),
        )

      val url = URI(mockServer.endpoint + "/person?name=peter").toURL()

      val connection = url.openConnection(proxy) as HttpURLConnection

      assertThat(
        connection.inputStream
          .source()

    * Otherwise, you might have to stop the TLS Termination Proxy momentarily, start the renewal program to acquire the certificates, then configure them with the TLS Termination Proxy, and then restart the TLS Termination Proxy. This is not ideal, as your app(s) will not be available during the time that the TLS Termination Proxy is off.

                    }

                    Proxy p = new Proxy();
                    p.setHost(proxy.getHost());
                    p.setProtocol(proxy.getProtocol());
                    p.setPort(proxy.getPort());
                    p.setNonProxyHosts(proxy.getNonProxyHosts());
                    p.setUserName(proxy.getUsername());
                    p.setPassword(proxy.getPassword());

                                "Legacy/insecurely encrypted password detected for proxy " + proxy.getId(),
                                Severity.WARNING,
                                "proxy: " + proxy.getId(),
                                -1,
                                -1,
                                null));
                    }
                    proxy.setPassword(securityDispatcher.decrypt(password));

      certificatePinner = null,
      proxyAuthenticator = proxyAuthenticator,
      proxy = proxy,
      protocols = protocols,
      connectionSpecs = connectionSpecs,
      proxySelector = proxySelector,
    )

  fun newRoute(
    address: Address = newAddress(),
    proxy: Proxy = this.proxy,
    socketAddress: InetSocketAddress = InetSocketAddress.createUnresolved(uriHost, uriPort),
  ): Route =

  ) {
  }

  /**
   * Invoked after proxy selection.
   *
   * Note that the list of proxies is never null, but it may be a list containing
   * only [Proxy.NO_PROXY]. This comes up in several situations:
   *
   * * If neither a proxy nor proxy selector is configured.
   * * If the proxy is configured explicitly as [Proxy.NO_PROXY].
   * * If the proxy selector returns only [Proxy.NO_PROXY].