return "included-by-buildSrc.txt"
        }

        @Override
        String excludedFileName() {
            return "excluded-by-buildSrc.txt"
        }

        @Override
        void applyDefaultExcludes(AbstractIntegrationSpec spec, ScriptLanguage scriptLanguage) {
            TestFile buildSrcDir = spec.testDirectory.file("buildSrc")

                "resolveProviders"
            ]
        ].combinations()
    }

    def "using #snippetsFactory.summary in transform action with #task of buildSrc build is not a problem"(SnippetsFactory snippetsFactory, String task) {
        given:
        createDir("buildSrc") {
            getTransformFixture(snippetsFactory.newSnippets(execOperationsFixture)).tap {
                withTransformPlugin(dir("transform-plugin"))

    private static final String HELLO_WORLD_MESSAGE = 'Hello world'
    private static final String BYE_WORLD_MESSAGE = 'Bye world'

    def "can group task output in buildSrc"() {
        file('buildSrc/build.gradle') << """
            task helloWorld {
                doLast {
                    logger.quiet '$HELLO_WORLD_MESSAGE'
                }
            }

    def "#method is instrumented in dynamic Groovy #indyStatus"() {
        def configurationCache = newConfigurationCacheFixture()

        given:
        file("buildSrc/src/main/groovy/SomePlugin.groovy") << """
            import ${Plugin.name}
            import ${Project.name}
            import static ${System.name}.clearProperty
            import static ${System.name}.getProperties

package org.gradle.internal.cc.impl.isolated

class IsolatedProjectsToolingApiCompositeBuildsIntegrationTest extends AbstractIsolatedProjectsToolingApiIntegrationTest {

    def "invalidates cached state when plugin in buildSrc changes"() {
        given:
        withSomeToolingModelBuilderPluginInBuildSrc()
        settingsFile << """
            include("a")
            include("b")
        """
        buildFile << """

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor::class)
    @LeaksFileHandles("Kotlin Compiler Daemon working directory")
    fun `can use accessors for plugins in the buildSrc classpath`() {

        withKotlinBuildSrc()
        withFile(
            "buildSrc/src/main/kotlin/my/plugin-a.gradle.kts",
            """
            package my
            println("*my.plugin-a*")
            """
        )

        return new Listener(buildSrcRootProjectConfiguration, resolver);
    }

    /**
     * Inspects the build when configured, and adds the appropriate task to build the "main" `buildSrc` component.
     * On build completion, makes the runtime classpath of the main `buildSrc` component available.
     */
    public static class Listener extends InternalBuildAdapter implements EntryTaskSelector {
        private Configuration classpathConfiguration;

        file('buildSrc/build.gradle') << """
            plugins {
                id 'java'
            }

            dependencies {
                implementation(gradleApi())
            }

            tasks.withType(JavaCompile) {
                ${javaVersion == null ? '' : forkingOptions(javaVersion)}
            }
        """

    }

    /**
     * This is just to ensure we test the overhead of having a buildSrc project, e.g. snapshotting the Gradle API.
     */
    private addDummyBuildSrcProject(File projectDir) {
        file projectDir, "buildSrc/src/main/${config.language.name}/Thing.${config.language.name}", "public class Thing {}"
        file projectDir, "buildSrc/build.gradle", "compileJava.options.incremental = true"
    }

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.initialization.buildsrc

import org.gradle.api.Action
import org.gradle.api.internal.GradleInternal
import org.gradle.api.internal.StartParameterInternal
import org.gradle.api.internal.initialization.DefaultScriptClassPathResolver