displayName == 'Notify beforeEvaluate listeners of :foo'
            children*.displayName == ["Execute Project.beforeEvaluate listener"]
            children.first().children*.displayName == ["Apply script '${relativePath('foo/before.gradle')}' to project ':foo'"]
            parentId == configOp.id
        }

			ci := tst.children[i]
			ciRange := ci.timeRange()
			for j := i + 1; j < len(tst.children); j++ {
				cj := tst.children[j]
				cjRange := cj.timeRange()
				if ciRange.overlaps(cjRange) {
					return fmt.Errorf("test %s: child %s[%s] overlaps with child %s[%s]",
						tst.name, ci.name, ciRange, cj.name, cjRange)
				}
			}
		}
	}

	// Now check the children.

    }

    private static List<String> visitAll(
            Collection<Vertex> children, Map<Vertex, DfsState> stateMap, List<String> list) {
        for (Vertex v : children) {
            DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
            if (state == null) {
                visitAll(v.children, stateMap, list);
                stateMap.put(v, DfsState.VISITED);
                list.add(v.label);

    final List<Tree> children;

    public Tree(char value, Tree... children) {
      super(value);
      this.children = Arrays.asList(children);
    }
  }

  private static final TreeTraverser<Tree> ADAPTER =
      new TreeTraverser<Tree>() {
        @Override
        public Iterable<Tree> children(Tree node) {
          return node.children;
        }
      };

    checkNotNull(nodeToChildrenFunction);
    return new TreeTraverser<T>() {
      @Override
      public Iterable<T> children(T root) {
        return nodeToChildrenFunction.apply(root);
      }
    };
  }

  /** Returns the children of the specified node. Must not contain null. */
  public abstract Iterable<T> children(T root);

  /**

        resolveB.children == [downloadBMetadata]
        resolveD.children == [downloadDMavenMetadata, downloadDPom]

        resolveCompileFiles.parent == applyRootBuildScript
        resolveCompileFiles.children.size() == 3 // resolution happens in parallel, so the operations may appear in any order
        resolveCompileFiles.children.contains(resolveArtifactB)

        then:
        project.parent == null
        project.name == 'test project'
        project.description == null
        project.children.size() == 1
        project.children[0] instanceof IdeaModule
        project.children == project.modules
    }

    def "provides basic project information"() {

        buildFile.text = """
apply plugin: 'java'
apply plugin: 'idea'

    checkNotNull(nodeToChildrenFunction);
    return new TreeTraverser<T>() {
      @Override
      public Iterable<T> children(T root) {
        return nodeToChildrenFunction.apply(root);
      }
    };
  }

  /** Returns the children of the specified node. Must not contain null. */
  public abstract Iterable<T> children(T root);

  /**

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,