// TODO reenable in official answers
//      .addPlatformTrustedCertificates()
          .addTrustedCertificate(cert)
          .build()

      clientBuilder
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        )
    }

    val client = clientBuilder.build()

    val request =
      Request
        .Builder()

    message = "moved to val",
    replaceWith = ReplaceWith(expression = "trustManager"),
    level = DeprecationLevel.ERROR,
  )
  fun trustManager(): X509TrustManager = trustManager

  fun sslSocketFactory(): SSLSocketFactory = sslContext().socketFactory

  fun sslContext(): SSLContext =
    Platform.get().newSSLContext().apply {
      init(arrayOf<KeyManager>(keyManager), arrayOf<TrustManager>(trustManager), SecureRandom())
    }

            formatDate(1, TimeUnit.HOURS)!!,
          ),
        body = "ABC.2",
      ),
    )
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).hostnameVerifier(nullHostnameVerifier)
        .build()
    val request = Request(server.url("/"))

    mockWebServer.protocolNegotiationEnabled = false
    mockWebServer.protocols = listOf()
    val protocols: List<Protocol> = mockWebServer.protocols
    mockWebServer.useHttps(SSLSocketFactory.getDefault() as SSLSocketFactory, false)
    mockWebServer.noClientAuth()
    mockWebServer.requestClientAuth()
    mockWebServer.requireClientAuth()
    val request: RecordedRequest = mockWebServer.takeRequest()

  }

  private fun enableTls() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

Kotlin does have properties and we take advantage of them in OkHttp.

 * **Address**: certificatePinner, connectionSpecs, dns, hostnameVerifier, protocols, proxy,
   proxyAuthenticator, proxySelector, socketFactory, sslSocketFactory, url
 * **Cache**: directory
 * **CacheControl**: immutable, maxAgeSeconds, maxStaleSeconds, minFreshSeconds, mustRevalidate,
   noCache, noStore, noTransform, onlyIfCached, sMaxAgeSeconds

    }
    val handshakeCertificates = builder.build()
    return clientTestRule
      .newClientBuilder()
      .sslSocketFactory(
        handshakeCertificates.sslSocketFactory(),
        handshakeCertificates.trustManager,
      ).build()
  }

  private fun buildServerSslSocketFactory(): SSLSocketFactory {
    // The test uses JDK default SSL Context instead of the Platform provided one

        .dns(dns)
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()
    val serverHandshakeCertificates =
      HandshakeCertificates
        .Builder()
        .heldCertificate(certificate)
        .build()
    server.useHttps(serverHandshakeCertificates.sslSocketFactory())
    url = server.url("/robots.txt")
  }

	public final fun socketFactory (Ljavax/net/SocketFactory;)Lokhttp3/OkHttpClient$Builder;
	public final fun sslSocketFactory (Ljavax/net/ssl/SSLSocketFactory;)Lokhttp3/OkHttpClient$Builder;
	public final fun sslSocketFactory (Ljavax/net/ssl/SSLSocketFactory;Ljavax/net/ssl/X509TrustManager;)Lokhttp3/OkHttpClient$Builder;

      )
    }
  }

  private fun enableTls() {
    client =
      client
        .newBuilder()
        .sslSocketFactory(
          handshakeCertificates.sslSocketFactory(),
          handshakeCertificates.trustManager,
        ).build()
    server.useHttps(handshakeCertificates.sslSocketFactory())
  }

  @RetryingTest(5)
  @Flaky
  fun testHeadAfterPut() {
    class ErringRequestBody : RequestBody() {