return copy(proxy = proxy)
  }

  override fun withProxySelector(proxySelector: ProxySelector): Interceptor.Chain {
    check(exchange == null) { "proxySelector can't be adjusted in a network interceptor" }

    return copy(proxySelector = proxySelector)
  }

  override fun withProxyAuthenticator(proxyAuthenticator: Authenticator): Interceptor.Chain {

      proxy = proxy,
      protocols = protocols,
      connectionSpecs = connectionSpecs,
      proxySelector = proxySelector,
    )

  fun newHttpsAddress(
    uriHost: String = this.uriHost,
    uriPort: Int = this.uriPort,
    proxy: Proxy? = null,
    proxySelector: ProxySelector = this.proxySelector,
    sslSocketFactory: SSLSocketFactory? = this.sslSocketFactory,

    }

    object ProxySelectorOverride : Override<ProxySelector> {
      override fun Interceptor.Chain.value(): ProxySelector = proxySelector

      override fun Interceptor.Chain.withOverride(value: ProxySelector): Interceptor.Chain = withProxySelector(value)

      override fun OkHttpClient.Builder.withOverride(value: ProxySelector): OkHttpClient.Builder = proxySelector(value)

      override val nonDefaultValue: ProxySelector =

        .Builder()
        .proxySelector(FakeProxySelector())
        .build()
    assertThat(client.proxy).isNull()
    assertThat(client.proxySelector)
      .isInstanceOf(FakeProxySelector::class.java)
  }

  @Test fun sharesRouteDatabase() {
    val client =
      OkHttpClient
        .Builder()
        .build()
    val proxySelector: ProxySelector =
      object : ProxySelector() {

    /**
     * Returns the [ProxySelector] for the OkHttpClient, or an override from the Call.Chain.
     */
    val proxySelector: ProxySelector

    /**
     * Override the [ProxySelector] for the Call.Chain.
     *
     * @throws IllegalStateException if this is a Network Interceptor, since the override is too late.
     */
    fun withProxySelector(proxySelector: ProxySelector): Chain

    /**

  @Test
  fun proxyMoveTest(cleanClose: Boolean = true) {
    // Define a single Proxy at myproxy:8008 that will artificially move during the test
    val proxySelector = RecordingProxySelector()
    val socketAddress = InetSocketAddress.createUnresolved("myproxy", 8008)
    proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, socketAddress))

    // Define two host names for the DNS routing of fake proxy servers

     *
     * If unset, the [system-wide default][ProxySelector.getDefault] proxy selector will be used.
     */
    fun proxySelector(proxySelector: ProxySelector) =
      apply {
        if (proxySelector != this.proxySelector) {
          this.routeDatabase = null
        }

        this.proxySelector = proxySelector
      }

    /**

    val proxyAuthenticator: Authenticator = address.proxyAuthenticator
    val protocols: List<Protocol> = address.protocols
    val connectionSpecs: List<ConnectionSpec> = address.connectionSpecs
    val proxySelector: ProxySelector = address.proxySelector
    val sslSocketFactory: SSLSocketFactory? = address.sslSocketFactory
    val hostnameVerifier: HostnameVerifier? = address.hostnameVerifier

        DefaultProxySelector proxySelector = new DefaultProxySelector();
        for (Proxy proxy : request.getProxies()) {
            AuthenticationBuilder authBuilder = new AuthenticationBuilder();
            authBuilder.addUsername(proxy.getUsername()).addPassword(proxy.getPassword());
            proxySelector.add(
                    new org.eclipse.aether.repository.Proxy(

	public final fun protocols ()Ljava/util/List;
	public final fun proxy ()Ljava/net/Proxy;
	public final fun proxyAuthenticator ()Lokhttp3/Authenticator;
	public final fun proxySelector ()Ljava/net/ProxySelector;
	public final fun socketFactory ()Ljavax/net/SocketFactory;
	public final fun sslSocketFactory ()Ljavax/net/ssl/SSLSocketFactory;
	public fun toString ()Ljava/lang/String;