class InvalidManagedModelRuleIntegrationTest extends AbstractIntegrationSpec {

    def "provides a useful error message when setting an incompatible type on a managed instance in Groovy"() {
        when:
        buildScript '''
            @Managed
            interface Person {
                int getThumbCount()
                void setThumbCount(int c)
            }

            class RulePlugin extends RuleSource {

class TestKitDependencyClassVisibilityIntegrationTest extends AbstractIntegrationSpec {

    def "test kit dependency is not implicitly put on the test compile classpath"() {
        when:
        buildScript """
            plugins { id "org.gradle.java" }
        """

        file("src/test/java/Test.java") << """
            import $GradleRunner.name;
            class Test {}
        """

        then:

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

    def "rule source can be applied to ModelMap element"() {
        when:
        buildScript '''
            class MessageTask extends DefaultTask {
                @Internal
                String message = "default"

                @TaskAction
                void printMessages() {

        );
        testFile("build.gradle").writelns(
                "buildscript {",
                "    repositories { flatDir { dirs 'repo' }}",
                "    dependencies { classpath name: 'test', version: '1.3' }",
                "}"
        );
        testFile("child/build.gradle").writelns(
                "assert parent.buildscript.classLoader == buildscript.classLoader",
                "task hello {",

        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"

        succeeds 'foo'

        then:
        outputDoesNotContain('Original bar')
    }

    def 'buildscript classpath has proper usage attribute'() {
        buildFile << """
buildscript {
    configurations.classpath {
        def value = attributes.getAttribute(Usage.USAGE_ATTRIBUTE)
        assert value.name == Usage.JAVA_RUNTIME
    }
}
"""

    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"

        file("a/build.gradle") << "task t {}"
        file("a/buildSrc/build.gradle") << ""
        file("b/build.gradle") << "task t {}"
        file("b/buildSrc/build.gradle") << ""

        buildScript """
            task t {
                dependsOn gradle.includedBuild("a").task(":t")
                dependsOn gradle.includedBuild("b").task(":t")
            }
        """

        then: