then:
        def buildDir = file('build')
        buildDir.assertHasDescendants("projectA-1.2.jar", "projectB-1.2.jar")
    }

    def "mavenLocal ignores missing jar for module with packaging 'pom'"() {
        given:
        m2.mavenRepo().module('group', 'projectB', '1.2').publish()
        def pomModule = m2.mavenRepo().module('group', 'projectA', '1.2')
        pomModule.packaging = 'pom'

        given:
        def build = build("p1", "p2")
        createRootProject()
        def project1 = project("p1")
        def state1 = registry.stateFor(projectId("p1"))
        createProject(state1, project1)
        def project2 = project("p2")
        def state2 = registry.stateFor(projectId("p2"))
        createProject(state2, project2)

        when:
        async {

        projects.add(project1);
        MavenProject project2 = createProject("groupId", "artifactId2", "1.0");
        projects.add(project2);
        project1.getDependencies().add(createDependency(project2));

        projects = new ProjectSorter(projects).getSortedProjects();

        assertEquals(project2, projects.get(0));
        assertEquals(project1, projects.get(1));
    }

    @Test

    }
}

project(':projectA') {
    dependencies {
        compileOnly 'org.gradle.test:compileOnly:1.0'
    }
}

project(':projectB') {
    dependencies {
        api project(':projectA')
    }

    task checkClasspath {
        def compileClasspathFiles = configurations.compileClasspath.files
        def projectAJavaDestDir = project(':projectA').compileJava.destinationDirectory

    def context = Mock(TaskDependencyResolveContext)
    def project1State = Mock(ProjectState)
    def project2State = Mock(ProjectState)
    def project1 = Mock(ProjectInternal)
    def project2 = Mock(ProjectInternal)
    def projectId1 = Path.path("project1")
    def projectId2 = Path.path("project2")
    def projectDep1 = Mock(ProjectDependencyInternal) { getIdentityPath() >> projectId1 }

    def "locates prebuilt library in another project"() {
        given:
        app.executable.writeSources(file("projectA/src/main"))
        app.librarySources*.writeToDir(file("projectA/src/main"))
        app.libraryHeader.writeToDir(file("projectB/libs/src/hello"))

        and:
        settingsFile.text = "include ':projectA', ':projectB'"
        buildFile << """
project(':projectA') {
    apply plugin: 'cpp'
    model {

        from configurations.compile
    }
    """

        when:
        projectA.pom.expectGet()
        projectA.artifact.expectGet()
        projectB.pom.expectGet()
        projectB.artifact.expectGet()
        mavenHttpRepo.getModuleMetaData("org.test", "projectC").expectGet()
        projectC.pom.expectGet()
        projectC.artifact.expectGet()

        and:
        run 'retrieve'

        then:

    }

    @Issue("https://github.com/gradle/gradle/issues/22685")
    @ToBeFixedForIsolatedProjects(because = "Access to root project from sub projects")
    def "can visit and edit tar archive differently from two different projects in a multiproject build"() {
        given: "an archive in the root of a multiproject build"
        createTar('test.tar') {

        cache.put(project1, new SetWithResolutionResult(null, artifacts));

        assertArrayEquals(
                artifacts.toArray(new Artifact[0]),
                cache.get(project1).getArtifacts().toArray(new Artifact[0]));

        ProjectArtifactsCache.Key project2 = new ProjectArtifactsCache.Key() {};

            assert context.details.status == context.details.id.name == "projectA" ? "release" : "integration"
            assert context.details.statusScheme == ['integration', 'milestone', 'release']
    }
}
dependencies {
    compile 'group1:projectA:1.0'
    compile 'group2:projectB:2.0-SNAPSHOT'
    compile 'group2:projectC:${c.publishArtifactVersion}'
    components {
        all(StatusRule)
    }
}