}

    @BeforeTemplate
    Iterable<N> before2(N root) {
      return new TreeTraverser<N>() {
        @Override
        public Iterable<N> children(N node) {
          return getChildren(node);
        }
      }.preOrderTraversal(root);
    }

    @AfterTemplate
    Iterable<N> after(N root) {

        }

        List<PBXObject> getChildren() {
            return getProperty("children")
        }

        def assertHasChildren(List<String> entries) {
            def children = getProperty("children")
            assert children.size() == entries.size()
            assert children*.name.containsAll(entries)
            return true
        }

        @Override

 */

package org.gradle.internal.snapshot;

import java.util.List;

public class LargeChildMap<T> extends AbstractListChildMap<T> {

    public LargeChildMap(List<Entry<T>> children) {
        super(children);
    }

    @Override
    public <R> R withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, R> handler) {

    /**
     * Visits a node of the tree.
     */
    public void node(T node) {
    }

    /**
     * Starts visiting the children of the most recently visited node.
     */
    public void startChildren() {
    }

    /**
     * Finishes visiting the children of the most recently started node.
     */
    public void endChildren() {
    }

    }

    private static List<String> visitCycle(
            Map<String, Set<String>> graph,
            Collection<String> children,
            Map<String, DfsState> stateMap,
            LinkedList<String> cycle) {
        if (children != null) {
            for (String v : children) {
                DfsState state = stateMap.putIfAbsent(v, DfsState.VISITING);
                if (state == null) {

        if (node.getValue() != null) {
            return node.getValue();
        } else {
            List<Object> children = new ArrayList<>();
            for (XmlNode child : node.getChildren()) {
                children.add(getValue(child));
            }
            return children;
        }
    }

    @Override
    public Object getBaseValue() {
        return node;
    }

    @Override

package org.gradle.internal.snapshot;

import java.util.List;
import java.util.Optional;

public class MediumChildMap<T> extends AbstractListChildMap<T> {
    protected MediumChildMap(List<Entry<T>> children) {
        super(children);
    }

    @Override
    public <RESULT> RESULT withNode(VfsRelativePath targetPath, CaseSensitivity caseSensitivity, NodeHandler<T, RESULT> handler) {
        for (Entry<T> entry : entries) {

  ASSERT_THAT(env->RecursivelyCreateDir(absl::StrCat(*tmp_dir, "/subdir")),
              IsOk());

  absl::StatusOr<std::vector<std::string>> children = ListDirectory(*tmp_dir);
  EXPECT_THAT(children, IsOk());
  EXPECT_THAT(children.value(), SizeIs(3));
  EXPECT_THAT(children.value(),
              UnorderedElementsAre("subdir", "tmp_file1", "tmp_file2"));
}

}  // namespace

     * Traverses this node and potentially its children using the specified visitor.
     *
     * @param visitor the visitor to call back, must not be {@code null}
     * @return {@code true} to visit siblings nodes of this node as well, {@code false} to skip siblings
     */
    boolean accept(@Nonnull NodeVisitor visitor);

    /**
     * Returns a new tree starting at this node, filtering the children.

        }

        return titles;
    }

    function findChildElements(container, name, targetClass) {
        var elements = [];
        var children = container.childNodes;

        for (var i = 0; i < children.length; i++) {
            var child = children.item(i);

            if (child.nodeType === 1 && child.nodeName === name) {
                if (targetClass && child.className.indexOf(targetClass) < 0) {