void "can resolve core plugins"() {
        when:
        buildScript """
            plugins {
              id 'java'
            }
        """

        then:
        succeeds "javadoc"
    }

    void "can resolve qualified core plugins"() {
        when:
        buildScript """
            plugins {
              id 'org.gradle.java'
            }
        """

) : CompiledKotlinSettingsScript(host) {

    /**
     * Configures the build script classpath for this project.
     *
     * @see [Project.buildscript]
     */
    open fun buildscript(block: ScriptHandlerScope.() -> Unit) {
        ScriptHandlerScope(buildscript).block()
    }

    open fun plugins(configuration: PluginDependenciesSpecScope.() -> Unit) {

    /**
     * The [ScriptHandler] for this script.
     */
    val buildscript: ScriptHandler
        get() = host.scriptHandler

    /**
     * Configures the build script classpath for this project.
     *
     * @see [Project.buildscript]
     */
    @Suppress("unused")
    open fun buildscript(@Suppress("unused_parameter") block: ScriptHandlerScope.() -> Unit): Unit =
        internalError()

    def "--continue flag PRESENT"() {
        given:
        buildScript()

        when:
        args("--continue")
        fails(":failTask", ":successTask")

        then:
        output.contains("2 actionable tasks: 2 executed")
    }

    def "--continue flag MISSING"() {
        given:
        buildScript()

        when:
        fails(":failTask", ":successTask")

        then:

            """.stripIndent().trim())
    }

    def "can resolve and plugin from portal with buildscript notation"() {
        given:
        def helloWorldGroup = 'org.gradle'
        def helloWorldName = 'gradle-hello-world-plugin'

        when:
        buildScript """
            buildscript {
                repositories {
                    gradlePluginPortal()
                }

    fun `can extract plugins block from script with a buildscript block`() {

        extractPluginsFrom(
            // the `buildscript` block is not really valid in precompiled script plugins (causes a runtime error)
            // but still worth testing here
            scriptPlugin(
                "buildscript-and-plugins.gradle.kts",
                """
                buildscript {}
                plugins { java }
                """

        given:
        buildScript simpleCppBuild()

        when:
        fails 'dependentComponents', '--component', 'unknown'

        then:
        failure.assertHasCause "Component 'unknown' not found."
    }

    def "fails when some of the targeted components are not found"() {
        given:
        buildScript simpleBuildWithTestSuites()

        when:

@UnsupportedWithConfigurationCache(because = "software model")
class RuleSourceAppliedAsProjectPluginIntegrationTest extends AbstractIntegrationSpec {

    def "plugin class can expose model rules"() {
        when:
        buildScript '''
            class MyPlugin {
                static class Rules extends RuleSource {
                    @Model
                    List<String> strings() {
                      []
                    }

            }
            """
        )

        withBuildScript(
            """
            buildscript {
                // buildSrc types are available within buildscript
                // and must always be fully qualified
                build.DeepThought().compute { answer ->
                    println("buildscript: " + answer)
                }
            }
            apply<build.DeepThoughtPlugin>()

    }

    def 'strict locks on buildscript classpath does not mean strict locks on project (initial unique: #unique)'() {
        given:
        mavenRepo.module('org.foo', 'foo-plugin', '1.0').publish()
        mavenRepo.module('org.foo', 'foo-plugin', '1.1').publish()

        settingsFile << """
rootProject.name = 'foo'
"""
        buildFile << """
buildscript {
    repositories {
        maven {