return "-Dorg.gradle.workers.max=%maxParallelForks% -PmaxParallelForks=%maxParallelForks% $pluginPortalUrlOverride -s --no-configuration-cache %additional.gradle.parameters% $daemon --continue $extraParameters \"-Dscan.tag.Check\" \"-Dscan.tag.\" -PteamCityBuildId=%teamcity.build.id% \"$expectedInstallationPaths\" -Porg.gradle.java.installations.auto-download=false -Porg.gradle.java.installations.auto-detect=false"...

        gradle.taskGraph.whenReady {
            val buildService: Provider<T> = gradle.sharedServices.registerIfAbsent("${klass.simpleName}-$rootProjectName", klass) {
                parameters.monitoredTaskPaths = allTasks.filter(taskFilter).map { if (isInBuildLogic) ":build-logic${it.path}" else it.path }.toSet()
            }
            gradle.serviceOf<BuildEventsListenerRegistry>().onTaskCompletion(buildService)

private
fun JApiMethod.isEnumImplicitMethodValueOf(): Boolean {
    return name == "valueOf" && parameters.size == 1 && parameters.first().type == "java.lang.String"
}


private
fun JApiMethod.isEnumImplicitMethodValues(): Boolean {
    return name == "values" && parameters.size == 0

    failureConditions.supportTestRetry = false

    val extraParameters = functionalTestExtraParameters("RerunFlakyTest", os, arch, "%$testJvmVersionParameter%", "%$testJvmVendorParameter%")
    val parameters = (
        buildToolGradleParameters(daemon) +
            listOf(extraParameters) +
            functionalTestParameters(os)
        ).joinToString(separator = " ")

        "-Dorg.gradle.workers.max=$maxParallelForks",
        "-PmaxParallelForks=$maxParallelForks",
        pluginPortalUrlOverride,
        "-s",
        "--no-configuration-cache",
        "%additional.gradle.parameters%",
        if (daemon) "--daemon" else "--no-daemon",
        if (isContinue) "--continue" else ""
    )

fun Dependencies.dependsOn(buildTypeId: RelativeId) {
    dependency(buildTypeId) {
        snapshot {

                param("env.HP_HOME_DIR", "/opt/honest-profiler")
            }
        }

        param("env.PERFORMANCE_DB_PASSWORD_TCAGENT", "%performance.db.password.tcagent%")
        param("additional.gradle.parameters", "")
    }

    val buildTypeThis = this
    steps {
        killProcessStep(buildTypeThis, KILL_ALL_GRADLE_PROCESSES, os)
        substDirOnWindows(os)
        gradleWrapper {

                }
            }
        }
    }

    private
    fun forEachJavaProcess(action: (pid: String, line: String) -> Unit) {
        KillLeakingJavaProcesses.forEachLeakingJavaProcess(parameters.rootProjectDir.asFile.get(), action)
    }

            }
            logger.lifecycle("Cleaning up caches...")
            val homeDir = parameters.homeDir.get()

            homeDir.asFile.listFiles()?.filter { it.name.startsWith("distributions-") }?.forEach {
                val workerDir = homeDir.dir(it.name)
                cleanupDistributionCaches(workerDir, GradleVersion.version(parameters.gradleVersion.get()))
            }
            hasCleaned = true
        }
    }

        vendor = JvmVendorSpec.ADOPTIUM
    }

    tasks.withType<JavaCompile>().configureEach {
        configureCompileTask(options)
        options.compilerArgs.add("-parameters")
    }
    tasks.withType<GroovyCompile>().configureEach {
        groovyOptions.encoding = "utf-8"
        sourceCompatibility = "1.8"
        targetCompatibility = "1.8"
        configureCompileTask(options)

    testsWithOs.forEachIndexed { index, testCoverage ->
        val extraParameters = functionalTestExtraParameters("FlakyTestQuarantine", os, arch, testCoverage.testJvmVersion.major.toString(), testCoverage.vendor.name)
        val parameters = (
            buildToolGradleParameters(true) +
                listOf(
                    "-PflakyTests=only",
                    "-x", ":docs:platformTest",
                    "-x", ":docs:configCacheTest",