@ToBeFixedForConfigurationCache(because = "source dependencies")
    def "can define source repositories in root of composite build when child build has classpath dependencies"() {
        settingsFile << """
            includeBuild 'child'
        """
        mappingFor(repo, "org.test:dep")

        def mavenRepo = new MavenFileRepository(file("maven-repo"))
        mavenRepo.module("other", "other", "1.0").publish()

            cacheKeyStringFromStartParameter {
                includeBuild(file("included"))
            },
            equalTo(
                cacheKeyStringFromStartParameter {
                    includeBuild(file("included"))
                }
            )
        )
        assertThat(
            cacheKeyStringFromStartParameter {
                includeBuild(file("included"))
            },

    @Override
    public PluginDependenciesSpec getPlugins() {
        return pluginDependenciesSpec;
    }

    @Override
    public void includeBuild(String rootProject) {
        includeBuild(rootProject, Actions.doNothing());
    }

    @Override
    public void includeBuild(String rootProject, Action<ConfigurableIncludedPluginBuild> configuration) {
        File projectDir = fileResolver.resolve(rootProject);

        given:
        createDirs("third", "third/t1")
        file("settings.gradle") << """rootProject.name = 'my-root-project'
includeBuild('another')"""
        file('another/settings.gradle') << "includeBuild('../third')"
        file('third/settings.gradle') << "include('t1')"

        when:
        run ":projects"

        then:
        outputContains """

        """
        using m2
    }

    def "context travels to transitive dependencies"() {
        given:
        createDirs("a", "b", "includedBuild")
        file('settings.gradle') << """
            include 'a', 'b'
            includeBuild 'includedBuild'
        """
        buildFile << '''
            def buildType = Attribute.of('buildType', String)
            def flavor = Attribute.of('flavor', String)

                """
            }
        }

        createBuild "root", "."
        settingsFile << """
            includeBuild 'included'
        """

        createBuild "included", "included"
        file("included/settings.gradle") << """
            includeBuild '../nested'
        """

        createBuild "nested", "nested"

        when:
        run('help')

        then:

        rootProject.name = 'root'
        include ':a', ':b'
        """
    }

    def "Included builds are deduplicated"() {
        given:
        settingsFile << """
                includeBuild 'includedBuild1'
                includeBuild 'includedBuild2'
            """
        multiProjectBuildInSubFolder("includedBuild1", ["a", "b", "c"])
        multiProjectBuildInSubFolder("includedBuild2", ["a", "b", "c"])

        when:

            }
            dependencies {
                implementation("org.test:included")
            }
        """
        settingsFile << """
            rootProject.name = "root"
            includeBuild("included")
        """

        expect:
        succeeds("assemble")
    }

    def "included build can access root project sneakily when used as a plugin"() {
        given:

            pluginManagement {
                includeBuild "plugin"
            }
            rootProject.name = "app"

            includeBuild "lib"
        """

        withFileHelperInPluginBuild()
        withTypedWorkerPluginInPluginBuild()

        lib.file('settings.gradle') << """
            pluginManagement {
                includeBuild "../plugin"
            }
        """

    def "caches BuildAction that queries models from included build "() {
        given:
        withSomeToolingModelBuilderPluginInChildBuild("plugins")
        settingsFile << """
            includeBuild("plugins")
            includeBuild("libs")
        """
        file("libs/settings.gradle") << """
            include("a")
            include("b")
        """
        file("libs/build.gradle") << """