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

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

		}
	}
	sort.Strings(fields) // for stable output, regardless of optimizations
	for _, field := range fields {
		println(field)
	}
}

type T struct {
	X int `go:"track"`
	Y int `go:"track"`
	Z int // untracked
}

func (t *T) GetX() int {
	return t.X
}
func (t *T) GetY() int {
	return t.Y
}
func (t *T) GetZ() int {
	return t.Z
}

func samePackage() {
	var t T
	println(t.GetX())

    }

    @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.

        1 * relativeFilePathResolver.resolveForDisplay(overlappingOutputs.overlappedFilePath) >> "relative/path"
    }

    def "caching is disabled for untracked tasks"() {
        when:
        def reason = determineNoCacheReason(
            [inputProperty],
            [cacheableOutputProperty],
            [spec({ true })]
        )

        then:

//
//	$ 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")

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 hgrevision
rm $GOBIN/a$GOEXE

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