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

/**

package gradlebuild.basics.testing

import org.gradle.api.tasks.testing.Test


enum class TestType(val prefix: String, val executers: List<String>) {
    INTEGRATION("integ", listOf("embedded", "forking", "noDaemon", "parallel", "configCache", "isolatedProjects")),
    CROSSVERSION("crossVersion", listOf("embedded", "forking"))
}


fun Test.includeSpockAnnotation(fqcn: String) {

 * limitations under the License.
 */
package okhttp3.survey.types

data class Client(
  val userAgent: String,
  val version: String,
  val platform: String? = null,
  val enabled: List<SuiteId> = listOf(),
  val supported: List<SuiteId> = listOf(),
) {
  val nameAndVersion: String
    get() = "$userAgent/$version"

        assertNull(resolver.trace.assignmentResolution(failedLhs).result)
        assertEquals(listOf(ErrorReason.UnresolvedAssignmentLhs::class), resolver.trace.assignmentResolution(failedLhs).errors?.map { it.errorReason::class })

        assertNull(resolver.trace.expressionResolution(failedLhs.lhs).result)

}

dependencies {
    testImplementation("junit:junit:4.13")
}

// tag::custom-src-dirs[]
sourceSets {
    main {
        java {
            setSrcDirs(listOf("src"))
        }
    }

    test {
        java {
            setSrcDirs(listOf("test"))
        }
    }
}
// end::custom-src-dirs[]

// tag::custom-extra-src-dir[]
sourceSets {
    main {
        java {

            parser("foo bar"),
            listOf(Unit)
        )
        assertSuccess(
            parser("foo foo bar"),
            listOf(Unit, Unit)
        )
    }

    @Test
    fun `can fail many symbols`() {
        val parser = zeroOrMore(combinator.symbol("foo"))
        assertSuccess(
            parser("foofoo"),
            listOf()
        )
    }

    @Test

 */
internal
abstract class KotlinDslStandaloneScriptCompilationConfiguration protected constructor(
    body: Builder.() -> Unit
) : ScriptCompilationConfiguration({

    isStandalone(true)
    compilerOptions.put(listOf(
        "-language-version", "1.8",
        "-api-version", "1.8",
        "-Xjvm-default=all",
        "-Xjsr305=strict",
        "-Xskip-prerelease-check",
        "-Xallow-unstable-dependencies",

            id = "<your plugin identifier>" // <5>
            displayName = "<short displayable name for plugin>" // <6>
            description = "<human-readable description of what your plugin is about>" // <7>
            tags = listOf("tags", "for", "your", "plugins") // <8>
            implementationClass = "<your plugin class>"
        }
    }
}
// end::per_plugin_config[]

// tag::plugin_example[]
gradlePlugin {

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

        val code = """
            addSomething(1) { }
            addSomething(2)
        """.trimIndent()

        val receiver = runtimeInstanceFromResult(schema, schema.resolve(code), kotlinFunctionAsConfigureLambda, RuntimeCustomAccessors.none, ::MyTopLevelReceiver)