assertFailsWith<IOException> {
      call.execute()
    }
  }

  private fun randomString(length: Int): String {
    val byteArray = ByteArray(length)
    Random(0).nextBytes(byteArray)
    return byteArray.toByteString().base64()
  }

  private val getAlpnSelectedProtocol = sslSocketClass.getMethod("getAlpnSelectedProtocol")
  private val setAlpnProtocols =
    sslSocketClass.getMethod("setAlpnProtocols", ByteArray::class.java)

  override fun isSupported(): Boolean = AndroidPlatform.isSupported

  override fun matchesSocket(sslSocket: SSLSocket): Boolean = sslSocketClass.isInstance(sslSocket)

  private var writerClosed = false

  /** Lazily initialized on first use. */
  private var messageDeflater: MessageDeflater? = null

  // Masks are only a concern for client writers.
  private val maskKey: ByteArray? = if (isClient) ByteArray(4) else null
  private val maskCursor: Buffer.UnsafeCursor? = if (isClient) Buffer.UnsafeCursor() else null

  /** Send a ping with the supplied [payload]. */
  @Throws(IOException::class)

        .body(
          Buffer()
            .write(ByteArray(responseBodySize)),
        ).throttleBody(64 * 1024, 125, MILLISECONDS) // 500 Kbps
        .build(),
    )
    val call = client.newCall(Request(server.url("/")))
    val response = call.execute()
    cancelLater(call, 500)
    val responseBody = response.body.byteStream()
    val buffer = ByteArray(1024)
    assertFailsWith<IOException> {

  }

  @Test
  fun canonicalizeInetAddressIPv6RepresentationOfCompatibleIPV4() {
    val addressAIpv6 = decodeIpv6("::192.168.0.1")!!
    assertThat(canonicalizeInetAddress(addressAIpv6)).isEqualTo(
      ByteArray(12) +
        byteArrayOf(
          192.toByte(),
          168.toByte(),
          0,
          1,
        ),
    )
  }

  @Test
  fun canonicalizeInetAddressIPv6RepresentationOfMappedIPV4() {

    }
  }

  @Test
  fun interruptReadingResponseBody() {
    val responseBodySize = 8 * 1024 * 1024 // 8 MiB.
    server.enqueue(
      MockResponse()
        .setBody(Buffer().write(ByteArray(responseBodySize)))
        .throttleBody((64 * 1024).toLong(), 125, TimeUnit.MILLISECONDS),
    ) // 500 Kbps
    server.start()
    val call =
      client.newCall(
        Request
          .Builder()

    val s = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
    for (i in s.indices) {
      assertRoundTrip(s.substring(0, i).encodeUtf8())
    }
    val random = Random(123456789L)
    val buf = ByteArray(4096)
    random.nextBytes(buf)
    assertRoundTrip(buf.toByteString())
  }

  private fun assertRoundTrip(data: ByteString) {
    val encodeBuffer = Buffer()
    encode(data, encodeBuffer)

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

  override fun getCreationTime(): Long = throw UnsupportedOperationException()

  override fun getId(): ByteArray = throw UnsupportedOperationException()

  override fun getLastAccessedTime(): Long = throw UnsupportedOperationException()

  override fun getLocalCertificates(): Array<Certificate> = throw UnsupportedOperationException()

import javax.security.cert.X509Certificate

/** An [SSLSession] that delegates all calls.  */
abstract class DelegatingSSLSession(
  protected val delegate: SSLSession?,
) : SSLSession {
  override fun getId(): ByteArray = delegate!!.id

  override fun getSessionContext(): SSLSessionContext = delegate!!.sessionContext

  override fun getCreationTime(): Long = delegate!!.creationTime

  /** Used when an empty close frame was received (i.e., without a status code). */
  internal const val CLOSE_NO_STATUS_CODE = 1005

  fun toggleMask(
    cursor: Buffer.UnsafeCursor,
    key: ByteArray,
  ) {
    var keyIndex = 0
    val keyLength = key.size
    do {
      val buffer = cursor.data
      var i = cursor.start
      val end = cursor.end
      if (buffer != null) {