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

    var utf8Body: String = recordedRequest.body.readUtf8()
    var sequenceNumber: Int = recordedRequest.sequenceNumber
    var tlsVersion: TlsVersion? = recordedRequest.tlsVersion
    var handshake: Handshake? = recordedRequest.handshake
  }

  @Test @Ignore
  fun socketPolicy() {
    val socketPolicy: SocketPolicy = SocketPolicy.KEEP_OPEN
  }

  println(Platform.get())
  val request =
    Request.Builder()
      .url(url)
      .build()
  try {
    client.newCall(request).execute().use { response ->
      val handshake = response.handshake
      println(
        "${handshake!!.tlsVersion} ${handshake.cipherSuite} ${response.protocol} " +
          "${response.code} ${response.body.bytes().size}b",
      )
    }
  } catch (ioe: IOException) {
    println(ioe)
  }
}

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

    }

  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)
    }

  /**

 * Client and server exchange these certificates during the handshake phase of a TLS connection.
 *
 * ### Server Authentication
 *
 * This is the most common form of TLS authentication: clients verify that servers are trusted and
 * that they own the hostnames that they represent. Server authentication is required.
 *
 * To perform server authentication:
 *
 *  * The server's handshake certificates must have a [held certificate][HeldCertificate] (a

    open fun code(code: Int) = commonCode(code)

    open fun message(message: String) = commonMessage(message)

    open fun handshake(handshake: Handshake?) =
      apply {
        this.handshake = handshake
      }

    /**
     * Sets the header named [name] to [value]. If this request already has any headers
     * with that name, they are all replaced.
     */

        ),
      )
      .assertLogMatch(
        Regex(

    @Override
    public int getContentLength () {
        handshake();
        return this.connection.getContentLength();
    }


    @Override
    public String getContentType () {
        handshake();
        return this.connection.getContentType();
    }


    @Override
    public String getContentEncoding () {
        handshake();
        return this.connection.getContentEncoding();
    }

Call call = client.newCall(new Request.Builder()
    .url(server.url("/"))
    .build());
Response response = call.execute();
System.out.println(response.handshake().peerPrincipal());
RecordedRequest recordedRequest = server.takeRequest();
System.out.println(recordedRequest.getHandshake().peerPrincipal());
```