}
        }
    }

    val failingTask by registering {
        doLast {
            problems.forNamespace("buildscript").throwing {
                id("broken-task", "Task should not be called")
                    .contextualLabel("Task 'failingTask' should not be called")
                    .severity(Severity.ERROR)
                    .withException(RuntimeException("The 'failingTask' should not be called"))

        }
    }
}

tasks.register('failingTask') {
    doLast {
        problems.forNamespace('buildscript').throwing {
            it.id('broken-task', 'Task should not be called')
                .contextualLabel("Task 'failingTask' should not be called")
                .severity(Severity.ERROR)
                .withException(new RuntimeException("The 'failingTask' should not be called"))

@SuppressWarnings("IntegrationTestFixtures")
class RichConsoleBasicGroupedTaskLoggingFunctionalTest extends AbstractBasicGroupedTaskLoggingFunctionalTest {
    ConsoleOutput consoleType = ConsoleOutput.Rich

    private final StyledOutput failingTask = styled(Ansi.Color.RED, Ansi.Attribute.INTENSITY_BOLD).text("> Task :failing").styled(null).text(" FAILED").off()
    private final StyledOutput succeedingTask = styled(Ansi.Attribute.INTENSITY_BOLD).text("> Task :succeeding").off()

        given:
        buildFile << """
            task failingTask {
                doFirst {
                    throw new GradleException('task failed intentionally')
                }
            }
        """

        when:
        runBuild('failingTask')

        then:
        thrown(BuildException)
        with (taskFailureResult(':failingTask')) {
            !executionReasons.empty

        buildFile("""
            abstract class FailingTask extends DefaultTask {
                @Input
                abstract Property<String> getStringInput()

                @TaskAction
                void doStuff() {
                    println("Hello world")
                }
            }

            tasks.register("failingTask", FailingTask) {

            }
        """
    }

    private void failingDependenciesForTestTask() {
        buildFile << """
            task failingTask { doLast { throw new RuntimeException() } }

            test.dependsOn failingTask
        """
    }

    private void setupSubproject() {
        def subprojectDir = file('subproject')
        goodCode(subprojectDir)

    }

    void 'finalizer tasks work with --continue (#requestedTasks, #failingTask)'() {
        setupProject()
        executer.beforeExecute {
            withArguments('--continue')
        }

        buildFile << """
            ${failingTask}.doLast { throw new RuntimeException() }
        """

        expect:
        2.times {

    static class BrokenTask extends DefaultTask {
        @OutputFiles
        FileCollection getOutputFiles() {
            throw new Exception("BOOM!")
        }
    }

    static class FailingTask extends DefaultTask {
        @TaskAction
        void execute() {
            throw new RuntimeException("BOOM!")
        }
    }

    /**