Assume.assumeTrue(canCreateSymbolicLinkToDirectory())

        given:
        def keepTxt = tmpDir.createFile("originalDir", "keep.txt")
        def originalDir = keepTxt.parentFile
        def link = new File(tmpDir.getTestDirectory(), "link")

        when:
        createSymbolicLink(link, originalDir)

        then:
        link.exists()

        when:
        boolean didWork = delete(false, link)

    abstract String getForkOptionsObject()

    def "can provide relocatable command line arguments to forked daemons"() {
        def originalDir = file("original-dir")
        originalDir.file("settings.gradle") << localCacheConfiguration()
        setupProjectWithJavaAgentIn(originalDir)

        def relocatedDir = file("relocated-dir")
        relocatedDir.file("settings.gradle") << localCacheConfiguration()

    def "can follow symlinks"() {
        given:
        def keepTxt = temporaryFolder.createFile("originalDir", "keep.txt")
        def originalDir = keepTxt.getParentFile()
        def link = new File(temporaryFolder.getTestDirectory(), "link")
        fileSystem().createSymbolicLink(link, originalDir)

        when:
        delete.delete(link)
        delete.setFollowSymlinks(true)
        execute(delete)

    def "project is relocatable"() {
        def originalDir = file("original-dir")
        def originalJavaHome = Jvm.current().javaHome
        originalDir.file("settings.gradle") << localCacheConfiguration()
        setupProjectIn(originalDir)

        def relocatedDir = file("relocated-dir")
        def relocatedJavaHome = file("relocated-java-home")

        File originalDir = new File(System.getProperty("user.dir"))

        when:
        env.setProcessDir(tmpDir.testDirectory)

        then:
        env.processDir.canonicalFile == tmpDir.testDirectory
        new File(".").canonicalFile == tmpDir.testDirectory

        cleanup:
        System.setProperty("user.dir", originalDir.absolutePath)
        env.setProcessDir(originalDir)
    }

                source = file("source.txt")
                target = file("build/target.txt")
            }
        """

        def originalDir = file("original")
        def renamedDir = file("renamed")
        def projectDir = originalDir.file(*projectDirPath)
        def settingsFile = projectDir.file("settings.gradle")
        def buildFile = projectDir.file("build.gradle")

    }

    private JarTestFixture transformJar(TransformFactoryType factory, File originalJar) {
        def outputJar = testDir.file("transformed.jar")
        return new JarTestFixture(transform(factory, originalJar, outputJar), 'UTF-8', null, /* checkManifest */ false)
    }

    private TestFile transformDirectory(TransformFactoryType factory, File originalDir) {
        def outputDir = testDir.file("transformed")

                id 'base'
            }

            def originalDir = file('build/original')
            def backupDir = file('backup')

            task backup(type: Copy) {
                from originalDir
                into backupDir
            }

            task restore(type: Copy) {
                from backupDir
                into originalDir
            }
        """

        and:

        and:
        def originalDir = temporaryFolder.createDir("original")
        def relocatedDir = temporaryFolder.createDir("relocated")

        and:
        setupCopyOfSantaTracker(originalDir)
        setupCopyOfSantaTracker(relocatedDir)

        when: 'clean build'
        SantaTrackerConfigurationCacheWorkaround.beforeBuild(originalDir, homeDir)

        File originalJar = getInputArtifact().get().getAsFile();
        String originalJarName = originalJar.getName();

        if (isModule(originalJar)) {
            outputs.file(originalJar);
        } else if (moduleInfo.containsKey(originalJarName)) {
            addModuleDescriptor(originalJar, getModuleJar(outputs, originalJar), moduleInfo.get(originalJarName));