connection.notifyDaemonsAboutChangedPaths(toPaths(changedPaths))
        }

        then:
        toolingApi.daemons.daemons.empty
    }

    @TargetGradleVersion(">=6.1")
    def "changed paths need to be absolute"() {
        changedPaths = ["some/relative/path"]

        when:
        withConnection { connection ->
            connection.notifyDaemonsAboutChangedPaths(toPaths(changedPaths))
        }

        then:

                }
            }

            task transform(type: TransformTask) {
                inputFile = file("file1.txt").toPath()
                inputDir = file("dir1").toPath()
                outputFile = file("build/file1.txt").toPath()
                outputDir = file("build/dir1").toPath()
            }
"""

        when:
        file("file1.txt").text = "123"
        file("dir1/file2.txt").text = "1234"

        try {
            Files.createDirectories(parentDir.toPath());
            inPlaceBuilder.jar(tmpFile, action);
            Files.move(tmpFile.toPath(), jarFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
        } finally {
            Files.deleteIfExists(tmpFile.toPath());
        }
    }

    private void buildDirectory(File destinationDir, Action action) throws IOException {

                "Files.newByteChannel(File(\"$filePath\").toPath()).close()"
            }

            @Override
            String getJavaExpression() {
                """
                ((Supplier<Object>) () -> {
                    try {
                        Files.newByteChannel(new File("$filePath").toPath()).close();
                    } catch (IOException e) {

    }

    @Override
    public void writeDependencyAnalysis(File output, InstrumentationDependencyAnalysis dependencyAnalysis) {
        try (KryoBackedEncoder encoder = new KryoBackedEncoder(Files.newOutputStream(output.toPath()))) {
            writeMetadata(dependencyAnalysis.getMetadata(), encoder);
            HierarchicalNameSerializer nameSerializer = new HierarchicalNameSerializer(stringInterner);

            throw UnsupportedOperationException()

        override fun delete() {
            if (file.exists()) {
                Files.delete(file.toPath())
            }
        }

        override fun moveFrom(file: File) {
            Files.move(file.toPath(), this.file.toPath(), StandardCopyOption.ATOMIC_MOVE)
        }

        override fun stateFileForIncludedBuild(build: BuildDefinition): ConfigurationCacheStateFile =

        }
    }

    private static void buildJar(File jarFile, Action action) throws IOException {
        Files.createDirectories(jarFile.getParentFile().toPath());
        try (ZipArchiveOutputStream outputStream = new ZipArchiveOutputStream(new BufferedOutputStream(Files.newOutputStream(jarFile.toPath()), BUFFER_SIZE))) {
            outputStream.setLevel(0);
            action.execute(new ZipEntryBuilder(outputStream));
        }
    }

        missing = new File(UUID.randomUUID().toString());
        missingPath = missing.toPath();
        directory = File.createTempFile("jmh", "dir");
        directoryPath = directory.toPath();
        directory.mkdirs();
        realFile = File.createTempFile("jmh", "tmp");
        realFilePath = realFile.toPath();

        FileOutputStream fos = new FileOutputStream(realFile);
        fos.write(new byte[1024]);

        return "Build cache"
    }

    @Override
    void createBuildCacheEntry(String key, File value, long timestamp) {
        File cacheFile = cacheDir.file(key)
        Files.copy(value.toPath(), cacheFile.toPath())
        writeLastFileAccessTimeToJournal(cacheFile, timestamp)
    }

    @Override
    boolean existsBuildCacheEntry(String key) {
        cacheDir.file(key).exists()
    }

    @Override

        for (File classpathEntry : spec.getCompileClasspath()){
            classpath.add(CONVERTER.toVirtualFile(classpathEntry.toPath()));
        }
        List<VirtualFile> sourceFiles = new LinkedList<>();
        for(File f: spec.getSourceFiles()){
            sourceFiles.add(CONVERTER.toVirtualFile(f.toPath()));
        }
        CompileOptions compileOptions = CompileOptions.create()