when (function.name) {
                    "invariant" -> function.parameters.single().assertSingleTypeArgumentWithVariance(Variance.INVARIANT)
                    "covariant" -> function.parameters.single().assertSingleTypeArgumentWithVariance(Variance.COVARIANT)
                    "contravariant" -> function.parameters.single().assertSingleTypeArgumentWithVariance(Variance.CONTRAVARIANT)
                }
            }

    }

    val bucketProvider = when {
        parameters.includeTestClasses.get().isNotBlank() -> {
            val content = parameters.repoRoot.file("test-splits/include-test-classes.properties").get().asFile.readText()
            println("Tests to be included:\n$content")
            IncludeTestClassProvider(readTestClasses(content))
        }
        parameters.excludeTestClasses.get().isNotBlank() -> {

                parameters.rootBuildDir = project.layout.buildDirectory
                parameters.projectStates.putAll(globalExtension.projectStates)
                parameters.testPathToBinaryResultsDirs = allTasks.filterIsInstance<Test>().associate { it.path to it.binaryResultsDirectory.get().asFile }

        }

        val substitutions = LinkedHashMap<TypeConstructor, TypeProjection>(parameters.size)
        for (index in parameters.indices) {
            val parameterTypeConstructor = parameters[index].typeConstructor
            substitutions[parameterTypeConstructor] = TypeProjectionImpl(arguments[index] as KotlinType)
        }

        //  inside other value sources. This is not really necessary for the correctness and causes excessive cache invalidation.
        when (val parameters = obtainedValue.valueSourceParameters) {
            is FileContentValueSource.Parameters -> {
                parameters.file.orNull?.asFile?.let { file ->
                    // TODO - consider the potential race condition in computing the hash code here

            options.release = null
            options.compilerArgs.remove("-parameters")
            sourceCompatibility = "$majorVersion"
            targetCompatibility = "$majorVersion"
        }
        // Apply ParameterNamesIndex since 6 doesn't support -parameters
        project.apply(plugin = "gradlebuild.api-parameter-names-index")
    }

import org.gradle.api.services.BuildServiceParameters
import org.gradle.internal.os.OperatingSystem
import javax.inject.Inject


abstract class BuildEnvironmentService : BuildService<BuildEnvironmentService.Parameters> {

    interface Parameters : BuildServiceParameters {
        val rootProjectDir: DirectoryProperty
    }

    @get:Inject
    abstract val providers: ProviderFactory

    val gitCommitId = git("rev-parse", "HEAD")

                    listOf("java.lang.String"),
                    true
                )
            )
        )
    }

    @Test
    fun `can extract JavaFunction from multiple parameters signature string`() {
        assertThat(
            javaFunctionOf("org.gradle.SomeType.methodMan(java.lang.String, java.util.List)"),
            equalTo(
                JavaFunction(

        </parameter>
        <parameter>
          <name>repositories</name>
          <type>java.util.List</type>
          <required>true</required>
          <editable>false</editable>
        </parameter>
        <parameter>
          <name>resourceBundles</name>
          <type>java.util.List</type>
          <required>true</required>
          <editable>true</editable>
        </parameter>
        <parameter>

    }

    private fun writeGenericArguments(
        sw: JvmSignatureWriter,
        arguments: List<TypeProjection>,
        parameters: List<TypeParameterDescriptor>,
        mode: TypeMappingMode
    ) {
        with(KotlinTypeMapper) {
            typeContext.writeGenericArguments(sw, arguments, parameters, mode) { type, sw, mode ->
                mapType(type as KotlinType, mode, sw)
            }