def "can add dir to empty set"() {
        def empty = EMPTY
        def dir1 = tmpDir.createDir("dir1")
        def dir2 = tmpDir.createDir("dir2")

        def dir1Snapshot = snapshotDir(dir1)
        def dir2Snapshot = snapshotDir(dir2)
        expect:
        def s1 = empty.store(dir1.absolutePath, dir1Snapshot, diffListener)
        assertDirectorySnapshot(s1, dir1)
        assertHasNoMetadata(s1, dir2)

     */
    ValueSnapshot snapshot(@Nullable Object value, ValueSnapshotter snapshotter);

    def virtualFileSystem = TestFiles.virtualFileSystem()
    def fileSystemAccess = TestFiles.fileSystemAccess(virtualFileSystem)
    def snapshotter = new DefaultFileCollectionSnapshotter(fileSystemAccess, TestFiles.fileSystem())
    def fingerprinter = new AbsolutePathFileCollectionFingerprinter(DirectorySensitivity.DEFAULT, snapshotter, FileSystemLocationSnapshotHasher.DEFAULT)
    def executionHistoryStore = new TestExecutionHistoryStore()

    def "loads from cache"() {
        def cachedOriginMetadata = Stub(OriginMetadata)
        cachedOriginMetadata.executionTime >> Duration.ofSeconds(1)
        def outputsFromCache = snapshotsOf("test": [])
        def localStateFile = file("local-state.txt") << "local state"

        when:
        def result = step.execute(work, context)

        then:
        result.execution.get().outcome == FROM_CACHE

class DirectorySnapshotterAsDirectoryWalkerTest extends AbstractDirectoryWalkerTest<DirectorySnapshotter> {
    Consumer<FileSystemLocationSnapshot> completeSnapshotConsumer = Stub()

    def "directory snapshotter returns the same details as directory walker"() {
        given:
        def rootDir = tmpDir.createDir("root")
        generateFilesAndSubDirectories(rootDir, 10, 5, 3, 1, new AtomicInteger())

        File original,
        ClasspathFileTransformer transformer,
        Set<HashCode> seen,
        InstrumentationTypeRegistry typeRegistry
    ) {
        FileSystemLocationSnapshot snapshot = snapshotOf(original);
        if (snapshot.getType() == FileType.Missing) {
            return empty();
        }
        if (shouldUseFromCache(original)) {
            final HashCode contentHash = snapshot.getHash();

        cleanupRegistry,
        deleter,
        outputChangeListener,
        outputFilesRepository,
        delegate)

    def outputFile = file("output.txt").text = "output"
    def outputFilesProducedByWork = snapshotsOf(output: outputFile)
    def afterExecutionState = Stub(AfterExecutionState) {
        getOutputFilesProducedByWork() >> outputFilesProducedByWork
    }

    def delegateResult = Mock(AfterExecutionResult)

type FileSnapshot struct {
	root             string
	domainSuffix     string
	configTypeFilter map[config.GroupVersionKind]bool
}

// NewFileSnapshot returns a snapshotter.
// If no types are provided in the descriptor, all Istio types will be allowed.
func NewFileSnapshot(root string, schemas collection.Schemas, domainSuffix string) *FileSnapshot {
	snapshot := &FileSnapshot{

        @Provides
        InputFingerprinter createInputFingerprinter(
            FileCollectionSnapshotter snapshotter,
            FileCollectionFingerprinterRegistry fingerprinterRegistry,
            ValueSnapshotter valueSnapshotter
        ) {
            return new DefaultInputFingerprinter(snapshotter, fingerprinterRegistry, valueSnapshotter);
        }

        @Provides

    }

    @Override
    public ValueSnapshot snapshot(@Nullable Object value, ValueSnapshotter snapshotter) {
        PrimitiveType valueType = PrimitiveType.maybeOfValue(value);
        if (primitiveType == valueType && primitiveType.equals(array, value)) {
            return this;
        }
        ValueSnapshot snapshot = snapshotter.snapshot(value);
        if (snapshot.equals(this)) {
            return this;
        }