}
            gradle.serviceOf<BuildEventsListenerRegistry>().onTaskCompletion(buildService)
            gradleRootProject.extensions.extraProperties.set("collectedInfo-${klass.simpleName}-${rootProjectName}", buildService.get().collectedInformation)

    REPO=$dir
    if [ -e ${'$'}REPO ] ; then
        tree ${'$'}REPO
        rm -rf ${'$'}REPO
        echo "${'$'}REPO was polluted during the build"
        ${if (exitOnFailure) "exit 1" else ""}
    else
        echo "${'$'}REPO does not exist"
    fi

""".trimIndent()

fun checkCleanDirWindows(dir: String, exitOnFailure: Boolean = true) = """
    IF exist $dir (
        TREE $dir

# Development best practices

This is a collection of best practices for Gradle implementation.
Should and should not do's.

## Error messages and suggestions

Traditionally, if an error occurred, the error message and the possible solution were provided to the console via a single String in the corresponding exception.
That meant possible solutions for Problems could be scattered all over the console output.

# Each automation has an `if` key that defines conditions to run the automation,
# as well as a `run` key with the actions to do. All the conditions need to be true
# for the actions to run (there is an implicit AND relation between
# the conditions on each line).  Each condition is specified as a Jinja expression.  You
# can also use the constant `true` if you want to always run the actions.

        val monitoredTaskPaths: SetProperty<String>
    }

    override fun onFinish(event: FinishEvent) {
        if (event !is TaskFinishEvent) {
            return
        }

        val taskPath = event.descriptor.taskPath
        if (shouldInclude(taskPath)) {
            action(taskPath, event.result)
        }
    }

        if (!milestone.isPresent) {
            throw IllegalStateException("Milestone not set: please rerun the task with `--milestone <milestone>`")
        }
        val prs: MutableList<GitHubPullRequest> = mutableListOf()
        (1..10).forEach { page ->
            val prPage = getMergedContributorPullRequests(page)
            prs.addAll(prPage)
            if (prPage.size < pageSize) {

    @get:Inject
    internal
    abstract val classLoaderFactory: ClassLoaderFactory

    @TaskAction
    fun generate(): Unit =
        destinationFile.get().asFile.let {
            if (sources.isEmpty) it.writeText("")
            else generateParameterNamesResource(sources.files, classpath.files, it)
        }

    private

            else -> throw IllegalArgumentException("Expected ResolvedDependencyResult")
        }

        if (dependency.isConstraint) {
            continue
        }

        val to = dependency.resolvedVariant

        when (val fromComponent = dependency.from.id) {
            is ProjectComponentIdentifier -> if (fromComponent != rootComponent.id) {

            allowEmpty = true,
            description = "Set to 'true' if you want to skip all dependency builds"
        )
    }

    var prevStage: Stage? = null
    val previousPerformanceTestPasses: MutableList<PerformanceTestsPass> = mutableListOf()
    model.stages.forEach { stage ->
        if (isSecurityFork() && stage.stageName > StageName.READY_FOR_RELEASE) {
            return@forEach
        }

        val templateVersionConfiguration = project.configurations.detachedConfiguration(*libDependencies)
        templateVersionConfiguration.resolutionStrategy.componentSelection.all {
            devSuffixes.forEach {
                if (it.containsMatchIn(candidate.version)) {
                    reject("don't use snapshots")
                    return@forEach
                }
            }
        }