settingsFile << """
            rootProject.name = "master"
            include 'api'
            include 'shared:api', 'shared:model'
            include 'util'
        """

        def buildFile = file("build.gradle")
        buildFile << """
            allprojects {
                apply plugin: 'java'
                apply plugin: 'idea'
            }

            project(':api') {
                dependencies {

        succeeds(":child:grand:codenarcMain")
        report(file("child/grand"), "main").exists()
    }

    private void writeBuildFile() {
        writeBuildFile(buildFile)
    }

    private static void writeBuildFile(File buildFile) {
        buildFile << """
            apply plugin: "groovy"
            apply plugin: "codenarc"

            ${mavenCentralRepository()}

            dependencies {

        plugin('foo', 'com.example.foo')
        publishToIvy()
        publishToMaven()
        buildFile << """
            afterEvaluate {
                assert publishing.publications.size() == 4
            }
        """

        expect:
        succeeds 'help'
    }
    def publishToMaven() {
        buildFile << """
            apply plugin: 'maven-publish'
            publishing {
                repositories {

import static org.gradle.integtests.fixtures.executer.TaskOrderSpecs.exact

class FinalizerTaskIntegrationTest extends AbstractIntegrationSpec {
    def setup() {
        buildFile '''
            class BreakingTask extends DefaultTask {
                @TaskAction
                def run() {}
            }

            tasks.withType(BreakingTask).configureEach { t ->

        when:
        buildFile << applyGroovyPlugin()
        buildFile << gradleApiDependency()

        file('src/main/groovy/MyPlugin.groovy') << customGroovyPlugin()

        then:
        succeeds 'build'
    }

    def "can use ProjectBuilder to unit test a plugin"() {
        when:
        buildFile << testablePluginProject()

        skipped ":appVisualStudioSolution"
        executedAndNotSkipped getComponentTasks("app")

        when:
        buildFile.text = buildFile.text.replace "projectFile.withXml { }", """
                    projectFile.withXml { xml ->
                        Node globals = xml.asNode().PropertyGroup.find({it.'@Label' == 'Globals'}) as Node
                        globals.appendNode("ExtraInfo", "Some extra info")

        buildFile << defineCacheableTask()
        withBuildCache()
        succeeds "cacheable", "--info"

        expect:
        outputContains "Using local directory build cache for the root build (location = ${cacheDir}, removeUnusedEntriesAfter = 7 days)."
    }

    def "cache entry contains expected contents"() {
        buildFile << defineCacheableTask()
        when:

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

        buildFile << declareManagedExtendingUnmanaged()

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

        buildFile << """
            verify {
                prop.add(null)
            }
        """
        expect:
        def failure = fails("verify")
        failure.assertHasCause("Cannot add a null element to a property of type List.")
    }

    def "has no value when providing null to a list property"() {
        buildFile << """
            verify {

    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: