}

    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) {

 */

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) {

    private void wrapContentInContainer(Document document) {
        // Wrap the page in a text container to get the margins
        Elements bodyContent = document.body().children().remove();
        document.body().prepend("<div class='container'/>");
        document.body().children().get(0).html(bodyContent.outerHtml());
    }

    private void addTOC(Document document) {

     * 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.

            val actions = readList().uncheckedCast<List<Action<FileCopyDetails>>>()
            val children = readList().uncheckedCast<List<CopySpecInternal>>()
            val copySpec = DefaultCopySpec(fileCollectionFactory, objectFactory, instantiator, patternSetFactory, destPath, sourceFiles, patterns, actions, children)
            copySpec.duplicatesStrategy = duplicatesStrategy
            copySpec.includeEmptyDirs = includeEmptyDirs

    private final String description;
    private final Action<? super ModelSchema<T>> validator;
    private ModelSchema<T> result;
    private final List<DefaultModelSchemaExtractionContext<?>> children = new ArrayList<>();
    private final FormattingValidationProblemCollector problems;

        0 * _

        when:
        invalidate(rootDirSnapshot.children[0])
        invalidate(rootDirSnapshot.children[1])
        then:
        0 * _

        when:
        invalidate(rootDirSnapshot.children[2])
        then:
        1 * watcher.stopWatching({ equalIgnoringOrder(it, [rootDir]) })

        if (unpackedNode instanceof DirectorySnapshot) {
            def children = unpackedNode.children
            children.forEach { child ->
                collectPrefixes(child.name, child, 0, prefixes)
            }
        } else if (unpackedNode instanceof AbstractIncompleteFileSystemNode) {
            def children = unpackedNode.children
            children.stream()

    }

    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) {

    }

    @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) {