}

        // Enabled caching if task type is annotated with @CacheableTask
        if (taskClassInfo.isCacheable()) {
            task.getOutputs().cacheIf("Annotated with @CacheableTask", Specs.SATISFIES_ALL);
        }
        taskClassInfo.getReasonNotToTrackState()
            .ifPresent(task::doNotTrackState);

        return task;
    }

WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/

package cacher

import (
	"context"
	"fmt"
	"testing"

	clientv3 "go.etcd.io/etcd/client/v3"

	"k8s.io/apimachinery/pkg/api/apitesting"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"

        return createCacheSubDir(version.version, type)
    }

    TestFile createCacheSubDir(String name, MarkerFileType type = MISSING_MARKER_FILE) {
        def versionDir = cachesDir.file(name).createDir()
        def markerFile = versionDir.file(MARKER_FILE_PATH)
        type.process(markerFile)
        return versionDir
    }

    TestFile getGcFile(TestFile currentCacheDir) {

func (c *LocalFileCache) getEntry(key cacheKey, ignoreResourceVersion bool) (*cacheEntry, string) {
	cacheHit := false

	c.mux.Lock()
	defer func() {
		c.mux.Unlock()
		wasmCacheLookupCount.With(hitTag.Value(strconv.FormatBool(cacheHit))).Increment()
	}()

	if len(key.checksum) == 0 && strings.HasPrefix(key.downloadURL, ociURLPrefix) {

     * @since 5.0
     */
    NON_CACHEABLE_TREE_OUTPUT,

    /**
     * Condition enabling caching isn't satisfied.
     * <p>
     * E.g. for a task caching is disabled via {@code org.gradle.api.tasks.TaskOutputs#cacheIf(Spec)}.
     */
    CACHE_IF_SPEC_NOT_SATISFIED,

    /**
     * Condition disabling caching satisfied.
     * <p>

package routes

import (
	handlersmetrics "k8s.io/apiserver/pkg/endpoints/handlers/metrics"
	apimetrics "k8s.io/apiserver/pkg/endpoints/metrics"
	"k8s.io/apiserver/pkg/server/mux"
	cachermetrics "k8s.io/apiserver/pkg/storage/cacher/metrics"
	etcd3metrics "k8s.io/apiserver/pkg/storage/etcd3/metrics"
	flowcontrolmetrics "k8s.io/apiserver/pkg/util/flowcontrol/metrics"
	peerproxymetrics "k8s.io/apiserver/pkg/util/peerproxy/metrics"

    void configurationCacheRun(List<String> tasks, int daemonId = 0) {
        def ccOptions = [
            // TODO: the version of KGP we use still accesses Task.project from a cacheIf predicate
            "-Dorg.gradle.configuration-cache.internal.task-execution-access-pre-stable=true",
            "--stacktrace",
            "--${ConfigurationCacheOption.LONG_OPTION}".toString(),
        ]

    listener.cacheConditionalHit(call, response)
    listener.cacheHit(call, response)
    listener.cacheMiss(call)
    listener.satisfactionFailure(call, response)
    logRecorder
      .assertLogMatch(Regex("""cacheConditionalHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))
      .assertLogMatch(Regex("""cacheHit: Response\{protocol=h2, code=200, message=, url=$url\}"""))

	return NewRawStorage(config, newFunc, newListFunc, resourcePrefix)
}

// NewRawStorage creates the low level kv storage. This is a work-around for current
// two layer of same storage interface.
// TODO: Once cacher is enabled on all registries (event registry is special), we will remove this method.

 * It also allows attaching an explanation about why a certain work unit is not made cacheable.
 *
 * <p>Caching for individual task instances can be enabled and disabled via {@link TaskOutputs#cacheIf(String, Spec)} or disabled via {@link TaskOutputs#doNotCacheIf(String, Spec)}.
 * Using these APIs takes precedence over the presence (or absence) of {@code @DisableCachingByDefault}.</p>
 *
 * @see org.gradle.api.tasks.CacheableTask