.run()
        }
        return OutputScrapingExecutionResult.from(output.toString(), error.toString())
    }

    ExecutionResult runBuildWithToolingConnection(Function<ProjectConnection, ExecutionResult> action) {
        return run {
            def result = null
            usingToolingConnection(workingDir) {
                result = action(it)
            }
            result

        this.buildOperationRunner = buildOperationRunner;
    }

    @Override
    public ExecutionResult<Void> execute(GradleInternal gradle, FinalizedExecutionPlan plan) {
        return buildOperationRunner.call(new ExecuteTasks(gradle, plan));
    }

    private class ExecuteTasks implements CallableBuildOperation<ExecutionResult<Void>> {
        private final GradleInternal gradle;
        private final FinalizedExecutionPlan plan;

        return this;
    }

    @Override
    public ExecutionResult assertHasPostBuildOutput(String expectedOutput) {
        return assertContentContains(postBuild.withNormalizedEol(), expectedOutput, "Post-build output");
    }

    @Override
    public ExecutionResult assertNotPostBuildOutput(String expectedOutput) {

        this.buildOperationRunner = buildOperationRunner;
    }

    @Override
    public ExecutionResult<Void> execute(BuildTreeWorkGraph.FinalizedGraph graph) {
        return buildOperationRunner.call(new CallableBuildOperation<ExecutionResult<Void>>() {
            @Override
            public ExecutionResult<Void> call(BuildOperationContext context) {
                return delegate.execute(graph);
            }

        def plan = controller.newWorkGraph()
        controller.populateWorkGraph(plan) { b -> b.addRequestedTasks() }
        controller.finalizeWorkGraph(plan)
        def executionResult = controller.executeTasks(plan)
        executionResult.failures.empty

        def finishResult = controller.finishBuild(null)
        finishResult.failures.empty

        def discardResult = controller.beforeModelDiscarded(false)

        super(stdinPipe, isDaemon, resultAssertion, outputEncoding, execHandleFactory, durationMeasurement);
    }

    @Override
    protected ExecutionResult toExecutionResult(String output, String error) {

    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;

 */

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) =