*
 * In the external resource example, a record may consist of the external resource URI and
 * the external resource text. Then when we need to check if the resource is up-to-date,
 * we can ask the service by calling {@code isUpToDate(IN, OUT)} with
 * the URI as an input.
 *
 * It's up to the service implementation to determine:
 *
 * - the type of the input which allows requesting its up-to-date ness ({@link IN}

        this.skipped = skipped;
        this.upToDate = upToDate;
        this.message = message;
    }

    public boolean isSkipped() {
        return skipped;
    }

    public boolean isUpToDate() {
        return upToDate;
    }

    @Nullable
    public String getMessage() {
        return message;
    }

        super(startTime, endTime);
        this.upToDate = upToDate;
        this.fromCache = fromCache;
        this.taskExecutionDetails = taskExecutionDetails;
    }

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

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

    @Override
    public boolean isIncremental() {

        private boolean isSkipped(TaskOperationResult result) {
            return result instanceof TaskSkippedResult;
        }

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

        private boolean isFromCache(TaskOperationResult result) {

        1 * implicitInput2.getInput() >> '/foo/baz'
        1 * implicitInput2.getOutput() >> 'abcdef987'
        1 * validator.isValid(cachePolicy, _) >> true
        1 * service.isUpToDate('/foo/bar', 'abcdef012') >> true
        1 * service.isUpToDate('/foo/baz', 'abcdef987') >> false
        2 * serviceRegistry.find(SomeService) >> service
        2 * service.withImplicitInputRecorder(_) >> service

    /**
     * Returns whether this task was up-to-date.
     *
     * @return {@code true} if this task was up-to-date
     */
    boolean isUpToDate();

public interface TaskSuccessResult extends TaskExecutionResult, SuccessResult {
    /**
     * Returns whether this task was up-to-date.
     *
     * @return {@code true} if this task was up-to-date
     */
    boolean isUpToDate();

    /**
     * Returns whether the output for this task was pulled from a build cache when using

    private val externalResourceConnector: ExternalResourceConnector,
    private val cachedExternalResourceIndex: CachedExternalResourceIndex<String>
) {

    fun isUpToDate(uri: URI): Boolean =
        if (startParameter.isOffline) {
            true
        } else {
            val externalResourceName = ExternalResourceName(uri)

    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)
        }
    }
}


/**

        val outputXmlPath = parameters.testTaskPathToJUnitXmlLocation.get().get(taskPath) ?: return

        val taskResult = event.result

        if (taskResult is TaskSuccessResult && (taskResult.isFromCache || taskResult.isUpToDate)) {
            println("##teamcity[importData type='junit' path='$outputXmlPath/TEST-*.xml' verbose='true']")
        }
    }
}

if (isTeamCityParallelTestsEnabled) {