}
            }
        """
        buildScript "plugins { id '$PLUGIN_ID' }"

        then:
        verifyPluginApplied('2.0')
    }

    def "can override plugin version in settings script"() {
        when:
        buildScript "plugins { id '$PLUGIN_ID' version '2.0' }"

        then:
        verifyPluginApplied('2.0')
    }

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

    def "unbound rule by-type subject and inputs are reported"() {
        given:
        buildScript """
            class MyPlugin {
                static class MyThing1 {}
                static class MyThing2 {}
                static class MyThing3 {}

                static class Rules extends RuleSource {

        repo.module("", "test", "1.3-BUILD-SNAPSHOT").allowAll()

        server.start()
    }

    @Unroll("jars on buildscript classpath can change (loopNumber: #loopNumber)")
    def "jars on buildscript classpath can change"() {
        given:
        buildFile << '''
            buildscript {
                repositories { flatDir { dirs 'repo' }}

        then:
        executed ":pluginDependencyA:jar", ":pluginBuild:jar", ":taskFromPluginBuild"
    }

    def "can develop a buildscript dependency that is also used by main build"() {
        given:
        buildA.buildFile << """
            buildscript {
                dependencies {
                    classpath 'org.test:pluginDependencyA:1.0'
                }
            }
        """

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

    def "rule can create a map of model elements"() {
        when:
        buildScript '''
            @Managed
            interface Thing extends Named {
              void setValue(String value)
              String getValue()
            }

            @Managed

 */

package org.gradle.kotlin.dsl.compile

import org.junit.Test


class PrecompiledPluginsCompileAvoidanceIntegrationTest : AbstractCompileAvoidanceIntegrationTest() {

    @Test
    fun `avoids buildscript recompilation when task is configured in precompiled script plugin`() {
        val pluginId = "my-plugin"
        withPrecompiledScriptPluginInBuildSrc(
            pluginId,
            """
                println("foo")

                    url "${mavenRepo.uri}"
                }
            }
          }
        """
    }

    def 'Can specify snapshot version'() {
        given:
        publishTestPlugin()
        buildScript """
          plugins {
              id "org.example.plugin" version '1.0-SNAPSHOT'
          }
          plugins.withType(org.gradle.test.TestPlugin) {
            println "I'm here"
          }
        """

        '''.stripIndent()
    }

    @Issue('https://github.com/gradle/gradle/issues/4924')
    def 'test task is up-to-date when #property is changed because it should not impact output'() {
        given:
        buildScript """
            apply plugin: "java"
            ${mavenCentralRepository()}
            testing {
                suites {
                    test {
                        useTestNG('${TestNGCoverage.NEWEST}')

        def settings = withSettings("""
            buildscript {
                dependencies {
                    classpath(files("${normalizedPathOf(settingsDependency)}"))
                }
            }
        """)

        and:
        def projectDependency = withEmptyJar("project-dependency.jar")
        file("build.gradle") << """
            buildscript {
                dependencies {

class PolymorphicManagedTypeIntegrationTest extends AbstractIntegrationSpec {

    def "rule can provide a managed model element backed by an abstract class that implements interfaces"() {
        when:
        buildScript '''
            @Managed
            interface Named {
                String getName()
            }

            @Managed
            abstract class Person implements Named {