then:
        iprHasModules "buildA.iml",
            "b1/buildA-b1.iml",
            "../buildB/buildB.iml",
            "../buildB/b1/buildB-b1.iml",
            "../buildB/b2/b2.iml",
            "../buildC/buildC.iml",
            "../buildC/buildA/buildC-buildA.iml"

        imlHasDependencies "buildC-buildA", "buildA-b1", "buildB-b1"
    }

    @ToBeImplemented

        def moduleA = allProjects.rootIdeaProject.modules[0]
        moduleA.dependencies.each {
            assert it instanceof  IdeaModuleDependency
        }
        moduleA.dependencies.collect { it.targetModuleName } == ['buildB-b1', 'buildA-buildC', 'buildD-b1']

        allProjects.getIdeaProject('buildB').modules.collect { it.name } == ['buildB', 'buildB-b1', 'b2']

    }

    def "reports failure for included build name that conflicts with subproject name"() {
        given:
        createDirs("buildA", "buildA/buildC")
        buildA.settingsFile << """
            include 'buildC'
"""
        def buildC = singleProjectBuild("buildC")
        def buildB = singleProjectBuild("buildB") {

        execute(buildA, ":buildC:build")
    }

    @Issue("https://github.com/gradle/gradle/issues/15659")
    def "resolves dependencies of included build with dependency substitution when substitution build uses a plugin from its build-logic build"() {
        given:
        includeBuild(buildB, """
            substitute(module("org.test:b1")).using(project(":b1"))
        """)
        includeBuild(buildC)
        buildC.buildFile << """

        }

        buildD = singleProjectBuild('buildD') {
            buildFile << javaProject()
            file('src/test/java/SampleTestD.java') << junitTestClass('SampleTestD')
        }
    }

    def "can collect build failures from multiple included builds"() {
        when:
        includedBuilds << buildB << buildC << buildD

        buildA.buildFile << """
            task testAll {

                buildFile << """
                    apply plugin: 'java'
"""
            }
            dependency previousBuild, "org.test:${buildName}:1.0"
            includedBuilds << build
            previousBuild = build
        }

        expect:
        execute(buildA, "jar", "--max-workers=1")
    }

    def "constructs included build artifacts in parallel"() {

        when:
        execute(buildA, "delegate")

        then:
        executed ":buildB:logProject"
        output.contains("Executing build 'buildB' project ':' task ':logProject'")
    }

    def "can depend on task with name in all included builds"() {
        when:
        BuildTestFile buildC = singleProjectBuild("buildC") {

        given:
        buildB
        def buildC = multiProjectBuild("buildC", ['c1', 'c2']);
        createDirs("buildC", "buildC/nested", "buildC/nested/c1")
        buildC.settingsFile << """
            include ':nested:c1'
        """
        buildC.buildFile << """
            allprojects {
                apply plugin: 'java'
            }

    @ToBeFixedForConfigurationCache
    def "builds IDE metadata artifacts in parallel"() {
        given:
        server.start()
        buildTestFixture.withBuildInSubDir()
        def buildA = singleProjectBuild("buildA") {
            buildFile << """
                apply plugin: 'java'
                apply plugin: 'idea'
            """
        }

        def included = ['buildB', 'buildC', 'buildD']

        assertResolved buildB.file('b1/build/libs/b1-1.0.jar')

        configured("buildB") == 1
    }

    def "included build references substituted dependency from preceding included build"() {
        dependency 'org.test:buildC:1.0'
        configurationTimeDependency buildC, 'org.test:buildB:1.0'

        when:
        execute buildA, ":help"

        then:
        executed ":help"