}

    @Override
    protected String getComponentUnderTestDsl() {
        return "library"
    }

    def "creates shared library binary by default when both linkage specified"() {
        def library = new SwiftLib()
        makeSingleProject()
        settingsFile << """
            rootProject.name = 'foo'
        """
        library.writeToProject(testDirectory)

        when:
        succeeds('assemble')

    |--------------------------------|--------------|--------------|
    | org.gradle.status              | release      |              |
    | org.gradle.category            | library      | library      |
    | org.gradle.libraryelements     | jar          | jar          |
    | org.gradle.usage               | java-runtime | java-runtime |
    | org.gradle.dependency.bundling |              | external     |

                                    lib project: ':api', library: 'api'
                                    lib project: ':spi', library: 'spi'
                                    lib project: ':runtime', library: 'runtime'
                                    lib library: 'bootstrap'
                                    lib project: ':libraries', library: 'foo'
                                    lib project: ':libraries', library: 'bar'

.Configuring a Java library for publishing
====
include::sample[dir="snippets/publishing/javaLibrary/kotlin",files="build.gradle.kts[tags=configure-publishing]"]
include::sample[dir="snippets/publishing/javaLibrary/groovy",files="build.gradle[tags=configure-publishing]"]
====

        app.executable.writeSources(file("src/main"))
        app.library.writeSources(file("src/library"))

        buildFile << """
apply plugin: 'c'

model {
    components {
        main(NativeExecutableSpec) {
            sources {
                library(CSourceSet) {
                    source.srcDir "src/library/c"
                    exportedHeaders.srcDir "src/library/headers"
                }
                c.lib library

        final DefaultSwiftLibrary library = componentFactory.newInstance(SwiftLibrary.class, DefaultSwiftLibrary.class, "main");
        project.getExtensions().add(SwiftLibrary.class, "library", library);
        project.getComponents().add(library);

        // Setup component
        final Property<String> module = library.getModule();
        module.set(GUtil.toCamelCase(project.getName()));

        installation("build/install/main/release").exec().out == "Hello from the release library"
    }

    @ToBeFixedForConfigurationCache
    def "can choose alternative library implementation of api"() {
        given:
        def app = new CppHelloWorldApp()
        app.executable.writeSources(file("src/main"))
        app.library.writeSources(file("src/hello"))

        tool chain: Tool chain 'clang' (Clang)
        shared library file: build/libs/someLib/shared/libsomeLib.dylib
    Static library 'someLib:staticLibrary'
        build using task: :someLibStaticLibrary
        build type: build type 'debug'
        flavor: flavor 'default'
        target platform: platform '$currentNative'
        tool chain: Tool chain 'clang' (Clang)
        static library file: build/libs/someLib/static/libsomeLib.a

    @ToBeFixedForConfigurationCache(because = "Task.getProject() during execution")
    def "produces manifest for C++ library with shared and static linkage"() {
        given:
        buildFile << """
            plugins {
                id 'swiftpm-export'
                id 'cpp-library'
            }
            library.linkage = [Linkage.SHARED, Linkage.STATIC]
"""
        def lib = new CppLib()

Note the default linkage of a {cpp} library is shared linkage as shown in the diagram.

.{cpp} Library Plugin default task graph
image::cpp-shared-library-task-graph.png[]

With static linkage, the diagram changes to the following:

.{cpp} Library Plugin static library only task graph
image::cpp-static-library-task-graph.png[]

[[sec:cpp_library_task_variants]]
=== Variant-dependent Tasks