}

        @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;

            .withArguments("helloWorld")
            .build();

        assertTrue(result.getOutput().contains("Hello world!"));
        assertEquals(SUCCESS, result.task(":helloWorld").getOutcome());
    }

    private void writeFile(File destination, String content) throws IOException {
        BufferedWriter output = null;
        try {
            output = new BufferedWriter(new FileWriter(destination));

         */
        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.
         */

        """

        when:
        def result = runner().withArguments("testGroovyVersion")
            .withGradleVersion("6.8.3")
            .build()

        then:
        result.task(":testGroovyVersion").getOutcome() == TaskOutcome.SUCCESS

        cleanup:
        testKitDaemons(GradleVersion.version("6.8.3")).killAll()
    }

    def "old TestKit can run build with current Gradle"() {
        given:

            .withArguments("helloWorld")
            .build();

        assertTrue(result.getOutput().contains("Hello world!"));
        assertEquals(SUCCESS, result.task(":helloWorld").getOutcome());
    }

    private void writeFile(File destination, String content) throws IOException {
        BufferedWriter output = null;
        try {
            output = new BufferedWriter(new FileWriter(destination));

        this.path = path;
        this.outcome = outcome;
    }

    @Override
    public String getPath() {
        return path;
    }

    @Override
    public TaskOutcome getOutcome() {
        return outcome;
    }

    @Override
    public String toString() {
        return path + "=" + outcome;
    }

    public void afterExecute(TaskIdentity<?> taskIdentity, TaskState state) {
        TaskStateInternal stateInternal = (TaskStateInternal) state;
        if (stateInternal.isActionable()) {
            switch (stateInternal.getOutcome()) {
                case EXECUTED:
                    executedTasksCount++;
                    break;
                case FROM_CACHE:
                    fromCacheTaskCount++;
                    break;

        return Collections.unmodifiableList(CollectionUtils.filter(tasks, new Spec<BuildTask>() {
            @Override
            public boolean isSatisfiedBy(BuildTask element) {
                return element.getOutcome() == outcome;
            }
        }));
    }

    @Override
    public List<String> taskPaths(TaskOutcome outcome) {