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

        cacheConfigurations.releasedWrappers.setRemoveUnusedEntriesAfterDays(2)
        cacheConfigurations.snapshotWrappers.setRemoveUnusedEntriesAfterDays(2)
        cacheConfigurations.buildCache.setRemoveUnusedEntriesAfterDays(2)
        cacheConfigurations.cleanup.set(Cleanup.DISABLED)

        then:
        noExceptionThrown()

        when:
        cacheConfigurations.finalizeConfigurationValues()

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

        delegate.includeFlat(projectNames)
    }

    override fun getStartParameter(): StartParameter =
        delegate.startParameter

    override fun buildCache(action: Action<in BuildCacheConfiguration>) =
        delegate.buildCache(action)

    override fun getSourceControl(): SourceControl =
        delegate.sourceControl

    override fun getProviders(): ProviderFactory =
        delegate.providers

https://blog.jetbrains.com/kotlin/2018/01/kotlin-1-2-20-is-out/[You can opt into it] (which is recommended) by adding the following to build scripts:

====
include::sample[dir="snippets/buildCache/caching-android-projects/kotlin",files="build.gradle.kts[tags=cacheKapt]"]
include::sample[dir="snippets/buildCache/caching-android-projects/groovy",files="build.gradle[tags=cacheKapt]"]
====

== Unit test execution

 */

plugins {
    id("gradlebuild.internal.java")
    id("application")
}

description = "Example client application using the build-cache library"

dependencies {
    implementation(projects.buildCache)
    implementation(projects.buildCacheBase)
    implementation(projects.buildCacheLocal)
    implementation(projects.buildCachePackaging)
    implementation(projects.buildCacheSpi)