* <p>Only tasks that produce reproducible and relocatable output should be marked with {@code CacheableTask}.</p>
 *
 * <p>Caching for individual task instances can be enabled and disabled via {@link TaskOutputs#cacheIf(String, Spec)} or disabled via {@link TaskOutputs#doNotCacheIf(String, Spec)}.
 * Using these APIs takes precedence over the presence (or absence) of {@code @CacheableTask}.</p>
 *
 * @see DisableCachingByDefault
 *
 * @since 3.0
 */

        when:
        withBuildCache().run cacheableTask

        then:
        executedAndNotSkipped(cacheableTask)
        cacheOperations.assertStoredToLocalCacheForTask(cacheableTask)
        remoteCache.empty

        when:
        pullOnly()
        withBuildCache().run 'clean', cacheableTask

        then:
        skipped(cacheableTask)
        cacheOperations.getPackOperationsForTask(cacheableTask).empty

    // tag::functional-test-build-cache[]
    def "cacheableTask is loaded from cache"() {
        given:
        buildFile << """
            plugins {
                id 'org.gradle.sample.helloworld'
            }
        """

        when:
        def result = runner()
            .withArguments( '--build-cache', 'cacheableTask')
            .build()

        then:

        executedAndNotSkipped(":cacheableTask")

        when:
        succeeds "cacheableTask", "--scan"

        then:
        transitivePluginFixture.appliedOnce(output)
        assertNotAutoApplied(output)
        skipped(":cacheableTask")
    }

package org.gradle.sample

import org.gradle.api.DefaultTask
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.InputFile
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.PathSensitive
import org.gradle.api.tasks.PathSensitivity
import org.gradle.api.tasks.TaskAction

@CacheableTask
class MyCacheableTask extends DefaultTask {
    @InputFile
    @PathSensitive(PathSensitivity.NONE)
    File inputFile

            }

            buildCache {
                registerBuildCacheService(${className}, ${className}ServiceFactory)
            }
        """
    }

    String cacheableTask() {
        """
            @CacheableTask
            class CustomTask extends DefaultTask {

                @Input
                String val = "foo"

                @Input
                List<String> paths = []

import org.gradle.api.Incubating;
import org.gradle.api.tasks.CacheableTask;
import org.gradle.language.c.internal.DefaultCCompileSpec;
import org.gradle.language.nativeplatform.tasks.AbstractNativeSourceCompileTask;
import org.gradle.nativeplatform.toolchain.internal.NativeCompileSpec;

/**
 * Compiles C source files into object files.
 */
@Incubating
@CacheableTask
public abstract class CCompile extends AbstractNativeSourceCompileTask {

 * limitations under the License.
 */

package gradlebuild.integrationtests.tasks

import org.gradle.api.tasks.CacheableTask


/**
 * A test that verifies Gradle can be used with popular third party plugins.
 */
@CacheableTask
abstract class SmokeTest : DistributionTest() {
    override val prefix = "smoke"

import org.gradle.api.DefaultTask
import org.gradle.api.file.ConfigurableFileCollection
import org.gradle.api.file.RegularFileProperty
import org.gradle.api.provider.Property
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.Input
import org.gradle.api.tasks.InputFile
import org.gradle.api.tasks.InputFiles
import org.gradle.api.tasks.OutputFile
import org.gradle.api.tasks.PathSensitive

import org.gradle.api.Task;
import org.gradle.api.tasks.CacheableTask;
import org.gradle.internal.properties.annotations.AbstractTypeAnnotationHandler;
import org.gradle.internal.reflect.validation.TypeValidationContext;

public class CacheableTaskTypeAnnotationHandler extends AbstractTypeAnnotationHandler {
    public CacheableTaskTypeAnnotationHandler() {
        super(CacheableTask.class);
    }

    @Override