def "can define GAV with reference to parent.GAV"() {
        when:
        pomFile << """
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>\${parent.groupId}</groupId>
    <artifactId>\${parent.artifactId}</artifactId>
    <version>\${parent.version}</version>

    <parent>
        <groupId>parent-group</groupId>
        <artifactId>parent-artifact</artifactId>

     */
    interface Gradle extends Build {}

    /**
     * These services are created once per project per build invocation.
     * These services are closed at the end of the build invocation.
     *
     * <p>{@link Gradle} and parent scope services are visible to {@link Project} scope services, but not vice versa.</p>
     */

	}

	return nil
}

// Reliably retries os.MkdirAll if for some reason os.MkdirAll returns
// syscall.ENOENT (parent does not exist).
func reliableMkdirAll(dirPath string, mode os.FileMode, baseDir string) (err error) {
	i := 0
	for {
		// Creates all the parent directories, with mode 0777 mkdir honors system umask.
		if err = osMkdirAll(dirPath, mode, baseDir); err != nil {

	}

	// RemoveAll recurses by deleting the path base from
	// its parent directory
	parentDir, base := splitPath(path)

	parent, err := Open(parentDir)
	if IsNotExist(err) {
		// If parent does not exist, base cannot exist. Fail silently
		return nil
	}
	if err != nil {
		return err
	}
	defer parent.Close()

	if err := removeAllFrom(parent, base); err != nil {
		if pathErr, ok := err.(*PathError); ok {

internal
class ClassLoaderScopeSpec(
    val parent: ClassLoaderScopeSpec?,
    val name: String,
    val origin: ClassLoaderScopeOrigin?
) {
    var localClassPath: ClassPath = ClassPath.EMPTY
    var localImplementationHash: HashCode? = null
    var exportClassPath: ClassPath = ClassPath.EMPTY

    override fun toString(): String {
        return if (parent != null) {
            "$parent:$name"
        } else {
            name

    for (parent in parentsWithSelf) {
        if (parent is KtElement) {
            val scope = bindingContext[BindingContext.LEXICAL_SCOPE, parent]
            if (scope != null) return scope
        }

        if (parent is KtClassBody) {
            val classDescriptor = bindingContext[BindingContext.CLASS, parent.getParent()] as? ClassDescriptorWithResolutionScopes

    def outerSuiteDescriptor = new SimpleTestDescriptor(name: "com.OuterSuiteClass", composite: true, parent: workerDescriptor)
    def innerSuiteDescriptor = new SimpleTestDescriptor(name: "com.InnerSuiteClass", composite: true, parent: outerSuiteDescriptor)
    def classDescriptor = new SimpleTestDescriptor(name: "foo.bar.TestClass", composite: true, parent: innerSuiteDescriptor)

    }

    private
    fun collect(project: ProjectState, projects: MutableSet<ProjectState>) {
        if (!projects.add(project)) {
            return
        }
        val parent = project.parent
        if (parent != null) {
            collect(parent, projects)
        }
    }

    private
    fun projectStateOf(node: Node) = node.owningProject?.owner

    private

        def t1 = events.operation("Task :para1")
        def t2 = events.operation("Task :para2")
        def t3 = events.operation("Task :parallelTasks")

        t1.parent == runTasks
        t2.parent == runTasks
        t3.parent == runTasks

        cleanup:
        server.stop()
    }

    @TargetGradleVersion(">=3.6")

        }

        build.services >> serviceRegistry

        def container = Mock(ProjectState)
        _ * container.projectPath >> (parent == null ? Path.ROOT : parent.projectPath.child(name))
        _ * container.identityPath >> (parent == null ? build.identityPath : build.identityPath.append(parent.projectPath).child(name))

        def descriptor = Mock(ProjectDescriptor) {
            getName() >> name