extraDir { file 'extra.txt' }
            dir1 {
                file 'extra.txt'
                extraDir { file 'extra.txt' }
            }
            someOtherEmptyDir {}
        }

        buildScript '''
            task sync(type: Sync) {
                into 'dest'
                from 'source'
            }
        '''.stripIndent()

        when:
        run 'sync'

        then:

    }

    def "can specify plugin version"() {
        when:
        buildScript "plugins { id '$PLUGIN_ID' version '1.0' }"

        then:
        verifyPluginApplied('1.0')
    }

    def "can specify plugin version using gradle properties"() {
        when:
        file("gradle.properties") << "myPluginVersion=2.0"
        buildScript """
            plugins {
                id '$PLUGIN_ID' version "\${myPluginVersion}"

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

    def "mutating managed inputs of a rule is not allowed"() {
        when:
        buildScript '''
            @Managed
            interface Person {
                String getName()
                void setName(String name)
            }

            class RulePlugin extends RuleSource {

                }
            }
        """
        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"
          }
        """