import java.util.Map;
import java.util.Properties;
import java.util.stream.Collectors;

/**
 * Generates plugin descriptors from plugin declarations.
 */
@DisableCachingByDefault(because = "Not worth caching")
public abstract class GeneratePluginDescriptors extends DefaultTask {

    private final ListProperty<PluginDeclaration> declarations;
    private final Provider<Map<String, String>> implementationClassById;

import java.util.Properties
import javax.xml.parsers.DocumentBuilderFactory


/**
 * Fetch the latest Kotlin versions and write a properties file.
 * Never up-to-date, non-cacheable.
 */
@UntrackedTask(because = "Not worth tracking")
abstract class UpdateKotlinVersions : DefaultTask() {

    @get:Internal
    abstract val comment: Property<String>

    @get:Internal
    abstract val minimumSupported: Property<String>

import static org.gradle.util.internal.CollectionUtils.collect;

/**
 * Custom task for generating the metadata for a plugin user test.
 *
 * @since 2.13
 */
@DisableCachingByDefault(because = "Not worth caching")
public abstract class PluginUnderTestMetadata extends DefaultTask {

    public static final String IMPLEMENTATION_CLASSPATH_PROP_KEY = "implementation-classpath";

 * is located in the output directory of the transform and is named after the zipped file name
 * minus the extension.
 */
@DisableCachingByDefault(because = "Not worth caching")
public abstract class UnzipTransform implements TransformAction<TransformParameters.None> {

    @PathSensitive(PathSensitivity.NAME_ONLY)
    @InputArtifact

            .flatMap { platform -> subDirsOf(platform) }

    private
    fun unzippedDistroDir(): File? =
        input.get().asFile.listFiles().singleOrNull()
}


@DisableCachingByDefault(because = "Not worth caching")
internal
abstract class UnzipDistribution : TransformAction<TransformParameters.None> {
    @get:PathSensitive(PathSensitivity.NONE)
    @get:InputArtifact
    abstract val input: Provider<FileSystemLocation>

import org.gradle.work.DisableCachingByDefault
import java.text.SimpleDateFormat
import java.util.Date
import java.util.Properties
import java.util.TimeZone


@DisableCachingByDefault(because = "Not worth caching")
abstract class BuildReceipt : DefaultTask() {
    companion object {
        private
        val timestampFormat = newSimpleDateFormatUTC("yyyyMMddHHmmssZ")

        private

 *   windowsStartScriptGenerator.template = resources.text.fromFile('customWindowsStartScript.txt')
 * }
 * </pre>
 */
@DisableCachingByDefault(because = "Not worth caching")
public abstract class CreateStartScripts extends org.gradle.jvm.application.tasks.CreateStartScripts {

    projectVersion = project.version
    projectDirectory = layout.buildDirectory.dir("buildshipProject").get().asFile
}

@DisableCachingByDefault(because = "Not worth caching")
abstract class CreateBuildshipEclipseProjectTask extends DefaultTask {

    @InputFile
    abstract RegularFileProperty getToolingApiShadedJar()

    @Input
    abstract Property<String> getProjectVersion()

Gradle's _incremental build_ feature helps to avoid work that is already done, but once you re-execute a task, any previous results are forgotten.
When you are switching branches back and forth, the local results get rebuilt over and over again, even if you are building something that has already been built before.

# https://go.dev/issue/51723: 'go test' should not stamp VCS metadata
# in the build settings. (It isn't worth the latency hit, given that
# test binaries are almost never distributed to users.)

[short] skip
[!git] skip

exec git init

# The test binaries should not have VCS settings stamped by default.
# (The test itself verifies that.)
go test . ./testonly

# However, setting -buildvcs explicitly should override that and