1 * snapshot.asFileSystemNode() >> newGrandChild
        _ * newGrandChild.snapshot >> Optional.of(snapshot)
        _ * selectedChild.snapshot >> Optional.empty()
        1 * snapshot.type >> fileType
        interaction { noMoreInteractions() }

        where:
        vfsSpecWithFileType << [COMMON_PREFIX, [FileType.RegularFile, FileType.Directory]].combinations()
        vfsSpec = vfsSpecWithFileType[0] as VirtualFileSystemTestSpec

        return askUser(interaction -> interaction.askYesNoQuestion(question)).getOrNull();
    }

    /**
     * Ask the user one or more questions to produce a value of type {@link T}.
     */
    <T> Provider<T> askUser(Function<? super UserQuestions, ? extends T> interaction);

    /**
     * Return true if the user input has been interrupted, e.g. via Ctrl+C or some interaction with the client UI.
     */

        then:
        interaction compilerShouldBeExecuted

        when:
        def secondMetadata = metadataProvider(compiler).getCompilerMetaData([]) { it.executable(secondBinary) }

        then:
        interaction compilerShouldBeExecuted
        firstMetadata != secondMetadata

        when:

        resultRoot.children == children
        removedNodes == [initialRoot.getSnapshot().get()]
        addedNodes == children.stream().map(ChildMap.Entry::getValue).toList()
        interaction { noMoreInteractions() }

        where:
        vfsSpec << onlyDirectChildren(NO_COMMON_PREFIX)
    }

    def "invalidate a single child creates a partial directory node without the child (#vfsSpec)"() {

        result == delegateResult

        interaction { withValidCacheKey() }

        then:
        _ * work.allowedToLoadFromCache >> false

        then:
        1 * delegate.execute(work, context) >> delegateResult
        1 * delegateResult.execution >> Try.successful(execution)
        1 * execution.canStoreOutputsInCache() >> true

        then:
        interaction { outputStored {} }
        0 * _
    }

        then:
        resultRoot.children == childrenWithSelectedChildRemoved()
        isSameNodeType(resultRoot)
        removedNodes == [selectedChild]
        addedNodes.empty
        interaction { noMoreInteractions() }

        where:
        vfsSpec << (IS_PREFIX_OF_CHILD + SAME_PATH).findAll { it.childPaths.size() > 1 }
    }

        outputs.snapshot()
        outputs.dir.file("some/notOutput1.txt") << "notOutput1"
        outputs.dir.createDir("some/notOutput2")

        when:
        step.execute(work, context)
        then:
        interaction {
            cleanupOverlappingOutputs(outputs)
        }
        1 * delegate.execute(work, context) >> delegateResult
        0 * _

        !outputs.file.exists()

        and:
        interaction {
            snapshotRegularFile(file)
        }
        1 * calculator.calculate(file, true) >> 12
        0 * _

        when:
        listenerManager.getBroadcaster(OutputChangeListener).invalidateCachesFor([])
        result = cache.get(file)

        then:
        result == 12

        and:
        interaction {
            snapshotRegularFile(file)

        then:
        interaction {
            receivesChanges(change1, change2, change3)
        }
        0 * _

        when:
        cachingChanges.accept(new CollectingChangeVisitor())
        cachingChanges.accept(collectingVisitor)
        def reported = collectingVisitor.changes

        then:
        interaction {
            receivesChanges(change1, change2, change3)

}

type ResolvedData[T ResolvedDataConstraint] map[uint64]T

type ResolvedDataConstraint interface {
	User | Message
}

type User struct{}

type Message struct {
	Interaction *Interaction[[]byte] `json:"interaction,omitempty"`