configurer.configure(project.getMutableModel());
            if (taskNameResolver.tryFindUnqualifiedTaskCheaply(taskName, project.getMutableModel())) {
                // An exact match in the target project - can just filter tasks by path to avoid configuring subprojects at this point
                return new TaskPathSpec(project.getMutableModel(), taskName);
            }
        }

        DefaultNestedBuild build = new DefaultNestedBuild(buildIdentifier, identityPath, buildDefinition, owner, buildTreeState);
        // Expose any contributions from the parent's settings
        build.getMutableModel().setClassLoaderScope(() -> owner.getMutableModel().getSettings().getClassLoaderScope());
        return build;
    }

    public NestedBuildTree createNestedTree(
        BuildInvocationScopeId buildInvocationScopeId,

                return projectScopeServices;
            };
            project = projectFactory.createProject(build.getMutableModel(), descriptor, owner, parentModel, serviceRegistryFactory, selfClassLoaderScope, baseClassLoaderScope);
        });
    }

    public ProjectInternal getMutableModel() {
        controller.assertInStateOrLater(State.Created);
        return project;
    }

            controller.createMutableModel(descriptor, owner, this, selfClassLoaderScope, baseClassLoaderScope, projectFactory);
        }

        @Override
        public ProjectInternal getMutableModel() {
            return controller.getMutableModel();
        }

        @Override
        public void ensureConfigured() {
            // Need to configure intermediate parent projects for configure-on-demand

        ProjectState defaultProject = gradle.getOwner().getProjects().getProject(defaultProjectDescriptor.path());
        gradle.setDefaultProject(defaultProject.getMutableModel());
    }

    private void createProjects(GradleInternal gradle, DefaultProjectDescriptor rootProjectDescriptor) {
        ClassLoaderScope baseProjectClassLoaderScope = gradle.baseProjectClassLoaderScope();

    ProjectStateRegistry projectStateRegistry

    def setup() {
        _ * project1.tasks >> tasks1
        _ * project2.tasks >> tasks2
        _ * project1State.getMutableModel() >> project1
        _ * project2State.getMutableModel() >> project2
        projectStateRegistry = Mock(ProjectStateRegistry) {
            stateFor(projectId1) >> project1State
            stateFor(projectId2) >> project2State
        }
    }

        projectState.createMutableModel(parentProject.getClassLoaderScope().createChild("project-" + name, null), parentProject.getBaseClassLoaderScope());
        ProjectInternal project = projectState.getMutableModel();

        // Lock the project, these won't ever be released as ProjectBuilder has no lifecycle
        ResourceLockCoordinationService coordinationService = project.getServices().get(ResourceLockCoordinationService.class);

    }

    @Override
    public void prepareToScheduleTasks(BuildTreeWorkGraph.Builder workGraph) {
        RootBuildState targetBuild = buildRegistry.getRootBuild();
        Set<String> excludedTaskNames = targetBuild.getMutableModel().getStartParameter().getExcludedTaskNames();
        for (String taskName : excludedTaskNames) {
            BuildTaskSelector.Filter filter = taskSelector.resolveExcludedTaskName(targetBuild, taskName);

        context.add(resolveTask());
    }

    private Task resolveTask() {
        includedBuild.ensureProjectsConfigured();
        return includedBuild.getMutableModel().getRootProject().getTasks().getByPath(taskPath);
    }

            ProjectState projectState = projectStateRegistry.stateFor(identityPath);
            projectState.ensureTasksDiscovered();

            Task nextTask = projectState.getMutableModel().getTasks().findByName(taskName);
            if (nextTask != null && context.getTask() != nextTask) {
                context.add(nextTask);
            }
        }
    }

    @Override