def setup() {
        buildFile << '''
@Managed
interface Thing {
    String getValue()
    void setValue(String v)
}

class MyPlugin extends RuleSource {
    @Model
    void things(ModelMap<Thing> things) { }
}

apply plugin: MyPlugin
'''
    }

    def "nested create rule is executed only as required"() {
        buildFile << '''
model {
    tasks {
        show(Task) {

    def "dependencies in jvm test suites are marked with test classpath attribute"() {
        buildFile.text = """
            plugins {
                id 'jvm-test-suite'
            }
            ${buildFile.text}
        """
        buildFile << """
            testing {
                suites {
                    integration(JvmTestSuite) {
                        dependencies {

        file("settings.gradle").text = "rootProject.name='TestProject'"
        file("someFile").createFile()
        using m2
    }

    def createTaskForCustomDistribution() {
        when:
        buildFile << """
            apply plugin:'distribution'

            distributions {
                custom{
                    contents {
                        from { "someFile" }
                    }

    def setup() {
        buildFile << """
            allprojects {
                apply plugin: 'visual-studio'
            }
        """
        settingsFile << """
            rootProject.name = "${rootProjectName}"
        """
    }

    @ToBeFixedForConfigurationCache
    def "ignores target machine not buildable from project configuration dimensions"() {

        given:
        buildA.buildFile << """
            dependencies {
                implementation "org.test:buildB:1.0"
            }
        """
        buildB.buildFile << """
            dependencies {
                implementation "org.test:buildC:1.0"
            }
        """
        def buildC = singleProjectBuild("buildC") {
            buildFile << """
                apply plugin: 'java'

            .assertHasFileName("Build file '${buildA.buildFile}'")
            .assertHasLineNumber(17)
        failure.assertHasDescription("build B broken")
            .assertHasFileName("Build file '${buildB.buildFile}'")
            .assertHasLineNumber(13)
        failure.assertHasDescription("build C broken")
            .assertHasFileName("Build file '${buildC.buildFile}'")
            .assertHasLineNumber(9)
    }

            rootProject.name = 'B'
            include 'foo', 'bar'
        """
        buildB.buildFile << """
            allprojects {
                apply plugin: 'java'
                group = 'org.test'
                version = '1.0'
            }
        """
        repo.commit('initial')
        buildFile << """
            apply plugin: 'base'

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

        given:
        buildFile()
        goodPlugin()

        expect:
        succeeds "jar"
        output.contains(NO_DESCRIPTOR_WARNING)
    }

    def "jar issues warning if built jar does not contain declared plugin" () {
        given:
        buildFile()
        goodPlugin()
        goodPluginDescriptor()
        buildFile << """
            gradlePlugin {
                plugins {

    }

    @ToBeFixedForConfigurationCache
    def "assemble task constructs all buildable binaries"() {
        given:
        new CHelloWorldApp().writeSources(file("src/main"))

        and:
        buildFile << """
import org.gradle.nativeplatform.platform.internal.NativePlatforms

apply plugin: 'c'

model {
    platforms {
        unknown {
            architecture "unknown"

        buildFile << """
            configurations {
                a
                b
                b.resolve()
            }
            dependencies { a "a:b:c" }
        """
        expect: succeeds()
    }

    def "allows changing a non-empty configuration that does not affect a resolved configuration"() {
        buildFile << """
            configurations {