* [proxy selector][proxySelector].
   */
  @get:JvmName("proxy") val proxy: Proxy?,
  protocols: List<Protocol>,
  connectionSpecs: List<ConnectionSpec>,
  /**
   * Returns this address's proxy selector. Only used if the proxy is null. If none of this
   * selector's proxies are reachable, a direct connection will be attempted.
   */

}

public final class okhttp3/ConnectionSpec {
	public static final field CLEARTEXT Lokhttp3/ConnectionSpec;
	public static final field COMPATIBLE_TLS Lokhttp3/ConnectionSpec;
	public static final field Companion Lokhttp3/ConnectionSpec$Companion;
	public static final field MODERN_TLS Lokhttp3/ConnectionSpec;
	public static final field RESTRICTED_TLS Lokhttp3/ConnectionSpec;

      builder.socketFactory(SSLSocketFactory.getDefault())
    }
  }

  @Test fun noSslSocketFactoryConfigured() {
    val client =
      OkHttpClient
        .Builder()
        .connectionSpecs(listOf(ConnectionSpec.CLEARTEXT))
        .build()
    assertFailsWith<IllegalStateException> {
      client.sslSocketFactory
    }
  }

  @Test fun nullHostileProtocolList() {
    val nullHostileProtocols =

HSPLokhttp3/ConnectionSpec$Builder;-><init>(Lokhttp3/ConnectionSpec;)V
HSPLokhttp3/ConnectionSpec$Builder;-><init>(Z)V
HSPLokhttp3/ConnectionSpec$Builder;->build()Lokhttp3/ConnectionSpec;
HSPLokhttp3/ConnectionSpec$Builder;->cipherSuites([Ljava/lang/String;)Lokhttp3/ConnectionSpec$Builder;
HSPLokhttp3/ConnectionSpec$Builder;->cipherSuites([Lokhttp3/CipherSuite;)Lokhttp3/ConnectionSpec$Builder;

    e is ProtocolException -> false

    // If there was an interruption or timeout (SocketTimeoutException), don't recover.
    // For the socket connect timeout case we do not try the same host with a different
    // ConnectionSpec: we assume it is unreachable.
    e is InterruptedIOException -> false

    // If the problem was a CertificateException from the X509TrustManager, do not retry.

            if (socketMode.socketMode == Channel) {
              socketFactory(ChannelSocketFactory())
            }

            connectionSpecs(
              listOf(
                ConnectionSpec
                  .Builder(ConnectionSpec.COMPATIBLE_TLS)
                  .tlsVersions(socketMode.tlsVersion)
                  .supportsTlsExtensions(socketMode.tlsExtensionMode == STANDARD)
                  .build(),
              ),

 */
package okhttp3.internal.connection

import java.io.IOException
import java.net.HttpURLConnection
import java.net.Socket
import java.net.UnknownServiceException
import okhttp3.Address
import okhttp3.ConnectionSpec
import okhttp3.HttpUrl
import okhttp3.Protocol
import okhttp3.Request
import okhttp3.Response
import okhttp3.Route
import okhttp3.internal.USER_AGENT
import okhttp3.internal.canReuseConnectionFor

  }

  companion object {
    internal val DEFAULT_PROTOCOLS = immutableListOf(HTTP_2, HTTP_1_1)

    internal val DEFAULT_CONNECTION_SPECS =
      immutableListOf(
        ConnectionSpec.MODERN_TLS,
        ConnectionSpec.CLEARTEXT,
      )
  }

        .hostnameVerifier(RecordingHostnameVerifier())
        .connectionSpecs(
          // Attempt RESTRICTED_TLS then fall back to MODERN_TLS.
          listOf(
            ConnectionSpec.RESTRICTED_TLS,
            ConnectionSpec.MODERN_TLS,
          ),
        ).sslSocketFactory(
          suppressTlsFallbackClientSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()

import okhttp3.internal.toImmutableList

/**
 * A record of a TLS handshake. For HTTPS clients, the client is *local* and the remote server is
 * its *peer*.
 *
 * This value object describes a completed handshake. Use [ConnectionSpec] to set policy for new
 * handshakes.
 */
class Handshake internal constructor(
  /**
   * Returns the TLS version used for this connection. This value wasn't tracked prior to OkHttp