* </ul>
         */
        @Nullable
        String getSkipMessage();

        /**
         * If work was UP_TO_DATE or FROM_CACHE, this will convey the ID of the build that produced the outputs being reused.
         * Value will be null for any other outcome.
         *

import java.util.Map;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;

import static org.gradle.testkit.runner.TaskOutcome.FAILED;
import static org.gradle.testkit.runner.TaskOutcome.FROM_CACHE;
import static org.gradle.testkit.runner.TaskOutcome.NO_SOURCE;
import static org.gradle.testkit.runner.TaskOutcome.SKIPPED;
import static org.gradle.testkit.runner.TaskOutcome.SUCCESS;

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

    @TargetGradleVersion('>=3.5')
    def "cacheable task is reported as FROM_CACHE"() {
        when:
        def pushToCacheEvents = ProgressEvents.create()
        runCacheableBuild(pushToCacheEvents)
        then:
        !cacheableTaskResult(pushToCacheEvents).fromCache

import java.io.File;
import java.io.IOException;
import java.io.UncheckedIOException;
import java.time.Duration;
import java.util.Optional;

import static org.gradle.internal.execution.ExecutionEngine.ExecutionOutcome.FROM_CACHE;

public class BuildCacheStep<C extends WorkspaceContext & CachingContext> implements Step<C, AfterExecutionResult> {
    private static final Logger LOGGER = LoggerFactory.getLogger(BuildCacheStep.class);

import java.time.Duration
import java.time.temporal.ChronoUnit

import static org.gradle.internal.execution.ExecutionEngine.Execution
import static org.gradle.internal.execution.ExecutionEngine.ExecutionOutcome.FROM_CACHE

class BuildCacheStepTest extends StepSpec<TestCachingContext> implements SnapshotterFixture {
    def buildCacheController = Mock(BuildCacheController)

    def beforeExecutionState = Stub(BeforeExecutionState)

            switch (execution.getOutcome()) {
                case SHORT_CIRCUITED:
                    return "NO-SOURCE";
                case FROM_CACHE:
                    return "FROM-CACHE";
                case UP_TO_DATE:
                    return "UP-TO-DATE";
                case EXECUTED_INCREMENTALLY:
                case EXECUTED_NON_INCREMENTALLY:

    String getClassAttr();

    String getTitle();

    String getUrl();

    default boolean isValid() {
        return this != UNTAGGED;
    }

    enum FixedTag implements Tag {
        FROM_CACHE("FROM-CACHE", "badge badge-info", "The test is not really executed - its results are fetched from build cache."),
        FAILED("FAILED", "badge badge-danger", "Regression confidence > 99.9% despite retries."),

         * same workspace).
         */
        UP_TO_DATE,

        /**
         * The outputs of the work have been loaded from the build cache.
         */
        FROM_CACHE,

        /**
         * Executing the work was not necessary to produce the outputs.
         * This is usually due to the work having no inputs to process.
         */
        SHORT_CIRCUITED,

=== Example: Testing cacheable tasks

[source,groovy,indent=0]
.BuildLogicFunctionalTest.groovy
----

If this can’t be done right away, using tests that run all tasks contributed by the plugin several times, for e.g. asserting the `UP_TO_DATE` and `FROM_CACHE` behavior, is also a good strategy.
====

[[config_cache:requirements]]
== Requirements