* `heldCertificate` is null.
   */
  @JvmStatic
  fun newKeyManager(
    keyStoreType: String?,
    heldCertificate: HeldCertificate?,
    vararg intermediates: X509Certificate,
  ): X509KeyManager {
    val keyStore = newEmptyKeyStore(keyStoreType)
    if (heldCertificate != null) {
      val chain = arrayOfNulls<Certificate>(1 + intermediates.size)

 * **TlsVersion**: javaName

#### Renamed Functions

* **Headers.of()**: for symmetry with `listOf()`, `setOf()`, etc., we’ve replaced
  `Headers.of(String...)` with `headersOf(vararg String)`.

#### Extension Functions

We’ve migrated from static functions to extension functions where we think they fit.

| Java                                | Kotlin                          |

import java.security.cert.Certificate
import javax.net.ssl.SSLPeerUnverifiedException
import javax.net.ssl.SSLSession
import javax.net.ssl.SSLSessionContext
import javax.security.cert.X509Certificate

class FakeSSLSession(
  vararg val certificates: Certificate,
) : SSLSession {
  override fun getApplicationBufferSize(): Int = throw UnsupportedOperationException()

  override fun getCipherSuite(): String = throw UnsupportedOperationException()

 * a specific "Accept-Encoding: identity" or similar.
 *
 * See https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Accept-Encoding
 */
open class CompressionInterceptor(
  vararg val algorithms: DecompressionAlgorithm,
) : Interceptor {
  internal val acceptEncoding =
    algorithms
      .map {
        it.encoding
      }.joinToString(separator = ", ")

  return if (includeDefaultPort || port != defaultPort(scheme)) {
    "$host:$port"
  } else {
    host
  }
}

/** Returns a [Locale.US] formatted [String]. */
internal fun format(
  format: String,
  vararg args: Any,
): String = String.format(Locale.US, format, *args)

/**
 * will also strip BOM from the source
 */
@Throws(IOException::class)
internal fun BufferedSource.readBomAsCharset(default: Charset): Charset =

        "http://example.com",
      ).createRequest()
    assertThat(request.header("If-Modified-Since")).isEqualTo(
      "Mon, 18 Aug 2014 15:16:06 GMT",
    )
  }

  companion object {
    fun fromArgs(vararg args: String): Main =
      Main().apply {
        parse(args.toList())
      }

    private fun bodyAsString(body: RequestBody?): String =
      try {
        val buffer = Buffer()

  /** See `org.graalvm.nativeimage.ImageInfo`. */
  @JvmStatic val isGraalVmImage = System.getProperty("org.graalvm.nativeimage.imagecode") != null

  @JvmStatic
  fun headerEntries(vararg elements: String?): List<Header> = List(elements.size / 2) { Header(elements[it * 2]!!, elements[it * 2 + 1]!!) }

  @JvmStatic
  fun repeat(
    c: Char,
    count: Int,
  ): String {
    val array = CharArray(count)

    "replaced with {@link #check(String, List)}.",
    ReplaceWith("check(hostname, peerCertificates.toList())"),
  )
  @Throws(SSLPeerUnverifiedException::class)
  fun check(
    hostname: String,
    vararg peerCertificates: Certificate,
  ) {
    check(hostname, peerCertificates.toList())
  }

  /**
   * Returns list of matching certificates' pins for the hostname. Returns an empty list if the

    val event = nextEvent() as Failure
    assertThat(event.response).isNull()
    assertThat(event.t).isSameAs(t)
  }

  fun assertFailure(
    cls: Class<out IOException?>?,
    vararg messages: String,
  ) {
    val event = nextEvent() as Failure
    assertThat(event.response).isNull()
    assertThat(event.t.javaClass).isEqualTo(cls)
    if (messages.isNotEmpty()) {

      }

    fun bootstrapDnsHosts(bootstrapDnsHosts: List<InetAddress>?) =
      apply {
        this.bootstrapDnsHosts = bootstrapDnsHosts
      }

    fun bootstrapDnsHosts(vararg bootstrapDnsHosts: InetAddress): Builder = bootstrapDnsHosts(bootstrapDnsHosts.toList())

    fun systemDns(systemDns: Dns) =
      apply {
        this.systemDns = systemDns
      }
  }