*/
class MinimalSchemaBuildingComponent : AnalysisSchemaComponent {
    override fun propertyExtractors(): List<PropertyExtractor> = listOf(DefaultPropertyExtractor())
    override fun functionExtractors(): List<FunctionExtractor> = listOf(DefaultFunctionExtractor(configureLambdas = gradleConfigureLambdas))

                    "my" to PluginTree.PluginGroup(
                        listOf("my"),
                        linkedMapOf(
                            "plugin-a" to PluginTree.PluginSpec("my.plugin-a", "my.PluginA")
                        )
                    )
                )
            ).toList(),
            equalTo(
                listOf(
                    PluginDependencySpecAccessor.ForPlugin(

    @get:InputDirectory
    @get:PathSensitive(PathSensitivity.RELATIVE)  // <2>
    abstract val distribution: DirectoryProperty

    override fun asArguments(): Iterable<String> =
        listOf("-Ddistribution.location=${distribution.get().asFile.absolutePath}")  // <3>
}

tasks.integTest {
    jvmArgumentProviders.add(
        objects.newInstance<DistributionLocationProvider>().apply {  // <4>

class DefaultProjectSchemaProviderTest {

    @Test
    fun `chooses first public interface in type hierarchy`() {

        val androidExtensionsSchema = DefaultExtensionsSchema.create(
            listOf(
                extensionSchema(
                    "kotlinOptions",
                    typeOf<KotlinJvmOptionsImpl>()
                )
            )
        )

 */
private
val conversionSupport: ObjectConversionComponent = object : ObjectConversionComponent {
    override fun runtimePropertyResolvers(): List<RuntimePropertyResolver> = listOf(ReflectionRuntimePropertyResolver)
    override fun runtimeFunctionResolvers(): List<RuntimeFunctionResolver> = listOf(MemberFunctionResolver(gradleConfigureLambdas))

        socket,
        socket.inetAddress.hostAddress,
        socket.port,
        true,
      ) as SSLSocket
    sslSocket.useClientMode = false
    Platform.get().configureTlsExtensions(sslSocket, null, listOf(Protocol.HTTP_2))
    sslSocket.startHandshake()
    return sslSocket
  }

  override fun onStream(stream: Http2Stream) {
    try {
      val requestHeaders = stream.takeHeaders()
      var path: String? = null

// tag::apply-plugin[]
plugins {
    xctest
}
// end::apply-plugin[]

// tag::configure-target-machines[]
xctest {
    targetMachines = listOf(machines.linux.x86_64, machines.macOS.x86_64)
}

 * limitations under the License.
 */

package gradlebuild

import org.gradle.api.tasks.testing.Test
import org.gradle.internal.os.OperatingSystem


val propagatedEnvironmentVariables = listOf(
    // Obviously necessary
    "HOME",
    "SHELL",
    "TERM",

    // Otherwise Windows complains "Unrecognized Windows Sockets error: 10106"
    "SystemRoot",
    "OS",

    // For Android tests

    val socketFactory = context.socketFactory

    val sslSocket = socketFactory.createSocket() as SSLSocket
    assertTrue(adapter.matchesSocket(sslSocket))

    adapter.configureTlsExtensions(sslSocket, null, listOf(HTTP_2, HTTP_1_1))
    // not connected
    assertNull(adapter.getSelectedProtocol(sslSocket))
  }

  @ParameterizedTest
  @MethodSource("data")
  fun testMatchesSupportedAndroidSocketFactory(adapter: SocketAdapter) {

                    name = propertyName,
                    valueParameters = listOf(
                        newValueParameterOf("dependency", KotlinType.typeParameter),
                        newValueParameterOf("action", actionTypeOf(KotlinType.typeParameter))
                    ),
                    typeParameters = listOf(