}

    private DirectoryContents toDir(File includeDir) {
        DirectoryContents directoryContents = includeRoots.get(includeDir);
        if (directoryContents == null) {
            directoryContents = new DirectoryContents(includeDir);
            includeRoots.put(includeDir, directoryContents);
        }
        return directoryContents;
    }

     * which in turn depend on a plugin from another included build (:plugin-0).
     *
     * In addition, projects :a and :b also depend on the :plugins build for the model building plugin.
     **/
    def "projects are configured in parallel when projects use plugins from included builds and project scoped model is queried concurrently"() {

        when:
        run "mainExecutable"
        then:
        skipped compileTask
    }

    @ToBeFixedForConfigurationCache
    def "does not recompile when included header has the same name as a directory"() {
        given:
        buildFile << """
model {
    components {
        main {
            sources.all {
                exportedHeaders {

        File existingForPath = nestedBuildDirectoriesByPath.putIfAbsent(requestedPath, dir);
        if (existingForPath != null) {
            throw new GradleException("Included build " + dir + " has build path " + requestedPath + " which is the same as included build " + existingForPath);
        }

        return requestedPath;
    }

    private static boolean isPrefix(File prefix, File toCheck) {

                allprojects {
                    apply plugin: 'java'
                }
"""
        }
        includedBuilds << buildB
    }

    def "generates build operations for tasks in included builds"() {
        given:
        dependency 'org.test:buildB:1.0'

        when:
        execute(buildA, ":jar")

        then:
        executed ":buildB:jar"

        and:

        when:
        sourceFile << """
    #include "$included"
    #import "$included"
"""
        then:
        includes == ['"' + included + '"'].collect { include(it) }
        imports == ['"' + included + '"'].collect { include(it, true) }

        where:
        included << ["test'file", "testfile'", "'testfile'", "test<>file", "test>file", "<testFile>", "test<file", "test file"]

        when:
        fails(includingBuild, 'help')
        then:
        failure.assertHasDescription("Included build ${file('nested')} has build path :nested which is the same as included build ${file('includedBuildB/nested')}")

        where:
        laterDescription             | includeFromNestedBuild
        'later from nested build'    | true

    /**
     * Provides the software component that should be published.
     *
     * <ul>
     *     <li>Any artifacts declared by the component will be included in the publication.</li>
     *     <li>The dependencies declared by the component will be included in the published meta-data.</li>
     * </ul>
     *

        runtimeExec().groovy                   | _
    }

    def "using #snippetsFactory.summary in task of included plugin build is not a problem"() {
        given:
        def snippets = snippetsFactory.newSnippets(execOperationsFixture)
        def includedBuildFile = testDirectory.file("included/build.gradle")
        includedBuildFile << """
            import ${DefaultTask.name};

    def "fires build listener events on included builds"() {
        given:
        dependency 'org.test:buildB:1.0'
        dependency buildB, 'org.test:buildC:1.0'

        when:
        execute()

        then:
        verifyBuildEvents()
    }

    @ToBeFixedForConfigurationCache(because = "build listener")
    def "fires build listener events for unused included builds"() {
        when:
        execute()