}

    def "reports task as failed when afterTask closure fails"() {
        when:
        buildFile << """
    gradle.taskGraph.afterTask {
        throw new RuntimeException("afterTask failure")
    }
    task test
"""
        then:
        fails('test')
        failure.assertHasDescription("Execution failed for task ':test'.")
                .assertHasCause("afterTask failure")

    }

    @UnsupportedWithConfigurationCache
    def "does emit result for afterTask failure"() {
        when:
        buildScript """
            task t {
                doLast {}
            }

            gradle.taskGraph.afterTask {
                throw new RuntimeException("!")
            }
        """
        fails "t"

        then:

    }

    @Deprecated("Deprecated in Java")
    override fun afterTask(closure: Closure<*>) {
        @Suppress("DEPRECATION")
        delegate.afterTask(closure)
    }

    @Deprecated("Deprecated in Java")
    override fun afterTask(action: Action<Task>) {
        @Suppress("DEPRECATION")
        delegate.afterTask(action)
    }

    // endregion

    override fun resetState() {

tasks.register('broken') {
    dependsOn ok
    doLast {
        throw new RuntimeException('broken')
    }
}

gradle.taskGraph.beforeTask { Task task ->
    println "executing $task ..."
}

gradle.taskGraph.afterTask { Task task, TaskState state ->
    if (state.failure) {
        println "FAILED"
    }
    else {
        println "done"
    }

tasks.register("ok")

tasks.register("broken") {
    dependsOn("ok")
    doLast {
        throw RuntimeException("broken")
    }
}

gradle.taskGraph.beforeTask {
    println("executing $this ...")
}

gradle.taskGraph.afterTask {
    if (state.failure != null) {
        println("FAILED")
    } else {
        println("done")
    }

        noExceptionThrown()

        where:
        path                          | registrationPoint
        "gradle.taskGraph.beforeTask" | "TaskExecutionGraph.beforeTask"
        "gradle.taskGraph.afterTask"  | "TaskExecutionGraph.afterTask"
    }

    @UnsupportedWithConfigurationCache(because = "tests listener behaviour")
    def "events passed to any task execution listener are synchronised"() {
        createDirs("a", "b", "c")

        then:
        assert classloader.loadClass('Thing').getDeclaredFields()*.name == ["CHANGED"]
    }

    @UnsupportedWithConfigurationCache(because = "taskGraph.afterTask")
    def "new build should be triggered when input files to tasks are changed after each task has been executed, but before the build has completed (changed: #changingInput)"() {
        given:

    }

    @Override
    public void afterTask(final Closure closure) {
        notifyListenerRegistration("TaskExecutionGraph.afterTask", closure);
        taskListeners.add(new ClosureBackedMethodInvocationDispatch("afterExecute", closure));
    }

    @Override
    public void afterTask(final Action<Task> action) {
        notifyListenerRegistration("TaskExecutionGraph.afterTask", action);

     *
     * @param closure The closure to execute when a task has been executed
     * @deprecated This method is not supported when configuration caching is enabled.
     */
    @Deprecated
    void afterTask(Closure closure);

    /**
     * <p>Adds an action to be called immediately after a task has executed. The task is passed to the action as the
     * first parameter.</p>
     *

    }

    @ToBeFixedForConfigurationCache(because = "taskGraph.afterTask")
    def "should report changes that happen when the build is executing"() {
        given:
        buildFile << """
            gradle.taskGraph.afterTask { Task task ->
                if(task.path == ':theTask' && !file('changetrigged').exists()) {