"-SNAP\\d+",
        "-SNAPSHOT",
        "-alpha.*\\d+",
        "-beta.*\\d+",
        "-dev-?\\d+",
        "-dev-\\d+-\\d+",
        "-rc-?\\d+",
        "-M.+",
        "-eap-?\\d+"
    ).map { it.toRegex(RegexOption.IGNORE_CASE) }

    @get:Internal
    abstract val libraryVersionFile: RegularFileProperty

    @TaskAction
    fun updateInitPluginTemplateVersionFile() {

val Project.flakyTestStrategy: FlakyTestStrategy
    get() = gradleProperty(FLAKY_TEST).let {
        if (it.getOrElse("").isEmpty()) {
            return FlakyTestStrategy.INCLUDE
        } else {
            return FlakyTestStrategy.valueOf(it.get().toUpperCaseAsciiOnly())
        }
    }


val Project.ignoreIncomingBuildReceipt: Provider<Boolean>

  - Select `Manually`.
  - Give it a name. The name will be displayed on TeamCity web UI. We highly recommend it be capitalized from the branch name, i.e. `MyTestBranch`.

                parameters.monitoredTaskPaths = allTasks.filter(taskFilter).map { if (isInBuildLogic) ":build-logic${it.path}" else it.path }.toSet()
            }
            gradle.serviceOf<BuildEventsListenerRegistry>().onTaskCompletion(buildService)

                .firstOrNull { it.fqName?.asString() == fqn }
                ?.isDocumentedAsSince(version) == true
        }

    private
    fun KtFile.isDocumentedAsSince(version: String, declaringClass: CtClass, constructor: CtConstructor): Boolean {
        val classFqName = declaringClass.name
        val ctorParamTypes = constructor.parameterTypes.map { it.name }

                }
                val androidStudioDependencyProvider =
                    androidStudioProvisioningExtension.androidStudioVersion.map { "android-studio:android-studio:$it@$extension" }

                androidStudioRuntime(androidStudioDependencyProvider)
            }

            tasks.register<Copy>("unpackAndroidStudio") {
                from(
                    Callable {

            "-PtestJavaVendor=$testJvmVendor"
        ) +
            listOf(buildScanTag(buildScanTag)) +
            buildScanValues.map { buildScanCustomValue(it.key, it.value) }
        ).filter { it.isNotBlank() }.joinToString(separator = " ")
}

fun functionalTestParameters(os: Os): List<String> {
    return listOf(
        "-PteamCityBuildId=%teamcity.build.id%",

            model.buildTypes.map { it.name }
        )
    }

    @Test
    fun `promotion project has expected build types for other branches`() {
        val model = setupModelFor("release")

        assertEquals("Promotion", model.name)

    override val vendor: JvmVendor,
    override val version: JvmVersion
) : Jvm {
    MIN_VERSION(JvmVendor.oracle, JvmVersion.java8),
    // Oracle doesn't provide zip JDK distribution for Windows anymore, we avoid using it
    MIN_VERSION_WINDOWS(JvmVendor.openjdk, JvmVersion.java8),
    MAX_LTS_VERSION(JvmVendor.openjdk, JvmVersion.java21),
    MAX_VERSION(JvmVendor.openjdk, JvmVersion.java22),

        excludedPackages.add("org.gradle.platform.base.test");
        return excludedPackages;
    }

    // TODO: This doesn't really make sense to be part of the user manual generation, but it's so tied up into it
    // it's left here for a future project.
    private void generateDefaultImports(Project project, TaskContainer tasks, GradleDocumentationExtension extension) {