result.getExecution(),
                        result.getCachingState(),
                        result.getReusedOutputOriginMetadata(),
                        result.getExecutionReasons()
                    );
                    operationContext.setResult(operationResult);
                    result.getExecution().getFailure().ifPresent(operationContext::failed);

                assertNotNull(event.getProject());
                assertNotNull(event.getExecution());
                assertNotNull(event.getMojo());
                assertNull(event.getCause());

                log.add("beforeMojoExecution " + event.getProject().getArtifactId() + ":"
                        + event.getExecution().getExecutionId());
            }

        this.duration = duration;
        this.execution = execution;
    }

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

    public static Result failed(Throwable t, Duration duration) {
        return new Result(duration, Try.failure(t));
    }

    public static Result success(Duration duration, Execution outcome) {

        then:
        1 * workerThreadRegistry.workerThread >> true
        1 * executionQueue.submit(_) >> { args -> task = args[0] }

        when:
        task.getExecution().run()

        then:
        1 * workerDaemonFactory.getWorker(_) >> worker
        1 * worker.execute(_, _) >> { spec, buildOperation ->
            assert spec.implementationClass == TestExecutable.class

        PerformanceTestExecution performanceTestExecution = getExecution(testHistory);
        if (performanceTestExecution == null || performanceTestExecution.getCleanTasks() == null) {
            return "";
        }
        return Joiner.on(" ").join(performanceTestExecution.getCleanTasks());
    }

    private static PerformanceTestExecution getExecution(PerformanceTestHistory testHistory) {

        context.getTaskExecutionMode().getRebuildReason().ifPresent(request::forceNonIncremental);
        request.withValidationContext(context.getValidationContext());
        Result result = request.execute();
        result.getExecution().ifSuccessfulOrElse(
            success -> state.setOutcome(convertOutcome(success.getOutcome())),
            failure -> state.setOutcome(new TaskExecutionException(task, failure))
        );

            getOriginMetadata() >> delegateOriginMetadata
            getOutputFilesProducedByWork() >> delegateOutputFiles
        }
        def delegateResult = Stub(CachingResult) {
            getExecution() >> Try.successful(delegateExecution)
            getDuration() >> delegateDuration
            getAfterExecutionOutputState() >> Optional.of(delegateOutputState)
        }

        super(parent);
        this.workspace = workspace;
    }

    @Override
    public <T> Try<T> getOutputAs(Class<T> type) {
        return getExecution()
            .map(execution -> execution.getOutput(workspace))
            .map(type::cast);
    }

/**
 * Represents an execution.
 */
public interface ConditionalExecution<T> {
    /**
     * Provides the Runnable that should be executed once the resource lock is acquired.
     */
    Runnable getExecution();

    /**
     * Blocks waiting for this execution to complete. Returns a result provided by the execution.
     */
    T await();

    /**
     * This method will be called upon completion of the execution.

    private final RunnableFuture<T> runnable;

    public AbstractConditionalExecution(final Callable<T> callable) {
        this.runnable = new FutureTask<T>(callable);
    }

    @Override
    public Runnable getExecution() {
        return runnable;
    }

    @Override
    public T await() {
        boolean interrupted = false;
        while (true) {
            try {
                finished.await();