given:
        def defaultProjectCacheDir = file(".gradle")
        def projectCacheDir = file("project-cache-dir")

        // Make sure buildSrc is built
        file("buildSrc/build.gradle").touch()

        settingsFile << """
            includeBuild('included')
        """
        buildFile << """
            task doIt {

        outputContains("settings source file: " + buildB.settingsFile.absolutePath + ".")
    }

    def "locations are as expected in buildSrc settings"() {
        settingsFile """
        // just a marker file
        """

        def buildSrcDir = file("buildSrc")
        def buildSrcSettingsFile = buildSrcDir.file("settings.gradle")
        groovyFile(buildSrcSettingsFile, """
            ${printLocations()}

    @Test
    fun `should not allow precompiled plugin to conflict with core plugin`() {
        withKotlinBuildSrc()
        withFile(
            "buildSrc/src/main/kotlin/java.gradle.kts",
            """
            tasks.register("myTask") {}
            """
        )
        withDefaultSettings()
        withFile(
            "build.gradle",
            """

    def operations = new BuildOperationsFixture(executer, temporaryFolder)

    def "emits settings finalized event when not configured"() {
        given:
        file("buildSrc/src/main/java/Thing.java") << "class Thing {}"

        when:
        succeeds("help")

        then:
        isolatedProjectsEvents().enabled == [false]

        then:
        file("user-home/caches/${distribution.version.version}/generated-gradle-jars").assertIsEmptyDir()
    }

    def "buildSrc project implicitly forces generation of Gradle API JAR"() {
        given:
        buildFile << applyJavaPlugin()
        temporaryFolder.createFile('buildSrc/src/main/groovy/MyPlugin.groovy') << customGroovyPlugin()

        when:
        succeeds 'build'

        then:

                    }
                }
            }
        }

        and: "a component metadata rule that adds a variant"
        file("buildSrc/build.gradle") << """
            plugins {
                id("java")
            }
        """
        file("buildSrc/src/main/java/AddVariantRule.java") << """
            package com.example;

            import org.gradle.api.artifacts.ComponentMetadataContext;

// tag::plugins[]
plugins {
    id("myproject.java-conventions")
    // myproject.greeting is implemented in the buildSrc project that has myproject.java-conventions applied as well
    id("myproject.greeting")
    id("application")
}
// end::plugins[]

dependencies {
    implementation(project(":utilities"))
}

application {
    mainClass = "org.gradle.sample.app.Main"

        result.assertTasksNotSkipped(":noActions")
        result.assertNotOutput("actionable tasks")
    }

    @ToBeFixedForConfigurationCache(because = "buildSrc tasks are not executed when loaded from cache")
    def "reports tasks from buildSrc"() {
        file("buildSrc/src/main/java/Thing.java") << """
            public class Thing {
            }
        """

        when:
        run "adHocTask"

    def task = ":createReports"

    def setup() {
        // Do not define the task in the build script, so that changes to the build script do not invalidate the task implementation
        file("buildSrc/src/main/groovy/TestTaskReportContainer.groovy") << """
            import org.gradle.api.*
            import org.gradle.api.reporting.*
            import org.gradle.api.reporting.internal.*

        def configurationCache = newConfigurationCacheFixture()

        given:
        // Why the separate plugin? The Project.getProperties() is available in the build.gradle.kts as getProperties().
        file("buildSrc/src/main/kotlin/SomePlugin.kt") << """
            import ${Plugin.name}
            import ${Project.name}

            class SomePlugin : Plugin<Project> {
                override fun apply(project: Project) {