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

[[sec:continuous_build_untracked]]
=== Inputs of untracked tasks
Changes to the inputs of <<incremental_build.adoc#sec:disable-state-tracking,untracked tasks>> or tasks that have no outputs may not trigger a build.

[[sec:continuous_build_project_dir]]
=== Changes to files outside of project directories

    def setup() {
        _ * context.identity >> identity
        _ * context.history >> Optional.of(executionHistoryStore)
    }

    def "loads execution history and removes untracked outputs when output is not captured"() {
        when:
        def result = step.execute(work, context)

        then:
        1 * executionHistoryStore.load(uniqueId) >> Optional.of(previousExecutionState)

    }

    @Override
    public TaskExecutionMode getExecutionMode(TaskInternal task, TaskProperties properties) {
        if (task.getReasonNotToTrackState().isPresent()) {
            return DefaultTaskExecutionMode.untracked(task.getReasonNotToTrackState().get());
        }
        // Only false if no declared outputs AND no Task.upToDateWhen spec. We force to true for incremental tasks.

//
//	$ dd if=/dev/zero bs=1 seek=4 count=4 conv=notrunc of=filename.gz
//
// See https://golang.org/issue/14937.
func TestGZIPFilesHaveZeroMTimes(t *testing.T) {
	// To avoid spurious false positives due to untracked GZIP files that
	// may be in the user's GOROOT (Issue 18604), we only run this test on
	// the builders, which should have a clean checkout of the tree.
	if testenv.Builder() == "" {
		t.Skip("skipping test on non-builder")

    @Internal
    boolean hasTaskActions();

    @Internal
    Spec<? super TaskInternal> getOnlyIf();

    /**
     * Return the reason for not to track state.
     *
     * Gradle considers the task as untracked if the reason is present.
     * When not tracking state, a reason must be present. Hence the {@code Optional} represents the state of enablement, too.
     *
     * @see org.gradle.api.tasks.UntrackedTask
     */

stdout '^\tbuild\tvcs.modified=false$'
rm $GOBIN/a$GOEXE

# Building with -buildvcs=false suppresses the info.
go install -buildvcs=false
go version -m $GOBIN/a$GOEXE
! stdout vcs.revision
rm $GOBIN/a$GOEXE

# An untracked file is shown as modified, even if it isn't part of the build.
cp ../../outside/empty.txt .
go install
go version -m $GOBIN/a$GOEXE
stdout '^\tbuild\tvcs=fossil\n'
stdout '^\tbuild\tvcs.modified=true$'
rm empty.txt

        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        1 * previousExecutionState.outputFilesProducedByWork >> outputFilesProducedByWork
        0 * _
    }

    def "does not store untracked outputs"() {
        when:
        def result = step.execute(work, context)

        then:
        result == delegateResult
        1 * delegate.execute(work, context) >> delegateResult

        then:

            failure.assertHasDocumentedCause("Cannot access input property 'rootSpec\$1' of task ':copy'. " +
                "Accessing unreadable inputs or outputs is not supported. " +
                "Declare the task as untracked by using Task.doNotTrackState(). " +
                new DocumentationRegistry().getDocumentationRecommendationFor("information", "incremental_build", "sec:disable-state-tracking")
            )