}

        @Nullable
        private static String getSkipMessage(ExecutionEngine.Execution execution) {
            switch (execution.getOutcome()) {
                case SHORT_CIRCUITED:
                    return "NO-SOURCE";
                case FROM_CACHE:
                    return "FROM-CACHE";
                case UP_TO_DATE:

        Result result = request.execute();
        result.getExecution().ifSuccessfulOrElse(
            success -> state.setOutcome(convertOutcome(success.getOutcome())),
            failure -> state.setOutcome(new TaskExecutionException(task, failure))
        );
        return new TaskExecuterResult() {
            @Override

        this.taskName = taskName;
    }

    public void setOutcome(String taskOutcome) {
        if (this.taskOutcome != null) {
            throw new AssertionError(taskName + " task's outcome is set twice!");
        }
        this.taskOutcome = taskOutcome;
    }

    public String getOutcome() {
        return taskOutcome;
    }

    public String getName() {
        return taskName;

         */
        Optional<OriginMetadata> getOriginMetadata();
    }

    interface Execution {
        /**
         * Get how the outputs have been produced.
         */
        ExecutionOutcome getOutcome();

        /**
         * Get the object representing the produced output.
         * The type of value returned here depends on the {@link UnitOfWork} implmenetation.
         */

            this.mode = mode;
            this.workOutput = workOutput;
        }

        @Override
        public ExecutionOutcome getOutcome() {
            return mode;
        }

        @Override
        public Object getOutput(File workspace) {
            return workOutput.getOutput(workspace);
        }

        @Override

        1 * taskListener.beforeExecute(taskIdentity)
        1 * taskExecutionListener.beforeExecute(task)

        then:
        1 * delegate.execute(task, state, executionContext) >> {
            state.setOutcome(failure)
            return TaskExecuterResult.WITHOUT_OUTPUTS
        }

        then:
        1 * taskExecutionListener.afterExecute(task, state)
        1 * task.getTaskIdentity() >> taskIdentity

                        contextAwareTaskLogger.setFallbackBuildOperationId(currentOperation.getId());
                    }
                } catch (Throwable t) {
                    state.setOutcome(new TaskExecutionException(task, t));
                    return TaskExecuterResult.WITHOUT_OUTPUTS;
                }

                TaskExecuterResult result = delegate.execute(task, state, context);

        if (task == null) {
            task = new GroupedTaskOutputFixture(taskName);
            tasks.put(taskName, task);
        }

        task.addOutput(taskOutput);
        task.setOutcome(taskOutcome);
    }

    private void consumeTransformOutput(Matcher matcher) {
        String initialSubjectType = matcher.group(1);
        String subject = matcher.group(2);