private final RuntimeException failure;

    public AbstractFailure(RuntimeException failure) {
        this.failure = failure;
    }

    @Override
    public boolean isFailure() {
        return true;
    }

    @Override
    public RuntimeException getFailure() {
        return failure;
    }

    @Override
    public void writeTo(int requestId, HttpExchange exchange) {

 */

package org.gradle.test.fixtures.server.http;

import com.sun.net.httpserver.HttpExchange;

import java.io.IOException;

interface ResponseProducer {
    default boolean isFailure() {
        return false;
    }

    /**
     * Called to handle a request. Is *not* called under lock.
     */
    void writeTo(int requestId, HttpExchange exchange) throws IOException;

    /**

            configurationCacheBuildOperations.assertStateStored(false)
        }

        def message = "Configuration cache entry ${details.storeAction}"
        boolean isFailure = spec.result instanceof ExecutionFailure
        if (isFailure) {
            spec.outputContains(message)
        } else {
            spec.postBuildOutputContains(message)
        }

        assertHasProblems(problemDetails)
    }

                ResponseProducer responseProducer = selectProducer(id, httpExchange);
                System.out.printf("[%d] sending response for %s%n", id, outcome.getDisplayName());
                if (!responseProducer.isFailure()) {
                    responseProducer.writeTo(id, httpExchange);
                } else {
                    Throwable failure = responseProducer.getFailure();
                    requestFailed(outcome, failure);

     */
    public abstract ExecutionResult<T> withFailures(ExecutionResult<Void> otherResult);

    /**
     * Casts a failed result.
     */
    public abstract <S> ExecutionResult<S> asFailure();

    public static <T> ExecutionResult<T> succeeded(T value) {
        return new Success<T>() {
            @Override
            public T getValue() {
                return value;
            }
        };

fFailedTest; protected Throwable fThrownException; public void TestFailure(Test, Throwable); public Test failedTest(); public Throwable thrownException(); public String toString(); public String trace(); public String exceptionMessage(); public boolean isFailure(); } junit/framework/JUnit4TestAdapterCac$1.class package junit.framework; synchronized class JUnit4TestAdapterCac$1 extends org.junit.runner.notification.RunListener { void JUnit4TestAdapterCac$1(JUnit4TestAdapterCac, TestResult); public void t...

        result.failures.empty
        result.rethrow()

        when:
        result.failure

        then:
        thrown(IllegalArgumentException)

        when:
        result.asFailure()

        then:
        thrown(IllegalArgumentException)
    }

    def "can query successful void result"() {
        def result = ExecutionResult.succeeded()

        expect:

                ExecutionResult<Void> result = workController.scheduleAndRunRequestedTasks(null);
                if (!result.getFailures().isEmpty()) {
                    return result.asFailure();
                }
            }
            T model = modelCreator.fromBuildModel(action);
            return ExecutionResult.succeeded(model);
        });
    }

    @Override

            throwFailure();
            return false;
        }

        @Override
        public ExecutionResult<Void> asResult() {
            return failure.asFailure();
        }

        @Override
        public boolean inStateAndNotTransitioning(T toState) {
            throwFailure();
            return false;
        }

        @Override