class ArtifactDeclarationIntegrationTest extends AbstractIntegrationSpec {
    ResolveTestFixture resolve = new ResolveTestFixture(buildFile, "compile")

    def setup() {
        settingsFile << """
            rootProject.name = 'test'
        """
        buildFile << """
            def usage = Attribute.of('usage', String)
            allprojects {
                dependencies {

    ResolveTestFixture resolve = new ResolveTestFixture(buildFile, "conf")

    def setup() {
        mavenRepo.module("org", "default-dependency").publish()
        mavenRepo.module("org", "explicit-dependency").publish()
        settingsFile << """
            rootProject.name = 'test'
        """
        buildFile << """
configurations {
    conf
    child.extendsFrom conf
}
repositories {

    def resolve = new ResolveTestFixture(buildFile, "compile").expectDefaultConfiguration('runtime')
    MavenModule bom
    MavenModule moduleA

    def setup() {
        resolve.prepare()
        resolve.addDefaultVariantDerivationStrategy()
        settingsFile << "rootProject.name = 'testproject'"
        buildFile << """
            repositories { maven { url "${mavenHttpRepo.uri}" } }

@SuppressWarnings('IntegrationTestFixtures')
class JavaProjectIntegrationTest extends AbstractIntegrationTest {
    @Test
    void compilationFailureBreaksBuild() {
        TestFile buildFile = testFile("build.gradle")
        buildFile.writelns("apply plugin: 'java'")
        testFile("src/main/java/org/gradle/broken.java") << "broken"

        ExecutionFailure failure = executer.withTasks("build").runWithFailure()

        given:
        buildFile << '''
            verify {
                prop.put('key', project.provider { null })
                expected = null
            }
            '''.stripIndent()

        expect:
        succeeds('verify')
    }

    def "has no value when providing a null map to a map property"() {
        given:
        buildFile << '''
            verify {

    def setup() {
        javaProjectUnderTest.writeSourceFiles()
    }

    def "can define no rules"() {
        given:
        buildFile << """
            jacocoTestCoverageVerification {
                violationRules {}
            }
        """

        when:
        succeeds TEST_AND_JACOCO_COVERAGE_VERIFICATION_TASK_PATHS

        then:

        then:
        targetDir.file(settingsFile).exists()
        !targetDir.file(buildFile).exists()

        def buildLogicDir = targetDir.file(incubating ? "build-logic" : "buildSrc")
        assertBuildLogicSources(dsl, language, buildLogicDir, settingsFile, buildFile, javaMajorVersion)

        assertApplicationProjectsSources(buildFile, language, "org.example.", ext)

        when:
        succeeds "build"

        def fixture = new ResolveFailureTestFixture(buildFile)

        given:
        def build = pluginAndLibraryBuild("included-build")
        settingsFile << """
            pluginManagement {
                includeBuild("${build.buildName}")
            }
        """

        when:
        buildFile << """
            configurations.create("conf") {

        singleProjectBuild("greeter") {
            buildFile << """
                apply plugin: 'swift-library'
            """
            fixture.library.writeToProject(it)
        }
        def commit = repo.commit('initial commit')

        and:
        singleProjectBuild("app") {
            buildFile << """
                apply plugin: 'swift-application'

        buildFile """
            interface Thing extends Named { }

            def t = objects.newInstance(Thing, "thingName")
            assert t.name == "thingName"
"""

        expect:
        succeeds()
    }

    def "plugin can create instance of abstract class with name property"() {
        buildFile """
            abstract class Thing {