} else if (cacheEntryRequiresCommit) {
            val projectUsage = collectProjectUsage()
            commitCacheEntry(projectUsage.reused)
            problems.projectStateStats(projectUsage.reused.size, projectUsage.updated.size)
            cacheEntryRequiresCommit = false
            // Can reuse the cache entry for the rest of this build invocation
            cacheAction = ConfigurationCacheAction.LOAD
        }

     *
     * @since 8.7
     */
    String getOriginBuildInvocationId();

    /**
     * The build cache key of the work in the origin build invocation.
     *
     * @since 8.7
     */
    byte[] getOriginBuildCacheKeyBytes();

    /**
     * The execution time of the work in the build that produced the outputs being reused.
     *
     * @since 8.7
     */

     * A list of messages describing the first few reasons encountered that caused the work to be executed.
     * An empty list means the work was up-to-date and hasn't been executed.
     */
    public ImmutableList<String> getExecutionReasons() {
        return executionReasons;
    }

    /**
     * If a previously produced output was reused in some way, the reused output's origin metadata is returned.
     */

    def "can use multiple action implementations with different classpath roots and loaded from same ClassLoader"() {
        settingsFile.text = 'rootProject.name = "not broken"'

        // Ensure daemon is reused
        toolingApi.requireIsolatedDaemons()

        // Copy each of the action classes into its own classes directory and load into a single ClassLoader

        DefaultClassPath.of(paths.collect { file(it) } as Iterable<File>)
    }

    ClassLoader classLoader(ClassPath classPath) {
        new URLClassLoader(classPath.asURLArray)
    }

    def "class loaders are reused when parent, class path and implementation hash are the same"() {
        expect:
        def root = classLoader(classPath("root"))
        cache.get(id1, classPath("c1"), root, null) == cache.get(id1, classPath("c1"), root, null)

@IntegrationTestTimeout(180)
class WorkerDaemonLifecycleTest extends AbstractDaemonWorkerExecutorIntegrationSpec {
    String logSnapshot = ""

    def "worker daemons are not reused across builds"() {
        fixture.withWorkActionClassInBuildScript()
        buildFile << """
            import org.gradle.workers.internal.WorkerDaemonFactory

            task runInWorker1(type: WorkerTask) {

        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) {

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.

        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])