*/
  @get:JvmName("tlsVersion") val tlsVersion: TlsVersion,
  /** Returns the cipher suite used for the connection. */
  @get:JvmName("cipherSuite") val cipherSuite: CipherSuite,
  /** Returns a possibly-empty list of certificates that identify this peer. */
  @get:JvmName("localCertificates") val localCertificates: List<Certificate>,

        }

    private
    data class FetchedVersions(
        val latests: List<String>,
        val nightlyBuildId: String,
        val nightlyVersion: String,
        val aapt2Versions: List<String>,
        val buildToolsVersion: String
    )

    private
    fun fetchLatestAgpVersions(): FetchedVersions {
        val latests = fetchLatests(
            currentGradleVersion.get(),

  fun parseCacheControlAndPragmaAreCombined() {
    val headers = headersOf("Cache-Control", "max-age=12", "Pragma", "must-revalidate", "Pragma", "public")
    val cacheControl = parse(headers)
    assertThat(cacheControl.toString()).isEqualTo("max-age=12, public, must-revalidate")
  }

  @Test
  fun parseCacheControlHeaderValueIsRetained() {
    val value = "max-age=12"
    val headers = headersOf("Cache-Control", value)

import org.junit.Test


class SinceAndIncubatingRulesKotlinTest : AbstractBinaryCompatibilityTest() {

    @Language("kotlin")
    private
    val publicKotlinMembers = """

        fun foo() {}

        val bar: String = "bar"

        val bool: Boolean = true

        val isBool: Boolean = true

        var bazar = "bazar"

        var bazool: Boolean = true

        var isFool: Boolean = true

    val certificatePinner =
      CertificatePinner
        .Builder()
        .add("EXAMPLE.com", certA1Sha256Pin)
        .add("*.MyExample.Com", certB1Sha256Pin)
        .build()

    val expectedPin1 = listOf(Pin("EXAMPLE.com", certA1Sha256Pin))
    assertThat(certificatePinner.findMatchingPins("example.com")).isEqualTo(expectedPin1)

             * @see $implementationClass
             */
            inline val $pluginDependenciesSpecQualifiedName.`$memberName`: $pluginDependencySpecQualifiedName
                get() = id("$pluginId")
            """.trimIndent()
        }
}


private
data class PluginExtension(
    val memberName: String,
    val pluginId: String,
    val implementationClass: String
)


private

    if (limit == -1L && source.exhausted()) return END_OF_DATA

    // Read the tag.
    val tagAndClass = source.readByte().toInt() and 0xff
    val tagClass = tagAndClass and 0b1100_0000
    val constructed = (tagAndClass and 0b0010_0000) == 0b0010_0000
    val tag =
      when (val tag0 = tagAndClass and 0b0001_1111) {
        0b0001_1111 -> readVariableLengthLong()
        else -> tag0.toLong()
      }

open class DelegatingServerSocketFactory(
  private val delegate: ServerSocketFactory,
) : ServerSocketFactory() {
  @Throws(IOException::class)
  override fun createServerSocket(): ServerSocket {
    val serverSocket = delegate.createServerSocket()
    return configureServerSocket(serverSocket)
  }

  @Throws(IOException::class)
  override fun createServerSocket(port: Int): ServerSocket {
    val serverSocket = delegate.createServerSocket(port)

import org.junit.jupiter.api.extension.RegisterExtension

class HttpUpgradesTest {
  @RegisterExtension
  val platform = PlatformRule()

  @RegisterExtension
  val clientTestRule = OkHttpClientTestRule()

  @StartStop
  private val server = MockWebServer()

  private var eventRecorder = EventRecorder()
  private val handshakeCertificates = platform.localhostHandshakeCertificates()
  private var client =
    clientTestRule

    val altIpaNames = getSubjectAltNames(certificate, ALT_IPA_NAME)
    val altDnsNames = getSubjectAltNames(certificate, ALT_DNS_NAME)
    return altIpaNames + altDnsNames
  }

  private fun getSubjectAltNames(
    certificate: X509Certificate,
    type: Int,
  ): List<String> {
    try {
      val subjectAltNames = certificate.subjectAlternativeNames ?: return emptyList()