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 static void assertJarContainsAllEntries(final File jar, final Set<String> entries) {
        ZipFile originalJar = new ZipFile(jar)

        originalJar.withCloseable {
            Enumeration<? extends ZipEntry> enumeration = originalJar.entries()
            while (enumeration.hasMoreElements()) {
                ZipEntry entry = enumeration.nextElement()

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

	originalGVRs, originalErr := m.Delegate.ResourcesFor(partiallySpecifiedResource)
	if originalErr != nil && len(originalGVRs) == 0 {
		return schema.GroupVersionResource{}, originalErr
	}
	if len(originalGVRs) == 1 {
		return originalGVRs[0], originalErr
	}

	remainingGVRs := append([]schema.GroupVersionResource{}, originalGVRs...)

		filepath.Join(subDir, constants.APIServerKeyName):  filepath.Join(tmpdir, constants.APIServerKeyName),
	}

	errString := "there are files need roll back"
	originalErr := errors.New(errString)
	err = rollbackFiles(filesToRollBack, originalErr)
	if err == nil {
		t.Fatalf("Expected error contains %q, got nil", errString)
	}
	if !strings.Contains(err.Error(), errString) {