this.buildFile = buildFile
        this.config = config
    }

    void prepare(String config = this.config) {
        buildFile << """
            allprojects {
                tasks.register("checkDeps") {
                    if (${GradleContextualExecuter.configCache}) {
                        def files = configurations.${config}
                        doLast {

        delegate.rootProject(action.withCrossProjectModelAccessCheck())
    }

    override fun allprojects(action: Action<in Project>) {
        // Use the delegate's implementation of `rootProject` to ensure that the action is only invoked once the rootProject is available
        delegate.rootProject {
            // Instead of the rootProject's `allProjects`, collect the projects while still tracking the current referrer project

        createDirs("buildSrc/ignored")
        file("buildSrc/settings.gradle") << """
            include 'ignored' // include some content
        """
        file("buildSrc/build.gradle") << """
            allprojects { apply plugin: 'java-library' } // include some content
        """
        file("buildSrc/src/main/java/CustomTask.java") << """
            import ${DefaultTask.name};
            import ${TaskAction.name};

        where:
        by << EnabledBy.values()
    }

    @Issue("https://github.com/gradle/gradle/issues/4216")
    @ToBeFixedForIsolatedProjects(because = "allprojects")
    def "build cache service is closed only after all included builds are finished"() {
        executer.beforeExecute { it.withBuildCacheEnabled() }
        def localCache = new TestBuildCache(file("local-cache"))

        given:
        settingsFile << """
            include('a')
            include('b')
        """
        withSomeToolingModelBuilderPluginInBuildSrc()
        buildFile << """
            allprojects {
                plugins.apply('java-library')
            }
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI, WARN_PROBLEMS_CLI_OPT)

                $localMaven
            }

            dependencies {
                implementation 'org.example:lib-impl:1.0'
            }

            gradle.projectsEvaluated {
                allprojects {
                    configurations.all {
                        dependencies.all { dep ->
                            if (!(dep instanceof ProjectDependency) && dep.hasProperty('transitive')) {

        // since allprojects callbacks are executed inside an internal rootProject listener
        initFile << """
            rootProject { project ->
                ${addBeforeProjectListeners('init file rootProject')}
            }
            apply from: file('$scriptFile.name')
        """
        scriptFile << """
            allprojects { project ->

TIP:  Avoid using `subprojects {}` and `allprojects {}`.

With cross-configuration, build logic can be injected into a subproject which is not obvious when looking at its build script.

    }

    def "reuses cache for relative task invocation from subproject dir"() {
        given:
        settingsFile << """
            include 'a', 'b'
        """
        buildScript """
            allprojects {
                task ok
            }
        """
        def a = createDir('a')
        def b = createDir('b')
        def configurationCache = newConfigurationCacheFixture()

        when:

    @ToBeFixedForConfigurationCache(because = "Task uses the Configuration API")
    def "can query file dependency for its files"() {
        buildFile << """
allprojects {
    configurations {
        compile
    }
}
artifacts {
    compile file("main.jar") // include to ensure artifacts are not included in the result
}
dependencies {
    compile files("lib.jar")