/**
     * The execution mode when the task is marked explicitly untracked.
     * The message will be `Task state is not tracked.`.
     */
    public static TaskExecutionMode untracked() {
        return UNTRACKED_NO_REASON;
    }

    /**
     * The execution mode when the task is marked explicitly untracked.
     * The message will be `"Task is untracked because: " + reason`.
     */

 * Attached to a task to declare that the task should be untracked.
 *
 * <p>If a task is untracked, then Gradle will not try to capture its state.
 * That also means that Gradle does not do any optimizations for running the task.
 * For example, such a task will always be out of date and never stored in or loaded from the build cache.
 *
 * <p>There can be different reasons for declaring a task as untracked, for example:
 * <ul>

        _ * task.getOutputs() >> outputs
        _ * outputs.getUpToDateSpec() >> upToDateSpec
    }

    def "untracked"() {
        when:
        def state = repository.getExecutionMode(task, taskProperties)

        then:
        state == DefaultTaskExecutionMode.untracked("For testing")
        _ * task.getReasonNotToTrackState() >> Optional.of("For testing")
        0 * _
    }

    def "no outputs"() {

    private static final ImmutableList<String> NO_HISTORY = ImmutableList.of("No history is available.");
    private static final ImmutableList<String> UNTRACKED = ImmutableList.of("Change tracking is disabled.");

kube::golang::setup_env

cd "${KUBE_ROOT}"

function git_find() {
    # Similar to find but faster and easier to understand.  We want to include
    # modified and untracked files because this might be running against code
    # which is not tracked by git yet.
    git ls-files -cmo --exclude-standard \
        ':!:vendor/*'        `# catches vendor/...` \
        ':!:*/vendor/*'      `# catches any subdir/vendor/...` \

                }
            }

            return Optional.of(task.getReasonNotToTrackState()
                .map(s -> new CachingDisabledReason(CachingDisabledReasonCategory.NOT_CACHEABLE, "Task is untracked because: " + s))
                .orElse(CACHING_NOT_ENABLED));

        }

        if (!taskProperties.hasDeclaredOutputs()) {
            return Optional.of(NO_OUTPUTS_DECLARED);
        }

        "Copying to a directory which contains unreadable content is not supported. " +
        "Declare the task as untracked by using Task.doNotTrackState(). " +
        new DocumentationRegistry().getDocumentationRecommendationFor("information", "incremental_build", "sec:disable-state-tracking")

    void expectUnreadableCopyDestinationFailure() {

cd "${KUBE_ROOT}"

function git_find() {
    # Similar to find but faster and easier to understand.  We want to include
    # modified and untracked files because this might be running against code
    # which is not tracked by git yet.
    git ls-files -cmo --exclude-standard \
        ':!:vendor/*'        `# catches vendor/...` \
        ':!:*/vendor/*'      `# catches any subdir/vendor/...` \

    protected AfterExecutionResult(AfterExecutionResult parent) {
        this(parent, parent.getAfterExecutionOutputState().orElse(null));
    }

    /**
     * State after execution, or {@link Optional#empty()} if work is untracked.
     */
    public Optional<ExecutionOutputState> getAfterExecutionOutputState() {
        return Optional.ofNullable(afterExecutionOutputState);
    }

        currentClosuresEntries.computeInt(thisClosure, (key, oldValue) -> {
            if (oldValue == null) {
                throw new IllegalStateException("leaveClosure called with an untracked instance");
            } else {
                if (oldValue == 1) {
                    return null;
                } else {
                    return oldValue - 1;
                }
            }
        });