}

description = "Generates a public API jar and corresponding component to publish it"

// Defines configurations used to resolve the public Gradle API.
val distribution = configurations.dependencyScope("distribution") {
    description = "Dependencies to extract the public Gradle API from"
}
val distributionClasspath = configurations.resolvable("distributionClasspath") {
    extendsFrom(distribution.get())

    javaComponent.withVariantsFromConfiguration(configurations["runtimeElements"]) {
        skip()
    }
    javaComponent.withVariantsFromConfiguration(configurations["apiElements"]) {
        skip()
    }
}

fun configureShadedSourcesJarVariant() {
    val implementation by configurations
    val sourcesPath by configurations.creating {
        isCanBeResolved = true

            ),
            not(
                equalTo(
                    hashCodeFor(
                        configurations = listOf("implementation")
                    )
                )
            )
        )
    }

    @Test
    fun `hash code is configuration order insensitive`() {

        assertThat(
            hashCodeFor(

            "api",
            """

            val foo: Configuration = configurations.getByName("foo")
            val bar: Configuration = configurations.getByName("bar") {
                extendsFrom(foo)
            }

            val bazar: Configuration = configurations.create("bazar")
            val cathedral: Configuration = configurations.create("cathedral") {
                extendsFrom(bazar)
            }

 */

import gradlebuild.startscript.tasks.GradleStartScriptGenerator
import gradlebuild.configureAsRuntimeJarClasspath

plugins {
    java
}

val agentsClasspath = configurations.dependencyScope("agentsClasspath")
val resolveAgentsClasspath = configurations.resolvable("resolveAgentsClasspath") {
    extendsFrom(agentsClasspath.get())
    configureAsRuntimeJarClasspath(objects)
}

    val containerElements: List<ProjectSchemaEntry<T>>,
    val configurations: List<ConfigurationEntry<String>>,
    val scriptTarget: Any? = null
) {

    fun <U> map(f: (T) -> U) = ProjectSchema(
        extensions.map { it.map(f) },
        conventions.map { it.map(f) },
        tasks.map { it.map(f) },
        containerElements.map { it.map(f) },
        configurations,
        scriptTarget
    )

    configurations[implementationConfigurationName].dependencies.add(
        dependencies.testFixtures(project)
    )
}

val testFixturesApi by configurations
val testFixturesImplementation by configurations
val testFixturesRuntimeOnly by configurations
val testFixturesRuntimeElements by configurations
val testFixturesApiElements by configurations

    abstract val upgradedPropertiesFile: RegularFileProperty

    @Suppress("MemberVisibilityCanBePrivate")
    fun createInstrumentationMetadataViewOf(other: Configuration): FileCollection {
        val runtimeInstrumentationMetadata = configurations.create("${other.name}InstrumentationMetadata") {
            attributes.attribute(Attributes.artifactType, INSTRUMENTATION_METADATA)
            isCanBeResolved = true

import common.uuidPrefix
import configurations.BaseGradleBuildType
import configurations.DocsTestProject
import configurations.DocsTestTrigger
import configurations.FunctionalTest
import configurations.FunctionalTestsPass
import configurations.PartialTrigger
import configurations.PerformanceTest
import configurations.PerformanceTestsPass
import configurations.SmokeTests
import configurations.buildReportTab

            tasks.register('test', Test) {
                bean = new Bean().tap {
                    files = configurations.implementation
                }
            }
        '''

        when:
        configurationCacheFails 'test'

        then: