gradle.rootProject {
                tasks.register('verifyBuildCache') {
                    doLast {
                        def buildCache = services.get(BuildCacheConfiguration)
                        assert buildCache.remote instanceof AnotherBuildCache
                        assert buildCache.registrations.size() == 4
                    }
                }
            }
        """

        expect:

    @Nullable
    @Override
    public BuildCache getRemote() {
        return remote;
    }

    @Override
    public void setRemote(@Nullable BuildCache remote) {
        this.remote = remote;
    }

    @Override
    public <T extends BuildCache> T remote(Class<T> type) {
        return remote(type, Actions.doNothing());
    }

    @Override

        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"() {

import org.gradle.caching.configuration.BuildCache;

public class DefaultBuildCacheServiceRegistration implements BuildCacheServiceRegistration {
    private final Class<? extends BuildCacheServiceFactory<?>> factoryType;
    private final Class<? extends BuildCache> configurationType;

    def "remote build cache configuration is exposed"() {
        given:
        httpBuildCacheServer.start()
        def url = "${httpBuildCacheServer.uri}/"
        settingsFile << """
            buildCache {
                local {
                    enabled = false
                }
                remote(org.gradle.caching.http.HttpBuildCache) {
                    enabled = true
                    url = "$url"