import org.eclipse.aether.graph.DependencyNode;

class WrapperNode extends AbstractNode {
    protected final Node delegate;
    protected final List<Node> children;

    WrapperNode(Node delegate, List<Node> children) {
        this.delegate = delegate;
        this.children = children;
    }

    @Override
    DependencyNode getDependencyNode() {
        return Utils.cast(AbstractNode.class, delegate, "delegate").getDependencyNode();

	id string

	parent *scope

	resources []resource.Resource

	closers []io.Closer

	children []*scope

	closeChan chan struct{}

	topLevel bool

	skipDump bool

	// Mutex to lock changes to resources, children, and closers that can be done concurrently
	mu sync.Mutex
}

func newScope(id string, p *scope) *scope {
	s := &scope{
		id:        id,

        then:
        fixture.assertNoConfigurationCache()

        with(expectedProjectModel) {
            it.name == "root"
            it.tasks.size() > 0
            it.children.size() == 1
            it.children[0].children.size() == 1
        }

        when: "fetching with Isolated Projects"
        executer.withArguments(ENABLE_CLI)
        def projectModel = fetchModel(GradleProject)

        then:

                if (child != null) {
                    children.add(child);
                }
            }

            message = "The build could not read " + children.size() + " project" + (children.size() == 1 ? "" : "s");
        } else {
            message = getMessage(message, exception);
        }

        return new ExceptionSummary(exception, message, reference, children);
    }

         */
        List<Operation> children(String displayName) {
            return children.findAll { it.descriptor.displayName == displayName }
        }

        List<Operation> descendants(Spec<? super Operation> filter) {
            def found = [] as List<Operation>
            def recurse
            recurse = { List<Operation> children ->
                children.each { child ->

            unpackOperations.each {
                assert !it.children
            }
            pullOperations.each {
                if (it.descriptor.displayName.contains('local')) {
                    assert unpackOperations.containsAll(it.children)
                } else {
                    assert !it.children
                }
            }
        } else {

		oi := (oldHash >> hashShift) & nChildrenMask
		ni := (newHash >> hashShift) & nChildrenMask
		if oi != ni {
			newIndirect.children[oi].Store(&oldEntry.node)
			newIndirect.children[ni].Store(&newEntry.node)
			break
		}
		nextIndirect := newIndirectNode(newIndirect)
		newIndirect.children[oi].Store(&nextIndirect.node)
		newIndirect = nextIndirect
	}
	return &top.node
}

        this.root = ImmutableAttributes.EMPTY;
        this.children = new HashMap<>();
        this.children.put(root, new ArrayList<DefaultImmutableAttributes>());
        this.usageCompatibilityHandler = new UsageCompatibilityHandler(isolatableFactory, instantiator);
    }

    public int size() {
        return children.size();
    }

    @Override
    public DefaultMutableAttributeContainer mutable() {

                        }
                    }
                } else {
                    if (children == null) {
                        children = new ArrayList<>();
                    }
                    XmlNode child = build(parser, trim, locationBuilder);
                    children.add(child);
                }

        when:
        EclipseProject rootProject = loadToolingModel(EclipseProject)
        EclipseProject rootImplProject = rootProject.children.find { it.name == 'root-impl' }
        EclipseProject contribProject = rootProject.children.find { it.name == 'contrib' }
        EclipseProject contribImplProject = contribProject.children.find { it.name == 'contrib-impl' }

        then:
        contribImplProject.projectDependencies.any { it.path == 'contrib-api' }