CompileAll {
        override fun create(model: CIBuildModel, stage: Stage): BaseGradleBuildType {
            return CompileAll(model, stage)
        }
    },
    SanityCheck {
        override fun create(model: CIBuildModel, stage: Stage): BaseGradleBuildType {
            return SanityCheck(model, stage)
        }
    },
    BuildDistributions {

plugins {
    `kotlin-dsl`
}

group = "gradlebuild"

description = "Provides plugins used to create a Gradle plugin with Groovy or Kotlin DSL within build-logic builds"

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

dependencies {
    compileOnly("com.gradle:develocity-gradle-plugin:3.17.2")

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

    override fun apply(project: Project) {
        require(project.rootProject == project) { "This plugin should be applied to root project!" }
        val globalExtension = project.extensions.create<TestFilesCleanupBuildServiceRootExtension>("testFilesCleanupRoot")
        project.gradle.taskGraph.whenReady {

class AndroidStudioProvisioningPlugin : Plugin<Project> {
    override fun apply(target: Project) {
        with(target) {
            val androidStudioProvisioningExtension = extensions
                .create("androidStudioProvisioning", AndroidStudioProvisioningExtension::class)
                .apply {
                    androidStudioVersion.convention(defaultAndroidStudioVersion)
                }

            repositories {

            // :updateReleasedVersionsToLatestNightly and :updateReleasedVersions
            taskNames.any { it.contains("updateReleasedVersions") }
    }


/**
 * If `-DbundleGroovy4=true` is specified, create a distribution using Groovy 4 libs.  Otherwise use Groovy 3 classic libs.
 */
val Project.isBundleGroovy4: Boolean

private
fun Project.bucket(name: String, description: String) = configurations.create(name) {
    isVisible = false
    isCanBeResolved = false
    isCanBeConsumed = false
    this.description = description
}


private
fun Project.resolver(name: String, libraryElements: String, extends: Configuration? = null) = configurations.create(name) {
    attributes {

open class ErrorProneProjectExtension(
    val disabledChecks: ListProperty<String>
)

open class ErrorProneSourceSetExtension(
    val enabled: Property<Boolean>
)

val errorproneExtension = project.extensions.create<ErrorProneProjectExtension>("errorprone", project.objects.listProperty<String>())
errorproneExtension.disabledChecks.addAll(
    // DISCUSS
    "EqualsGetClass", // Let's agree if we want to adopt Error Prone's idea of valid equals()

plugins {
    id("gradlebuild.build-logic.kotlin-dsl-gradle-plugin")
}

description = "Provides plugins to create and configure integration, cross-version and distribution tests"

gradlePlugin {
    plugins {
        register("androidStudioProvisioning") {
            id = "gradlebuild.android-studio-provisioning"
            implementationClass = "gradlebuild.integrationtests.ide.AndroidStudioProvisioningPlugin"
        }
    }
}

            .withBinding("classesUpToDate", "" + classesUpToDate)
            .create().generate()
        projectLayoutSetupRegistry.templateOperationFactory.newTemplateOperation()
            .withTemplate(templateFolder.template("build.sample.conf"))
            .withTarget(settings.target.file("../tests/build.sample.conf").asFile)
            .create().generate()
    }

    private

import gradlebuild.integrationtests.createTestTask
import gradlebuild.integrationtests.extension.IntegrationTestExtension

plugins {
    java
    id("gradlebuild.dependency-modules")
}

extensions.create<IntegrationTestExtension>("integTest").apply {
    usesJavadocCodeSnippets.convention(false)
    testJvmXmx.convention("512m")
}

val sourceSet = addSourceSet(TestType.INTEGRATION)