/**
 * DO NOT CHANGE THIS INTERFACE. It is part of the cross-version protocol.
 *
 * @since 3.3
 */
public interface InternalTaskCachedResult extends InternalTaskResult {
    boolean isFromCache();

        this.taskExecutionDetails = taskExecutionDetails;
    }

    @Override
    public boolean isUpToDate() {
        return this.upToDate;
    }

    @Override
    public boolean isFromCache() {
        return fromCache;
    }

    @Override
    public boolean isIncremental() {
        return taskExecutionDetails.isIncremental();
    }

    @Override
    @Nullable

        boolean incremental = result != null && result.isIncremental();

        if (state.getUpToDate()) {
            return new DefaultTaskSuccessResult(startTime, endTime, true, state.isFromCache(), state.getSkipMessage(), incremental, Collections.emptyList());
        } else if (state.getSkipped()) {
            return new DefaultTaskSkippedResult(startTime, endTime, state.getSkipMessage(), incremental);

            return result instanceof TaskSuccessResult && ((TaskSuccessResult) result).isUpToDate();
        }

        private boolean isFromCache(TaskOperationResult result) {
            return result instanceof TaskSuccessResult && ((TaskSuccessResult) result).isFromCache();
        }
    }

     * not support task output caching.</p>
     *
     * @return {@code true} if the output for this task was from a build cache
     * @since 3.3
     */
    boolean isFromCache();

    override val collectedInformation: Serializable = cacheMiss

    override fun action(taskPath: String, taskResult: TaskOperationResult) {
        if (taskResult is TaskSuccessResult && !taskResult.isFromCache && !taskResult.isUpToDate) {
            println("CACHE_MISS in task $taskPath")
            cacheMiss.set(true)
        }
    }
}


/**

            }

            @Override
            protected Set<Tag> determineTags(PerformanceReportScenario scenario) {
                Set<Tag> result = new HashSet<>();
                if (scenario.isFromCache()) {
                    result.add(FROM_CACHE);
                }

                markFlakyTestInfo(scenario, result);

                if (scenario.isUnknown()) {
                    result.add(UNKNOWN);

            }
            return new DefaultTaskSuccessResult(result.getStartTime(), result.getEndTime(), successResult.isUpToDate(), isFromCache(result), toTaskExecutionDetails(result));
        } else if (result instanceof InternalTaskSkippedResult) {