@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 {",

 */

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"

internal
enum class TopLevelBlockId {
    buildscript,
    plugins,
    pluginManagement,
    initscript;

    val tokenText: String
        get() = name

    companion object {

        fun topLevelBlockIdFor(target: ProgramTarget) = when (target) {
            ProgramTarget.Project -> arrayOf(buildscript, plugins)
            ProgramTarget.Settings -> arrayOf(buildscript, pluginManagement, plugins)

        id                  | pluginsBlock
        "plugins block"     | """
            plugins {
                id 'com.acme.my.plugin' version '1.0'
            }
        """

        "buildscript block" | """
                buildscript {
                    repositories {
                        maven {
                            url "%repoloc%"
                        }
                    }
                    dependencies {

        buildScript(scalaProjectBuildScript(defaultZincVersion, defaultScalaVersion))

        when:
        run 'compileScala'

        then:
        executedAndNotSkipped ':compileScala'

        when:
        run 'compileScala'

        then:
        skipped ':compileScala'

        when:
        buildScript(scalaProjectBuildScript(newZincVersion, newScalaVersion))

import org.gradle.internal.jvm.Jvm

class JavaToolchainIntegrationTest extends AbstractIntegrationSpec implements JavaToolchainFixture {

    def "fails when using an invalid toolchain spec when #description"() {

        buildScript """
            apply plugin: JvmToolchainsPlugin

            abstract class UnpackLauncher extends DefaultTask {
                @Nested
                abstract Property<JavaLauncher> getLauncher()