withBuildScript(
            """
            @Suppress("DSL_SCOPE_VIOLATION")
            plugins {
                id("base")
            }
            """
        )

        build("clean")
    }

    @Test
    fun `non top-level use of the plugins block fails with reasonable error message`() {

        withBuildScript(
            """
            plugins {

            """
        )

        withBuildScript(
            """
            apply(from = "gradle/script.gradle.kts")
            """
        )

        assertThat(
            build("-q", "ok").output.trim(),
            equalTo("ok!")
        )
    }

    @Test
    fun `can run a simple task`() {
        withBuildScript(
            """

        val script = withBuildScript("buildscript { $boom }")

        assertFailingBuildOutputOf("help") {
            """
            * Where:
            Build file '${script.canonicalPath}' line: 1
            """
        }
    }

    @Test
    fun `location of exception thrown from plugins block is reported`() {

        val script = withBuildScript("plugins { $boom }")

                    name.toUpperCase()
                })
                """.trimIndent(),
                "my"
            )
            generateForBuildSrc()
        }

        withBuildScript(
            """
            plugins {
                my
            }

            inline fun <reified T> typeOf(value: T) = typeOf<T>()

            println("closureExtension: " + typeOf(closureExtension))

class GradleKotlinDslRegressionsTest : AbstractKotlinIntegrationTest() {

    @Test
    @Issue("https://github.com/gradle/gradle/issues/9919")
    fun `gradleKotlinDsl dependency declaration does not throw`() {

        withBuildScript(
            """
            plugins { java }
            dependencies {
                compileOnly(gradleKotlinDsl())
            }
            """
        )

        build("help")
    }

        assertThat(result.output, containsString("No dependencies"))
    }

    @Test
    fun `embedded kotlin dependencies are pinned to the embedded version`() {

        withBuildScript(
            """
            buildscript {
                $repositoriesBlock
                dependencies {
                    classpath("org.jetbrains.kotlin:kotlin-stdlib:1.0")

    @Test
    fun `implicit imports are fully qualified to allow use of the preferred type amongst those with same simple name in different Gradle API packages`() {

        // given:
        withBuildScript(
            """

            println("*" + Jar::class.qualifiedName + "*")

            """
        )

        // when:
        val result = build("help")

        // then:

                myBaseTask {
                    doLast {
                        println("*my base*")
                    }
                }
            }
            """
        )

        withBuildScript(
            """
            plugins {
                base
            }

            tasks {
                wrapper {
                    gradleVersion = "5.0"
                }

        )
    }

    @Test
    @Requires(IntegTestPreconditions.NotEmbeddedExecutor::class)
    fun `succeeds on precompiled project script`() {

        withKotlinBuildSrc()

        withBuildScript(
            """
            plugins {
                id("my-plugin")
            }
            """
        )

        assertSucceedsForScriptWithReceiver(

import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class EmbeddedKotlinPluginIntegTest : AbstractKotlinIntegrationTest() {

    @Test
    fun `applies the kotlin plugin`() {

        withBuildScript(
            """

            plugins {
                `embedded-kotlin`
            }

            $repositoriesBlock

            """
        )

        val result = build("assemble")