certificateChainCleaner = null,
      )
    }
  }

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

    return copy(hostnameVerifier = hostnameVerifier)
  }

  override fun withCertificatePinner(certificatePinner: CertificatePinner): Interceptor.Chain {

    sslSocketFactory: SSLSocketFactory? = this.sslSocketFactory,
    hostnameVerifier: HostnameVerifier? = this.hostnameVerifier,
  ): Address =
    Address(
      uriHost = uriHost,
      uriPort = uriPort,
      dns = dns,
      socketFactory = SocketFactory.getDefault(),
      sslSocketFactory = sslSocketFactory,
      hostnameVerifier = hostnameVerifier,
      certificatePinner = null,

    }

    object HostnameVerifierOverride : Override<HostnameVerifier> {
      override fun Interceptor.Chain.value(): HostnameVerifier = hostnameVerifier

      override fun Interceptor.Chain.withOverride(value: HostnameVerifier): Interceptor.Chain = withHostnameVerifier(value)

      override fun OkHttpClient.Builder.withOverride(value: HostnameVerifier): OkHttpClient.Builder = hostnameVerifier(value)

     */
    val x509TrustManagerOrNull: X509TrustManager?

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

    /**
     * Override the [HostnameVerifier] for the Call.Chain.
     *
     * @throws IllegalStateException if this is a Network Interceptor, since the override is too late.

    val client =
      clientTestRule
        .newClientBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(RecordingHostnameVerifier())
        .certificatePinner(certificatePinner)
        .build()
    val serverHandshakeCertificates =
      HandshakeCertificates
        .Builder()

     *
     * If unset, a default hostname verifier will be used.
     */
    fun hostnameVerifier(hostnameVerifier: HostnameVerifier) =
      apply {
        if (hostnameVerifier != this.hostnameVerifier) {
          this.routeDatabase = null
        }

        this.hostnameVerifier = hostnameVerifier
      }

    /**

      val socketFactory = handshakeCertificates.sslSocketFactory()
      val hostnameVerifier = RecordingHostnameVerifier()
      server.useHttps(socketFactory)
      client =
        client
          .newBuilder()
          .sslSocketFactory(socketFactory, handshakeCertificates.trustManager)
          .hostnameVerifier(hostnameVerifier)
          .build()
    }
    val responseOne =
      MockResponse

      }
    val sslSocketFactory = sslContext.socketFactory

    val hostnameVerifier = HostnameVerifier { _, _ -> true }

    client =
      client
        .newBuilder()
        .sslSocketFactory(sslSocketFactory, trustManager)
        .hostnameVerifier(hostnameVerifier)
        .build()

    client.get("https://www.facebook.com/robots.txt")
  }

  @Test

    val proxySelector: ProxySelector = address.proxySelector
    val sslSocketFactory: SSLSocketFactory? = address.sslSocketFactory
    val hostnameVerifier: HostnameVerifier? = address.hostnameVerifier
    val certificatePinner: CertificatePinner? = address.certificatePinner
  }

  @Test
  fun authenticator() {

import java.security.cert.X509Certificate
import java.util.Locale
import javax.net.ssl.HostnameVerifier
import javax.net.ssl.SSLException
import javax.net.ssl.SSLSession
import okhttp3.internal.canParseAsIpAddress
import okhttp3.internal.toCanonicalHost
import okio.utf8Size

/**
 * A HostnameVerifier consistent with [RFC 2818][rfc_2818].
 *
 * [rfc_2818]: http://www.ietf.org/rfc/rfc2818.txt
 */