<library>
        <CLASSES>
          <root url="jar://$MODULE_DIR$/lib/compile-1.0.jar!/"/>
        </CLASSES>
        <JAVADOC/>
        <SOURCES/>
      </library>
    </orderEntry>
    <orderEntry type="module-library" scope="RUNTIME">
      <library>
        <CLASSES>
          <root url="jar://@CACHE_DIR@/commons-lang/commons-lang/2.4/@SHA1@/commons-lang-2.4.jar!/"/>
        </CLASSES>
        <JAVADOC>

        def library = new SwiftLib()
        def test = new SwiftLibTest(library, library.greeter, library.sum, library.multiply)

        given:
        buildTestFixture.withBuildInSubDir()
        singleProjectBuild("greeter") {
            buildFile << """
                apply plugin: 'swift-library'
            """
            library.writeToProject(it)
        }

Note the default linkage of a Swift library is shared linkage as shown in the diagram.

.Swift Library Plugin default task graph
image::swift-shared-library-task-graph.png[]

With static linkage, the diagram changes to the following:

.Swift Library Plugin static library only task graph
image::swift-static-library-task-graph.png[]

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

    }

    @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"))