def setup() {
        _ * work.inputFingerprinter >> inputFingerprinter
    }

    def "output file properties are snapshotted"() {
        def outputSnapshots = ImmutableSortedMap.<String, FileSystemSnapshot>of("outputDir", Mock(FileSystemSnapshot))

        when:
        step.execute(work, context)

        then:
        _ * outputSnapshotter.snapshotOutputs(work, _) >> outputSnapshots
        interaction { snapshotState() }

import org.gradle.caching.BuildCacheKey;
import org.gradle.caching.internal.CacheableEntity;
import org.gradle.caching.internal.controller.service.BuildCacheLoadResult;
import org.gradle.internal.snapshot.FileSystemSnapshot;

import java.time.Duration;
import java.util.Map;
import java.util.Optional;

public class NoOpBuildCacheController implements BuildCacheController {

import org.gradle.internal.service.scopes.ServiceScope;
import org.gradle.internal.snapshot.FileSystemSnapshot;

import javax.annotation.Nullable;

@ServiceScope(Scope.Global.class)
public interface OverlappingOutputDetector {
    @Nullable
    OverlappingOutputs detect(ImmutableSortedMap<String, FileSystemSnapshot> previous, ImmutableSortedMap<String, FileSystemSnapshot> current);

import org.gradle.internal.fingerprint.CurrentFileCollectionFingerprint;
import org.gradle.internal.fingerprint.FileCollectionFingerprint;
import org.gradle.internal.fingerprint.FileNormalizer;
import org.gradle.internal.snapshot.FileSystemSnapshot;

import javax.annotation.Nullable;

public interface FileCollectionFingerprinter {
    /**
     * The type used to refer to this fingerprinter in the {@link FileCollectionFingerprinterRegistry}.
     */

        when:
        def out = serialize(snapshots, serializer)

        then:
        assertEqualSnapshots(out, snapshots)
    }

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

    def pack(OutputStream output, OriginWriter writeOrigin = this.writeOrigin, TreeDefinition... treeDefs) {
        Map<String, FileSystemSnapshot> snapshots = treeDefs.collectEntries { treeDef ->
            FileSystemSnapshot result = FileSystemSnapshot.EMPTY
            if (treeDef.root != null) {
                result = fileSystemAccess.read(treeDef.root.absolutePath)
            }

import org.gradle.internal.RelativePathSupplier

import static org.gradle.internal.snapshot.SnapshotVisitResult.CONTINUE

class SnapshotVisitorUtil {
    static List<String> getAbsolutePaths(FileSystemSnapshot snapshot, boolean includeRoots = false) {
        def absolutePaths = []
        snapshot.accept(new RootTrackingFileSystemSnapshotHierarchyVisitor() {
            @Override

                }
                @Override
                public ImmutableSortedMap<String, FileSystemSnapshot> getResultingSnapshots() {
                    return resultingSnapshots;
                }
            };
        }

        private ImmutableSortedMap<String, FileSystemSnapshot> snapshotUnpackedData(CacheableEntity entity, Map<String, ? extends FileSystemLocationSnapshot> treeSnapshots) {

public class FileSystemSnapshotFilter {

    private FileSystemSnapshotFilter() {
    }

    public static FileSystemSnapshot filterSnapshot(SnapshottingFilter.FileSystemSnapshotPredicate predicate, FileSystemSnapshot unfiltered) {
        DirectorySnapshotBuilder builder = MerkleDirectorySnapshotBuilder.noSortingRequired();
        AtomicBoolean hasBeenFiltered = new AtomicBoolean();

    }

    @Override
    public Map<String, FileSystemLocationFingerprint> getFingerprints() {
        return Collections.emptyMap();
    }

    @Override
    public FileSystemSnapshot getSnapshot() {
        return FileSystemSnapshot.EMPTY;
    }

    @Override
    public ImmutableMultimap<String, HashCode> getRootHashes() {
        return ImmutableMultimap.of();
    }

    @Override