when:
        createDirs("otherProject")
        settingsFile << "include 'otherProject'"

        buildFile <<  """
configurations {
    conf
    confTwo
}

project(':otherProject') {
    configurations {
        otherConf
    }
}

dependencies {
    conf project(':otherProject')
    confTwo project(path: ':otherProject', configuration: 'otherConf')
}

        when:
        container.library('someLib')
        container.project('otherProject').library('someLib')
        container.project('otherProject')

        container.library('someLib')
        container.library('someLib').project('otherProject')
        container.project('otherProject')

        then:
        container.dependencies.size() == 3

            #include "hello.h"
            extern "C" {
                #include "otherProject/bonjour.h"
            }

            int main () {
              hello();
              bonjour();
              return 0;
            }
        """

        and:
        file("include", "otherProject", "bonjour.h") << """
            void bonjour();
        """

        and:

    }

    private
    fun checkForCoupledProjects(taskDependencies: Set<Task>) {
        taskDependencies.forEach { task ->
            val otherProject = task.project as ProjectInternal
            coupledProjectsListener.onProjectReference(referrer.owner, otherProject.owner)
        }
    }

    private
    fun reportProjectIsolationProblemOnApiUsage() {
        val problem = problemFactory.problem {

        def otherProject = Mock(Project)
        def otherProjectDependency = Mock(ProjectDependency)

        when:
        dependencies {
            implementation(project(":path:to:somewhere")) {
                // configure dependency
            }
        }

        then:
        1 * currentProject.project(":path:to:somewhere") >> otherProject

        and:
        def oneProject = projectFile("one/one.vcxproj")
        def twoProject = projectFile("two/twoDll.vcxproj")
        def utilProject = projectFile("util/utilDll.vcxproj")
        def otherProject = projectFile("other/other.vcxproj")

        final mainSolution = solutionFile("app.sln")
        mainSolution.assertHasProjects("one", "twoDll", "utilDll", "other")

            myExtension.message = "the message"
        """
        file("b/build.gradle") << """
            plugins.apply(my.MyPlugin)
            def otherProject = project(':a')
            myExtension.message = otherProject.myExtension.message
        """

        when:
        executer.withArguments(ENABLE_CLI, WARN_PROBLEMS_CLI_OPT)

        libProject.testComponent != null

        def otherProject = models[3]
        otherProject.projectIdentifier.projectPath == ':other'
        otherProject.mainComponent == null
        otherProject.testComponent == null
    }

    def "can query the models for each project in a composite build"() {
        settingsFile << """

        def otherProject = Mock(ProjectInternal)
        def otherTaskContainer = Mock(TaskContainerInternal)
        def otherProjectState = Mock(ProjectState)

        projectRegistry.getProject(_) >> otherProject

        otherProject.owner >> otherProjectState
        1 * otherProjectState.ensureTasksDiscovered()
        otherProject.tasks >> otherTaskContainer

    override fun getVersion(): Any =
        delegate.version

    override fun getRootProject(): Project =
        delegate.rootProject

    override fun depthCompare(otherProject: Project): Int =
        delegate.depthCompare(otherProject)

    override fun getGradle(): Gradle =
        delegate.gradle

    override fun getAllTasks(recursive: Boolean): MutableMap<Project, MutableSet<Task>> =