calculatedValue.get() == "initial"

        when:
        state1.applyToMutableState {
            calculatedValue.set("updated")
        }

        then:
        calculatedValue.get() == "updated"

        when:
        state1.applyToMutableState {
            state2.applyToMutableState {
                // Thread no longer owns the project state
                calculatedValue.set("bad")

        }

        @Override
        public void visitConsumableConfigurations(Consumer<LocalConfigurationGraphResolveMetadata> visitor) {
            model.applyToMutableState(p -> {
                VariantIdentityUniquenessVerifier.buildReport(configurationsProvider).assertNoConflicts();

                configurationsProvider.visitAll(configuration -> {

     * However, it is currently easy for state to leak from one project to another so this is not a strong guarantee.
     */
    void applyToMutableState(Consumer<? super T> action);

    /**
     * Returns whether or not the current thread has access to the mutable model.
     */
    boolean hasMutableState();

    /**

    def setup() {
        def projectState = Stub(ProjectState)
        _ * projectRegistry.stateFor(_) >> projectState
        _ * projectState.applyToMutableState(_) >> { Consumer consumer -> consumer.accept(Stub(ProjectInternal)) }
    }

    def "resolves project dependency"() {
        setup:
        def selector = TestComponentIdentifiers.newSelector(":project")

        }

        @Override
        @SuppressWarnings("deprecation")
        public void applyTasksTo(Context context, ExecutionPlan plan) {
            rootProjectState.applyToMutableState(rootProject -> {
                resolutionContext = resolver.prepareDependencyHandler(rootProject.getDependencies());

    }

    private void runProjectConfigureAction(final ProjectInternal project, final Action<? super Project> configureAction) {
        project.getOwner().applyToMutableState(p -> buildOperationRunner.run(new CrossConfigureProjectBuildOperation(project) {
            @Override
            public void run(BuildOperationContext context) {

        _ * gradleInternal.owner >> buildState
        _ * buildState.projects >> buildProjectRegistry
        _ * buildProjectRegistry.allProjects >> [projectState]
        _ * projectState.applyToMutableState(_) >> { Consumer consumer -> consumer.accept(projectInternal) }
        _ * context.gradle >> gradleInternal
    }

    def "empty test execution request configures no tasks"() {

            // Cross-project ModelRegistry operations do not happen concurrently.
            synchronized (DependentComponentsReport.class) {
                ((ProjectInternal) getProject()).getOwner().applyToMutableState(project -> {
                    ModelRegistry modelRegistry = getModelRegistry();

        project.stepEvaluationListener(listener, _) >> { listener, step ->
            step.execute(listener)
            null
        }
        project.getOwner() >> mutationState
        mutationState.applyToMutableState(_) >> { Consumer consumer -> consumer.accept(project) }
    }

    void "nothing happens if project was already configured"() {
        given:
        state.configured()

        when:
        evaluate()

            this.project = project;
            this.state = state;
        }

        @Override
        public void run(final BuildOperationContext context) {
            project.getOwner().applyToMutableState(p -> {
                // Note: beforeEvaluate and afterEvaluate ops do not throw, instead mark state as failed
                try {
                    state.toBeforeEvaluate();