boolean isLocalProject = projectIdentifier.getBuild().getBuildPath().equals(currentBuildPath.getPath());
        if (isLocalProject) {
            return getLocalComponent(projectIdentifier, projectStateRegistry.stateFor(projectIdentifier));
        } else {
            return getLocalComponentWithForeignId(projectIdentifier);
        }
    }

    }

    private static void assertSameIdentifiers(List gradleProjects, List models) {
        def gradleProjectIdentifiers = gradleProjects.collect { it.projectIdentifier } as Set<ProjectIdentifier>
        def modelIdentifiers = models.collect { it.projectIdentifier } as Set<ProjectIdentifier>
        assert gradleProjectIdentifiers*.projectPath == modelIdentifiers*.projectPath

        def rootProject = models[0]
        rootProject.projectIdentifier.projectPath == ':'
        rootProject.projectIdentifier.buildIdentifier.rootDir == projectDir
        rootProject.mainComponent == null
        rootProject.testComponent == null

        def appProject = models[1]
        appProject.projectIdentifier.projectPath == ':app'
        appProject.projectIdentifier.buildIdentifier.rootDir == projectDir

            include 'b'
        """

        when:
        def gradleBuild = withConnection {
            action(new FetchGradleBuild()).run()
        }
        then:
        gradleBuild.projects*.projectIdentifier.toSet().size() == 3
    }

    def "Applies BuildInvocations compatibility mapping"() {
        when:
        def buildInvocations = withConnection {
            action(new FetchBuildInvocations()).run()

        }
        // Order of children is not guaranteed for Gradle < 2.0
        assert project.children*.path as Set == childPaths as Set
        assert project.projectIdentifier.projectPath == path
        assert project.projectIdentifier.buildIdentifier.rootDir == rootDir
    }

    private GradleProject getGradleProjectWithProjectConnection(TestFile rootDir, Class modelType = GradleProject, boolean searchUpwards = true) {

        when:
        def project = withConnection { connection -> connection.getModel(CppProject.class) }

        then:
        project.projectIdentifier.projectPath == ':'
        project.projectIdentifier.buildIdentifier.rootDir == projectDir

        project.mainComponent instanceof CppApplication
        project.mainComponent.name == 'main'
        project.mainComponent.baseName == 'app'

    private static final ModelType<File> FILE_MODEL_TYPE = ModelType.of(File.class);
    private static final ModelType<ProjectIdentifier> PROJECT_IDENTIFIER_MODEL_TYPE = ModelType.of(ProjectIdentifier.class);
    private static final ModelType<ExtensionContainer> EXTENSION_CONTAINER_MODEL_TYPE = ModelType.of(ExtensionContainer.class);

        ])
    }

    private static void checkIdeaModule(IdeaModule actualModule, IdeaModule expectedModule) {
        checkModel(actualModule, expectedModule, [
            { it.name },
            [{ it.projectIdentifier }, { a, e -> checkProjectIdentifier(a, e) }],
            [{ it.javaLanguageSettings }, { a, e -> checkLanguageSettings(a, e) }],
            { it.jdkName },

import org.gradle.api.internal.plugins.ExtensionContainerInternal
import org.gradle.api.internal.plugins.PluginManagerInternal
import org.gradle.api.internal.project.CrossProjectModelAccess
import org.gradle.api.internal.project.ProjectIdentifier
import org.gradle.api.internal.project.ProjectInternal
import org.gradle.api.internal.project.ProjectState
import org.gradle.api.internal.project.ProjectStateInternal