when:
        buildFile.text = """
            buildscript {
                repositories { maven { url "${mavenRemote.uri}" } }
                dependencies { classpath "$artifactCoordinates" }
            }
        """

        then:
        run("help")

        when:
        buildFile.text = """
            buildscript {

 */

package org.gradle.kotlin.dsl.compile

import org.junit.Test


class BuildSrcScriptCompileAvoidanceIntegrationTest : AbstractCompileAvoidanceIntegrationTest() {

    @Test
    fun `avoids buildscript recompilation on public function change in buildSrc script`() {
        val packageName = givenKotlinScriptInBuildSrcContains(
            "Foo",
            """
            fun foo() {
                println("foo")

    def "can resolve local module with custom packaging"() {
        using m2
        def local = m2.mavenRepo().module("local", "local", "1.0").hasType("aar").hasPackaging("aar").publish()

        when:
        buildScript """
            configurations {
                local
            }
            repositories {
                mavenLocal()
            }
            dependencies {
                local "local:local:1.0"

    def "model block can be used in nested context in build script - #code"() {
        given:
        createDirs("a", "b")
        settingsFile << "include 'a', 'b'"

        when:
        buildScript """
            ${testPluginImpl()}

            allprojects { apply type: TestPlugin }

            $code {
                model {
                    strings {
                        add "foo"

internal
enum class TopLevelBlockId {
    buildscript,
    plugins,
    pluginManagement,
    initscript;

    val tokenText: String
        get() = name

    companion object {

        fun topLevelBlockIdFor(target: ProgramTarget) = when (target) {
            ProgramTarget.Project -> arrayOf(buildscript, plugins)
            ProgramTarget.Settings -> arrayOf(buildscript, pluginManagement, plugins)

        id                  | pluginsBlock
        "plugins block"     | """
            plugins {
                id 'com.acme.my.plugin' version '1.0'
            }
        """

        "buildscript block" | """
                buildscript {
                    repositories {
                        maven {
                            url "%repoloc%"
                        }
                    }
                    dependencies {

        buildScript(scalaProjectBuildScript(defaultZincVersion, defaultScalaVersion))

        when:
        run 'compileScala'

        then:
        executedAndNotSkipped ':compileScala'

        when:
        run 'compileScala'

        then:
        skipped ':compileScala'

        when:
        buildScript(scalaProjectBuildScript(newZincVersion, newScalaVersion))

import org.gradle.internal.jvm.Jvm

class JavaToolchainIntegrationTest extends AbstractIntegrationSpec implements JavaToolchainFixture {

    def "fails when using an invalid toolchain spec when #description"() {

        buildScript """
            apply plugin: JvmToolchainsPlugin

            abstract class UnpackLauncher extends DefaultTask {
                @Nested
                abstract Property<JavaLauncher> getLauncher()

        }
    }
}
// end::convention-callsites-from-plugin[]

// tag::convention-callsites-from-buildscript[]
apply<GreetingPlugin>()

tasks.withType<GreetingTask>().configureEach {
    // setting convention from build script
    guest.convention("Guest")
}
// end::convention-callsites-from-buildscript[]

abstract class GreetingTask : DefaultTask() {
    // tag::convention-callsites-from-constructor[]

    }

    /**
     * Configures the build script classpath for this project.
     *
     * @see [Project.buildscript]
     */
    @Suppress("unused")
    open fun buildscript(@Suppress("unused_parameter") block: ScriptHandlerScope.() -> Unit) {
        throw IllegalStateException("The `buildscript` block is not supported on Kotlin script plugins, please use the `plugins` block or project level dependencies.")
    }

    /**