}

    private static void assertEqualSnapshots(FileSystemSnapshot snapshot, FileSystemSnapshot expected) {
        assert snapshot == expected
        assert indexByAbsolutePath(snapshot) == indexByAbsolutePath(expected)
    }

        allowFileSystemAccess(true)
        def childSnapshot = read(childDir)

        when:
        def parentSnapshot = read(parentDir)
        def index = SnapshotUtil.indexByAbsolutePath(parentSnapshot)

        then:
        index[childDir.absolutePath].is(childSnapshot)
    }

    def "reuses cached descendant tree when it has siblings on read"() {
        given:

        Map<String, FileSystemLocationSnapshot> beforeExecutionIndex = indexByAbsolutePath(unfilteredBeforeExecution);
        if (beforeExecutionIndex.isEmpty()) {
            return unfilteredAfterExecution;
        }

        Map<String, FileSystemLocationSnapshot> previousIndex = previous != null
            ? indexByAbsolutePath(previous)
            : ImmutableMap.of();

        ])

        when:
        def relocated = directorySnapshot.relocate(targetDir.absolutePath, stringInterner).get()
        def index = SnapshotUtil.indexByAbsolutePath(relocated)

        then:
        index.keySet() == [
            targetDir.absolutePath,
            targetDir.file("child").absolutePath,
            targetDir.file("child/child.txt").absolutePath,

import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.Supplier;

public class SnapshotUtil {

    public static Map<String, FileSystemLocationSnapshot> indexByAbsolutePath(FileSystemSnapshot snapshot) {
        HashMap<String, FileSystemLocationSnapshot> index = new HashMap<>();
        snapshot.accept(entrySnapshot -> {
            index.put(entrySnapshot.getAbsolutePath(), entrySnapshot);

    public void cleanupOutputs(FileSystemSnapshot snapshot) throws IOException {
        // TODO We could make this faster by visiting the snapshot
        for (Map.Entry<String, FileSystemLocationSnapshot> entry : SnapshotUtil.indexByAbsolutePath(snapshot).entrySet()) {
            cleanupOutput(new File(entry.getKey()), entry.getValue().getType());
        }
        cleanupDirectories();
    }

    /**
     * Cleans up a single location.
     *

        }

        @Override
        public FileCollectionInternal createDelegate() {
            List<File> outputs = previousOutputs.values().stream()
                .map(SnapshotUtil::indexByAbsolutePath)
                .map(Map::keySet)
                .flatMap(Collection::stream)
                .map(File::new)
                .collect(Collectors.toList());

        def snapshot = directorySnapshotter.snapshot(rootDir.absolutePath, null, knownSnapshots, unfilteredSubSnapshotsCollector)

        then:
        0 * _

        when:
        def visited = SnapshotUtil.indexByAbsolutePath(snapshot)

        then:
        visited[rootDir.absolutePath] instanceof DirectorySnapshot
        visited[rootTextFile.absolutePath] instanceof RegularFileSnapshot