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.

    "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",

        gradle.settings.buildCache.let { buildCache ->
            write(buildCache.local)
            write(buildCache.remote)
            write(buildCache.registrations)
        }
    }

    private
    suspend fun DefaultReadContext.readBuildCacheConfiguration(gradle: GradleInternal) {
        gradle.settings.buildCache.let { buildCache ->
            buildCache.local = readNonNull()

    private final BuildCacheController buildCache;
    private final Deleter deleter;
    private final FileSystemAccess fileSystemAccess;
    private final OutputChangeListener outputChangeListener;
    private final Step<? super C, ? extends AfterExecutionResult> delegate;

    public BuildCacheStep(
        BuildCacheController buildCache,
        Deleter deleter,
        FileSystemAccess fileSystemAccess,

  }, {
    "testId" : "org.gradle.performance.regression.buildcache.TaskOutputCachingJavaPerformanceTest.clean check on ephemeral ci with remote http cache",
    "groups" : [ {
      "testProject" : "smallJavaMultiProjectManyExternalDependencies",
      "coverage" : {
        "per_day" : [ "linux" ]
      }
    } ]
  }, {

        then:
        skipped ":compileJava"
        executedAndNotSkipped ":jar"
    }

    def "task results don't get stored when pushing is disabled"() {
        settingsFile << """
            buildCache {
                local {
                    push = false
                }
            }
        """

        when:
        withBuildCache().run "jar"
        then:
        noneSkipped()

                    downloadedResources.removeUnusedEntriesAfterDays = 10
                    createdResources.removeUnusedEntriesAfterDays = 5
                    buildCache.removeUnusedEntriesAfterDays = 15
                }
            }
        """
        settingsFile << """
            caches {
                assert markingStrategy.get() == MarkingStrategy.NONE