settingsFile << """
            buildCache {
                $localCacheConfig
            }
        """
        execute()

        then:
        cached()
        localCache.empty

        when:
        assert remoteCache.cacheDir.deleteDir()
        settingsFile << """
            buildCache.remote.enabled = false
            buildCache.local.enabled = true

    private final BuildCacheController buildCache;
    private final boolean emitDebugLogging;

    public AbstractResolveCachingStateStep(
        BuildCacheController buildCache,
        boolean emitDebugLogging
    ) {
        this.buildCache = buildCache;
        this.emitDebugLogging = emitDebugLogging;
    }

    @Override

@SelfType(AbstractIntegrationSpec)
trait DirectoryBuildCacheFixture {
    private TestBuildCache buildCache

    @Before
    void setupCacheDirectory() {
        // Make sure cache dir is empty for every test execution
        buildCache = new TestBuildCache(temporaryFolder.file("cache-dir").deleteDir().createDir())
        settingsFile << buildCache.localCacheConfiguration()
    }

    // Spock 2 executes @Before after the setup() methods

        private final ImmutableSortedMap<String, String> config;

        private BuildCacheDescription(BuildCache buildCache, String type, ImmutableSortedMap<String, String> config) {
            this.className = GeneratedSubclasses.unpackType(buildCache).getName();
            this.push = buildCache.isPush();
            this.type = type;
            this.config = config;
        }

        @Override

        def artifactFileCopy = file("artifact")
        // move it out of the local for us to use
        buildCache.getCacheEntry(initialPackOp.details.cacheKey.toString()).copyBytesTo(artifactFileCopy)
        buildCache.deleteCacheEntry(initialPackOp.details.cacheKey.toString())
        assert !buildCache.hasCacheEntry(initialPackOp.details.cacheKey.toString())

        when:
        settingsFile.text = ""

        then:
        skipped ":compileJava"
    }

    def "credentials can be specified via DSL"() {
        httpBuildCacheServer.withBasicAuth("user", "pass")
        settingsFile << """
            buildCache {
                remote.credentials {
                    username = "user"
                    password = "pass"
                }
            }
        """

        when:

.Custom cacheable BundleTask
====
include::sample[dir="snippets/buildCache/cacheable-bundle-task/kotlin",files="build.gradle.kts[tags=bundle-task]"]
include::sample[dir="snippets/buildCache/cacheable-bundle-task/groovy",files="build.gradle[tags=bundle-task]"]
====
- (1) Add `@CacheableTask` to enable caching for the task.

rootProject.name = "configure-built-in-caches"
// tag::configure-directory-build-cache[]
buildCache {
    local {
        directory = File(rootDir, "build-cache")
    }
}
// end::configure-directory-build-cache[]

// tag::configure-http-build-cache[]
buildCache {
    remote<HttpBuildCache> {
        url = uri("https://example.com:8123/cache/")
        credentials {
            username = "build-cache-user"

    @Override
    ResolveIncrementalCachingStateStep<IncrementalChangesContext> createStep() {
        return new ResolveIncrementalCachingStateStep<>(buildCache, false, delegate)
    }

    def executionStateChanges = Mock(ExecutionStateChanges)
    def previousExecutionState = Mock(PreviousExecutionState)

    def "uses cache key from execution history when no changes"() {

    "linux" : 428
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.buildcache.TaskOutputCachingJavaPerformanceTest.clean assemble for abi change with local cache",
  "durations" : [ {
    "testProject" : "largeJavaMultiProject",
    "linux" : 828
  } ]
}, {
  "scenario" : "org.gradle.performance.regression.buildcache.TaskOutputCachingJavaPerformanceTest.clean assemble for non-abi change with local cache",