def "core plugins are detectable - applied by #appliedBy, detected by #detectedBy"() {
        buildFile << """
            def operations = []
            plugins.withId("$detectedBy") {
                operations << 'withId for ' + it.class.simpleName
            }
            pluginManager.withPlugin("$detectedBy") {
                // assert we are using our closure decoration and not closure coercion

plugins {
    id("org.jetbrains.kotlin.jvm") version "1.9.23"
    id("org.jetbrains.kotlin.kapt") version "1.9.23"
}

// tag::cacheKapt[]
plugins.withId("kotlin-kapt") {
    kapt.useBuildCache = true
}
// end::cacheKapt[]

// tag::fabricGroovy[]
plugins.withId("com.android.application") { // or "com.android.library"
    android.buildTypes.debug.ext.enableCrashlytics = false
}

        }
        hasPlugin('with-rich2') {
            withId 'org.example'
            withVersion {
                prefer '1.0'
            }
        }
        hasPlugin('with-rich3') {
            withId 'org.example'
            withVersion {
                require '1.0'
            }
        }
        hasPlugin('with-rich4') {
            withId 'org.example'
            withVersion {

        def plugin = container.apply("custom-plugin-with-injection")
        def executed = false

        then:

        container.withId("custom-plugin-with-injection", {
            assert it == plugin
            executed = true
        })
        executed
        container.getPlugin("custom-plugin-with-injection") == plugin
        container.hasPlugin("custom-plugin-with-injection")
    }

    htmlReportFile = file(layout.buildDirectory.file("reports/incubation/${project.name}.html"))
    textReportFile = file(layout.buildDirectory.file("reports/incubation/${project.name}.txt"))
}

plugins.withId("org.jetbrains.kotlin.jvm") {
    reportTask {
        sources.from(kotlinMainSourceSet.sourceDirectories)
    }
}

tasks.named("check") { dependsOn(reportTask) }

  }
}

// Opt-in to @ExperimentalOkHttpApi everywhere.
subprojects {
  plugins.withId("org.jetbrains.kotlin.jvm") {
    kotlinExtension.sourceSets.configureEach {
      languageSettings.optIn("okhttp3.ExperimentalOkHttpApi")
    }
  }
  plugins.withId("org.jetbrains.kotlin.android") {
    kotlinExtension.sourceSets.configureEach {

import org.gradle.kotlin.dsl.dependencies
import org.gradle.kotlin.dsl.findByType
import org.gradle.kotlin.dsl.get
import org.gradle.kotlin.dsl.getByName

fun Project.applyOsgi(vararg bndProperties: String) {
  plugins.withId("org.jetbrains.kotlin.jvm") {
    applyOsgi("jar", "osgiApi", bndProperties)
  }
}

private fun Project.applyOsgi(
  jarTaskName: String,
  osgiApiConfigurationName: String,
  bndProperties: Array<out String>,

            allprojects {
                tasks.withType(AbstractScalaCompile) {
                    options.fork = true
                }
                ${mavenCentralRepository()}
                plugins.withId("scala") {
                    dependencies {
                        implementation 'org.scala-lang:scala-library:${ScalaCoverage.SCALA_2.last()}'

                        testImplementation 'junit:junit:4.12'

}

configureJavadocVariant()

publishing {
    publications {
        create<MavenPublication>("gradleDistribution") {
            configureGradleModulePublication()
        }
    }

    plugins.withId("gradlebuild.shaded-jar") {
        publishNormalizedToLocalRepository()
    }
}

val pgpSigningKey: Provider<String> = providers.environmentVariable("PGP_SIGNING_KEY")

                allprojects {
                    repositories {
                        ${mavenCentralRepository()}
                    }
                }
                subprojects {
                    plugins.withId('java') {
                        testing {
                            suites {
                                test {
                                    useJUnit()
                                }