def projects = registry.projectsFor(build.buildIdentifier)

        expect:
        !state.hasMutableState()

        and:
        projects.withMutableStateOfAllProjects {
            assert state.hasMutableState()
            projects.withMutableStateOfAllProjects {
                assert state.hasMutableState()
            }
            assert state.hasMutableState()
        }

        and:

     *
     * <p>Any attempt to lock a project by some other thread will block while the given action is running. This includes calls to {@link ProjectState#applyToMutableState(Consumer)}.
     */
    void withMutableStateOfAllProjects(Runnable runnable);

    /**

    }

    @Override
    public void scheduleRequestedTasks(GradleInternal gradle, @Nullable EntryTaskSelector selector, ExecutionPlan plan) {
        gradle.getOwner().getProjects().withMutableStateOfAllProjects(() -> {
            buildTaskScheduler.scheduleRequestedTasks(gradle, selector, plan);

            if (buildModelParameters.isConfigureOnDemand() && gradle.isRootBuild()) {

            return projects;
        }

        @Override
        public void withMutableStateOfAllProjects(Runnable runnable) {
            withMutableStateOfAllProjects(Factories.toFactory(runnable));
        }

        @Override
        public <T> T withMutableStateOfAllProjects(Factory<T> factory) {
            ResourceLock allProjectsLock = workerLeaseService.getAllProjectsLock(owner.getIdentityPath());

                }
            }
            if (tasks.isEmpty()) {
                return false;
            }
            controller.getGradle().getOwner().getProjects().withMutableStateOfAllProjects(() -> {
                createPlan();
                controller.prepareToScheduleTasks();
                controller.populateWorkGraph(plan, workGraph -> workGraph.addEntryTasks(tasks));
            });

    }

    private void fireWhenReady() {
        // We know that we're running single-threaded here, so we can use coarse grained project locks
        gradleInternal.getOwner().getProjects().withMutableStateOfAllProjects(
            () -> buildOperationRunner.run(
                new NotifyTaskGraphWhenReady(DefaultTaskExecutionGraph.this, graphListeners.getSource(), gradleInternal)
            )
        );
    }

            write(state.identityPath)
        }
        // Encode the build state using the contextualized IO service for the nested build
        state.projects.withMutableStateOfAllProjects {
            gradle.serviceOf<ConfigurationCacheIO>().writeIncludedBuildStateTo(
                stateFileFor(state.buildDefinition),
                buildTreeState
            )
        }
    }

        configurationTimeBarrier.cross()
    }

    private
    fun writeConfigurationCacheState(stateFile: ConfigurationCacheStateFile) =
        host.currentBuild.gradle.owner.projects.withMutableStateOfAllProjects {
            cacheIO.writeRootBuildStateTo(stateFile)
        }

    private
    fun writeConfigurationCacheFingerprint(layout: ConfigurationCacheRepository.Layout, reusedProjects: Set<Path>) {

            } else if (node instanceof SelfExecutingNode) {
                return true
            } else {
                return false
            }
        }
        _ * projectStateRegistry.withMutableStateOfAllProjects(_) >> { Runnable r -> r.run() }
    }

    def cleanup() {
        parentWorkerLease.leaseFinish()
        workerLeases.stop()
    }

    def "collects task failures"() {