output.contains('system_property_available in included buildSrc:        true')
        output.contains("project_property_available in included buildSrc:       ${projectPropertyAvailableInIncludedBuildSrc()}")
        output.contains('system_property_available in included root:            true')
        output.contains("project_property_available in included root:           ${projectPropertyAvailableInIncludedRoot()}")

            nestedVisitor.visitDir(included)
            nestedVisitor.visitDir(excluded)
        }
        1 * visitor.visitDir(included)
        0 * _
    }

    def "ignores file that is not included"() {
        def spec = Mock(Spec)
        def included = Stub(FileVisitDetails)
        def excluded = Stub(FileVisitDetails)
        def visitor = Mock(FileVisitor)

        when:

        """

        then:
        succeeds()
        settingsPluginBuild.assertSettingsPluginApplied()
    }

    def "a build can depend on included library build that applies a project plugin that comes from an included settings plugin and depends on another included build"() {
        given:
        def pluginLibraryBuild = pluginAndLibraryBuild("plugin-lib")
        def projectPluginBuild = pluginBuild("project-plugin")

                }
        """
        file("included/settings.gradle") << """
            rootProject.name = 'included'
        """
        buildFile << """
            dependencies {
                conf 'com.acme:included:1.0'
            }
        """
        settingsFile << """
            includeBuild 'included'
        """

        when:
        repositoryInteractions {

    def "name conflict between subproject and included build does not break IDEA import"() {
        given:
        settingsFile << """
            rootProject.name = 'module-main'
            include 'module-b'
            includeBuild('subfolder/module-b') { name = 'included-module-b' }
        """
        file('module-b').mkdir()
        file('subfolder/module-b').mkdirs()

                    assert artifactFiles.size() == 0
                }
            }
        """

        def includedLoggingProjectDir = file("included-logging")

        includedLoggingProjectDir.file("settings.gradle").text = """
            rootProject.name = "included-logging"
            include("lib")
        """

        includedLoggingProjectDir.file("lib/build.gradle").text = """
            plugins {

            outputContains("do something")
        }
        2.times {
            succeeds("other-build:doSomething")
            outputContains("do something")
        }
    }

    def "can run included build task included with --include-build"() {
        setup:
        settingsFile << ""
        file('other-build/settings.gradle') << "rootProject.name = 'other-build'"
        file('other-build/build.gradle') << """

     */
    void finalizeIncludedBuilds();

    /**
     * Creates an included build. An included build is-a nested build whose projects and outputs are treated as part of the composite build.
     */
    IncludedBuildState addIncludedBuild(BuildDefinition buildDefinition);

    /**
     * Creates an included build. An included build is-a nested build whose projects and outputs are treated as part of the composite build.
     *

            includeBuild('included')
        """
        buildFile << """
            task doIt {
                dependsOn gradle.includedBuild("included").task(":doIt")
                doLast {
                    println "Hello from root"
                }
            }
        """
        file("included/settings.gradle") << """
            rootProject.name = "included"
        """

        then:
        failure.assertHasDescription("A problem occurred evaluating root project 'buildA'.")
        failure.assertHasCause("Included build 'does-not-exist' not found in build 'buildA'.")
    }

    def "reports failure when task does not exist for included build"() {
        when:
        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuild('buildB').task(':does-not-exist')