then:
        settings.rootProject.children.size() == 2
        testDescriptor(settings.project(":" + projectA), projectA, new File(settingsDir.parentFile, projectA))
        testDescriptor(settings.project(":" + projectB), projectB, new File(settingsDir.parentFile, projectB))

        where:

            switch (change.changeType) {
                case ADDED:
                case MODIFIED:
                    println("Processing file ${changedFile.name}")
                    outputLocation.parentFile.mkdirs()

                    outputLocation.text = changedFile.readLines().size()

                case REMOVED:
                    println("Removing leftover output file ${outputLocation.name}")

include("web")
include("java1")
include("java2")
include("groovy")
        """

        def webBuildFile = getFile(project: "web", "build.gradle")
        createJavaSourceDirs(webBuildFile)
        webBuildFile.parentFile.file("src/main/webapp").createDir()

        webBuildFile << """
apply plugin: "eclipse-wtp"
apply plugin: "war"

repositories {
    maven { url "${repoDir.toURI()}" }
}

dependencies {

    destinationFile = apiDeclarationPropertiesFile
}

sourceSets.main {
    output.dir(mapOf("builtBy" to apiDeclaration), apiDeclarationPropertiesFile.map { it.asFile.parentFile })
}

fun generatedPropertiesFileFor(name: String) =

    operator fun String.unaryPlus(): File =
        canonicalFile(this).apply { mkdirs() }

    fun withFile(fileName: String, content: String = ""): File =
        canonicalFile(fileName).apply {
            parentFile.mkdirs()
            writeText(content)
        }

    fun existing(fileName: String): File =
        canonicalFile(fileName).also {
            require(it.exists()) { "$it doesn't exist" }
        }

class TestFilesCleanupServiceTest {
    @TempDir
    lateinit var projectDir: File

    private
    fun File.mkdirsAndWriteText(text: String) {
        parentFile.mkdirs()
        writeText(text)
    }

    @BeforeEach
    fun setUp() {
        projectDir.resolve("settings.gradle.kts").writeText(
            """
            include(":failed-test-with-leftover")

    def setup() {
        def archive = project.file("archive.tar.gz")
        def archiveEntry = project.file("archive/path/to/text")
        archiveEntry.parentFile.mkdirs()
        archiveEntry.text = "contents"
        project.ant.tar(basedir: project.file("archive"), destfile: archive, compression: "gzip")

        moduleIdentity.baseName.map { "generated-resources/$it-parameter-names/$it-parameter-names.properties" }
    )
}

main.output.dir(
    parameterNamesIndex.map { it.destinationFile.get().asFile.parentFile }

        return new GradleDistDirs(
            createVersionSpecificCacheDir(distVersion, lastUsed),
            createDistributionChecksumDir(distVersion).parentFile,
            createCustomDistributionChecksumDir(customDistName, distVersion).parentFile
        )
    }

    static class GradleDistDirs {
        private final TestFile cacheDir
        private final TestFile distDir

                @Inject abstract ArchiveOperations getArchives()
                @TaskAction def action() {
                    def outFile = outputFile.get().asFile
                    outFile.parentFile.mkdirs()
                    outFile.text = archives.${archiveType}(inputFile.get().asFile).read().text
                }
            }

            tasks.register("myTask", MyTask) {