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"

    def "changing expansion makes task out-of-date"() {
        given:
        buildScript '''
            task (copy, type:Copy) {
               from 'src'
               into 'dest'
               expand(one: 1)
            }
        '''.stripIndent()
        run 'copy'

        buildScript '''
            task (copy, type:Copy) {
               from 'src'
               into 'dest'

        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 ModelSetIntegrationTest extends AbstractIntegrationSpec {

    def "provides basic meta-data for set"() {
        when:
        buildScript '''
            @Managed
            interface Person {
            }

            class Rules extends RuleSource {
              @Model
              void people(ModelSet<Person> people) {
              }

@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) {

            task first
            assert buildscript.sourceFile == null
            assert "${server.uri}/external.gradle?first" == buildscript.sourceURI as String
        """
        def second = file('second.gradle') << """
            task second
            assert buildscript.sourceFile == null
            assert "${server.uri}/external.gradle?second" == buildscript.sourceURI as String
        """