client.newBuilder()
        .dns { listOf() }
        .build()
        .routeDatabase,
    )
    assertNotSame(
      client.routeDatabase,
      client.newBuilder()
        .proxyAuthenticator { _: Route?, _: Response? -> null }
        .build()
        .routeDatabase,
    )
    assertNotSame(
      client.routeDatabase,
      client.newBuilder()
        .protocols(listOf(Protocol.HTTP_1_1))

        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
        .proxy(server.toProxyAddress())
        .proxyAuthenticator(RecordingOkAuthenticator("password", "Basic"))
        .hostnameVerifier(RecordingHostnameVerifier())
        .build()
    val request = Request("https://android.com/foo".toHttpUrl())

      tunnelCodec.skipConnectBody(response)

      when (response.code) {
        HttpURLConnection.HTTP_OK -> return null

        HttpURLConnection.HTTP_PROXY_AUTH -> {
          nextRequest = route.address.proxyAuthenticator.authenticate(route, response)
            ?: throw IOException("Failed to authenticate with proxy")

          if ("close".equals(response.header("Connection"), ignoreCase = true)) {
            return nextRequest

	public fun hashCode ()I
	public final fun hostnameVerifier ()Ljavax/net/ssl/HostnameVerifier;
	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;

      MockResponse.Builder()
        .inTunnel()
        .build(),
    )
    server.enqueue(MockResponse())
    client =
      client.newBuilder()
        .proxy(server.toProxyAddress())
        .proxyAuthenticator(RecordingOkAuthenticator("password", "Basic"))
        .build()
    val call =
      client.newCall(
        Request.Builder()
          .url(server.url("/"))
          .build(),
      )

        inTunnel = true,
      ),
    )
    server.enqueue(MockResponse(inTunnel = true))
    server.enqueue(MockResponse(body = "A"))
    client =
      client.newBuilder()
        .proxyAuthenticator(Authenticator.JAVA_NET_AUTHENTICATOR)
        .proxy(server.toProxyAddress())
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,

    )
    server.enqueue(MockResponse(inTunnel = true))
    server.enqueue(MockResponse(body = "response body"))
    val client =
      client.newBuilder()
        .proxy(server.toProxyAddress())
        .proxyAuthenticator(RecordingOkAuthenticator("password", "Basic"))
        .build()

    val url = server.url("/").resolve("//android.com/foo")!!
    val port =
      when (url.scheme) {
        "https" -> 443