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

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

 */
internal fun canonicalizeInetAddress(address: ByteArray): ByteArray =
  when {
    isMappedIpv4Address(address) -> address.sliceArray(12 until 16)
    else -> address
  }

/** Returns true for IPv6 addresses like `0000:0000:0000:0000:0000:ffff:XXXX:XXXX`. */
private fun isMappedIpv4Address(address: ByteArray): Boolean {
  if (address.size != 16) return false

  for (i in 0 until 10) {

  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)

    }
  }

  @Test fun readPaddedDataFrame() {
    val dataLength = 1123
    val expectedData = ByteArray(dataLength)
    Arrays.fill(expectedData, 2.toByte())
    val paddingLength = 254
    val padding = ByteArray(paddingLength)
    Arrays.fill(padding, 0.toByte())
    writeMedium(frame, dataLength + paddingLength + 1)
    frame.writeByte(Http2.TYPE_DATA)

  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)

| MediaType.get(String)               | String.toMediaType()            |
| MediaType.parse(String)             | String.toMediaTypeOrNull()      |
| RequestBody.create(ByteArray)       | ByteArray.toRequestBody()       |
| RequestBody.create(ByteString)      | ByteString.toRequestBody()      |
| RequestBody.create(File)            | File.asRequestBody()            |

        .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()

  /** Lazily initialized on first use. */
  private var messageInflater: MessageInflater? = null

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

  interface FrameCallback {
    @Throws(IOException::class)
    fun onReadMessage(text: String)