model3[1].message == "It works from project :b"

        and:
        // TODO - should not invalidate all cached state
        fixture.assertStateRecreated {
            gradlePropertyChanged()
            buildModelQueries = 1 // TODO:configuration-cache ???
            projectConfigured(":buildSrc")
            projectsConfigured(":", ":a", ":b", ":c")
            modelsCreated(":a", ":b")

        /**
         * Whether the instrumentation agent was used when computing the cache.
         * With the agent, the class paths may be stored differently, making the caches incompatible with one another.
         */
        val instrumentationAgentUsed: Boolean,
        /**
         * The file system paths that will be ignored during file system checks tracking for the cache fingerprint.

include::sample[dir="snippets/buildCache/http-build-cache/kotlin",files="settings.gradle.kts[tags=http-build-cache]"]
include::sample[dir="snippets/buildCache/http-build-cache/groovy",files="settings.gradle[tags=http-build-cache]"]
====

When attempting to load an entry, a `GET` request is made to `\https://example.com:8123/cache/«cache-key»`.

        then:
        // FIXME Loading from cache destroys the overlap directory, but the task should not be loaded from cache
        fileTaskOutput.assertDoesNotExist()
        localStateDirTaskOutput.assertExists()
        // Task was loaded from cache, so local state was removed
        localStateDirTaskState.assertDoesNotExist()
        // fileTask can be from the cache, but the dirTask cannot due to a cache miss

 */

package org.gradle.internal.cc.impl.isolated

class IsolatedProjectsToolingApiCompositeBuildsIntegrationTest extends AbstractIsolatedProjectsToolingApiIntegrationTest {

    def "invalidates cached state when plugin in buildSrc changes"() {
        given:
        withSomeToolingModelBuilderPluginInBuildSrc()
        settingsFile << """
            include("a")
            include("b")
        """

			t.Fatalf("Unexpected error: %v", err)
		}
	}

	cacher, _, err := newTestCacher(etcdStorage)
	if err != nil {
		t.Fatalf("Couldn't create cacher: %v", err)
	}
	defer cacher.Stop()

	// Given that cacher is always initialized from the "current" version of etcd,
	// we now have a cacher with an empty cache of watch events and a resourceVersion of rv.

    /**
     * Loads the cached model, if available, or else runs the given function to create it and then writes the result to the cache.
     */
    fun <T : Any> loadOrCreateModel(creator: () -> T): T

    /**
     * Loads a cached intermediate model, if available, or else runs the given function to create it and then writes the result to the cache.
     *

    def listener = Stub(ChangingValueDependencyResolutionListener)
    def caches = new ModuleRepositoryCaches(moduleResolutionCache, moduleDescriptorCache, moduleArtifactsCache, artifactAtRepositoryCache)
    def resolveStateFactory = DependencyManagementTestUtil.modelGraphResolveFactory()
    def repo = new CachingModuleComponentRepository(realRepo, caches, resolveStateFactory, cachePolicy, Stub(BuildCommencedTimeProvider), metadataProcessor, listener)

import okhttp3.internal.toNonNegativeInt

/**
 * Given a request and cached response, this figures out whether to use the network, the cache, or
 * both.
 *
 * Selecting a cache strategy may add conditions to the request (like the "If-Modified-Since" header
 * for conditional GETs) or warnings to the cached response (if the cached data is potentially
 * stale).
 */
class CacheStrategy internal constructor(

    }

    def "task can be cached after loaded from cache"() {
        file("input.txt").text = "input"
        buildFile << defineProducerTask()

        // Store in local cache
        withBuildCache().run "producer"

        // Load from local cache
        cleanBuildDir()
        withBuildCache().run "producer"

        // Store to a different local cache