@file:JvmName("Internal")
@file:Suppress("ktlint:standard:filename")

package okhttp3.internal

import java.nio.charset.Charset
import javax.net.ssl.SSLSocket
import okhttp3.Cache
import okhttp3.CipherSuite
import okhttp3.ConnectionPool
import okhttp3.ConnectionSpec
import okhttp3.Cookie
import okhttp3.Headers
import okhttp3.HttpUrl
import okhttp3.MediaType
import okhttp3.MediaType.Companion.toMediaTypeOrNull

```java
ConnectionSpec spec = new ConnectionSpec.Builder(ConnectionSpec.MODERN_TLS)
    .tlsVersions(TlsVersion.TLS_1_2)
    .cipherSuites(
          CipherSuite.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
          CipherSuite.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
          CipherSuite.TLS_DHE_RSA_WITH_AES_128_GCM_SHA256)
    .build();

OkHttpClient client = new OkHttpClient.Builder()

      assertThat(body).isEqualTo(expectedBody)
    }

  fun assertHandshake() =
    apply {
      val handshake = response!!.handshake!!
      assertThat(handshake.tlsVersion).isNotNull()
      assertThat(handshake.cipherSuite).isNotNull()
      assertThat(handshake.peerPrincipal).isNotNull()
      assertThat(handshake.peerCertificates.size).isEqualTo(1)
      assertThat(handshake.localPrincipal).isNull()

  override fun getPeerPrincipal(): Principal = delegate!!.peerPrincipal

  override fun getLocalPrincipal(): Principal = delegate!!.localPrincipal

  override fun getCipherSuite(): String = delegate!!.cipherSuite

  override fun getProtocol(): String = delegate!!.protocol

  override fun getPeerHost(): String = delegate!!.peerHost

  override fun getPeerPort(): Int = delegate!!.peerPort

        }
      }

      val certificatePinner = address.certificatePinner!!

      val handshake =
        Handshake(
          unverifiedHandshake.tlsVersion,
          unverifiedHandshake.cipherSuite,
          unverifiedHandshake.localCertificates,
        ) {
          certificatePinner.certificateChainCleaner!!.clean(
            unverifiedHandshake.peerCertificates,
            address.url.host,

    )
    server.enqueue(MockResponse())
    val cipherSuite = CipherSuite.TLS_DH_anon_WITH_AES_128_GCM_SHA256
    val clientCertificates =
      HandshakeCertificates
        .Builder()
        .build()
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          socketFactoryWithCipherSuite(clientCertificates.sslSocketFactory(), cipherSuite),
          clientCertificates.trustManager,

HSPLokhttp3/CipherSuite$Companion$ORDER_BY_NAME$1;-><init>()V
HSPLokhttp3/CipherSuite$Companion$ORDER_BY_NAME$1;->compare(Ljava/lang/Object;Ljava/lang/Object;)I
HSPLokhttp3/CipherSuite$Companion;-><init>(Landroidx/lifecycle/viewmodel/R$id;)V
HSPLokhttp3/CipherSuite$Companion;->access$init(Lokhttp3/CipherSuite$Companion;Ljava/lang/String;I)Lokhttp3/CipherSuite;

  override fun toString(): String =
    "Connection{${route.address.url.host}:${route.address.url.port}," +
      " proxy=${route.proxy}" +
      " hostAddress=${route.socketAddress}" +
      " cipherSuite=${handshake?.cipherSuite ?: "none"}" +
      " protocol=$protocol}"

  companion object {
    const val IDLE_CONNECTION_HEALTHY_NS = 10_000_000_000 // 10 seconds.

    fun newTestConnection(
      taskRunner: TaskRunner,

    extensions.configure<JavaPluginExtension> {
      toolchain {
        languageVersion.set(JavaLanguageVersion.of(17))
      }
    }
  }

  tasks.withType<Checkstyle>().configureEach {
    exclude("**/CipherSuite.java")
  }

  val checkstyleConfig: Configuration by configurations.creating
  dependencies {
    checkstyleConfig(rootProject.libs.checkStyle) {
      isTransitive = false
    }
  }

    val request = server.takeRequest()
    assertThat(request.requestUrl!!.scheme).isEqualTo("https")
    val handshake = request.handshake
    assertThat(handshake!!.tlsVersion).isNotNull()
    assertThat(handshake.cipherSuite).isNotNull()
    assertThat(handshake.localPrincipal).isNotNull()
    assertThat(handshake.localCertificates.size).isEqualTo(1)
    assertThat(handshake.peerPrincipal).isNull()