private val delegate: BuildTreeModelCreator,
    private val cache: BuildTreeConfigurationCache
) : BuildTreeModelCreator {
    override fun <T : Any> beforeTasks(action: BuildTreeModelAction<out T>) {
        cache.maybePrepareModel {
            delegate.beforeTasks(action)
        }
    }

    override fun <T : Any?> fromBuildModel(action: BuildTreeModelAction<out T>): T? {
        return cache.loadOrCreateModel {

        result.buildFailure == null
        result.clientFailure == null

        and:
        1 * buildController.fromBuildModel(_, _) >> { Boolean b, BuildTreeModelAction modelAction ->
            modelAction.beforeTasks(modelController)
            modelAction.fromBuildModel(modelController)
        }
        1 * projectsLoadedAction.execute(_) >> result1
        1 * buildFinishedAction.execute(_) >> result2

    ) {
        this.defaultTarget = defaultTarget;
        this.actionRunner = actionRunner;
    }

    @Override
    public <T> void beforeTasks(BuildTreeModelAction<? extends T> action) {
        action.beforeTasks(new DefaultBuildTreeModelController());
    }

    @Override
    public <T> T fromBuildModel(BuildTreeModelAction<? extends T> action) {

 * limitations under the License.
 */

package org.gradle.internal.buildtree;

import javax.annotation.Nullable;

public interface BuildTreeModelAction<T> {
    void beforeTasks(BuildTreeModelController controller);

    @Nullable
    T fromBuildModel(BuildTreeModelController controller);

package org.gradle.internal.buildtree;

import javax.annotation.Nullable;

/**
 * Responsible for creating a model from the build tree model.
 */
public interface BuildTreeModelCreator {
    <T> void beforeTasks(BuildTreeModelAction<? extends T> action);

    @Nullable
    <T> T fromBuildModel(BuildTreeModelAction<? extends T> action);

        public ModelCreateAction(BuildModelAction buildModelAction) {
            this.buildModelAction = buildModelAction;
        }

        @Override
        public void beforeTasks(BuildTreeModelController controller) {
            // Ignore
        }

        @Override
        public Object fromBuildModel(BuildTreeModelController controller) {

            this.clientAction = clientAction;
            this.payloadSerializer = payloadSerializer;
        }

        @Override
        public void beforeTasks(BuildTreeModelController controller) {
            runAction(controller, clientAction.getProjectsEvaluatedAction(), PhasedActionResult.Phase.PROJECTS_LOADED);
        }

        @Override

    }

    @Override
    public <T> T fromBuildModel(boolean runTasks, BuildTreeModelAction<? extends T> action) {
        return runBuild(() -> {
            modelCreator.beforeTasks(action);
            if (runTasks && isEligibleToRunTasks()) {
                ExecutionResult<Void> result = workController.scheduleAndRunRequestedTasks(null);
                if (!result.getFailures().isEmpty()) {

    }

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

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

    @Deprecated("Deprecated in Java")

tasks.register('ok')

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