children.forEach { child ->
                collectPrefixes(child.name, child, 0, prefixes)
            }
        } else if (unpackedNode instanceof AbstractIncompleteFileSystemNode) {
            def children = unpackedNode.children
            children.stream()
                .forEach(child -> collectPrefixes(child.path, child.value, 0, prefixes))
        }
        return prefixes
    }

        createDirs("child1", "child2");
        testFile("settings.gradle").writelns(
            "include 'child1', 'child2'",
            "project(':child1').buildFileName = '../child.gradle'",
            "project(':child2').buildFileName = '../child.gradle'"
        );
        testFile("child.gradle").write("task('do-stuff')");

        model.projectDirectory == file("buildSrc")
    }

    def buildsWithBuildSrc() {
        buildSrc(projectDir)
        def child = "child"
        settingsFile << """
            includeBuild("$child")
        """


        def childBuild = file(child)
        buildSrc(childBuild)
        def nested = "nested"
        childBuild.file("settings.gradle") << """
            includeBuild("$nested")

        def child1 = consumable("child1", [conf1, conf2])
        consumable("child2", [conf1])

        addArtifact(conf1, artifact1, file1)
        addArtifact(conf2, artifact2, file2)
        addArtifact(child1, artifact3, file3)

        when:
        def conf1State = state.candidatesForGraphVariantSelection.getVariantByConfigurationName("child1", Stub(ResolutionFailureHandler))

        given:
        settingsFile << "\ninclude 'root', 'child1', 'child2', 'child3'"
        buildFile << """
            allprojects {
                apply plugin: 'idea'
                apply plugin: 'java'
            }

            idea {
                module {
                    jdkName = 'MyJDK1'
                }
            }

            project(':child1') {
                idea {
                    module {

class CompositeOperationTest extends Specification {

    def "execution time is sum of execution time of child operations"() {
        given:
        Operation child1 = operation(12)
        Operation child2 = operation(10)
        def operation = new CompositeOperation<Operation>([child1, child2])

        expect:
        operation.elapsedTime == 22
    }

    def operation(long elapsedTime) {

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// This file implements CGI from the perspective of a child
// process.

package cgi

import (
	"bufio"
	"crypto/tls"
	"errors"
	"fmt"
	"io"
	"net"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
)

        when:
        file("settings.gradle") << "include 'child1', 'child2'"
        file("child1/build.gradle") << plugin.build().useDeclaration
        file("child2/build.gradle") << plugin.useDeclaration
        buildFile << """
            task compare {
                doLast {
                    project("child1").tasks.helloWorld1.getClass() == project("child2").tasks.helloWorld1.getClass()
                }
            }

    }

    static ChildMap<FileSystemNode> sortedChildren(String path1, FileSystemNode child1, String path2, FileSystemNode child2) {
        def compared = PathUtil.getPathComparator(CASE_SENSITIVE).compare(path1, path2)
        def entry1 = new ChildMap.Entry<FileSystemNode>(path1, child1)
        def entry2 = new ChildMap.Entry<FileSystemNode>(path2, child2)

        when:
        registry.realize("thing")

        then:
        ModelRuleExecutionException e = thrown()
        e.cause instanceof IllegalStateException
        e.cause.message == "Cannot create 'thing.child' using creation rule 'create thing.child as String' as model element 'thing' is no longer mutable."