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 {

 */

package gradlebuild.integrationtests.tasks

import org.gradle.api.tasks.CacheableTask


/**
 * A test that provides an IDE as environment for checking IDE and Gradle behavior during synchronization process.
 * These tests are running using `forking` executor, since current Gradle distribution has to be used as a Gradle version for IDE.
 */
@CacheableTask
abstract class SmokeIdeTest : DistributionTest() {

package org.gradle.language.cpp.tasks;

import org.gradle.api.tasks.CacheableTask;
import org.gradle.language.cpp.tasks.internal.DefaultCppCompileSpec;
import org.gradle.language.nativeplatform.tasks.AbstractNativeSourceCompileTask;
import org.gradle.nativeplatform.toolchain.internal.NativeCompileSpec;

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

import org.gradle.api.provider.Property;
import org.gradle.api.tasks.CacheableTask;
import org.gradle.api.tasks.Input;
import org.gradle.api.tasks.OutputFile;
import org.gradle.api.tasks.TaskAction;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;

@CacheableTask
public abstract class TomlFileGenerator extends DefaultTask {

import org.gradle.api.GradleException
import org.gradle.api.tasks.CacheableTask
import org.gradle.api.tasks.TaskAction
import java.io.File


/**
 * This [Task][org.gradle.api.Task] checks that the contents of a given accepted API changes files
 * are present in alphabetical order (by type, then member), and throws an exception and reports
 * any changes that are not.
 */
@CacheableTask