*
     * @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
     */

    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

			name: "retry patch request when an 'connection refused' error is returned",
			client: func() *clientsetfake.Clientset {
				client := clientsetfake.NewSimpleClientset()

				reqcount := 0
				client.PrependReactor("patch", "pods", func(action clienttesting.Action) (bool, runtime.Object, error) {
					defer func() { reqcount++ }()
					if reqcount == 0 {
						// return an connection refused error for the first patch request.

          },
          "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",

            }
        }
        settingsFile << withHttpBuildCacheServer()

        // We see connection refused because the first partial request is retried,
        // then the subsequent is flat refused because we stopped the server.
        String errorPattern = /(Connect to 127\.0\.0\.1:\d+ \[\/127\.0\.0\.1\] failed: Connection refused|127\.0\.0\.1:\d+ failed to respond|Connection reset)/

        when:

				inst.Prefix[repIndex] |= PrefixIgnored
			}
		}
	}

	// If REX was present, mark implicit if all the 1 bits were consumed.
	if rexIndex >= 0 {
		if rexUsed != 0 {
			rexUsed |= PrefixREX
		}
		if rex&^rexUsed == 0 {
			inst.Prefix[rexIndex] |= PrefixImplicit
		}
	}

	inst.DataSize = dataMode
	inst.AddrSize = addrMode
	inst.Mode = mode
	inst.Len = pos

			if err := store.loadUsers(ctx, regUser, newCache.iamUsersMap); err != nil {
				return err
			}
			bootstrapTraceMsg("loading regular groups")
			if err := store.loadGroups(ctx, newCache.iamGroupsMap); err != nil {
				return err
			}
		}

		bootstrapTraceMsg("loading user policy mapping")
		// load polices mapped to users
		if err := store.loadMappedPolicies(ctx, regUser, false, newCache.iamUserPolicyMap); err != nil {

        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: