parameters.projectStates.get().values.forEach { projectExtension ->
            cleanUp(projectExtension.tmpExtractedResourcesDirs())
        }

        // Second run: collect and archive leftover files
        parameters.projectStates.get().forEach { (projectPath: String, projectExtension: TestFileCleanUpExtension) ->

        assertEquals(model.stages.size, stagePassConfigs.size)
        stagePassConfigs.forEach {
            val stageNumber = stagePassConfigs.indexOf(it) + 1
            val stage = model.stages[stageNumber - 1]
            val prevStage = if (stageNumber > 1) model.stages[stageNumber - 2] else null

            if (stage.runsIndependent) {
                return@forEach
            }

            assertEquals(

  ) {
    access.registerAsUsed(java)
    RuntimeReflection.register(java)
    java.constructors.forEach {
      RuntimeReflection.register(it)
    }
    java.declaredMethods.forEach {
      RuntimeReflection.register(it)
    }
    java.declaredFields.forEach {
      RuntimeReflection.register(it)
    }
    java.methods.forEach {
      RuntimeReflection.register(it)
    }
  }

val multiProjectApplicationSampleLanguages = listOf(JAVA, GROOVY, SCALA, KOTLIN)

singleProjectSampleLanguages.forEach { language ->
    setupGeneratorTask(language, "library", ModularizationOption.SINGLE_PROJECT)
    setupGeneratorTask(language, "application", ModularizationOption.SINGLE_PROJECT)
}

multiProjectApplicationSampleLanguages.forEach { language ->
    setupGeneratorTask(language, "application", ModularizationOption.WITH_LIBRARY_PROJECTS)
}

    if (cachesDir.isDirectory) {
        cachesDir.listFiles()
            .filter { it.isDirectory }
            .flatMap { scriptsCacheDirsUnder(it) }
            .forEach { scriptsCacheDir ->
                logger.lifecycle("Removing scripts cache directory : $scriptsCacheDir")
                delete { delete(scriptsCacheDir) }
            }
    }
}

        docsTestProjects.forEach(this::subProject)
        docsTestTriggers = docsTestProjects.map { DocsTestTrigger(model, it) }
        docsTestTriggers.forEach(this::buildType)

        stage.performanceTestPartialTriggers.forEach { trigger ->
            buildType(
                PartialTrigger(

import org.jetbrains.kotlin.name.Name


internal fun FirScope.getCallableSymbols(
    callableNames: Collection<Name>,
    builder: KtSymbolByFirBuilder
): Sequence<KtCallableSymbol> = sequence {
    callableNames.forEach { name ->
        yieldList {
            processFunctionsByName(name) { firSymbol ->
                add(builder.functionLikeBuilder.buildFunctionSymbol(firSymbol))
            }
        }
        yieldList {

                add(firCandidate)

                if (firCandidate is FirBlock) {
                    firCandidate.statements.forEach(::addCandidate)
                }
            }

            firStatements.forEach(::addCandidate)
        }

        val parentDeclarations = anchor.parentsOfType<KtDeclaration>(withSelf = true)
        for (parentDeclaration in parentDeclarations) {

    this.name = testCoverage.asName()
}) {
    val functionalTests: List<BaseGradleBuildType> = functionalTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)
    init {
        functionalTests.forEach(this::buildType)
    }

    this.id(spec.asConfigurationId(model))
    this.name = spec.asName()
}) {
    init {
        performanceTests.forEach(this::buildType)
    }
}