}

  @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() {

 */

package org.gradle.kotlin.dsl.internal.sharedruntime.support

import java.io.Closeable
import java.io.File
import java.util.jar.JarFile


private
typealias ClassBytesSupplier = () -> ByteArray


private
typealias ClassBytesIndex = (String) -> ClassBytesSupplier?


/**
 * Repository providing access to class bytes by Kotlin source names.
 *

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

import javax.security.cert.X509Certificate

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

  override fun getSessionContext(): SSLSessionContext {
    return delegate!!.sessionContext
  }

  override fun getCreationTime(): Long {
    return delegate!!.creationTime

          }
        }
      }
    }

    /** Returns a new request body that transmits this. */
    @JvmOverloads
    @JvmStatic
    @JvmName("create")
    fun ByteArray.toRequestBody(
      contentType: MediaType? = null,
      offset: Int = 0,
      byteCount: Int = size,
    ): RequestBody = commonToRequestBody(contentType, offset, byteCount)

        val firSymbol = useSiteSession.symbolProvider.getTopLevelCallableSymbols(kotlinPackage, identifier).firstOrNull {
            /* choose (for byte array)
             * public fun byteArrayOf(vararg elements: kotlin.Byte): kotlin.ByteArray
             */
            (it as? FirFunctionSymbol<*>)?.fir?.valueParameters?.singleOrNull()?.isVararg == true
        } as? FirNamedFunctionSymbol ?: return null

  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)

    throw IOException("Content-Length ($contentLength) and stream length ($size) disagree")
  }
  return bytes
}

internal fun ResponseBody.commonClose() = source().closeQuietly()

internal fun ByteArray.commonToResponseBody(contentType: MediaType?): ResponseBody {
  return Buffer()
    .write(this)
    .asResponseBody(contentType, size.toLong())
}

  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> {