assertThat(reader.readLine()).isEqualTo("abc")
    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(reader.readLine()).isEqualTo("abc")
    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)

    assertContent("def", getResponse(newRequest("/")))
    val tlsVersions: Set<TlsVersion?> =
      EnumSet.of(
        TlsVersion.TLS_1_0,
        TlsVersion.TLS_1_2,
        TlsVersion.TLS_1_3,
      ) // v1.2 on OpenJDK 8.
    val request1 = server.takeRequest()
    assertThat(tlsVersions).contains(request1.handshake?.tlsVersion)
    val request2 = server.takeRequest()

	public final fun getRequestLine ()Ljava/lang/String;
	public final fun getRequestUrl ()Lokhttp3/HttpUrl;
	public final fun getSequenceNumber ()I
	public final fun getTlsVersion ()Lokhttp3/TlsVersion;
	public final fun getUtf8Body ()Ljava/lang/String;
	public fun toString ()Ljava/lang/String;
}

public final class okhttp3/mockwebserver/SocketPolicy : java/lang/Enum {

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

          )
        }
      }

      val certificatePinner = address.certificatePinner!!

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

		cipherSuites, err := cliflag.TLSCipherSuites(s.CipherSuites)
		if err != nil {
			return err
		}
		c.CipherSuites = cipherSuites
	}

	var err error
	c.MinTLSVersion, err = cliflag.TLSVersion(s.MinTLSVersion)
	if err != nil {
		return err
	}

	// load SNI certs
	namedTLSCerts := make([]dynamiccertificates.SNICertKeyContentProvider, 0, len(s.SNICertKeys))
	for _, nck := range s.SNICertKeys {

    application code that creates challenges.

 *  New: The `TlsVersion` of a `Handshake` is now non-null. If you are calling
    `Handshake.get()` with a null TLS version, you must instead now provide a
    non-null `TlsVersion`. Cache responses persisted prior to OkHttp 3.0 did not
    store a TLS version; for these unknown values the handshake is defaulted to
    `TlsVersion.SSL_3_0`.

 *  New: Upgrade to Okio 1.13.0.

     ```xml

HSPLokhttp3/ResponseBody;->string()Ljava/lang/String;
HSPLokhttp3/Route;-><init>(Lokhttp3/Address;Ljava/net/Proxy;Ljava/net/InetSocketAddress;)V
HSPLokhttp3/Route;->hashCode()I
HSPLokhttp3/TlsVersion;-><clinit>()V
HSPLokhttp3/TlsVersion;-><init>(Ljava/lang/String;ILjava/lang/String;)V
HSPLokhttp3/internal/Internal;->charset$default(Lokhttp3/MediaType;Ljava/nio/charset/Charset;I)Ljava/nio/charset/Charset;

				if tlsCipherSuites[i] == cipherID {
					klog.InfoS("Use of insecure cipher detected.", "cipher", cipherName)
				}
			}
		}
	}

	minTLSVersion, err := cliflag.TLSVersion(kc.TLSMinVersion)
	if err != nil {
		return nil, err
	}

	if minTLSVersion == tls.VersionTLS13 {
		if len(tlsCipherSuites) != 0 {