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

        if (selectedProxy.type() != Proxy.Type.HTTP) {
          throw ProtocolException("Received HTTP_PROXY_AUTH (407) code while not using proxy")
        }
        return client.proxyAuthenticator.authenticate(route, userResponse)
      }

      HTTP_UNAUTHORIZED -> return client.authenticator.authenticate(route, userResponse)

	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;

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

	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;

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

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

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

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