@JvmName("-deprecated_proxySelector")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "proxySelector"),
    level = DeprecationLevel.ERROR,
  )
  fun proxySelector(): ProxySelector = proxySelector

  @JvmName("-deprecated_proxy")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "proxy"),

      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,

  @Test fun connectExceptionsAreReturnedAsSuppressed() {
    val proxySelector = RecordingProxySelector()
    proxySelector.proxies.add(Proxy(Proxy.Type.HTTP, TestUtil.UNREACHABLE_ADDRESS_IPV4))
    proxySelector.proxies.add(Proxy.NO_PROXY)
    server.close()

    client =
      client
        .newBuilder()
        .proxySelector(proxySelector)
        .readTimeout(Duration.ofMillis(100))

    dns.assertRequests(uriHost)
    proxySelector.assertRequests(address.url.toUri())
  }

  @Test fun proxySelectorReturnsMultipleProxies() {
    val address = factory.newAddress()
    proxySelector.proxies.add(proxyA)
    proxySelector.proxies.add(proxyB)
    val routeSelector = newRouteSelector(address)
    proxySelector.assertRequests(address.url.toUri())

        .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() {

    // The HTTP calls should share a single connection.
    assertThat(socksProxy.connectionCount()).isEqualTo(1)
  }

  @Test
  fun proxySelector() {
    server.enqueue(MockResponse.Builder().body("abc").build())
    val proxySelector: ProxySelector =
      object : ProxySelector() {
        override fun select(uri: URI) = listOf(socksProxy.proxy())

        override fun connectFailed(
          uri: URI,

  fun proxyMoveTest(cleanClose: Boolean) {
    // 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

    val a = factory.newAddress(proxySelector = RecordingProxySelector())
    val b = factory.newAddress(proxySelector = RecordingProxySelector())
    assertThat(b).isNotEqualTo(a)
  }

  @Test fun addressToString() {
    val address = factory.newAddress()
    assertThat(address.toString())
      .isEqualTo("Address{example.com:80, proxySelector=RecordingProxySelector}")
  }

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

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

    /**