val dependencies = newDependencyHandlerMock()
        val notation = mock<Provider<MinimalExternalModuleDependency>>()
        val buildscript = mock<ScriptHandler> {
            on { getDependencies() } doReturn dependencies
        }

        ScriptHandlerScope(buildscript).apply {
            dependencies {
                classpath(notation)
                classpath(notation) { exclude(module = "com.google.guava") }

        val source = programSourceWith("""
            @Suppress("unused_variable")
            buildscript { println("Stage 1") }
            """.trimIndent())

        assertProgramOf(
            source,
            Program.Buildscript(source.fragment(29..39, 41..62, 0))
        )
    }

    @Test

                        }
                    }
                }
                """
    }

    def "will prioritize built-in option over a task option with a conflicting name"() {
        when:
        buildScript """
            ${defineTaskWithProfileOption()}

            tasks.register('mytask', MyTask.class)
        """

        then:
        succeeds "mytask", "--profile"

        succeeds('pluginTask')

        then:
        output.contains('from plugin')
    }

    def "can resolve plugins even if buildscript block contains wrong repo with same name"() {
        given:
        publishTestPlugin(MAVEN)
        buildScript """
          buildscript {
            repositories {
                maven {
                    url '${new MavenFileRepository(file("other-repo")).uri}'

    @Test
    fun `no extra dependencies are added to the buildscript classpath`() {

        val result = build("buildEnvironment")

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

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

        withBuildScript(
            """
            buildscript {
                $repositoriesBlock

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

    def "can reference rule inputs using dollar method syntax"() {
        when:
        buildScript '''
            class MyPlugin extends RuleSource {
                @Model
                String foo() {
                  "foo"
                }

                @Model

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

    def "can create and initialize elements"() {
        when:
        buildScript '''
            @Managed
            interface Thing {
                String getName()
                void setName(String name)
            }

            model {
                thing1(Thing) {

        overridePluginPortalUri(pluginPortalUri)

        and:
        buildScript """
            buildscript {
                repositories { maven { url "$buildscriptRepoUri" } }
                dependencies { classpath "my:plugin:1.0" }
            }

            plugins {
                id 'base'
            }

            apply plugin: 'my-plugin'

              don't support querying the output or tasks.
     */

    def "does not throw exception when build fails expectantly"() {
        given:
        buildScript """
            task helloWorld {
                doLast {
                    throw new GradleException('Expected exception')
                }
            }
        """

        when:

        }
    }

    @Test
    fun `given an environment with a 'getScriptSectionTokens' entry, when buildscript changes, it will try to retrieve the model again`() {

        val env1 = environmentWithGetScriptSectionTokensReturning("buildscript" to sequenceOf("foo"))
        val env2 = environmentWithGetScriptSectionTokensReturning("buildscript" to sequenceOf("bar"))

        val action1 = resolverActionFor(env1, null)