// Do nothing
    }

    @SuppressWarnings("GrMethodMayBeStatic")
    protected void removeResults(TestFile projectDir) {
        projectDir.file("build").deleteDir()
    }

    @SuppressWarnings("GrMethodMayBeStatic")
    protected void assertResultsEqual(def originalResult, def relocatedResult) {
        assert relocatedResult == originalResult
    }

// tag::adhoc-destroyable-task[]
tasks.register('removeTempDir') {
    def tempDir = layout.projectDirectory.dir('tmpDir')
    destroyables.register(tempDir)
    doLast {
        tempDir.asFile.deleteDir()
    }
}
// end::adhoc-destroyable-task[]

tasks.named('build') {
    dependsOn processTemplates, 'processTemplatesAdHoc', 'processTemplatesAdHocSkipWhenEmpty', 'processTemplatesWithExtraInputs'

        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "supplies no installations for non-existing directory"() {
        given:
        assert candidates.deleteDir()

        when:
        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "supplies single installations for single candidate"() {
        given:

     */
    @OutputDirectory
    final File outputDirectory = project.layout.buildDirectory.dir("$name").get().asFile

    @TaskAction
    void checkoutAndCopy() {
        outputDirectory.deleteDir()
        File checkoutDir = checkout(fsOps, execOps, remoteUri.get(), ref.get(), temporaryDir)
        moveToOutputDir(checkoutDir, outputDirectory, subdirectory.getOrNull())
    }

        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "supplies no installations for non-existing directory"() {
        given:
        assert candidates.deleteDir()

        when:
        def directories = supplier.get()

        then:
        directories.isEmpty()
    }

    def "supplies single installations for single candidate"() {
        given:

    }

    void deleteCacheEntry(String cacheKey) {
        def entry = getTestFileCacheEntry(cacheKey)
        if (entry.file.exists()) {
            entry.file.deleteDir()
        }
    }

    boolean hasCacheEntry(String cacheKey) {
        return getTestFileCacheEntry(cacheKey).file.exists()
    }

    TestCacheEntry getCacheEntry(String cacheKey) {

        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:

        def originalBuildSrcJarState = originalBuildSrcJar.snapshot()

        and: // Remove the src directory, leaving only the generated jar
        file("buildSrc/src").deleteDir()

        and: // Run another build, checking that `buildSrc.jar` is not in the class path
        buildFile << """
            try {
                getClass().classLoader.loadClass("org.acme.build.SomeBuildSrcClass")

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

            reportsDir.file('numbers.csv').touch()

            executer.inDirectory(dslDir)
            succeeds("moveReports", "--rerun-tasks")

            dslDir.file("build/toArchive").deleteDir()
        }

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("files/misc")
    def "can delete a directory with #dsl dsl"() {
        given: