if (buildState instanceof NestedBuildState) {
                ExecutionResult<Void> result = ((NestedBuildState) buildState).finishBuild();
                finishNestedBuildsFailures.addAll(result.getFailures());
            }
        });

        RuntimeException reportableFailure = exceptionAnalyser.transform(finishNestedBuildsFailures);
        ExecutionResult<Void> finishResult = buildLifecycleController.finishBuild(reportableFailure);

    private final Action<ExecutionResult> resultAssertion;
    private final PipedOutputStream stdinPipe;
    private final boolean isDaemon;

    private final DurationMeasurement durationMeasurement;
    private final AtomicReference<ExecHandle> execHandleRef = new AtomicReference<>();

        }
    }

    public static class InProcessExecutionResult implements ExecutionResult {
        protected static final Spec<String> NOT_BUILD_SRC_TASK = t -> !t.startsWith(":buildSrc:");
        protected final List<String> executedTasks;
        protected final Set<String> skippedTasks;
        private final ExecutionResult outputResult;

        this.checkJdkWarnings = checkJdkWarnings;
    }

    @Override
    public void execute(ExecutionResult executionResult) {
        String normalizedOutput = executionResult.getNormalizedOutput();
        String error = executionResult.getError();
        boolean executionFailure = executionResult instanceof ExecutionFailure;

import org.gradle.internal.build.ExecutionResult;

/**
 * Executes the work scheduled for a build. Prior to execution, the work will be prepared by a {@link org.gradle.initialization.TaskExecutionPreparer}.
 */
public interface BuildWorkExecutor {
    /**
     * Executes the given work and returns the failures.
     */
    ExecutionResult<Void> execute(GradleInternal gradle, FinalizedExecutionPlan plan);

 */

package org.gradle.kotlin.dsl.caching.fixtures

import org.gradle.integtests.fixtures.executer.ExecutionResult


internal
fun ExecutionResult.classLoadingCache(action: ClassLoadingCache.() -> Unit) =
    action(ClassLoadingCache(this))


internal
class ClassLoadingCache(private val result: ExecutionResult) : KotlinDslCacheFixture {

    override fun misses(vararg cachedScripts: CachedScript) =

            buildController.finalizeWorkGraph();
        }
    }

    @Override
    public ExecutionResult<Void> execute() {
        CountDownLatch complete = new CountDownLatch(controllers.size());
        Map<BuildController, ExecutionResult<Void>> results = new ConcurrentHashMap<>();

        // Start work in each build
        for (BuildController buildController : controllers.values()) {

                consumer.accept(((TaskNode) dependency).getTask());
            }
        }
    }

    private ExecutionResult<Void> doRun() {
        try {
            return workerLeaseService.runAsWorkerThread(workGraph::runWork);
        } catch (Throwable t) {
            return ExecutionResult.failed(t);
        }
    }

    private class BuildOpRunnable implements Runnable {

 */

package org.gradle.internal.buildtree;

import org.gradle.internal.build.ExecutionResult;

/**
 * Responsible for running all scheduled work for the build tree.
 */
public interface BuildTreeWorkExecutor {
    /**
     * Runs the scheduled work and returns a result object containing any failures.
     */
    ExecutionResult<Void> execute(BuildTreeWorkGraph.FinalizedGraph graph);

    String getJarTaskPath() {
        "${projectPath}:$JAR_TASK_NAME"
    }

    void assertBuildTasksExecuted(ExecutionResult result) {
        result.assertTaskNotSkipped(getCompileTaskPath())
        result.assertTaskNotSkipped(getJarTaskPath())
    }

    void assertBuildTasksSkipped(ExecutionResult result) {
        result.assertTaskSkipped(getCompileTaskPath())
        result.assertTaskSkipped(getJarTaskPath())
    }