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

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

    // Known output from Python smhasher
    HashCode foxHash =
        murmur3_128(0).hashString("The quick brown fox jumps over the lazy dog", Charsets.UTF_8);
    assertEquals("6c1b07bc7bbc4be347939ac4a93c437a", foxHash.toString());
  }

  private static void assertHash(int seed, long expected1, long expected2, String stringInput) {

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

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 =

        if (Files.isSymbolicLink(this.toPath())) {
            try {
                Files.delete(toPath());
            } catch (IOException e) {
                throw new UncheckedIOException(e);
            }
        }
        try {
            getParentFile().mkdirs();
            Files.createSymbolicLink(this.toPath(), target.toPath());
        } catch (IOException e) {

    @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);

    private void moveFile(File targetFile, File downloadFile) throws IOException {
        try {
            Files.move(downloadFile.toPath(), targetFile.toPath(), StandardCopyOption.ATOMIC_MOVE);
        } catch (AtomicMoveNotSupportedException e) {
            Files.move(downloadFile.toPath(), targetFile.toPath(), StandardCopyOption.REPLACE_EXISTING);
        }
    }

            switch (diff) {
                case FILE: {
                    Path expectedFile = buildDir.relativize(expected.getFile().toPath());
                    Path actualFile = buildDir.relativize(actual.getFile().toPath());
                    return "\t- file differs (relative to " + projectDisplayName + "): (expected) " + expectedFile + " != (actual) " + actualFile;
                }