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 {

  @JvmName("-deprecated_hostnameVerifier")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "hostnameVerifier"),
    level = DeprecationLevel.ERROR,
  )
  fun hostnameVerifier(): HostnameVerifier? = hostnameVerifier

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

    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 proxySelector: ProxySelector = address.proxySelector()
    val proxy: Proxy? = address.proxy()
    val sslSocketFactory: SSLSocketFactory? = address.sslSocketFactory()
    val hostnameVerifier: HostnameVerifier? = address.hostnameVerifier()
    val certificatePinner: CertificatePinner? = address.certificatePinner()
  }

  @Test @Disabled
  fun cache() {
    val cache = Cache(File("/cache/"), Integer.MAX_VALUE.toLong())

   * verification is a black box.
   */
  @Test
  fun skipsWhenHostnameVerifierUsed() {
    val verifier = HostnameVerifier { name: String?, session: SSLSession? -> true }
    client = client.newBuilder().hostnameVerifier(verifier).build()
    server.enqueue(MockResponse())
    server.enqueue(MockResponse())
    assert200Http2Response(execute(url), server.hostName)