private final PluginBuildFixture build2 = pluginBuild("logic-2")

    def "can nest included plugin builds"() {
        when:
        settingsFile << """
            pluginManagement {
                includeBuild("${build1.buildName}")
            }
        """
        build1.settingsFile << """
            includeBuild("../${build2.buildName}")
        """

        then:
        succeeds()
    }

        commonsPluginBuild.settingsFile.text = """
            pluginManagement {
                includeBuild("../${mainPluginBuild.buildName}")
            }
        """
        commonsPluginBuild.projectPluginFile.text = """
            plugins {
                id("groovy-gradle-plugin")
            }
        """

        mainPluginBuild.settingsFile.text = """
            pluginManagement {

    private class GroovyWriter {
        void writeTo(TestFile settingsFile) {
            settingsFile << """
                rootProject.name = '$rootProjectName'
            """
            includes.each { pName ->
                settingsFile << """
                include '$pName'
            """
            }
            includeBuilds.each { pName ->
                settingsFile << """
                includeBuild '$pName'

        when:
        buildB.settingsFile << "includeBuild '../buildC'"
        buildC.settingsFile << "includeBuild '../buildB'"

        then:
        execute(buildA, 'help')

        and:
        canRunFromCache(buildA, 'help')
    }

    def "included build can include root build"() {
        when:
        buildB.settingsFile << "includeBuild '../buildA'"

        and:
        def currentDir = tmpDir.testDirectory
        def settingsFile = currentDir.createFile(settingsFilename)

        expect:
        def layout = locator.getLayoutFor(currentDir, true)
        layout.rootDirectory == currentDir
        layout.settingsDir == currentDir
        layout.settingsFile == settingsFile
        !layout.buildDefinitionMissing

        where:

        assert operations().size() == 1
        operations()[0]
    }

    private void verifySettings(BuildOperationRecord operation, File settingsFile) {
        assert operation.details.settingsDir == settingsFile.parentFile.absolutePath
        assert operation.details.settingsFile == settingsFile.absolutePath
    }

class ProjectConfigureEventsErrorIntegrationTest extends AbstractIntegrationSpec {

    def "setup"() {
        settingsFile << "rootProject.name = 'projectConfigure'"
    }

    def "produces reasonable error message when Gradle.beforeProject closure fails"() {
        when:
        settingsFile << """
    gradle.beforeProject {
        throw new RuntimeException("beforeProject failure")
    }
"""

        given:
        createDirs("buildA", "buildA/buildC")
        buildA.settingsFile << """
            include 'buildC'
"""
        def buildC = singleProjectBuild("buildC")
        def buildB = singleProjectBuild("buildB") {
            settingsFile << """
                includeBuild('${buildC.toURI()}')
            """
        }
        includeBuild(buildB)

    def "uses specified settings script"() {
        def startParameter = new StartParameterInternal()
        def settingsFile = new File("settings.gradle")
        startParameter.settingsFile = settingsFile
        def config = new BuildLayoutConfiguration(startParameter)

        expect:
        config.settingsFile == settingsFile.canonicalFile
    }

    def "uses default settings file when none specified"() {

    }

    def "first included build can not see settings plugins contributed to root by second included build"() {
        when:
        settingsFile << """
            plugins {
                id("${build1.settingsPluginId}")
            }
        """

        build1.settingsFile.setText("""
            plugins {
                id("${build2.settingsPluginId}")
            }