timeline-not-cacheable.png...

task-execution-cacheable.png...

        when:
        withBuildCache().run("clean", "cacheable", "-PstoreInCache")

        then:
        listCacheFiles().any { it.name == cacheOperations.getCacheKeyForTask(taskPath) }

        when:
        withBuildCache().run("clean", "cacheable")

        then:
        skipped ":cacheable"
    }

    def "task is cacheable after previous failure"() {
        buildFile << """
            task foo {

    private final boolean cacheable;
    private final Optional<String> reasonNotToTrackState;

    public TaskClassInfo(ImmutableList<TaskActionFactory> taskActionFactories, boolean cacheable, Optional<String> reasonNotToTrackState) {
        this.taskActionFactories = taskActionFactories;
        this.cacheable = cacheable;
        this.reasonNotToTrackState = reasonNotToTrackState;
    }

        buildFile """
            task cacheable(type: Cacheable)
            task cacheableWithOverlap(type: Cacheable) {
                outputFile = cacheable.outputFile
            }
        """
        when:
        withBuildCache().run "cacheable", "cacheableWithOverlap"
        then:
        assertCachingDisabledFor null, null, ":cacheable"

        """
        file("input").text = "input file"

        when:
        def result = runner('cacheable').build()

        then:
        result.tasks.collect { it.path } == [':cacheable']
        result.taskPaths(SUCCESS) == [':cacheable']
        result.taskPaths(SKIPPED).empty
        result.taskPaths(UP_TO_DATE).empty
        result.taskPaths(FAILED).empty

import org.gradle.util.GradleVersion

class CacheableTaskProgressEventsCrossVersionSpec extends ToolingApiSpecification {
    def setup() {
        buildFile << """
            apply plugin: 'base'

            task cacheable {
                def outputFile = new File(buildDir, "output")
                inputs.file("input")
                outputs.file(outputFile)
                outputs.cacheIf { true }

                doLast {

        this.requiresDependencies = instanceFactory.serviceInjectionTriggeredByAnnotation(InputArtifactDependencies.class);
        this.requiresInputChanges = instanceFactory.requiresService(InputChanges.class);
        this.cacheable = cacheable;
        this.artifactDirectorySensitivity = artifactDirectorySensitivity;
        this.dependenciesDirectorySensitivity = dependenciesDirectorySensitivity;

            boolean cacheable = topLevelBean.isAnnotationPresent(cacheableAnnotationClass);
            DefaultTypeValidationContext validationContext = createValidationContext(topLevelBean, cacheable || enableStricterValidation);
            if (enableStricterValidation) {
                validateCacheabilityAnnotationPresent(topLevelBean, cacheable, cacheableAnnotationClass, validationContext);
            }

Build logic can override this decision via the runtime API (see below).

== Enable caching of non-cacheable tasks

As we have seen, built-in tasks, or tasks provided by plugins, are cacheable if their class is annotated with the `Cacheable` annotation.
But what if you want to make cacheable a task whose class is not cacheable?