*/
    DISABLE_CONDITION_SATISFIED,

    /**
     * The work has no outputs declared.
     */
    NO_OUTPUTS_DECLARED,

    /**
     * Work has declared output that is not cacheable.
     *
     * Reasons for non-cacheable outputs:
     * <ul>
     *     <li>an output contains a file tree,</li>
     *     <li>an output is not tracked.</li>
     * </ul>
     */
    NON_CACHEABLE_OUTPUT,

    /**

        def reason = determineNoCacheReason(
            [],
            [cacheableOutputProperty],
            [spec({ false }, "Cacheable test")]
        )

        then:
        reason.category == CachingDisabledReasonCategory.ENABLE_CONDITION_NOT_SATISFIED
        reason.message == "'Cacheable test' not satisfied"
    }

    def "error message contains which cacheIf spec failed to evaluate"() {
        when:

    public boolean isCacheable() {
        return cacheable;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        DefaultConfigurableRule<?> that = (DefaultConfigurableRule<?>) o;
        return cacheable == that.cacheable &&
            Objects.equal(rule, that.rule) &&

    def "cacheable tasks are detected"() {
        expect:
        taskClassInfoStore.getTaskClassInfo(MyCacheableTask).cacheable
    }

    private static class MyNonCacheableTask extends MyCacheableTask {}

    def "cacheability is not inherited"() {
        expect:
        !taskClassInfoStore.getTaskClassInfo(MyNonCacheableTask).cacheable
    }

        TypeMetadata actionMetadata = actionMetadataStore.getTypeMetadata(implementation);
        boolean cacheable = implementation.isAnnotationPresent(CacheableTransform.class);
        DefaultTypeValidationContext validationContext = DefaultTypeValidationContext.withoutRootType(cacheable);
        actionMetadata.visitValidationFailures(null, validationContext);

class CacheableTaskOutcomeCrossVersionSpec 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 {

    }

    /**
     * Is {@code source} a cacheable transport scheme (e.g., http)?
     *
     * Schemes like file:// are not cacheable.
     */
    private boolean isCacheableScheme(URI source) {
        return cachedSchemes.contains(source.getScheme());
    }

    /**
     * Is {@code source} a cacheable URL?
     *
     * A URI is not cacheable if it uses a query string because our underlying infrastructure

    }

    private final List<ConfigurableRule<DETAILS>> configurableRules;
    private final boolean cacheable;

    public DefaultConfigurableRules(List<ConfigurableRule<DETAILS>> rules) {
        this.configurableRules = ImmutableList.copyOf(rules);

        cacheable = computeCacheable();
    }

    private boolean computeCacheable() {
        boolean isCacheable = false;

         * Null if the task was cacheable.
         * Not null if {@link #getCachingDisabledReasonCategory()} is not null.
         */
        @Nullable
        String getCachingDisabledReasonMessage();

        /**
         * The categorisation of the why the task was not cacheable.
         * Null if the task was cacheable.

rootProject.name = 'cacheable-bundle'...