fun isMonitoredAsciidoctorTask() = false // No asciidoctor tasks are cacheable for now

fun Project.isExpectedAsciidoctorCacheMiss() =
// Expected cache-miss for asciidoctor task:
// 1. CompileAll is the seed build for docs:distDocs
// 2. BuildDistributions is the seed build for other asciidoctor tasks
// 3. buildScanPerformance test, which doesn't depend on compileAll

}

// cacheStats keeps track of cache usage stats.
type cacheStats struct {
	hits, miss int
}

func (c cacheStats) empty() bool {
	return c.hits == 0 && c.miss == 0
}

func (c cacheStats) merge(other cacheStats) cacheStats {
	return cacheStats{
		hits: c.hits + other.hits,
		miss: c.miss + other.miss,
	}
}

        firstOutput.assertExists()
        secondOutput.assertExists()
        // first can be loaded from the cache
        result.assertTaskSkipped(first)
        // second cannot be loaded from the cache due to a cache miss
        result.assertTaskNotSkipped(second)
    }

    def "overlapping output directory with first, second then second, first"() {
        def (String first, TestFile firstOutput,

 *
 * The cache key consists of the provided key and the rule. This means that if the implementation of the
 * rule changes, or that its configuration changes, then we will have a cache miss.
 *
 * @param <KEY> the primary key for the cache. This is an explicit input, whereas the rule is an implicit one.
 * @param <DETAILS> the publicly exposed type that a user would see. Typically component metadata details.

			hit := make(map[*profile.Mapping]bool)
			miss := make(map[*profile.Mapping]bool)
			for _, loc := range prof.Location {
				if symbolized(loc) {
					hit[loc.Mapping] = true
				} else {
					miss[loc.Mapping] = true
				}
			}
			if len(miss) == 0 {
				t.Log("no location with missing symbol info was sampled")
			}

			for _, m := range prof.Mapping {
				if miss[m] && m.HasFunctions {

If you have tasks that are re-executing instead of loading their outputs from the cache, then it may point to a problem in your build.
Techniques for debugging a cache miss are explained in the following section.

== Helpful data for diagnosing a cache miss

A cache miss happens when Gradle calculates a build cache key for a task which is different from any existing build cache key in the cache.

			expectMatches:   true,
			expectMatchKind: gvk("apps", "v1", "Deployment"),
		},
		{
			name: "specific rules, match miss",
			criteria: &v1.MatchResources{
				NamespaceSelector: &metav1.LabelSelector{},
				ObjectSelector:    &metav1.LabelSelector{},
				ResourceRules: []v1.NamedRuleWithOperations{{

 */

package org.gradle.caching.internal.operations;

import org.gradle.internal.operations.BuildOperationType;

/**
 * A load operation from the local build cache.
 *
 * A load operation may HIT or MISS.
 * It may also fail.
 * Load operation results and failures are mutually exclusive.
 *
 * @since 8.6
 */

plugins {
    id("gradlebuild.collect-failed-tasks")
    id("gradlebuild.cache-miss-monitor")
}

description = "Provides plugins that are used by Gradle subprojects"

tasks.register("check") {
    dependsOn(subprojects.map { "${it.name}:check" })
}

val clean by tasks.registering {
    val buildLogicPropertiesFile = layout.projectDirectory.file("gradle.properties")
    val rootPropertiesFile = layout.projectDirectory.file("../gradle.properties")

        assertTrue(cache.asMap().containsKey(entry.getKey()));
        assertTrue(cache.asMap().containsValue(entry.getValue()));
        // this getUnchecked() call shouldn't be a cache miss; verified below
        assertEquals(entry.getValue(), cache.getUnchecked(entry.getKey()));
      }
      assertEquals(WARMUP_SIZE, cache.stats().missCount());
      checkValidState(cache);
    }
  }