when:
        def result = controller.fromBuildModel(true, action)

        then:
        result == "result"

        and:
        1 * workController.scheduleAndRunRequestedTasks(null) >> ExecutionResult.succeeded()

        and:
        1 * modelCreator.fromBuildModel(action) >> "result"

        and:
        1 * finishExecutor.finishBuildTree([]) >> null

        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

        result.clientFailure == null

        and:
        1 * payloadSerializer.deserialize(action) >> internalAction
        1 * buildController.fromBuildModel(false, _) >> { Boolean b, BuildTreeModelAction modelAction -> modelAction.fromBuildModel(modelController) }
        1 * internalAction.execute(_) >> model
        1 * payloadSerializer.serialize(model) >> serialized
    }

        cache.maybePrepareModel {
            delegate.beforeTasks(action)
        }
    }

    override fun <T : Any?> fromBuildModel(action: BuildTreeModelAction<out T>): T? {
        return cache.loadOrCreateModel {
            val model = delegate.fromBuildModel(action)
            if (model == null) BuildTreeModel.NullModel else BuildTreeModel.Model(model)
        }.result()
    }

        action.beforeTasks(new DefaultBuildTreeModelController());
    }

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

    private class DefaultBuildTreeModelController implements BuildTreeModelController {
        @Override

        ModelCreateAction createAction = new ModelCreateAction(buildModelAction);
        try {
            if (buildModelAction.isCreateModel()) {
                Object result = buildController.fromBuildModel(buildModelAction.isRunTasks(), createAction);
                SerializedPayload serializedResult = payloadSerializer.serialize(result);
                return Result.of(serializedResult);
            } else {

        ActionAdapter adapter = new ActionAdapter(action, payloadSerializer);
        try {
            SerializedPayload result = buildController.fromBuildModel(action.isRunTasks(), adapter);
            return Result.of(result);
        } catch (RuntimeException e) {
            RuntimeException clientFailure = e;
            if (adapter.actionFailure != null) {

    @Override
    public void scheduleAndRunTasks(@Nullable EntryTaskSelector selector) {
        runBuild(() -> workController.scheduleAndRunRequestedTasks(selector));
    }

    @Override
    public <T> T fromBuildModel(boolean runTasks, BuildTreeModelAction<? extends T> action) {
        return runBuild(() -> {
            modelCreator.beforeTasks(action);
            if (runTasks && isEligibleToRunTasks()) {

 */

package org.gradle.internal.buildtree;

import javax.annotation.Nullable;

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

    @Nullable
    T fromBuildModel(BuildTreeModelController controller);

/**
 * 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);