.isEqualTo(listOf(Challenge("Basic", expectedAuthParams)))
  }

  @Test fun separatorsBeforeFirstChallenge() {
    val headers =
      Headers
        .Builder()
        .add("WWW-Authenticate", " ,  , Basic realm=myrealm")
        .build()
    assertThat(headers.parseChallenges("WWW-Authenticate"))
      .isEqualTo(listOf(Challenge("Basic", mapOf("realm" to "myrealm"))))
  }

    private
    fun List<MappedApiFunctionParameter>.toDeclarationString(): String =
        takeIf { it.isNotEmpty() }?.let { list ->
            list.mapIndexed { index, p ->
                when {
                    index == list.lastIndex && p.isVarargs && p.type.isKotlinArray -> "vararg `${p.name}`: ${singleTypeArgumentStringOf(p)}"

                SubprojectTestClassTime::totalTime,
                { largeElement, factor ->
                    List(factor) { SmallSubprojectBucket(largeElement.subProject, parallelization(factor)) }
                },
                { list ->
                    SmallSubprojectBucket(list.map { it.subProject }, parallelization(1))
                },
                testCoverage.expectedBucketNumber,

 */
package okhttp3

import java.io.IOException
import java.security.Security
import okhttp3.internal.platform.Platform
import org.conscrypt.Conscrypt

// TLS 1.3
private val TLS13_CIPHER_SUITES =
  listOf(
    CipherSuite.TLS_AES_128_GCM_SHA256,
    CipherSuite.TLS_AES_256_GCM_SHA384,
    CipherSuite.TLS_CHACHA20_POLY1305_SHA256,
    CipherSuite.TLS_AES_128_CCM_SHA256,
    CipherSuite.TLS_AES_128_CCM_8_SHA256,
  )

    }) {
    val specificBuildTypes: List<OsAwareBaseGradleBuildType>

    val performanceTests: List<PerformanceTestsPass>

    val functionalTests: List<OsAwareBaseGradleBuildType>

    val crossVersionTests: List<OsAwareBaseGradleBuildType>

    val docsTestTriggers: List<OsAwareBaseGradleBuildType>

    val flakyTestQuarantineTriggers: List<OsAwareBaseGradleBuildType>

    init {
        features {

    val handshake =
      Handshake.get(
        tlsVersion = TlsVersion.TLS_1_3,
        cipherSuite = CipherSuite.TLS_AES_128_GCM_SHA256,
        peerCertificates = listOf(serverCertificate.certificate, serverIntermediate.certificate),
        localCertificates = listOf(),
      )

    assertThat(handshake.tlsVersion).isEqualTo(TlsVersion.TLS_1_3)
    assertThat(handshake.cipherSuite).isEqualTo(CipherSuite.TLS_AES_128_GCM_SHA256)

    id("org.gradle.samples")
    id("gradlebuild.jvm-compile")
}

jvmCompile {
    addCompilationFrom(sourceSets.docsTest)
}

val singleProjectSampleLanguages = listOf(JAVA, GROOVY, SCALA, KOTLIN, SWIFT, CPP)
val multiProjectApplicationSampleLanguages = listOf(JAVA, GROOVY, SCALA, KOTLIN)

singleProjectSampleLanguages.forEach { language ->
    setupGeneratorTask(language, "library", ModularizationOption.SINGLE_PROJECT)

        val execOutput = providers.exec {
            workingDir = projectDir
            isIgnoreExitValue = true
            commandLine = listOf("git", *args)
            if (OperatingSystem.current().isWindows) {
                commandLine = listOf("cmd.exe", "/d", "/c") + commandLine
            }
        }
        return execOutput.result.zip(execOutput.standardOutput.asText) { result, outputText ->

tasks.withType<KotlinCompile> {
  compilerOptions {
    freeCompilerArgs = listOf("-module-name=okhttp")
  }
}

apply(plugin = "io.github.usefulness.maven-sympathy")

mavenPublishing {
  configure(KotlinMultiplatform(javadocJar = JavadocJar.Empty(), androidVariantsToPublish = listOf("release")))

                }
        } else {
            listOf()
        }
    }

    private
    fun getToolchainInstallationPathsProperty(): List<String> {
        return toolchainInstallationPaths.map { listOf("-D$JAVA_INSTALLATIONS_PATHS_PROPERTY.integTest=$it") }.getOrElse(emptyList())
    }

    private
    fun getRepoMirrorSystemProperties(): List<String> = collectMirrorUrls().map {