def setup() {
        executer.withArguments("-i")
        buildFile << """
            plugins {
                id("java-library")
            }
            tasks.withType(JavaCompile) {
                options.compilerArgs << '-Xlint:all,-options' << '-Werror'
            }
        """
        buildFile << compilerConfiguration()
    }

    def "can compile good code"() {
        given:

                String getManagedData()
                void setManagedData(String managedData)
            }
        """

        buildFile << declareManagedExtendingUnmanaged()

        buildFile << """
            class MutateComponentRules extends RuleSource {
                @Mutate
                void mutateUnmanaged(ModelMap<UnmanagedComponentSpec> components) {

    def "Gradle API and TestKit dependency can be resolved and used by concurrent Gradle builds"() {
        given:
        setupProjects(CONCURRENT_BUILDS_PROJECT_COUNT) { projectDirName, buildFile ->
            buildFile << testablePluginProject()
            file("$projectDirName/src/test/groovy/MyTest.groovy") << gradleApiAndTestKitClassLoadingTestClass()
        }

        expect:

    TestFile pluginDir = file("buildSrc/plugin")

    void usesKotlin(TestFile dir) {
        def buildfile = dir.file("build.gradle.kts")
        if (!buildfile.file) {
            buildfile.createFile()
        }
        buildfile.text = KotlinDslTestUtil.kotlinDslBuildSrcScript + buildfile.text
    }

    def setup() {
        executer.withRepositoryMirrors()
        file("buildSrc/settings.gradle.kts") << """

    }
}
'''

        when:
        run "show"

        then:
        output.contains("t.number: 12")
        output.contains("t.file: ${buildFile}")
    }

    def "cannot configure a reference property using nested closure"() {
        buildFile << '''
@Managed interface Person extends Named {
    Address getAddress()
    void setAddress(Address a)
}

@Managed interface Address {

            class Foo {
            }
        '''
        expect:
        succeeds(':compileScala', '--info')
        postBuildOutputContains('Stopped 1 worker daemon')

        when:
        buildFile.text = buildFile.text.replace('SESSION', 'DAEMON')

        then:
        succeeds(':compileScala', '--info')
        postBuildOutputDoesNotContain('Stopped 1 worker daemon')
    }

import spock.lang.Issue

class TaskUpToDateIntegrationTest extends AbstractIntegrationSpec {
    @Issue("https://issues.gradle.org/browse/GRADLE-3540")
    def "order of #annotation marks task not up-to-date"() {
        buildFile << """
            class MyTask extends DefaultTask {
                @Output${files ? "Files" : "Directories"} FileCollection out

                @TaskAction def exec() {

                .publish()
        buildFile << """
            dependencies {
                testImplementation(testFixtures('com.acme:external-module:1.3'))
            }
            repositories {
                maven {
                    url "${mavenRepo.uri}"
                }
            }
        """
        when:
        def resolve = new ResolveTestFixture(buildFile, "testCompileClasspath")

        given:
        buildFile << """
            apply plugin: 'java'

            task expect {
                assert project.components.mainComponent.get() == components.java
            }
        """

        expect:
        succeeds "expect"
    }

    def "Java plugin adds outgoing variant for main source set"() {
        buildFile << """
            plugins {
                id 'java'

            ConfigureUtil.configure(configClosure, p);
        }

        File getBuildFile() {
            def buildFile = projectDir.file("build.gradle")
            if (!buildFile.exists()) {
                buildFile.createFile()
            }
            return buildFile
        }
    }