when:
        binary.lib(lib1)
        def sourceSet = Stub(DependentSourceSet) {
            getLibs() >> [sourceLib]
        }
        binary.inputs.add sourceSet
        binary.lib(lib2)

        and:
        1 * resolver.resolve({ NativeBinaryResolveResult result ->
            result.allResolutions*.input == [lib1, lib2, sourceLib]
        }) >> { NativeBinaryResolveResult result ->

        products.name == ["lib1", "lib2"]
        products.target.name == ["Lib1", "Lib2"]
        products.target.publicHeaderDir == [null, null]
        products.every { it instanceof DefaultLibraryProduct }
    }

    def "adds a library product for each linkage of a Swift library"() {
        given:
        def lib1Project = ProjectBuilder.builder().withName("lib1").withParent(project).build()

    def "can fetch GradleProject model for empty projects"() {
        settingsFile << """
            rootProject.name = 'root'

            include(":lib1")
            include(":lib1:lib11")
        """

        when: "fetching without Isolated Projects"
        def expectedProjectModel = fetchModel(GradleProject)

        then:
        fixture.assertNoConfigurationCache()

        os.getLinkLibraryName("a.lib") == "a.lib"
    }

    def "windows transforms static library names"() {
        def os = new OperatingSystem.Windows()

        expect:
        os.staticLibrarySuffix == ".lib"
        os.getStaticLibraryName("a.lib") == "a.lib"
        os.getStaticLibraryName("a.LIB") == "a.LIB"
        os.getStaticLibraryName("a") == "a.lib"

            inCatalog('libs')
            forDependency('org', 'foo')
            versionRef('nope')
            existing('v1', 'v2')
        })
    }

    def "has all defined aliases"() {
        builder.library("foo-lib1", "org", "foo").version("lib-version")
        builder.library("foo-lib2", "org", "foo").version("lib-version2")

        sharedLibrary("lib1/build/lib/main/debug/lib1").assertExists()
        sharedLibrary("lib2/build/lib/main/debug/lib2").assertExists()
        executable("build/exe/main/debug/app").assertExists()
        installation("build/install/main/debug").exec().out == app.expectedOutput

        resolve.expectGraph {
            root(":b", "test:b:") {
                project(":a", "test:a:") {
                    artifact(name: "lib1")
                    artifact(name: "not-a-lib", extension: "zip", type: "not-a-lib", fileName: "lib2.zip")
                }
            }
        }
    }

    def "can define outgoing variants and artifacts for configuration"() {
        given:

            sources {
                cpp {
                    lib library: 'lib1', linkage: 'api'
                }
                otherCpp(CppSourceSet) {
                    lib library: 'lib2', linkage: 'api'
                }
            }
        }
    }
}
"""

        when:
        succeeds "mainExecutable"

        then:
        executable("build/exe/main/main").exec().out == "12\n"

    }

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "honors customizations to Swift module name"() {
        given:
        createDirs("lib1", "lib2")
        settingsFile << "include 'lib1', 'lib2'"
        buildFile << """
            plugins {
                id 'swiftpm-export'
                id 'swift-application'
            }
            subprojects {

                implementation "test:lib2:2.0.0"
            }
"""
        file("src/main/swift/Lib.swift") << """
            import Lib1
            import Lib2
            class Lib {
                init() {
                    Lib1.thing()
                    Lib2.thing()
                }
            }
        """

        when:
        run("generateSwiftPmManifest")