hashCodeFor(
                containerElements = listOf(
                    entry<TaskContainer, Delete>("clean")
                )
            ),
            equalTo(
                hashCodeFor(
                    containerElements = listOf(
                        entry<TaskContainer, Delete>("clean")
                    )
                )
            )
        )

        assertThat(

        val taskProvider = mockTaskProviderFor(mock<Delete>())
        val tasks = mock<TaskContainer> {
            on { register("clean", Delete::class.java) } doReturn taskProvider
        }

        tasks {

            val clean by registering(Delete::class)

            inOrder(tasks, taskProvider) {
                verify(tasks).register("clean", Delete::class.java)
                verifyNoMoreInteractions()

                delete("some")
            }
            getByName<Delete>("clean") {
                delete("stuff")
            }
            "clean"(type = Delete::class) {
                delete("things")
            }
        }

        tasks.getByName<Delete>("clean") {
            delete("build")
        }

        inOrder(clean) {
            verify(clean).delete("stuff")

git rm -r nested
git commit -m 'nested: delete subdirectory'

git show-ref --tags --heads
cmp stdout .git-refs

git log --pretty=oneline
cmp stdout .git-log

-- .git-refs --
f213069baa68ec26412fb373c7cf6669db1f8e69 refs/heads/main
08a4fa6bb9c04ffba03b26ae427b0d6335d90a2a refs/tags/has-nested
-- .git-log --
f213069baa68ec26412fb373c7cf6669db1f8e69 nested: delete subdirectory

            val tempFile = canonicalScriptFileFor(tempDir, scriptPath, scriptText)
            try {
                action(tempFile)
            } finally {
                tempFile.delete()
            }
        } finally {
            tempDir.delete()
        }
    }


private
fun canonicalScriptFileFor(baseDir: File, scriptPath: String, scriptText: String): File =
    baseDir.resolve(scriptFileNameFor(scriptPath)).run {

                    continue
                }

            if (shouldDelete(cacheVersion)) {
                logger.lifecycle("Removing old cache directory : $cacheDir")
                delete {
                    delete(cacheDir)
                }
            }
        }
    }
}


fun FileSystemOperations.removeCachedScripts(cachesDir: File) {
    if (cachesDir.isDirectory) {
        cachesDir.listFiles()

                            entry<Project, CustomConvention>("customConvention")
                        ),
                        tasks = listOf(
                            entry<TaskContainer, Delete>("delete")
                        ),
                        configurations = listOf(
                            ConfigurationEntry("api"),
                            ConfigurationEntry("compile", listOf("api", "implementation"))

            File(this, "gradle").writeText("stub")
            File(this, "gradle.exe").writeText("stub")
        }

        assertFails("Install directory $target does not look like a Gradle installation. Cannot delete it to install.")
        assertTargetIsPreserved()
    }

    @Test
    fun `does not install to non-empty dir with empty lib`() {
        target.resolve("bin").apply {
            mkdir()

    override fun mkdir(path: Any): File =
        fileOperations.mkdir(path)

    override fun delete(vararg paths: Any): Boolean =
        fileOperations.delete(*paths)

    override fun delete(configuration: Action<DeleteSpec>): WorkResult =
        fileOperations.delete(configuration)

    override fun exec(configuration: Action<ExecSpec>): ExecResult =
        processOperations.exec(configuration)

go test -fuzz=FuzzY -fuzztime=100x .
go run ./contains_files $GOCACHE/fuzz/example.com/y/FuzzY

# 'go clean -cache' should not delete the fuzz cache.
go clean -cache
exists $GOCACHE/fuzz

# 'go clean -fuzzcache' should delete the fuzz cache but not the build cache.
go build -x ./empty
stderr '(compile|gccgo)( |\.exe).*empty.go'
go clean -fuzzcache
! exists $GOCACHE/fuzz
go build -x ./empty