assert operation.id == parent.id
            assert context.failure == null
        }
    }

    def "cannot start child operation when parent has completed"() {
        BuildOperationRef parent = null

        given:
        operationRunner.run(runnableBuildOperation("parent") {
            parent = operationRunner.currentOperation
        })

        when:

                Objects.equal(parent, that.parent);
    }

    @Override
    public int hashCode() {
        return Objects.hashCode(self, parent);
    }

    @Override
    public String toString() {
        return "HierarchicalClassLoaderStructure{" +
                "self=" + self +
                ", parent=" + parent +
                '}';
    }

// It sets the parent context of cancelCtx.
func (c *cancelCtx) propagateCancel(parent Context, child canceler) {
	c.Context = parent

	done := parent.Done()
	if done == nil {
		return // parent is never canceled
	}

	select {
	case <-done:
		// parent is already canceled
		child.cancel(false, parent.Err(), Cause(parent))
		return
	default:
	}

// NewScope returns a new, empty scope contained in the given parent
// scope, if any. The comment is for debugging only.
func NewScope(parent *Scope, pos, end syntax.Pos, comment string) *Scope {
	s := &Scope{parent, nil, 0, nil, pos, end, comment, false}
	// don't add children to Universe scope!
	if parent != nil && parent != Universe {
		parent.children = append(parent.children, s)
		s.number = len(parent.children)
	}
	return s
}

// NewScope returns a new, empty scope contained in the given parent
// scope, if any. The comment is for debugging only.
func NewScope(parent *Scope, pos, end token.Pos, comment string) *Scope {
	s := &Scope{parent, nil, 0, nil, pos, end, comment, false}
	// don't add children to Universe scope!
	if parent != nil && parent != Universe {
		parent.children = append(parent.children, s)
		s.number = len(parent.children)
	}
	return s
}

		case '?', '!', '.', ',', ':', '@', '_', '~':
			// Trim certain trailing punctuation.
			i--
			continue Trim

		case ')':
			// Trim trailing unmatched (by count only) parens.
			if paren < 0 {
				for s[i-1] == ')' && paren < 0 {
					paren++
					i--
				}
				continue Trim
			}

		case ';':
			// Trim entity reference.
			// After doing the work of the scan, we either cut that part off the string

        private final ExternalResourceName parent;

        public ListOperation(ExternalResourceName parent) {
            this.parent = parent;
        }

        @Override
        public List<String> call(BuildOperationContext context) {
            try {
                return delegate.list(parent);
            } finally {
                context.setResult(LIST_RESULT);
            }

                    }
                }

                // parent should also be running
                assert descriptor.parent == null || running.containsKey(descriptor.parent)
                def parent = descriptor.parent == null ? null : operations.find { it.descriptor == descriptor.parent }

                Operation operation = newOperation(event, parent, descriptor)
                operations.add(operation)

        this.name = name;
        return this;
    }

    /**
     * Specifies the parent project. Use it to create multi-module projects.
     *
     * @param parent parent project
     * @return The builder
     */
    public ProjectBuilder withParent(@Nullable Project parent) {
        this.parent = parent;
        return this;
    }

    /**
     * Creates the project.
     *

        DefaultResolvedDependency parent = new DefaultResolvedDependency("someConfiguration", newId("someGroup", "parent", "someVersion"), buildOperationProcessor)
        resolvedDependency.getParents().add(parent)

        then:
        resolvedDependency.getArtifacts(parent).empty
    }

    def getParentArtifactsWithParentWithoutParentArtifacts() {
        when: