import org.gradle.cache.CacheCleanupStrategy;
import org.gradle.cache.CacheOpenException;
import org.gradle.cache.CleanupAction;
import org.gradle.cache.CleanupProgressMonitor;
import org.gradle.cache.IndexedCache;
import org.gradle.cache.IndexedCacheParameters;
import org.gradle.cache.LockOptions;
import org.gradle.cache.PersistentCache;
import org.gradle.cache.internal.CacheFactory;

 * limitations under the License.
 */

package org.gradle.cache.internal;

import com.google.common.cache.Cache;
import com.google.common.cache.CacheBuilder;
import org.gradle.cache.AsyncCacheAccess;
import org.gradle.cache.CacheDecorator;
import org.gradle.cache.CrossProcessCacheAccess;
import org.gradle.cache.FileLock;
import org.gradle.cache.MultiProcessSafeIndexedCache;
import org.slf4j.Logger;

In addition to the local build cache present on a developer's machine, Gradle can make use of remote build caches which can be used by multiple developers.

The idea of a remote cache is to share commonly built task outputs across remote builds to improve build times.

When both remote and local caches are enabled, then the build output is first checked in the local cache.

    def "configuration cache is out of incubation"() {
        given:
        settingsFile << ""

        when:
        run("help", "--configuration-cache")

        then:
        result.assertHasPostBuildOutput("Configuration cache entry stored.")
        !output.contains("Configuration cache is an incubating feature.")
    }

    def "configuration cache for Help plugin task '#task' on empty project"() {

	// updatedSecrets is a wrapper around the shared cache which allows us to record
	// and return our local mutations (since we're very likely to act on an updated
	// secret before the watch reports it).
	updatedSecrets cache.MutationCache

	// Since we join two objects, we'll watch both of them with controllers.
	serviceAccountSynced cache.InformerSynced
	secretSynced         cache.InformerSynced

        "jdks"          | "CACHEDIR_TAG"  | true      | "marked"
        // Caches will be generated by test framework, so marked even if not created
        "caches"        | "NONE"          | false     | "not marked"
        "caches"        | "NONE"          | true      | "not marked"
        "caches"        | "CACHEDIR_TAG"  | false     | "marked"
        "caches"        | "CACHEDIR_TAG"  | true      | "marked"

    @Override
    protected void cleanup() {
        System.out.println("> Cleaning '<gradle-home>/caches/transforms-*/' and '<gradle-home>/caches/<gradle-version>/transforms/*' caches in " + gradleUserHome)
        File caches = new File(gradleUserHome, "caches")

        // <gradle-home>/caches/transforms-*
        List<File> oldCaches = caches.listFiles().findAll {
            it.isDirectory() && it.name.startsWith("transforms-")
        }

"""
    fileSystem.createDirectory(cache.directoryPath)
    writeFile(cache.directoryPath, "$urlKey.0", entryMetadata)
    writeFile(cache.directoryPath, "$urlKey.1", entryBody)
    writeFile(cache.directoryPath, "journal", journalBody)
    cache = Cache(fileSystem, cache.directory.path.toPath(), Int.MAX_VALUE.toLong())
    client =
      client.newBuilder()
        .cache(cache)
        .build()

        then:
        configurationCache.assertStateLoaded()
        outputContains("result = [lib-1.3.jar]")

        when: // run again with different tasks, to verify behaviour when version list is already cached when configuration cache entry is written
        configurationCacheRun("resolve2")

        then:
        configurationCache.assertStateStored()
        outputContains("result = [lib-1.3.jar]")

        when:

  // 1. successful fresh cached GET response
  // 2. unsuccessful (404, 500) fresh cached GET response
  // 3. successful network response
  // 4. successful stale cached GET response
  // 5. unsuccessful response
  @Test
  fun usesCache() {
    val cache = Cache(cacheFs, "cache".toPath(), (100 * 1024).toLong())
    val cachedClient = bootstrapClient.newBuilder().cache(cache).build()