fun generateSubprojectsDirectories(): List<File> {
        val subprojectRoots = platformsFolder.asFile.listFiles(File::isDirectory).plus(subprojectsFolder.asFile).plus(testingFolder.asFile)
        return subprojectRoots.map { it.listFiles(File::isDirectory).asList() }.flatten()
    }

    private
    fun generateSubprojects(): List<GradleSubproject> {
        return generateSubprojectsDirectories()
            .filter {

@CompileStatic
abstract class AbstractGradleViolationRule extends AbstractContextAwareViolationRule {

    private final Map<ApiChange, String> acceptedApiChanges
    private final File apiChangesJsonFile
    private final File projectRootDir

    AbstractGradleViolationRule(Map<String, Object> params) {
        Map<String, String> acceptedApiChanges = (Map<String, String>)params.get("acceptedApiChanges")

        attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
    }
}

tasks.jar.configure {
    val classpath = manifestClasspath.elements.map { classpathDependency ->
        classpathDependency.joinToString(" ") {
            it.asFile.name
        }
    }
    manifest.attributes("Class-Path" to classpath)

) + listOf(
    "-Porg.gradle.performance.branchName" to "%teamcity.build.branch%",
    "-Porg.gradle.performance.db.url" to "%performance.db.url%",
    "-Porg.gradle.performance.db.username" to "%performance.db.username%"
).map { (key, value) -> os.escapeKeyValuePair(key, value) }

const val individualPerformanceTestArtifactRules = """
testing/*/build/test-results-*.zip => results
testing/*/build/tmp/**/log.txt => failure-logs

    }
)

fun getPerformanceTestTaskNames(performanceSubProject: String, testProjects: List<String>, performanceTestTaskSuffix: String): List<String> {
    return testProjects.map {
        ":$performanceSubProject:$it$performanceTestTaskSuffix"
    }

            "testJavaVendor",
            JvmVendor.openjdk.name,
            display = ParameterDisplay.PROMPT,
            description = "The java vendor to run the performance tests",
            options = JvmVendor.values().map { it.displayName to it.name }
        )
        when (os) {
            Os.WINDOWS -> {
                profilerParam("jprofiler")
                param("env.JPROFILER_HOME", "C:\\Program Files\\jprofiler\\jprofiler11.1.4")

        Map<AccessorKey, ReplacedAccessor> oldAccessorsOfUpgradedProperties = (Map<AccessorKey, ReplacedAccessor>) context.getUserData().get(OLD_ACCESSORS_OF_UPGRADED_PROPERTIES);

        // Find accessors that were not removed but should be
        Map<AccessorKey, ReplacedAccessor> keptAccessors = new HashMap<>(oldAccessorsOfUpgradedProperties);

    abstract val projectDependencies: ConfigurableFileCollection

    @Input
    val runtime = externalDependencies.elements.map { it.map { it.asFile.name }.sorted() }

    @get:Internal
    abstract val externalDependencies: ConfigurableFileCollection

    @Input
    val projects = projectDependencies.elements.map { it.map { it.toGradleModuleName() }.sorted() }

    @get:OutputFile
    abstract val manifestFile: RegularFileProperty

        "CompileAllBuild_BuildCacheNG",
        "CompileAllBuild_NGRemote"
    ) || isBuildCommitDistribution

val Project.isBuildCommitDistribution: Boolean
    get() = providers.gradleProperty("buildCommitDistribution").map { it.toBoolean() }.orElse(false).get()


fun Project.isInBuild(vararg buildTypeIds: String) = providers.environmentVariable("BUILD_TYPE_ID").orNull?.let { currentBuildTypeId ->

        }
    }

    private static void initExecutionMode(String[] args) {
        if (args.length != 1) {
            throw new IllegalArgumentException("Requires 1 param: " + Stream.of(ExecutionMode.values()).map(ExecutionMode::toString).collect(Collectors.joining("/")));
        }
        executionMode = ExecutionMode.valueOf(args[0]);