FileType previousFingerprintType = previousFingerprint.getType();
        String absolutePath = pathWithType.getAbsolutePath();

        List<FilePathWithType> filePathWithTypes = addedFilesByNormalizedPath.get(normalizedPath);
        Optional<FilePathWithType> match = filePathWithTypes.stream().filter(file -> absolutePath.equals(file.getAbsolutePath())).findFirst();
        return match
            .map(filePathWithType -> {

public abstract class AbstractFileSystemLocationSnapshot implements FileSystemLocationSnapshot {
    private final String absolutePath;
    private final String name;
    private final AccessType accessType;

    public AbstractFileSystemLocationSnapshot(String absolutePath, String name, AccessType accessType) {
        this.absolutePath = absolutePath;
        this.name = name;
        this.accessType = accessType;
    }

        then:
        visited.contains(rootTextFile.absolutePath)
        visited.contains(nestedTextFile.absolutePath)
        !visited.contains(notTextFile.absolutePath)
        !visited.contains(excludedFile.absolutePath)
        !visited.contains(notUnderRoot.absolutePath)
        !visited.contains(doesNotExist.absolutePath)

        where:
        walkerInstance << walkers
    }

configurations {
    compile
}
dependencies {
    repositories {
        ivy {
            artifactPattern projectDir.absolutePath + '/[module]-[revision].jar'
            ivyPattern projectDir.absolutePath + '/[module]-[revision]-ivy.xml'
        }
    }
    compile 'test:projectA:1.2'
}

file("projectA-1.2.jar").text = ''

                break;
        }
        1 * windowsRegistry.getStringValue(_, foundIn, "14.0") >> dir1.createDir("VC").absolutePath
        1 * windowsRegistry.getStringValue(_, foundIn, "12.0") >> dir2.createDir("VC").absolutePath
        1 * windowsRegistry.getStringValue(_, foundIn, "11.0") >> dir3.createDir("VC").absolutePath

        and:
        metadata.size() == 3
        metadata[0].installDir == dir1

        assert snapshot.absolutePath == file.absolutePath
        assert snapshot.name == file.name
        assert snapshot.type == FileType.RegularFile
        assert snapshot.hash == hashFile(file)
    }

    void assertIsMissingFileSnapshot(FileSystemLocationSnapshot snapshot, File file) {
        assert snapshot.absolutePath == file.absolutePath
        assert snapshot.name == file.name

        def directories = supplier.get()

        then:
        directoriesAsStablePaths(directories) == stablePaths([
            new File("/usr/lib/jvm/adoptopenjdk-16.jdk").absolutePath,
            new File("/usr/lib/jvm/temurin-17.jdk").absolutePath
        ])
        directories*.source == ["Maven Toolchains", "Maven Toolchains"]

        where:
        useProperty << [true, false]
    }

        execOps.exec {
            executable = javaExecutable.get().asFile.absolutePath
            args = ["-version"]
            standardOutput = outputBytes
            errorOutput = outputBytes
        }
        assert outputBytes.toString("UTF-8").contains("version \"11"):
            "unexpected '${javaExecutable.get().asFile.absolutePath} -version' output"
    }
}

        File parent = Paths.get(sourceFolder.absolutePath, "src", "main", "java", packageFolder).toFile()
        File f = Paths.get(parent.absolutePath, "${className}.java").toFile()
        parent.mkdirs()
        f.text = body
        return [f]
    }

    List<File> toModuleSourceFile(String body) {
        def className = "module-info"
        File parent = Paths.get(sourceFolder.absolutePath, "src", "main", "java").toFile()

     */
    Optional<MetadataSnapshot> findMetadata(String absolutePath);

    /**
     * Returns the snapshot stored at the absolute path if one exists.
     */
    default Optional<FileSystemLocationSnapshot> findSnapshot(String absolutePath) {
        return findMetadata(absolutePath)
            .filter(FileSystemLocationSnapshot.class::isInstance)