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)

        watchedWatchableHierarchies.forEach(absolutePath -> decrement(absolutePath, changedWatchDirectories));
        watchedWatchableHierarchies.clear();
        newWatchedFiles.visitRoots(absolutePath -> {
            watchedWatchableHierarchies.add(absolutePath);
            increment(absolutePath, changedWatchDirectories);
        });
        if (!changedWatchDirectories.isEmpty()) {

 */
public class FilePathWithType {
    private final String absolutePath;
    private final FileType fileType;

    public FilePathWithType(String absolutePath, FileType fileType) {
        this.absolutePath = absolutePath;
        this.fileType = fileType;
    }

    public String getAbsolutePath() {
        return absolutePath;
    }

    public FileType getFileType() {
        return fileType;
    }

            .withArgument("-Porg.gradle.java.installations.paths=${new File("/other/path").absolutePath}," + secondJavaHome)
            .withArgument("-Porg.gradle.java.installations.fromEnv=JDK1,JDK2")
            .withTasks("show")
            .run()
        then:

        when:
        configurationCacheRun 'build', '-I', initScript1.absolutePath, '-I', initScript2.absolutePath

        then:
        output.indexOf('initscript1!') < output.indexOf('initscript2!')
        configurationCache.assertStateStored()

        when:
        configurationCacheRun 'build', '-I', initScript2.absolutePath, '-I', initScript1.absolutePath

        then:

        when:
        def targetSnapshot = sourceSnapshot.relocate(targetFile.absolutePath, stringInterner)

        then:
        !targetSnapshot.present
    }

    private VfsRelativePath childAbsolutePath(String relativePath) {
        VfsRelativePath.of("${initialRoot.absolutePath}/${relativePath}", initialRoot.absolutePath.length() + 1)
    }

        assert rootProject.projectDir == testDirectory.absolutePath
        assert rootProject.buildFile == buildFile.absolutePath
        assert rootProject.children.size() == 3 // All projects are created when storing
        with(rootProject.children.first() as Map<String, Object>) {
            assert name == 'a'
            assert path == ':a'
            assert projectDir == file('a').absolutePath

        def dir = new File("empty").absoluteFile

        when:
        def watched = resolveWatchedFiles(watchable, buildHierarchy([
            directory(dir.absolutePath, [])
        ]))
        then:
        rootsOf(watched) == [dir.absolutePath]
        1 * watchable.stream() >> Stream.of(dir)
    }

    def "does not watch directory with only missing files inside"() {
        def watchable = Mock(WatchableHierarchies)