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

class UnixDerivativeSymlinkDeleterTest extends AbstractSymlinkDeleterTest {
    @Override
    protected void createSymbolicLink(File link, TestFile target) {
        Files.createSymbolicLink(link.toPath(), target.toPath())
    }

    @Override
    protected boolean canCreateSymbolicLinkToFile() {
        return true
    }

    @Override
    protected boolean canCreateSymbolicLinkToDirectory() {
        return true

        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()

        roCacheDir = temporaryFolder.createDir("read-only-cache")
        def cachePath = roCacheDir.toPath()
        doCopy(metadataCacheDir, cachePath, CacheLayout.MODULES)

        roCacheDir
    }

    private void doCopy(File cacheDir, Path cachePath, CacheLayout entry) {
        if (cacheDir.exists()) {
            Files.move(cacheDir.toPath(), cachePath.resolve(entry.key))
        }
    }

        final PosixFileAttributes posixFileAttributes = Files.readAttributes(file.toPath(), PosixFileAttributes.class);
        return convertToInt(posixFileAttributes.permissions());
    }

    @Override
    public void chmod(File f, int mode) throws IOException {
        PosixFileAttributeView fileAttributeView = Files.getFileAttributeView(f.toPath(), PosixFileAttributeView.class);

     * @return The relative path
     */
    public static String relativePath(File from, File to) {
        logDeprecation();
        try {
            return TextUtil.normaliseFileSeparators(from.toPath().relativize(to.toPath()).toString());
        } catch (Exception e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.asRequestBody
import okio.Path.Companion.toPath
import okio.buffer
import okio.fakefilesystem.FakeFileSystem

class PostPath {
  private val client = OkHttpClient()
  private val fileSystem = FakeFileSystem()
  val path = "test.json".toPath()

  fun run() {
    fileSystem.write(path) {
      writeUtf8("{}")
    }

    val request =

    @Override
    public Path getPath() {
        return path;
    }

    public void merge(File existing, File result) throws RepositoryException {
        merge(existing != null ? existing.toPath() : null, result != null ? result.toPath() : null);
    }

    @Override
    public void merge(Path existing, Path result) throws RepositoryException {
        Metadata recessive = read(existing);

        merge(recessive);

        return manifestFile;
    }

    @TaskAction
    public void generate() {
        DefaultPackage srcPackage = (DefaultPackage) packageProperty.get();
        Path manifest = manifestFile.get().getAsFile().toPath();
        try {
            Path baseDir = manifest.getParent();
            Files.createDirectories(baseDir);
            PrintWriter writer = new PrintWriter(Files.newBufferedWriter(manifest, Charset.forName("utf-8")));