// delete .gradle dir to simulate this
        when:
        file('.gradle').assertIsDir().deleteDir()
        outputAFile.makeOlder()
        outputBFile.makeOlder()
        succeeds "b"

        then:
        result.assertTasksNotSkipped(":a", ":b")

        when:
        file('build/b').deleteDir()
        succeeds "b"

        then:
        result.assertTasksNotSkipped(":b")

        lockFileReaderWriter = new LockFileReaderWriter(resolver, context, lockFile, listener)
    }

    def 'writes a unique lock file'() {
        when:
        lockDir.deleteDir()
        lockFileReaderWriter.writeUniqueLockfile([a: ['foo', 'bar'], b: ['foo'], c: []])

        then:

        """
        when:
        withBuildCache().run "customTask"
        then:
        result.assertTaskNotSkipped(":customTask")

        when:
        file("buildSrc/build").deleteDir()
        file("buildSrc/.gradle").deleteDir()
        cleanBuildDir()

        withBuildCache().run "customTask"
        then:
        result.groupedOutput.task(":customTask").outcome == "FROM-CACHE"
    }

                       TF_Status* status) {
  if (unlink(path) != 0)
    TF_SetStatusFromIOError(status, errno, path);
  else
    TF_SetStatus(status, TF_OK, "");
}

static void DeleteDir(const TF_Filesystem* filesystem, const char* path,
                      TF_Status* status) {
  if (rmdir(path) != 0)
    TF_SetStatusFromIOError(status, errno, path);
  else
    TF_SetStatus(status, TF_OK, "");
}

        sourceFile << """
            #include "directory"
"""

        and:
        outputs.snapshot { run "mainExecutable" }

        when:
        directoryHeader.deleteDir()
        directoryHeader << '#pragma message("NEW directory named header")'
        and:
        executer.withArgument("--info")
        run "mainExecutable"
        then:
        executedAndNotSkipped compileTask

                def ivyRepo = layout.buildDirectory.dir("ivyRepo").get().asFile
                doLast {
                    m2Repo.deleteDir()
                    ivyRepo.deleteDir()
                }
            }
            def sign = project.getProperty("sign")
            if (sign == 'skip') {
                tasks.withType(Sign)*.onlyIf { false }

		Creds:     credentials.NewStaticV4(ui.Credentials.AccessKey, ui.Credentials.SecretKey, ""),
		Secure:    globalIsTLS,
		Transport: globalRemoteFTPClientTransport,
	})
}

// DeleteDir implements ftpDriver
func (driver *ftpDriver) DeleteDir(ctx *ftp.Context, objPath string) (err error) {
	stopFn := globalFtpMetrics.log(ctx, objPath)
	defer stopFn(0, err)

	bucket, prefix := path2BucketObject(objPath)
	if bucket == "" {

            file("${outputDir}/data/input.txt")
        }

        String getTaskPath() {
            ":${taskName}"
        }

        void removeInputs() {
            inputFile.parentFile.deleteDir()
        }

        void createInputs() {
            inputFile.text = "input"
        }

        void outputsHaveBeenRemoved() {
            assert !outputFile.exists()

        when:
        run "sync"

        then:
        result.assertTaskSkipped(':sync')

        when:
        file("files/dir2").deleteDir()
        file("files/dir3/file3.txt") << ""
        run "sync"

        then:
        result.assertTaskNotSkipped(":sync")
        file("output").assertHasDescendants("file1.txt", "file3.txt")
    }

        gradleLauncherJar.parentFile.createDir()
        gradleLauncherJar.write('something')
        explodedZipDir.zipTo(new TestFile(zipDestination))
        explodedZipDir.deleteDir();
    }

    def "installs distribution and reuses on subsequent access"() {
        given:
        _ * pathAssembler.getDistribution(configuration) >> localDistribution