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

        when:
        buildScript """
            $USE

            def ops = []

            plugins.withId('$PLUGIN_ID') {
              ops << "withId 1"
            }

            plugins.withId("test-plugin-2") {
              ops << "withId 2"
            }

            def class1 = ${pluginBuilder.packageName}.TestPlugin
            def class2 = ${pluginBuilder2.packageName}.TestPlugin2

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.ref') {
            withId 'org.example'
            withVersionRef 'ref'
            withVersion {
                require '1.6'
            }
        }
        hasPlugin('with-rich1') {
            withId 'org.example'
            withVersion {
                prefer '1.0'
            }
        }
        hasPlugin('with-rich2') {
            withId 'org.example'
            withVersion {

        then:
        thrown UnknownPluginException

        when:
        container.withId("plugin2") { plugins << it }

        then:
        plugins.empty

        when:
        container.apply(pluginClass)

        then:
        plugins[0].class == pluginClass
    }

    def "no error when withId used and plugin with no id"() {
        given:

  }
}

// 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 {

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

        when:
        buildScript """
            plugins {
                id "$pluginId"
            }

            def i = 0
            plugins.withId("$QUALIFIED_JAVA") {
                ++i
            }
            plugins.withId("$UNQUALIFIED_JAVA") {
                ++i
            }
            assert i == 2

            assert plugins.getPlugin("$QUALIFIED_JAVA")

        // prepare testReportDirectory with a reasonable default, but override with JavaPluginExtension#testReportDirectory if available
        project.getPlugins().withId("java-base", plugin -> {
            JavaPluginExtension javaPluginExtension = project.getExtensions().getByType(JavaPluginExtension.class);
            testReportDirectory.convention(javaPluginExtension.getTestReportDir());

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