*/
fun FileSystemOperations.removeOldVersionsFromDir(dir: Directory, shouldDelete: Spec<GradleVersion>, dirPrefix: String = "", dirSuffix: String = "") {
    if (dir.asFile.isDirectory) {
        for (cacheDir in dir.asFile.listFiles()) {
            val cacheDirName = cacheDir.name
            if (!cacheDirName.startsWith(dirPrefix) || !cacheDirName.endsWith(dirSuffix)) {
                continue
            }

    private
    val taskPathReports: Map<String, List<File>>
        get() = parameters.taskPathToReports.get()

    private
    val rootBuildDir: File
        get() = parameters.rootBuildDir.get().asFile

    private
    val testPathToBinaryResultsDirs: Map<String, File>
        get() = parameters.testPathToBinaryResultsDirs.get()

    override fun onFinish(event: FinishEvent) {

fun Directory.parentOrRoot(): Directory = if (this.file("version.txt").asFile.exists()) {
    this
} else {
    val parent = dir("..")
    when {
        parent.file("version.txt").asFile.exists() -> parent
        this == parent -> throw IllegalStateException("Cannot find 'version.txt' file in root of repository")
        else -> parent.parentOrRoot()

## How the configuration works

We use Kotlin portable DSL to store TeamCity configuration, which means you can easily create a new pipeline
based on a specific branch. Currently, we have two pipelines: `master` and `release`, but you can easily create
and test another isolated pipeline from any branch. 

We'll explain everything via an example. Let's say you make some changes on your branch `myTestBranch`

        val unixScriptFile = startScriptsDir.file("gradle").get().asFile
        generator.generateUnixScript(unixScriptFile)
        unixScriptFile.injectAgentOptions(TextUtil.getUnixLineSeparator())

        val windowsScriptFile = startScriptsDir.file("gradle.bat").get().asFile
        generator.generateWindowsScript(windowsScriptFile)

@DisableCachingByDefault(because = "Not worth caching")
abstract class CheckSubprojectsInfo : SubprojectsInfo() {

    @TaskAction
    fun checkSubprojectsInfo() {
        if (subprojectsJson.asFile.readText() != generateSubprojectsJson()) {
            throw GradleException(
                "New project(s) added without updating subproject JSON. Please run `:${GenerateSubprojectsInfo.TASK_NAME}` task."
            )

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

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

        }
    }

    private
    fun buildErrorMessage(formattedMismatches: String): String {
        return "API changes in file '${apiChangesFile.get().asFile.name}' should be in alphabetical order (by type and member), yet these changes were not:\n" +
            "$formattedMismatches\n" +
            "\n" +

    @get:PathSensitive(PathSensitivity.NONE)
    abstract val apiChangesFile: RegularFileProperty

    protected
    fun loadChanges(): List<AcceptedApiChange> {
        val jsonString = apiChangesFile.get().asFile.readText()
        val json = Gson().fromJson(jsonString, AcceptedApiChanges::class.java)
        return json.acceptedApiChanges!!
    }

    /**
     * Sorts the given list of [AcceptedApiChange]s by type and member.

    @TaskAction
    fun execute() {
        val sortedChanges = sortChanges(loadChanges())
        val json = formatChanges(sortedChanges)
        apiChangesFile.asFile.get().bufferedWriter().use { out -> out.write(json) }
    }

    private
    fun formatChanges(changes: List<AbstractAcceptedApiChangesMaintenanceTask.AcceptedApiChange>): String {