projectRegistry.addProject(rootMock);
        projectRegistry.addProject(childMock);
        projectRegistry.addProject(childChildMock);
    }

    @Test
    public void rootProject() {
        assertSame(rootMock, projectRegistry.getRootProject());
    }

    @Test
    public void addProject() {

        1 * taskSelector.getSelection(_, other.rootProject, "task", false)
    }

    def "can use pattern matching to select project"() {
        withIncludedBuilds()
        def p1 = addProject(root, "someLibs")
        def p2 = addProject(root, "otherLibs")

        when:
        selector.resolveTaskName(null, null, target, ":sL:task")

        then:
        1 * taskSelector.getSelection(_, p1, "task", false)

        1 * projectRegistry.addProject(project)
        1 * dependencyResolutionManagement.configureProject(project)
    }

    def "creates a project with missing build script"() {
        def buildFile = tmpDir.file("build.gradle")

        model.setRootProject(convertedRootProject);

        for (ProjectState project : target.getProjects().getAllProjects()) {
            model.addProject(convertedProjects.get(project));
        }
    }

    private BasicGradleProject convert(BuildState owner, ProjectState project, Map<ProjectState, BasicGradleProject> convertedProjects) {

    @Override
    public void changeDescriptorPath(Path oldPath, Path newPath) {
        DefaultProjectDescriptor projectDescriptor = removeProject(oldPath.toString());
        projectDescriptor.setPath(newPath);
        addProject(projectDescriptor);
    }

import org.gradle.api.specs.Spec;

import javax.annotation.Nullable;
import java.io.File;
import java.util.Set;

public interface ProjectRegistry<T extends ProjectIdentifier> {
    void addProject(T project);

    @Nullable T getRootProject();

    @Nullable T getProject(String path);

    @Nullable T getProject(File projectDir);

    int size();

    Set<T> getAllProjects();

        return this;
    }

    public Set<? extends PartialBasicGradleProject> getProjects() {
        return projects;
    }

    public void addProject(PartialBasicGradleProject project) {
        projects.add(project);
    }

    public Set<DefaultGradleBuild> getEditableBuilds() {
        return allBuilds;
    }

            gradle.getServices().get(DependenciesAccessors.class).createExtensions(project);
        });
        gradle.getProjectRegistry().addProject(project);
        return project;
    }

                throw new IllegalStateException("Projects for " + owner.getDisplayName() + " have already been registered.");
            }
            for (DefaultProjectDescriptor descriptor : allProjects) {
                addProject(owner, buildProjectRegistry, descriptor);
            }
        }
    }

    private DefaultBuildProjectRegistry getBuildProjectRegistry(BuildState owner) {

    private final Map<String, T> projects = new HashMap<String, T>();
    private final Map<String, Set<T>> subProjects = new HashMap<String, Set<T>>();

    @Override
    public void addProject(T project) {
        T previous = projects.put(project.getPath(), project);
        if (previous != null) {