testFixturesRuntimeElements.extendsFrom(testFixturesRuntimeOnly)

// do not attempt to find projects when the plugin is applied just to generate accessors
if (project.name != "gradle-kotlin-dsl-accessors" && project.name != "test" /* remove once wrapper is updated */) {
    dependencies {
        testFixturesApi(project(":internal-testing"))
        // platform

                && versionUnderTest < GradleVersion.version(endVersionExclusive)
        }

        private
        fun extractTestTaskGradleVersion(name: String): String? = "gradle(.+)CrossVersionTest".toRegex().find(name)?.groupValues?.get(1)
    }

    class IncludeTestClassProvider(private val includeTestClasses: Map<String, List<String>>) : BuildBucketProvider {

            }
            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
        }
    }

        }
        api("com.beust:jcommander:1.78")
        api("org.codehaus.groovy:$groovyVersion")
        api("org.codehaus.groovy.modules.http-builder:http-builder:0.7.2") // TODO maybe change group name when upgrading to Groovy 4
        api("org.codenarc:CodeNarc:$codenarcVersion")
        api("org.eclipse.jgit:org.eclipse.jgit:5.13.3.202401111512-r")
        api("org.javassist:javassist:3.27.0-GA")

    @get:Internal
    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() }

            // complete distribution is used from 'build/bin distribution'
            distributionDir.parentFile.parentFile.name
        } else {
            // gradle-runtime-api-info.jar in 'build/libs'
            testTask.classpath.filter { it.name.startsWith("gradle-runtime-api-info") }.singleFile.parentFile.parentFile.parentFile.name
        }
        return (

                ""
            }
        val cleanedGenericReturnType =
            genericReturnType.toCodeTypeString()
        return "$cleanedTypeParameters $cleanedGenericReturnType $name(${parameters.joinToString { "${it.parameterizedType.toCodeTypeString()} ${it.name}" }}) {}".trim()
    }

    private
    fun Type.toCodeTypeString(): String {
        if (this is Class<*> && this.isArray) {

plugins {
    `kotlin-dsl`
}

description = "Provides a plugin to define the version and name for subproject publications"

group = "gradlebuild"

java {
    toolchain {
        languageVersion = JavaLanguageVersion.of(11)
        vendor = JvmVendorSpec.ADOPTIUM
    }
}

dependencies {
    api(platform(project(":build-platform")))

    implementation(project(":basics"))

    implementation("com.google.code.gson:gson")

package util

import common.Arch
import common.Os
import jetbrains.buildServer.configs.kotlin.Project

object UtilProject : Project({
    id("Util")
    name = "Util"

    buildType(RerunFlakyTest(Os.LINUX))
    buildType(RerunFlakyTest(Os.WINDOWS))
    buildType(RerunFlakyTest(Os.MACOS, Arch.AMD64))
    buildType(RerunFlakyTest(Os.MACOS, Arch.AARCH64))
    buildType(WarmupEc2Agent)

    buildType(PublishKotlinDslPlugin)

package configurations

import model.CIBuildModel
import model.Stage

class CheckLinks(model: CIBuildModel, stage: Stage) : BaseGradleBuildType(stage = stage, failStage = false, init = {
    id("${model.projectId}_CheckLinks")
    name = "CheckLinks"
    description = "Check links in documentations"

    applyDefaults(
        model,
        this,
        ":docs:checkLinks",