}
    }

    @Test
    fun `version catalogs from outer builds are not available as accessors`() {
        withKotlinBuildSrc()
        withSimpleVersionCatalog()
        withFile("buildSrc/src/main/kotlin/plugin-without-plugins.gradle.kts", "println(libs)")
        withFile(
            "buildSrc/src/main/kotlin/plugin-with-plugins.gradle.kts",
            """
            plugins { id("base") }

        snippetsFactory             | file
        exec().groovy               | "buildSrc/src/main/groovy/test-convention-plugin.gradle"
        javaexec().groovy           | "buildSrc/src/main/groovy/test-convention-plugin.gradle"
        processBuilder().groovy     | "buildSrc/src/main/groovy/test-convention-plugin.gradle"
        stringArrayExecute().groovy | "buildSrc/src/main/groovy/test-convention-plugin.gradle"

    }

    @Test
    fun `avoids buildscript recompilation on resource file change in buildSrc`() {
        val className = givenJavaClassInBuildSrcContains(
            """
            public void foo() {
                System.out.println("foo");
            }
            """
        )
        withFile("buildSrc/src/main/resources/foo.txt", "foo")
        withUniqueScript("$className().foo()")

    @Test
    fun `accessors to __untyped__ groovy closures extensions are typed Any`() {

        withDefaultSettings()
        PluginBuilder(file("buildSrc")).apply {
            addPlugin(
                """
                project.extensions.add("closureExtension", { String name ->
                    name.toUpperCase()
                })

        model3[1].message == "It works from project :a"

        and:
        fixture.assertStateUpdated {
            fileChanged("build.gradle")
            projectConfigured(":buildSrc")
            modelsCreated(":")
            modelsReused(":a", ":b", ":buildSrc")
        }
        outputContains("creating model for root project 'root'")

        when:
        executer.withArguments(ENABLE_CLI)

+
If you are developing custom Gradle plugins for your project, `buildSrc` is a convenient place to house the plugin code.
This makes the plugins easily accessible within your project.

The `buildSrc` directory is treated as an <<composite_builds.adoc#composite_build_intro,included build>>.

For multi-project builds, there can be only one `buildSrc` directory, which must be in the root project directory.

    @Issue("https://github.com/gradle/gradle/issues/5110")
    def "buildSrc project can apply IDE plugin"() {
        file("buildSrc/build.gradle") << """
            apply plugin: '${pluginId}'
        """

        expect:
        succeeds(":buildSrc:${workspaceTask}")
        def workspace = workspace(file("buildSrc"), "buildSrc")
        if (libraryPluginId == "java-library") {

    }

    def "invalidates cache upon change to #inputName used by buildSrc"() {

        assumeFalse(
            'property from gradle.properties is not available to buildSrc',
            inputName == 'gradle.properties'
        )

        given:
        def configurationCache = newConfigurationCacheFixture()
        file("buildSrc/build.gradle.kts").text = """

        then:
        output.contains('system_property_available in buildSrc:                 true')
        output.contains('system_property_available in buildSrc:                 true')
        output.contains("project_property_available in buildSrc:                ${projectPropertyAvailableInBuildSrc()}")
        output.contains('system_property_available in included buildSrc:        true')

For this, we utilize so-called _convention plugins_ that are located in the `buildSrc` folder.
Convention plugins in `buildSrc` are an easy way to utilise Gradle's plugin system to write reusable bits of build configuration.

in this sample, we can find three such convention plugins that are based on each other:

====
include::sample[dir="kotlin",files="buildSrc/src/main/kotlin/buildlogic.${languageLC.raw}-common-conventions.gradle.kts[]"]