}

    def verifyTestResultWith(TestExecutionResult executionResult, TestResultOutputAssociation outputAssociation) {
        executionResult.assertTestClassesExecuted("org.FailingTest", "org.PassingTest", "org.MixedMethodsTest", "org.NoOutputsTest", "org.EncodingTest", "org.ParameterizedTest", "org.OutputLifecycleTest")

        def mixedMethods = executionResult.testClass("org.MixedMethodsTest")
                .assertTestCount(4, 2, 0)

        });
    }

    private ExecutionResult<Void> doTransitionWithFailures(T toState, Function<ExecutionResult<Void>, ExecutionResult<Void>> action, CurrentState<T> current) {
        ExecutionResult<Void> currentResult = current.asResult();
        state = current.transitioningTo(toState);
        ExecutionResult<Void> result;
        try {
            result = action.apply(currentResult);
        } catch (Throwable t) {

        return this;
    }

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

    @Override
    public ExecutionResult assertNotPostBuildOutput(String expectedOutput) {

        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)

        }
    }

    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;

    }

    private ExecutionResult<Void> fireBeforeModelDiscarded(boolean failed) {
        if (hasFiredBeforeModelDiscarded) {
            return ExecutionResult.succeeded();
        } else {
            hasFiredBeforeModelDiscarded = true;
            return ExecutionResult.maybeFailing(() -> buildModelLifecycleListener.beforeModelDiscarded(gradle, failed));
        }
    }

    @Override

 */

package org.gradle.kotlin.dsl.fixtures

import org.gradle.integtests.fixtures.AbstractIntegrationTest
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.IntegrationTestBuildContext
import org.gradle.kotlin.dsl.resolver.GradleInstallation
import org.gradle.kotlin.dsl.support.zipTo
import org.junit.Before
import java.io.File

        }
        AfterExecutionResult result = executeWithoutCache(cacheableWork.work, context);
        try {
            result.getExecution().ifSuccessfulOrElse(
                executionResult -> storeInCacheUnlessDisabled(cacheableWork, cacheKey, result, executionResult),
                failure -> LOGGER.debug("Not storing result of {} in cache because the execution failed", cacheableWork.getDisplayName())
            );
            return result;

        buildFile << buildLogicForEndOfBuildWait(sleepPeriod)
    }

    @Override
    protected ExecutionResult succeeds(String... tasks) {
        runBuild(tasks)
        waitForBuild()
        throwOnBuildFailure()
        result
    }

    protected ExecutionResult buildTriggeredAndSucceeded() {
        if (!gradle.isRunning()) {
            throw new UnexpectedBuildFailure("Gradle has exited")