}

    def "dependency management block from parent pom is inherited"() {
        given:
        pomFile << """
<project>
    <modelVersion>4.0.0</modelVersion>
    <groupId>group-a</groupId>
    <artifactId>module-a</artifactId>
    <version>1.0</version>

    <parent>
        <groupId>group-a</groupId>
        <artifactId>parent</artifactId>
        <version>1.0</version>
    </parent>

<project>
  <modelVersion>4.0.0</modelVersion>
  <parent>
    <groupId>tests</groupId>
    <artifactId>resolve-parent-pom-parent</artifactId>
    <version>1</version>
  </parent>

  <artifactId>resolve-parent-pom</artifactId>

		copy(f.Decls[lastImport+2:], f.Decls[lastImport+1:])
		f.Decls[lastImport+1] = impDecl
	}

	// Ensure the import decl has parentheses, if needed.
	if len(impDecl.Specs) > 0 && !impDecl.Lparen.IsValid() {
		impDecl.Lparen = impDecl.Pos()
	}

	insertAt := impIndex + 1
	if insertAt == 0 {
		insertAt = len(impDecl.Specs)
	}
	impDecl.Specs = append(impDecl.Specs, nil)

	}

	scope.Debug("delete")
	if nc.Parent == nil {
		return errors.New("cannot delete root element")
	}

	switch {
	case isSliceOrPtrInterface(nc.Parent.Node):
		if err := util.DeleteFromSlicePtr(nc.Parent.Node, nc.Parent.KeyToChild.(int)); err != nil {
			return err
		}
		if isMapOrInterface(nc.Parent.Parent.Node) {
			return util.InsertIntoMap(nc.Parent.Parent.Node, nc.Parent.Parent.KeyToChild, nc.Parent.Node)
		}

public class ClassLoaderScopeIdentifier implements ClassLoaderScopeId {

    @Nullable
    private final ClassLoaderScopeIdentifier parent;
    private final String name;

    public ClassLoaderScopeIdentifier(@Nullable ClassLoaderScopeIdentifier parent, String name) {
        this.parent = parent;
        this.name = name;
    }

    public ClassLoaderScopeIdentifier child(String name) {

    def "resolves directory to watch from snapshot"() {
        def parent = temporaryFolder.createDir("parent")
        def dir = parent.createDir("dir")
        def file = parent.createFile("file.txt")
        def missingFile = parent.file("missing/file.txt")

        expect:
        getDirectoryToWatch(regularFile(file.absolutePath)) == parent
        getDirectoryToWatch(directory(dir.absolutePath, [])) == dir

                }
                int parent = idx - 1;
                while (parent >= 0 && result.charAt(parent) == '/') {
                    parent--;
                }
                parent = result.lastIndexOf('/', parent);
                if (parent < 0) {
                    result = result.substring(idx + 4);
                } else {
                    result = result.substring(0, parent) + result.substring(idx + 3);

    private final String displayName;
    private final OperationDescriptor parent;

    public DefaultOperationDescriptor(InternalOperationDescriptor internalDescriptor, OperationDescriptor parent) {
        this.name = internalDescriptor.getName();
        this.displayName = internalDescriptor.getDisplayName();
        this.parent = parent;
    }

        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)