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")

        ['/my/child1', '/my/child2', '/my/child1/other/child'] | '/my/child1/other/child/inside' | ['/my/child1/other/child/inside']           | ['/my/other', '/my/child2']
        ['/my/child1', '/my/child2', '/my/child1/other/child'] | '/my/child1'                    | ['/my/child1/other/child']                  | ['/my/other', '/my/child2']

    @Rule
    public final TestResources testResources = new TestResources(testDirectoryProvider)

    def setup() {
        createDirs("child1", "child2", "child3")
        settingsFile << """
rootProject.name = 'root'
include ':child1', ':child2', ':child3'
"""
    }

    @ToBeFixedForConfigurationCache
    void "global sourceCompatibility results in project language level"() {
        given:

}
configurations {
    child1
    child2
}
dependencies {
    child1 'org:child1:1.0'
    child2 'org:child2:1.0'
}
task retrieveChild1(type: Sync) {
    into 'libs/child1'
    from configurations.child1
}
task retrieveChild2(type: Sync) {
    into 'libs/child2'
    from configurations.child2
}
"""

        when:
        child1.pom.expectGet()

        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))

    compile project(':child1')
    compile project(':child2')
}
project(':child1') {
    artifacts {
        compile file("child1.jar")
    }
    dependencies {
        compile files("child1-lib.jar")
        compile "group:test2:1.0"
        compile project(':child3')
    }
}
project(':child2') {
    artifacts {
        compile file("child2.jar")
    }
    dependencies {

        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()
                }
            }

    super(TestModule, self).__init__()
    self.child1 = Child()
    self.child2 = self.child1

  # CHECK: tf_saved_model.global_tensor
  # CHECK-SAME: tf_saved_model.exported_names = ["child1.my_variable", "child2.my_variable"]


if __name__ == '__main__':

        EclipseProject child1 = children[0]
        child1.name == 'child1'
        child1.parent == rootProject
        child1.children.size() == 1

        EclipseProject child1Child1 = child1.children[0]
        child1Child1.name == 'grandChild1'
        child1Child1.parent == child1
        child1Child1.children.size() == 0

        EclipseProject child2 = children[1]
        child2.name == 'child2'

	r.Flush()
	return r.w.Close()
}

type child struct {
	conn    *conn
	handler http.Handler

	requests map[uint16]*request // keyed by request ID
}

func newChild(rwc io.ReadWriteCloser, handler http.Handler) *child {
	return &child{
		conn:     newConn(rwc),
		handler:  handler,
		requests: make(map[uint16]*request),
	}
}

func (c *child) serve() {
	defer c.conn.Close()
	defer c.cleanUp()