Projects:

------------------------------------------------------------
Root project 'my-root-project'
------------------------------------------------------------

Root project 'my-root-project'
+--- Project ':p1'
\\--- Project ':p2'
     \\--- Project ':p2:p22'

Included builds:

\\--- Included build ':another'
"""
    }

    def "reports project structure with transitive composite"() {
        given:

        ProjectBuilder.builder().withName("app2").withParent(project).build()

        project.pluginManager.apply(SwiftPackageManagerExportPlugin)
        project.pluginManager.apply("swift-library")

        project.evaluate()

        expect:
        def generateManifest = project.tasks['generateSwiftPmManifest']
        def products = generateManifest.package.get().products

        when:
        project.pluginManager.apply(CppLibraryPlugin)
        project.evaluate()

        then:
        project.components.main == project.library
        project.library.binaries.get().name == ['mainDebug', 'mainRelease']
        project.components.containsAll(project.library.binaries.get())

        and:
        def binaries = project.library.binaries.get()

            }

            project(':impl') {
                dependencies {
                    implementation project(':api')
                }
            }

            project(':app') {
                dependencies {
                    implementation project(':api')
                    testImplementation project(':impl')
                    runtimeOnly project(':impl')
                }
            }

        then:
        def messages = models.left
        messages.size() == 2
        messages[0] == "It works from project :"
        messages[1] == "It works from project :a"
        def model = models.right
        model.size() == 2
        model[0].message == "It works from project :"
        model[1].message == "It works from project :a"

        and:
        fixture.assertStateStored {
            projectConfigured(":buildSrc")

        project.library instanceof SwiftLibrary
        project.library.module.get() == "TestLib"
        project.library.swiftSource.files == [src] as Set
    }

    def "registers a component for the library with default linkage"() {
        when:
        project.pluginManager.apply(SwiftLibraryPlugin)
        project.evaluate()

        then:
        project.components.main == project.library

        MavenProject project = getProject(artifact);

        if (project != null) {
            File file = findArtifact(project, artifact);
            if (file == null && project != project.getExecutionProject()) {
                file = findArtifact(project.getExecutionProject(), artifact);
            }
            return file;
        }

        project.targets.size() == 2
        assertTargetIsTool(project.targets[0], 'App', 'app')
        project.targets[1].assertIsIndexerFor(project.targets[0])

        project.products.children.size() == 1
        project.products.children[0].path == exe("build/install/main/debug/lib/app").absolutePath
    }

    @ToBeFixedForConfigurationCache

    artifacts {
        'default' jar
    }
}

project('a') {
    dependencies {
        first project(':b')
        other project(':b')
    }
}

project('b') {
    dependencies {
        first project(':c')
    }
}

project('c') {
    dependencies {
        first project(':a')
    }
}
"""
        when:
        resolve.prepare("first")

        given:
        project.pluginManager.apply(NativeBasePlugin)
        project.pluginManager.apply(MavenPublishPlugin)
        project.components.add(component)
        project.group = "my.group"
        project.version = "1.2"
        ((ProjectInternal) project).evaluate()

        expect:
        def publishing = project.publishing
        publishing.publications.size() == 3