}
        return new Result<>(result.hasErrors() || hasErrors(problems), result.get(), list);
    }

    public static <T> Result<T> addProblems(Result<T> result, Result<?>... results) {
        final List<ModelProblem> problemsList = new ArrayList<>();

        for (Result<?> result1 : results) {
            for (ModelProblem modelProblem : result1.getProblems()) {
                problemsList.add(modelProblem);

 * <p>
 * The meaning of the value parameter is specific to each concrete subclass. The validity of {@code null}
 * is also to be defined by each subclass. This implementation does allow null values.
 *
 * <p>The result is the last message sent from the daemon back to the daemon client.
 */
public abstract class Result<T> extends Message {

    private final T value;

        }
        return new Result<>(result.hasErrors() || hasErrors(problems), result.get(), list);
    }

    public static <T> Result<T> addProblems(Result<T> result, Result<?>... results) {
        final List<ModelProblem> problemsList = new ArrayList<>();

        for (Result<?> result1 : results) {
            for (ModelProblem modelProblem : result1.getProblems()) {
                problemsList.add(modelProblem);
            }

import java.time.Duration;

public class Result {

    private final Duration duration;
    private final Try<Execution> execution;

    protected Result(Duration duration, Try<Execution> execution) {
        this.duration = duration;
        this.execution = execution;
    }

    protected Result(Result parent) {
        this(parent.getDuration(), parent.getExecution());
    }

        result.asFailure()

        then:
        thrown(IllegalArgumentException)
    }

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

        expect:
        result.value == null
        result.valueOrRethrow == null
        result.failureOrNull == null
        result.failures.empty
        result.rethrow()
    }

    def "can query failed result"() {

        when:
        TestFailure result = serialize(failure, DefaultTestFailure)

        then:
        result.rawFailure.message == 'cause'
        result.details.assertionFailure == true
        result.details.message == 'cause'
        result.details.expected == 'expectedValue'
        result.details.actual == 'actualValue'
        result.details.stacktrace.contains('java.lang.RuntimeException: cause')
    }

        result.baseline("1.0").results << operation(totalTime: 100)
        result.baseline("1.0").results << operation(totalTime: 100)
        result.baseline("1.0").results << operation(totalTime: 100)

        result.baseline("1.3").results << operation(totalTime: 110)
        result.baseline("1.3").results << operation(totalTime: 110)
        result.baseline("1.3").results << operation(totalTime: 111)

        given:
        def evaluation = Mock(TestEvaluation)

        when:
        def result1 = evaluator.apply(owner, evaluation)
        def result2 = evaluator.apply(owner, evaluation)

        then:
        2 * evaluation.evaluate() >>> ["result1", "result2"]
        result1 == "result1"
        result2 == "result2"

        where:
        evaluator << [evaluateInLambda(), evaluateInBlock()]
    }

        emptyListener.onResult(new BuildFinishedResult<String>('result2'))

        then:
        noExceptionThrown()
    }

    abstract class Result<T> implements PhasedActionResult<T> {
        T result
        PhasedActionResult.Phase phase

        Result(T result, PhasedActionResult.Phase phase) {
            this.result = result
            this.phase = phase
        }

    def "can run actions and results are sent to event consumer"() {
        def result1 = 'result1'
        def serializedResult1 = Mock(SerializedPayload)
        def result2 = 'result2'
        def serializedResult2 = Mock(SerializedPayload)

        given:
        payloadSerializer.serialize(result1) >> serializedResult1
        payloadSerializer.serialize(result2) >> serializedResult2

        when: