assert operation.id != null
            parent1Id = operation.id
            assert operation.parentId == null
        }
        1 * listener.start({ it.displayName == "<parent-2>" }, _) >> { BuildOperationDescriptor descriptor, BuildOperationState operation ->
            assert operation.id != null
            parent2Id = operation.id
            assert operation.parentId == null
        }

        parent1.hasPackaging('pom')
        parent1.publish()

        def parent2 = mavenRepo.module("org", "parent2", "1.0")
        parent2.hasPackaging('pom')
        parent2.publish()

        buildFile << """
            repositories {
                maven {
                    url = uri('$blockingServer.uri')
                    $authConfig
                }
            }

        notifications.op(CalculateTaskGraphBuildOperationType.Details, [buildPath: ":a:buildSrc"]).parentId == treeGraphOps[0].id

        notifications.op(NotifyTaskGraphWhenReadyBuildOperationType.Details, [buildPath: ":"]).parentId == treeGraphOps[2].id
        notifications.op(NotifyTaskGraphWhenReadyBuildOperationType.Details, [buildPath: ":a"]).parentId == treeGraphOps[2].id

        given:
        def parentDir = temporaryFolder.createDir("parent")
        def childDir = parentDir.createDir("child")
        parentDir.createDir("sibling")
        childDir.file("file.txt").createFile()

        allowFileSystemAccess(true)
        def childSnapshot = read(childDir)

        when:
        def parentSnapshot = read(parentDir)

	DB.First(&parent1, parent.ID)
	AssertObjEqual(t, parent, parent1, "ID", "FavChildID")
}

func TestSaveHasManyCircularReference(t *testing.T) {
	parent := Parent{}
	DB.Create(&parent)

	child := Child{ParentID: &parent.ID, Parent: &parent, Name: "HasManyCircularReference"}
	child1 := Child{ParentID: &parent.ID, Parent: &parent, Name: "HasManyCircularReference1"}

	parent.Children = []*Child{&child, &child1}

        loadOps[0].details.buildPath == ":"
        loadOps[0].parentId == root.id

        loadOps[1].displayName == "Load build (:buildB)"
        loadOps[1].details.buildPath == ":buildB"
        loadOps[1].parentId == loadOps[0].id

        loadOps[2].displayName == "Load build (:buildB:buildSrc)"
        loadOps[2].details.buildPath == ":buildB:buildSrc"
        loadOps[2].parentId == buildSrcOps[0].id

        taskGraphOps[0].parentId == treeTaskGraphOps[0].id
        taskGraphOps[1].displayName == "Calculate task graph (:buildC)"
        taskGraphOps[1].details.buildPath == ":buildC"
        taskGraphOps[1].parentId == treeTaskGraphOps[0].id
        taskGraphOps[2].displayName == "Calculate task graph"
        taskGraphOps[2].details.buildPath == ":"
        taskGraphOps[2].parentId == treeTaskGraphOps[1].id

            OperationIdentifier parentId = buildOperation.getParentId();

            if (parentId != null) {
                if (active.containsKey(parentId)) {
                    parents.put(id, parentId);
                } else {
                    parentId = parents.get(parentId);
                    if (parentId != null) {
                        parents.put(id, parentId);
                    }
                }

    def startConfigureRootBuild(Long id, Long parentId, int totalProgress) {
        return start(id, parentId, BuildOperationCategory.CONFIGURE_ROOT_BUILD, totalProgress)
    }

    def startConfigureBuild(Long id, Long parentId, int totalProgress) {
        return start(id, parentId, BuildOperationCategory.CONFIGURE_BUILD, totalProgress)
    }

    def startConfigureProject(Long id, Long parentId) {

            assert event.progressOperationId != parentId
            assert event.parentProgressOperationId == parentId
        }
    }

    def "can specify the parent of an operation"() {
        given:
        def sibling = factory.newOperation("category").setDescription("sibling")
        def parent = factory.newOperation("category").setDescription("parent")