LinkedList<String> fromPath = splitPath(from);
        LinkedList<String> toPath = splitPath(to);
        List<String> relativePath = new ArrayList<String>();

        while (!fromPath.isEmpty() && !toPath.isEmpty() && fromPath.get(0).equals(toPath.get(0))) {
            fromPath.removeFirst();
            toPath.removeFirst();
        }
        for (String ignored : fromPath) {
            relativePath.add("..");

        def target = tmpDir.file("target").tap { Files.createSymbolicLink(it.toPath(), linked.toPath()) }

        when:
        deleter.ensureEmptyDirectory(target, true)

        then:
        target.assertIsEmptyDir()
        linked.assertIsEmptyDir()
        Files.readSymbolicLink(target.toPath()) == linked.toPath()
        content.assertDoesNotExist()
    }

class RelativePathUtilTest extends Specification {

    def "relative path from #fromPath to #toPath is #path"() {
        when:
        def from = new File(fromPath)
        def to = new File(toPath)

        then:
        RelativePathUtil.relativePath(from, to) == path

        where:
        fromPath | toPath  | path
        "a"      | "a/b"   | "b"
        "a"      | "a/b/a" | "b/a"

        }
    }

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

            String relativePath = adocDir.relativize(adocFile.toPath()).toString();
            File docInfo = new File(destinationDirectory, docInfoName);
            try {
                Files.write(docInfo.toPath(), Collections.singleton(String.format("<meta name=\"adoc-src-path\" content=\"%s\">", relativePath)), StandardOpenOption.CREATE);

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

        def cause = new RuntimeException()
        def exception = new ModuleVersionResolveException(newSelector(mid("a", "b"), "c"), cause)
        def onePath = exception.withIncomingPaths([[a, b, c]])
        def twoPaths = exception.withIncomingPaths([[a, b, c], [a, c]])

        expect:
        exception.message == 'Could not resolve a:b:c.'

        onePath.message == toPlatformLineSeparators('''Could not resolve a:b:c.
Required by:

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