_ * 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"() {

     */
    ProjectInternal getMutableModel();

    /**
     * Returns the lock that will be acquired when accessing the mutable state of this project via {@link #applyToMutableState(Consumer)} and {@link #fromMutableState(Function)}.
     * A caller can optionally acquire this lock before calling one of these accessor methods, in order to avoid those methods blocking.
     *

            // 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();

        gradle.getOwner().ensureProjectsConfigured();
        for (ProjectState projectState : gradle.getOwner().getProjects().getAllProjects()) {
            projectState.ensureConfigured();
            projectState.applyToMutableState(project -> {
                final Collection<AbstractTestTask> testTasks = project.getTasks().withType(AbstractTestTask.class);
                tasksToExecute.addAll(testTasks);
            });
        }
    }

    }

    @Provides
    protected ModelRegistry createModelRegistry(ModelRuleExtractor ruleExtractor) {
        return new DefaultModelRegistry(ruleExtractor, project.getPath(), run -> project.getOwner().applyToMutableState(p -> run.run()));
    }

    @Provides
    protected ScriptHandlerInternal createScriptHandler(
        DependencyManagementServices dependencyManagementServices,
        FileResolver fileResolver,

            return projectLock;
        }

        @Override
        public ResourceLock getTaskExecutionLock() {
            return taskLock;
        }

        @Override
        public void applyToMutableState(Consumer<? super ProjectInternal> action) {
            fromMutableState(p -> {
                action.accept(p);
                return null;
            });
        }

        @Override

            result = eclipseProject;
        }
        eclipseProjects.add(eclipseProject);
    }

    private void populate(Project project) {
        ((ProjectInternal) project).getModel().applyToMutableState(state -> {
            EclipseModel eclipseModel = project.getExtensions().getByType(EclipseModel.class);

            boolean projectDependenciesOnly = this.projectDependenciesOnly;

            return null;
        }
    }

    private static void resolveAllConfigurationsAndForceDownload(Project project) {
        ((ProjectInternal) project).getOwner().applyToMutableState(p ->
            p.getConfigurations().all(cnf -> {
                if (((DeprecatableConfiguration) cnf).canSafelyBeResolved()) {
                    try {
                        resolveAndDownloadExternalFiles(cnf);