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"

        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 {

        when:
        EclipseProject project = loadToolingModel(EclipseProject)

        then:
        project.classpathContainers.isEmpty()
    }

    def "Project has some classpath containers"() {
        buildFile <<
        """apply plugin: 'java'
           apply plugin: 'eclipse'
           eclipse {
               classpath {
                   containers 'containerPath1', 'containerPath2'
               }
           }

    }

    def "can use GradleRunner to test"() {
        when:
        buildFile << gradleTestKitDependency()
        file("src/test/groovy/Test.groovy") << successfulSpockTest('Test')

        then:
        succeeds 'build'
    }

    def "can use GradleRunner to test concurrently"() {
        when:
        buildFile << gradleTestKitDependency() << """
            test {
                maxParallelForks = 3

        buildFile << """
            task unspecified(type: UnspecifiedCacheabilityTask) {}
        """
        when:
        withBuildCache().run "unspecified"
        then:
        assertCachingDisabledFor NOT_ENABLED_FOR_TASK, "Caching has not been enabled for the task"
    }

    def "cacheability for a cacheable task is null"() {
        buildFile << """

        buildFile """
            unknown(12, "things")
        """

        expect:
        fails()
        failure.assertHasLineNumber(2)
        failure.assertHasCause("Could not find method unknown() for arguments [12, things] on root project 'test' of type ${Project.name}.")
    }

    def failsWhenGettingUnknownPropertyOnTask() {
        buildFile """
            task p

        }
    }

    def "reports task action execution fails with error"() {
        buildFile << """
            task('do-stuff').doFirst {
                throw new ArithmeticException('broken')
            }
        """
        expect:
        fails "do-stuff"

        failure.assertHasFileName(String.format("Build file '%s'", buildFile))
        failure.assertHasLineNumber(3)

        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 {

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 ->

    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: