import okhttp3.internal.immutableListOf
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(
  /**

          message == "No session to resume." -> Type.Handshake
          message.startsWith("Consuming ") -> Type.Handshake
          message.startsWith("Produced ") -> Type.Handshake
          message.startsWith("Negotiated ") -> Type.Handshake
          message.startsWith("Found resumable session") -> Type.Handshake
          message.startsWith("Resuming session") -> Type.Handshake

          // Produced ClientHello handshake message
          // Consuming ServerHello handshake message
          // Consuming server Certificate handshake message
          // Consuming server CertificateStatus handshake message
          // Found trusted certificate
          // Consuming ECDH ServerKeyExchange handshake message
          // Consuming ServerHelloDone handshake message

    // We have a host mismatch. But if the certificate matches, we're still good.
    return !noCoalescedConnections && handshake != null && certificateSupportHost(url, handshake!!)
  }

  private fun certificateSupportHost(
    url: HttpUrl,
    handshake: Handshake,
  ): Boolean {
    val peerCertificates = handshake.peerCertificates

    return peerCertificates.isNotEmpty() &&

    }

  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()
      assertThat(handshake.localCertificates.size).isEqualTo(0)
    }

  /**

    method: String?,
    path: String?,
    handshake: Handshake?,
    requestUrl: HttpUrl?,
  ) {
    this.requestLine = requestLine
    this.headers = headers
    this.chunkSizes = chunkSizes
    this.bodySize = bodySize
    this.body = body
    this.sequenceNumber = sequenceNumber
    this.failure = failure
    this.method = method
    this.path = path
    this.handshake = handshake
    this.requestUrl = requestUrl
  }

        null,
      )

    val handshake = sslSession.handshake()

    assertThat(handshake.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    assertThat(handshake.cipherSuite).isEqualTo(CipherSuite.TLS_AES_128_GCM_SHA256)
    assertThat(handshake.peerCertificates).containsExactly(
      serverCertificate.certificate,
      serverIntermediate.certificate,
    )
    assertThat(handshake.localPrincipal).isNull()

  val method: String?
  val path: String?

  /**
   * The TLS handshake of the connection that carried this request, or null if the request was
   * received without TLS.
   */
  val handshake: Handshake?
  val requestUrl: HttpUrl?

  /**
   * Returns the name of the server the client requested via the SNI (Server Name Indication)
   * attribute in the TLS handshake. Unlike the rest of the HTTP exchange, this name is sent in

import java.util.concurrent.Executors
import java.util.concurrent.Future
import javax.net.ServerSocketFactory
import javax.net.SocketFactory
import javax.net.ssl.SSLSocket
import okhttp3.Handshake
import okhttp3.Handshake.Companion.handshake
import okhttp3.TestUtil.threadFactory
import okhttp3.internal.closeQuietly
import okhttp3.testing.PlatformRule
import okio.ByteString.Companion.toByteString
import org.junit.jupiter.api.AfterEach

    level = DeprecationLevel.ERROR,
  )
  fun message(): String = message

  @JvmName("-deprecated_handshake")
  @Deprecated(
    message = "moved to val",
    replaceWith = ReplaceWith(expression = "handshake"),
    level = DeprecationLevel.ERROR,
  )
  fun handshake(): Handshake? = handshake

  fun headers(name: String): List<String> = commonHeaders(name)

  @JvmOverloads
  fun header(