*
 * 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 DefaultJavaCompileTaskSuccessResult(DefaultTaskSuccessResult delegate, List<InternalAnnotationProcessorResult> annotationProcessorResults) {
        super(delegate.getStartTime(), delegate.getEndTime(), delegate.isUpToDate(), delegate.isFromCache(), delegate.getOutcomeDescription(), delegate.isIncremental(), delegate.getExecutionReasons());
        this.annotationProcessorResults = annotationProcessorResults;
    }

    @Nullable

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

        super(startTime, endTime, outcomeDescription, incremental, executionReasons);
        this.upToDate = upToDate;
        this.fromCache = fromCache;
    }

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

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

func (v *VersionFile) Write(vp *EtcdVersionPair) error {
	// We do write only if file content differs from given EtcdVersionPair.
	isUpToDate, err := v.equals(vp)
	if err != nil {
		return fmt.Errorf("failed to to check if version file %s should be changed: %v", v.path, err)
	}
	if isUpToDate {
		return nil
	}
	// We do write + rename instead of just write to protect from version.txt
	// corruption under full disk condition.