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

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

    @Override

        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:

    void select(T candidate);

    void fail(Throwable error);

    @Nullable
    T getSelected();

    @Nullable
    Throwable getFailure();

    boolean hasFailure();

    boolean hasSelected();

 */

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;

    /**

    public T getSelected() {
        return selected;
    }

    @Nullable
    @Override
    public Throwable getFailure() {
        return failure;
    }

    @Override
    public boolean hasFailure() {
        return failure != null;
    }

    @Override
    public boolean hasSelected() {
        return selected != null;
    }

    protected List<Throwable> failures = Collections.synchronizedList(new ArrayList<>());

    public void addFailure(final Throwable t) {
        failures.add(t);
    }

    public boolean hasFailure() {
        return !failures.isEmpty();
    }

    public List<Throwable> getFailures() {
        return failures;
    }

            return result;
        }

        @Nullable
        public Throwable getFailure() {
            return failure;
        }

        public boolean hasFailure() {
            return failure != null;
        }
    }

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

            );
            if (result.hasFailure()) {
                // Don't need to unpack the serialized failure. It will already have been reported and is not used by anything downstream of this action.
                throw new ReportedException();
            }