public Optional<FileSystemLocationSnapshot> findSnapshot(String absolutePath) {
        return root.findSnapshot(absolutePath);
    }

    @Override
    public Optional<MetadataSnapshot> findMetadata(String absolutePath) {
        return root.findMetadata(absolutePath);
    }

    @Override
    public Stream<FileSystemLocationSnapshot> findRootSnapshotsUnder(String absolutePath) {
        return root.rootSnapshotsUnder(absolutePath);
    }

            apply from: "${normaliseFileSeparators(otherScript2.absolutePath)}"
        """
        def initScript = file("init.gradle") << """
            apply from: "${normaliseFileSeparators(otherScript1.absolutePath)}"
        """

        when:
        succeeds "help", "-I", initScript.absolutePath

        then:
        def ops = operations.all(ApplyScriptPluginBuildOperationType) {

    }

    FileSystemLocationSnapshot regularFile(String absolutePath, FileMetadata.AccessType accessType = DIRECT) {
        regularFile(absolutePath, accessType, null)
    }

    FileSystemLocationSnapshot regularFile(String absolutePath, @Nullable Long hashCode) {
        regularFile(absolutePath, DIRECT, hashCode)
    }

    FileSystemLocationSnapshot regularFile(String absolutePath, FileMetadata.AccessType accessType, @Nullable Long hashCode) {

            targetDir.file("child").absolutePath,
            targetDir.file("child/child.txt").absolutePath,
            targetDir.file("parent.txt").absolutePath,
        ] as Set

        index.values()*.name as Set == [
            targetDir.name,
            childDir.name,
            childFile.name,
            parentFile.name,
        ] as Set

        index.values().forEach(this::assertInterned)
    }

        hierarchy.recordNodeAccessingLocations(rootNode, [root.absolutePath])
        hierarchy.recordNodeAccessingLocations(node1, [root.file("location").absolutePath])
        hierarchy.recordNodeAccessingLocations(node2, [root.file("sub/location").absolutePath])
        hierarchy.recordNodeAccessingLocations(node3, [root.file("third/within").absolutePath])

        vswhereInProgramFiles()

        expect:
        locator.getVswhereInstall().absolutePath == vswhere.absolutePath
    }

    def "finds vswhere executable in Program Files (X86)"() {
        given:
        vswhereInProgramFilesX86()

        expect:
        locator.getVswhereInstall().absolutePath == vswhere.absolutePath
    }

    def "finds vswhere executable in system path"() {
        given:

        then:
        result == hash

        and:
        1 * timeStampInspector.timestampCanBeUsedToDetectFileChange(file.absolutePath, stat.lastModified) >> true
        1 * cache.getIfPresent(file.absolutePath) >> null
        1 * target.hash(file) >> hash
        1 * cache.put(file.absolutePath, _) >> { String key, FileInfo fileInfo ->
            assert fileInfo.hash == hash
            assert fileInfo.length == stat.length

        when:
        generateFile(moduleMapFile, "foo", [headers.absolutePath, moreHeaders.absolutePath, new File('does-not-exist').absolutePath])

        then:
        normaliseLineSeparators(moduleMapFile.text) == """module foo {
\tumbrella "${headers.absolutePath}"
\tumbrella "${moreHeaders.absolutePath}"
\texport *
}
"""
    }

    def "creates parent directory if necessary"() {

    public Stream<FileSystemLocationSnapshot> rootSnapshotsUnder(String absolutePath) {
        return getNode(absolutePath)
            .map(FileSystemNode::rootSnapshots)
            .orElseGet(Stream::empty);
    }

    private Optional<FileSystemNode> getNode(String absolutePath) {
        VfsRelativePath relativePath = VfsRelativePath.of(absolutePath);
        return relativePath.isEmpty()
            ? Optional.of(rootNode)

        def process = [dumpbin.absolutePath, '/LIST', binaryFile.absolutePath].execute(["PATH=$vcPath"], null)
        return process.inputStream.readLines().drop(3).collect { new File(it).name }
    }

    List<String> listLinkedLibraries() {
        def dumpbin = findExe("dumpbin.exe")
        def process = [dumpbin.absolutePath, '/IMPORTS', binaryFile.absolutePath].execute(["PATH=$vcPath"], null)