@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,

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

  @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))

            Map<String, Object> configProperties,
            MirrorSelector mirrorSelector,
            ProxySelector proxySelector,
            AuthenticationSelector authenticationSelector) {
        injectMirror(mavenExecutionRequest.getRemoteRepositories(), mavenExecutionRequest.getMirrors());
        injectProxy(proxySelector, mavenExecutionRequest.getRemoteRepositories());

    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}")
  }

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

    /**

  @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 the URI lacks a host (as in "http://</"), don't call the ProxySelector.
      val uri = url.toUri()
      if (uri.host == null) return immutableListOf(Proxy.NO_PROXY)

      // Try each of the ProxySelector choices until one connection succeeds.
      val proxiesOrNull = address.proxySelector.select(uri)
      if (proxiesOrNull.isNullOrEmpty()) return immutableListOf(Proxy.NO_PROXY)

 */
package okhttp3.internal.proxy

import java.io.IOException
import java.net.Proxy
import java.net.ProxySelector
import java.net.SocketAddress
import java.net.URI

/**
 * A proxy selector that always returns the [Proxy.NO_PROXY].
 */
object NullProxySelector : ProxySelector() {
  override fun select(uri: URI?): List<Proxy> {
    requireNotNull(uri) { "uri must not be null" }