when:
        configurationCacheRun "help", "--offline"
        then:
        configurationCache.assertStateStored()

        // Now repeat invocations in different order to make sure both entries can be reused
        when:
        configurationCacheRun "help"
        then:
        configurationCache.assertStateLoaded()

        when:
        configurationCacheRun "help", "--offline"
        then:

        result.assertHasPostBuildOutput("Configuration cache entry stored.")

        when:
        configurationCacheRun("ok")

        then:
        result.assertHasPostBuildOutput("Configuration cache entry reused.")

        when:
        configurationCacheFails("broken")

        then:
        outputContains("Configuration cache entry discarded with 2 problems.")
        problems.assertFailureHasProblems(failure) {

     */
    public ImmutableList<String> getExecutionReasons() {
        return executionReasons;
    }

    /**
     * If a previously produced output was reused in some way, the reused output's origin metadata is returned.
     */
    public Optional<OriginMetadata> getReusedOutputOriginMetadata() {
        return Optional.ofNullable(reusedOutputOriginMetadata);
    }

        endorseFrom.targetComponent.nodes[0].ownStrictVersionConstraints.getModules().size() == 1
        endorseFrom.targetComponent.nodes[0].ownStrictVersionConstraints == endorsedStrictVersions //instance reused
    }

    def "collects multiple endorsed strict versions from one module"() {
        when:
        def endorseFrom = edge(root, false, null, nextNode(12), true)
        root.collectEndorsedStrictVersions([endorseFrom])

 */

package org.gradle.internal.execution;

import org.gradle.internal.execution.workspace.ImmutableWorkspaceProvider;

/**
 * A unit of work that will only be executed atomically and its outputs be reused indefinitely from an immutable workspace.
 */
public interface ImmutableUnitOfWork extends UnitOfWork {
    /**
     * Returns the {@link ImmutableWorkspaceProvider} to allocate a workspace to execution this work in.
     */

        when:
        file('foo/Changing.java').text = toWindows(TEXT_WITH_LINE_ENDINGS)
        cleanWorkspace()
        execute("taskWithInputs")

        then:
        reused(":taskWithInputs")

        when:
        file('foo/Changing.jpg').bytes = BINARY_CONTENT_WITH_CRLF
        cleanWorkspace()
        execute("taskWithInputs")

        then:

        """
    }

    @Override
    TestJvmComponent getComponent() {
        return new TestJavaComponent()
    }

    @Requires(UnitTestPreconditions.Windows)
    def "compiler daemon is not reused on Windows with Java agent"() {
        withSingleProjectSources()
        def javaAgent = new JavaAgentFixture()
        javaAgent.writeProjectTo(testDirectory)

        buildFile << """

          },
          "route": {
           "cluster": "outbound|8000||httpbin.default.svc.cluster.local",
           "timeout": "0s",
           "retry_policy": {
            "retry_on": "connect-failure,refused-stream,unavailable,cancelled,retriable-status-codes",
            "num_retries": 2,
            "retry_host_predicate": [
             {
              "name": "envoy.retry_host_predicates.previous_hosts",

When the cache entry can be reused, Gradle short-circuits the entire sync operation and simply returns the cached result to the IDE.

Generally, the settings and build scripts affect the IDE model, but the source code of the projects does not.
So, when these scripts change the cache entry cannot be reused.
When this happens, Gradle falls back to fine-grained caching.

and furthermore provides reuse of the structs used for the request and response.

Note that Responses sent for serialization are automatically reused for similar requests.
If the response contains shared data it will cause issues, since each unique response is reused.
To disable this behavior, use `(SingleHandler).WithSharedResponse()` to disable it.

## Streaming Requests