require(lookupParent != null) {
                    "Cannot find parent $parentId for child scope $childId"
                }
                lookupParent
            }

            val child = ClassLoaderScopeSpec(parent, childId.name, origin)
            scopeSpecs[childId] = child
        }
    }

        }

        depRequest.setRoot(node);

        if (logger.isWarnEnabled()) {
            for (DependencyNode child : node.getChildren()) {
                if (!child.getRelocations().isEmpty()) {
                    org.eclipse.aether.artifact.Artifact artifact =
                            child.getDependency().getArtifact();
                    String message =

    @Nullable
    Artifact getArtifact();

    /**
     * @return dependency for this node
     */
    @Nullable
    Dependency getDependency();

    /**
     * Gets the child nodes of this node.
     *
     * @return the child nodes of this node, never {@code null}
     */
    @Nonnull
    List<Node> getChildren();

    /**
     * @return repositories of this node
     */
    @Nonnull

     * @return requires a project
     */
    boolean projectRequired() default true;

    /**
     * if the Mojo uses the Maven project and its child modules.
     * @return uses the Maven project and its child modules
     */
    boolean aggregator() default false;

    /**
     * does this Mojo need to be online to be executed?
     * @return need to be online
     */

 * limitations under the License.
 */

package org.gradle.internal.cc.impl

import org.gradle.api.internal.project.ProjectInternal


internal
enum class CrossProjectModelAccessPattern {
    DIRECT,
    CHILD,
    SUBPROJECT,
    ALLPROJECTS
}


internal
data class CrossProjectModelAccessInstance(
    val pattern: CrossProjectModelAccessPattern,
    val relativeTo: ProjectInternal,

            buildDirs[project.projectPath]?.let {
                project.layout.buildDirectory.set(it)
            }
            for (child in descriptor.children()) {
                createProject(child)
            }
            return project
        }

        override fun getProject(path: String): ProjectInternal =

        runBuildAction(new FetchGradleProjectForTarget(":included1"))

        then:
        fixture.assertStateLoaded()
    }

    def "root GradleProject model is invalidated when a child project configuration changes"() {
        settingsFile << """
            rootProject.name = 'root'
            include("a")
            include("b")
        """
        file("a/build.gradle") << ""

	}

	p, err := FindProcess(pid)
	if err != nil {
		t.Fatalf("FindProcess(math.MaxInt32) got err %v, want nil", err)
	}

	if ps, err := p.Wait(); !errors.Is(err, syscall.ECHILD) {
		t.Errorf("Wait() got err %v (ps %+v), want %v", err, ps, syscall.ECHILD)
	}

	if err := p.Release(); err != nil {
		t.Errorf("Release() got err %v, want nil", err)
	}
}

func TestUNIXProcessAlive(t *testing.T) {
	testenv.MustHaveGoBuild(t)

) : CachedProjectState(path, projectDir, buildFile)


data class BuildToStore(
    val build: VintageGradleBuild,
    // Does this build have work scheduled?
    val hasWork: Boolean,
    // Does this build have a child build with work scheduled?
    val hasChildren: Boolean
) {
    fun hasChildren() = BuildToStore(build, hasWork, true)
}


/**
 * State cached for a build in the tree.
 */
internal

    fun Hasher.putAll(list: Collection<String>) {
        putInt(list.size)
        list.forEach(::putString)
    }

    /**
     * Returns the path of [target] relative to [base] if
     * [target] is a child of [base] or `null` otherwise.
     */
    private
    fun relativeChildPathOrNull(target: File, base: File): String? =
        relativePathOf(target, base)
            .takeIf { !it.startsWith('.') }