private final String description;
    private final Collection<ContinuousOperation> children = new HashSet<>();

    public FragmentedOperation(String description) {
        this.description = description;
    }

    @Override
    public long getElapsedTime() {
        long result = 0;
        for (ContinuousOperation child : children) {
            result += child.getElapsedTime();
        }
        return result;
    }

         */
        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 {

                } else if(listSelNum > listNum) {
                    listSelNum = 0;
                }

                var a = $boxElement.children("ol").children("li");
                $boxElement.children("ol").children("li").each(function(i){
                    if(i == (listSelNum-1)) {
                        if(typeof listSelectedCssInfo === 'undefined') {

        eclipseModel.children[0].name == 'child1'
        eclipseModel.children[0].buildCommands.collect { it.name } == ['child1BuildCommand']
        eclipseModel.children[0].buildCommands.collect { it.arguments } == [['child1Key': 'child1Value']]
        eclipseModel.children[1].name == 'child2'
        eclipseModel.children[1].buildCommands.collect { it.name } == ['child2BuildCommand']

		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
}

        def resolveArtifacts = events.operation(resolveConfigurationFiles(':configurationWithDependency'))
        resolveArtifacts.parent.descriptor.displayName.matches("Execute .* for :resolve")
        resolveArtifacts.children.size() == 1
        resolveArtifacts.child("Resolve ${expectedDisplayName('provider', 'jar', '1.0')} (test:provider:1.0)")
    }

    def "generates event for resolving intrinsic artifacts via file collection"() {

        if (!includedBuilds.isEmpty()) {
            Set<IncludedBuildInternal> children = new LinkedHashSet<>(includedBuilds.size());
            for (IncludedBuildSpec includedBuildSpec : includedBuilds) {
                CompositeBuildParticipantBuildState includedBuild = buildIncluder.includeBuild(includedBuildSpec);
                children.add(includedBuild.getModel());
            }

            // Set the visible included builds

        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);
                }