model.projects*.name == ["root", "child1", "child2"]
        model.projects*.path == [":", ":child1", ":child2"]
        model.includedBuilds.empty
        model.editableBuilds.empty

        where:
        startProject | _
        project      | _
        child2       | _
    }

    def "builds model for included builds"() {
        def buildRegistry = Mock(BuildStateRegistry)

    def rendersReportForRootProjectWithChildren() {
        project.description = 'this is the root project'
        Project child1 = TestUtil.createChildProject(project, "child1")
        child1.description = 'this is a subproject'
        TestUtil.createChildProject(child1, "child1")
        TestUtil.createChildProject(project, "child2")

        when:
        def model = task.calculateReportModelFor(project)

        given:
        def child1 = mavenRepo.module("org", "child1", "1.0")
        child1.parent("org", "parent1", "1.0")
        child1.publish()

        def child2 = mavenRepo.module("org", "child2", "1.0")
        child2.parent("org", "parent2", "1.0")
        child2.publish()

        def parent1 = mavenRepo.module("org", "parent1", "1.0")

exploded-war-child-copy-spec-example.png...

                vfsStore.store(regularFile("${location}/some/child"))
                vfsStore.store(regularFile("${location}/other/child"))
                instant.partialSnapshotsStored
                thread.blockUntil.invalidated
                vfsStore.store(regularFile("${location}/other/child2"))
                vfsStore.store(regularFile("${location}/some/child2"))
                instant.snapshottingFinished

        final Project child1 = createChildProject(project, "child1")
        final Project child2 = createChildProject(project, "child2")

        when:
        task.setProjects(project.getAllprojects())
        task.generate()

        then:
        1 * renderer.setClientMetaData(_)
        1 * renderer.setOutput(_ as StyledTextOutput)
        [project, child1, child2].each {

	cmd.Start()
	defer cmd.Stop()

	cpid, cpgrp := cmd.Info()

	if cpid == ppid {
		t.Fatalf("Parent and child have the same process ID")
	}

	if cpgrp == ppgrp {
		t.Fatalf("Parent and child are in the same process group")
	}

	if cpid != cpgrp {
		t.Fatalf("Child's process group is not the child's process ID")
	}
}

func TestPgid(t *testing.T) {
	ppid, ppgrp := parent()

	cmd1 := create(t)

        scope1.exportClassLoader

        def scope2 = root.createChild("child2", null).export(c1).local(c2).lock()
        scope2.exportClassLoader

        then:
        scope1.exportClassLoader.is scope2.exportClassLoader

        when:
        def child = scope1.createChild("child", null).export(c1).local(c2).lock()
        child.exportClassLoader

<project>
  <parent>
    <groupId>gid</groupId>
    <artifactId>child-3</artifactId>
    <version>1.0</version>
    <relativePath>child3.xml</relativePath>
  </parent>
  <modelVersion>4.0.0</modelVersion>
  <artifactId>child-2</artifactId>
  <packaging>pom</packaging>

            <parent>child</parent>
            <child>child</child>
            <parent-only>parent</parent-only>
          </defaults>
          <appends combine.children="append">
            <parent-only>parent</parent-only>
            <parent>parent</parent>
            <parent>child</parent>
            <child>child</child>
          </appends>
          <overrides combine.self="override">