}

    def "does not clean up stale outputs for untracked tasks"() {
        def untrackedStaleFile = file("build/untracked/stale-output-file").createFile()
        def untrackedOutputFile = file("build/untracked/output.txt")
        def trackedStaleFile = file("build/tracked/stale-output-file").createFile()
        def trackedOutputFile = file("build/tracked/output.txt")

        buildFile("""

        then:
        assertCachingDisabledFor NOT_ENABLED_FOR_TASK, "Task is untracked because: Untracked for testing from API"
    }


    def "cacheability for a untracked task is NOT_ENABLED_FOR_TASK with message"() {
        buildFile """
            task untrackedTrackWithReason(type: UntrackedTrackWithReason) {}
        """
        when:
        withBuildCache().run "untrackedTrackWithReason"
        then:

                .withContext("Copying to a directory which contains unreadable content is not supported.")
                .withAdvice("Declare the task as untracked by using Task.doNotTrackState().");
        } else if (isDestinationDir && task instanceof Sync) {
            builder.withSummary("Cannot access a file in the destination directory.")

    # 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/*' "${DIRS_TO_AVOID[@]}" "$@"
}

function git_grep() {
    # We want to include modified and untracked files because this might be
    # running against code which is not tracked by git yet.

            loadedOutputDir.mkdirs()
            loadedOutputDir.file("output.txt") << "output"
            throw failure
        }

        then:
        0 * _
    }

    def "does not store untracked result in cache"() {
        given:
        def execution = Mock(Execution)

        when:
        def result = step.execute(work, context)

        then:
        result == delegateResult

        }
    }

    /**
     * Stores the results of the given work in the build cache, unless storing was disabled for this execution or work was untracked.
     * <p>
     * The former is currently used only for tasks and can be triggered via {@code org.gradle.api.internal.TaskOutputsEnterpriseInternal}.
     */

             additionalData.asMap == [ 'typeName' : 'MyTransformAction' ]
         }
    }

    def "untracked tasks don't need a disable caching by default reason"() {
        javaTaskSource << """
            import org.gradle.api.*;
            import org.gradle.api.tasks.*;

            @UntrackedTask(because = "untracked for validation test")
            public abstract class MyTask extends DefaultTask {
            }

        exitsContinuousBuildSinceNotWatchingAnyLocationsExceptForConfigCache()

        where:
        description      | taskConfiguration
        "no outputs"     | ""
        "untracked task" | "outputs.file('output/marker'); doNotTrackState('for test')"
    }

    def "basic smoke test"() {
        given:
        def markerFile = file("input/marker")

        when:

                  to use for the Wireguard routing rule. [Default: 99]'
                type: integer
              xdpEnabled:
                description: 'XDPEnabled enables XDP acceleration for suitable untracked
                  incoming deny rules. [Default: true]'
                type: boolean
              xdpRefreshInterval:
                description: 'XDPRefreshInterval is the period at which Felix re-checks

		if i := bytes.IndexByte(out, ' '); i > 0 {
			out = out[:i]
		}
		rev, commitTime, err = parseRevTime(out)
		if err != nil {
			return Status{}, err
		}
	}

	// Also look for untracked files.
	out, err = vcsHg.runOutputVerboseOnly(rootDir, "status")
	if err != nil {
		return Status{}, err
	}
	uncommitted := len(out) > 0

	return Status{
		Revision:    rev,