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}
	DB.Save(&parent)

	var children []*Child
	DB.Where("parent_id = ?", parent.ID).Find(&children)

	"time"
)

// ProgCache implements Cache via JSON messages over stdin/stdout to a child
// helper process which can then implement whatever caching policy/mechanism it
// wants.
//
// See https://github.com/golang/go/issues/59719
type ProgCache struct {
	cmd    *exec.Cmd
	stdout io.ReadCloser  // from the child process
	stdin  io.WriteCloser // to the child process
	bw     *bufio.Writer  // to stdin
	jenc   *json.Encoder  // to bw

            });
        }
        for (ProjectState child : project.getChildProjects()) {
            ProjectState previous = candidates.put(child.getIdentityPath().getName(), child);
            if (previous != null) {
                throw new IllegalStateException("Duplicate child project names for " + project.getDisplayName());
            }
        }
        ProjectState child = candidates.get(childName);
        if (child != null) {

                }
            }
            ${buildFinishedCall('root-build-finished')}
        """
        createDirs("child/a", "child/b")
        file("child/settings.gradle") << """
            include 'a', 'b'
        """
        file("child/build.gradle") << """
            ${server.callFromBuild('child-build-script')}
            task hello {
                dependsOn {
                    // call during task graph calculation

        }

        Operation child(Spec<String> displayNameSpec) {
            def child = children.find { displayNameSpec.isSatisfiedBy(it.descriptor.displayName) }
            if (child == null) {
                throw new AssertionFailedError("No operation matching display name found in children of '$descriptor.displayName':\n${describeList(children)}")
            }
            return child
        }

        manager.useLogger(listener1)
        def child = manager.createChild(Scope.Build)
        def broadcaster = child.getBroadcaster(BuildScopeListener.class)
        child.useLogger(listener2)

        when:
        broadcaster.foo("param")

        then:
        1 * listener2.foo("param")
        0 * _

        when:
        child.useLogger(listener3)
        broadcaster.foo("param2")

    }

    def "injected classes are inherited by child projects of project that applies plugin"() {
        given:
        file("settings.gradle") << "include 'child'"
        buildFile << plugin.build().useDeclaration
        file("child/build.gradle") << plugin.echoClassNameTask()

        when:
        def result = runner("child:echo1")

                    boolean matched = false;
                    for (Node child : children) {
                        if (!matched) {
                            int childCommonPrefix = child.sizeOfCommonPrefix(path, startNextSegment);
                            if (childCommonPrefix > 0) {
                                merged.add(child.plusWithCommonPrefixLength(nextSegment, childCommonPrefix));

                implementation 'org.foo:unknown:1.0' //does not exist
                implementation project(":child")
                implementation 'org.foo:rock:1.0' //contains unresolved transitive dependency
            }
        """
        failedResolve.prepare("compileClasspath")
        createDirs("child")
        settingsFile << "include 'child'"
        def m1 = mavenHttpRepo.module('org.foo', 'hiphop').publish()

                    normalizeExecutor(it.name) == name
            }
            if (child == null) {
                failWith("test suite", name)
            }
            String expectedOperationDisplayName = name.startsWith("Gradle Test") ? normalizeExecutor(child.displayName) : "Test suite '$name'"
            assertSpec(child, testEvents, verifiedEvents, expectedOperationDisplayName, spec)
        }

        @Override