when:
        withBuildCache().run "compileJava"
        then:
        // :compileJava is not cached, but :jar is still cached as its inputs haven't changed
        executedAndNotSkipped ":compileJava"
    }

    def "non-cacheable task with cache enabled gets cached"() {
        file("input.txt") << "data"
        buildFile << """
            class NonCacheableTask extends DefaultTask {

The -cache flag causes clean to remove the entire go build cache.

The -testcache flag causes clean to expire all test results in the
go build cache.

The -modcache flag causes clean to remove the entire module
download cache, including unpacked source code of versioned
dependencies.

The -fuzzcache flag causes clean to remove files stored in the Go build

        then:
        1 * cacheFactory.open(sharedCacheDir, null, [:], mode(OnDemand), _, NO_CLEANUP) >> cache
    }

    void canSpecifyDisplayNameForDirectoryCache() {
        when:
        builder.withDisplayName("<cache>").open()

        then:
        1 * cacheFactory.open(sharedCacheDir, "<cache>", [:], mode(Shared), _, NO_CLEANUP) >> cache
    }

		}
	}
}

// dropCacheForRequest clears the cache in response to a push request
func (s *DiscoveryServer) dropCacheForRequest(req *model.PushRequest) {
	// If we don't know what updated, cannot safely cache. Clear the whole cache
	if len(req.ConfigsUpdated) == 0 {
		s.Cache.ClearAll()
	} else {
		// Otherwise, just clear the updated configs
		s.Cache.Clear(req.ConfigsUpdated)
	}
}

 * limitations under the License.
 */

package org.gradle.cache;

import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.io.File;
import java.util.List;

/**
 * Represents a location for global Gradle caches.
 *
 * The global cache is managed by Gradle, so we Gradle needs to take care

         * <br><br>
         *
         * Used for read-only file locks/caches, many processes can access the lock target/cache concurrently.
         * <br><br>
         *
         * For {@link PersistentCache} this is the default behaviour and the cache lock is created when cache is opened.
         * To release a lock a cache has to be closed.
         */
        Shared,

        /**

}

description = "Implementation for interacting with HTTP build caches"

dependencies {
    api(projects.stdlibJavaExtensions)
    api(projects.serviceProvider)

    api(libs.httpcore)
    api(libs.inject)
    api(libs.jsr305)

    api(project(":base-services"))
    api(project(":build-cache-spi"))
    api(project(":core-api"))
    api(project(":resources-http"))

plugins {
    id("gradlebuild.distribution.api-java")
    id("gradlebuild.publish-public-libraries")
}

description = """Persistent caches on disk and cross process locking.
    | Mostly for persisting Maps to the disk.
    | Also contains implementations for in-memory caches in front of the disk cache.
""".trimMargin()

dependencies {
    api(projects.concurrent)
    api(projects.stdlibJavaExtensions)
    api(projects.serialization)

			// If it is in the Cache, add it and continue
			// We skip cache if assertions are enabled, so that the cache will assert our eviction logic is correct
			results = append(results, cachedItem)
			cached++
			continue
		}
		regenerated++
		res := s.generate(sr, configClusterSecrets, proxyClusterSecrets, proxy)
		if res != nil {
			s.cache.Add(sr, req, res)
			results = append(results, res)
		}
	}

        given:
        def cachesDir = executer.gradleUserHomeDir.file("caches")
        cachesDir.touch()

        when:
        fails 'hello'

        then:
        cachesDir.isFile()
        assertHasStartupFailure(failure, "Cannot create directory '${executer.gradleUserHomeDir.file("caches")}")
    }

    def "Error message due to unwritable Gradle daemon directory is not scary"() {