ProjectInternal projectInternal = delegate.getProject(path);
        if (projectInternal == null) {
            throw new UnknownProjectException("Project with path '" + path + "' not found.");
        }

        // TODO This is a brain-dead way to ensure that the reference project's model is ready to access
        return projectInternal.getOwner().fromMutableState(project -> {

        }
        projectState.ensureTasksDiscovered();
    }

    @Override
    public void configureHierarchy(ProjectInternal project) {
        configure(project);
        for (Project sub : project.getSubprojects()) {
            configure((ProjectInternal) sub);
        }
    }

    @Override
    public void apply(final Project project) {
        final ProjectInternal projectInternal = (ProjectInternal) project;
        addClean(projectInternal);
        addCleanRule(project);
        addAssemble(project);
        addCheck(project);
        addBuild(project);
    }

    private void addClean(final ProjectInternal project) {
        Provider<Directory> buildDir = project.getLayout().getBuildDirectory();

    @Override
    public List<String> asDefaultTask() {
        return Collections.singletonList(ProjectInternal.HELP_TASK);
    }

    @Override
    public boolean commandLineMatches(List<String> taskNames) {
        return taskNames.isEmpty() || taskNames.get(0).equals(ProjectInternal.HELP_TASK) || taskNames.get(0).equals(":" + ProjectInternal.HELP_TASK);
    }

import org.gradle.api.file.Directory;

public final class DefaultIsolatedProject implements IsolatedProject {

    private final ProjectInternal project;
    private final ProjectInternal rootProject;

    public DefaultIsolatedProject(ProjectInternal project, ProjectInternal rootProject) {
        this.project = project;
        this.rootProject = rootProject;
    }

    @Override
    public String getName() {

 */

package org.gradle.configuration.project

import org.gradle.api.internal.project.ProjectInternal
import org.gradle.api.internal.project.ProjectStateInternal
import spock.lang.Specification

class ConfigureActionsProjectEvaluatorTest extends Specification {
    final def project = Mock(ProjectInternal)
    final def state = Mock(ProjectStateInternal)
    final def action1 = Mock(ProjectConfigureAction)

import java.io.Closeable;

/**
 * Controls the lifecycle of the mutable {@link ProjectInternal} instance for a project, plus its services.
 */
@ServiceScope(Scope.Project.class)
public class ProjectLifecycleController implements Closeable {
    private final ServiceRegistry buildServices;
    private final StateTransitionController<State> controller;
    private ProjectInternal project;
    private ProjectScopeServices projectScopeServices;

    private WorkNodeAction action;
    private List<Node> postExecutionNodes;
    private final ProjectInternal owningProject;
    private final ProjectInternal projectToLock;
    private boolean hasVisitedPreExecutionNode;

    public ActionNode(WorkNodeAction action) {
        this.action = action;
        this.owningProject = (ProjectInternal) action.getOwningProject();
        if (owningProject != null && action.usesMutableProjectState()) {

        def projectInternal = Stub(ProjectInternal) {
            group >> "group"
            name >> "name"
            version >> "1.0"
        }
        def dependency = new DefaultProjectDependency(projectInternal, false)
        dependency.setCapabilityNotationParser(new CapabilityNotationParserFactory(true).create())

import org.gradle.api.Action;
import org.gradle.api.internal.project.ProjectInternal;
import org.gradle.util.internal.ConfigureUtil;

import java.util.ArrayList;
import java.util.List;

public class DefaultProjectConfigurationActionContainer implements ProjectConfigurationActionContainer {
    private final List<Action<? super ProjectInternal>> actions = new ArrayList<Action<? super ProjectInternal>>();

    @Override
    public void finished() {