}

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;

    `ConnectionSpec` class.

    To disable TLS fallback:

    ```java
    client.setConnectionSpecs(Arrays.asList(
        ConnectionSpec.MODERN_TLS, ConnectionSpec.CLEARTEXT));
    ```

    To disable cleartext connections, permitting `https` URLs only:

    ```java
    client.setConnectionSpecs(Arrays.asList(
        ConnectionSpec.MODERN_TLS, ConnectionSpec.COMPATIBLE_TLS));

 * available in JDK11 or Conscrypt.
 */
private val TLS_13 =
  ConnectionSpec
    .Builder(true)
    .cipherSuites(*TLS13_CIPHER_SUITES.toTypedArray())
    .tlsVersions(TlsVersion.TLS_1_3)
    .build()

private val TLS_12 =
  ConnectionSpec
    .Builder(ConnectionSpec.RESTRICTED_TLS)
    .tlsVersions(TlsVersion.TLS_1_2)
    .build()

private fun testClient(

  }

  @Test fun someFallbacksSupported() {
    val sslV3 =
      ConnectionSpec
        .Builder(ConnectionSpec.MODERN_TLS)
        .tlsVersions(TlsVersion.SSL_3_0)
        .build()
    val routePlanner = factory.newRoutePlanner(client)
    val route = factory.newRoute()
    val connectionSpecs = listOf(ConnectionSpec.MODERN_TLS, ConnectionSpec.COMPATIBLE_TLS, sslV3)
    val enabledSocketTlsVersions =
      arrayOf(

        CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
        CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_256_GCM_SHA384,
        CipherSuite.TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384);
    final ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
        .cipherSuites(customCipherSuites.toArray(new CipherSuite[0]))
        .build();

    X509TrustManager trustManager = defaultTrustManager();

      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 =

import org.robolectric.RobolectricTestRunner
import org.robolectric.shadows.ShadowLog

@RunWith(RobolectricTestRunner::class)
class AndroidLoggingTest {
  val clientBuilder =
    OkHttpClient.Builder().connectionSpecs(listOf(ConnectionSpec.CLEARTEXT)).dns {
      throw UnknownHostException("shortcircuit")
    }

  val request = Request("http://google.com/robots.txt".toHttpUrl())

  @Test
  fun testHttpLoggingInterceptor() {

  Client(
    userAgent = "OkHttp",
    version = OkHttp.VERSION,
    enabled =
      ConnectionSpec.MODERN_TLS.cipherSuites!!.map {
        ianaSuites.fromJavaName(it.javaName)
      },
    supported =
      ConnectionSpec.COMPATIBLE_TLS.cipherSuites!!.map {
        ianaSuites.fromJavaName(it.javaName)
      },
  )

fun historicOkHttp(version: String): Client {
  val enabled =

   * contains minimally [Protocol.HTTP_1_1].
   */
  @get:JvmName("protocols")
  val protocols: List<Protocol> = protocols.toImmutableList()

  @get:JvmName("connectionSpecs")
  val connectionSpecs: List<ConnectionSpec> =
    connectionSpecs.toImmutableList()

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

  var proxySelector: ProxySelector = RecordingProxySelector()
  var proxyAuthenticator: Authenticator = RecordingOkAuthenticator("password", null)
  var connectionSpecs: List<ConnectionSpec> =
    listOf(
      ConnectionSpec.MODERN_TLS,
      ConnectionSpec.COMPATIBLE_TLS,
      ConnectionSpec.CLEARTEXT,
    )
  var protocols: List<Protocol> =
    listOf(
      Protocol.HTTP_1_1,
    )