null       | "SharedLibrary" | []             | "shared library 'sharedLibrary'"
        "parent"   | "SharedLibrary" | []             | "shared library 'parent:sharedLibrary'"
        "parent"   | "SharedLibrary" | ["one"]        | "shared library 'parent:one:sharedLibrary'"
        "parent"   | "SharedLibrary" | ["one", "two"] | "shared library 'parent:one:two:sharedLibrary'"
    }

    @Shared
    @ClassRule
    TestNameTestDirectoryProvider sharedTemporaryFolder = TestNameTestDirectoryProvider.newInstance(getClass())
    @Shared TestFile templateZipFile = new TestFile(sharedTemporaryFolder.testDirectory, "template-gradle.zip")
    @Shared TestFile templateEvalZipFile = new TestFile(sharedTemporaryFolder.testDirectory, "template-eval-gradle.zip")
    @Shared String templateZipHash

        project.library.linkage = [Linkage.SHARED, Linkage.STATIC]
        project.evaluate()

        then:
        def compileDebug = project.tasks.compileDebugSharedSwift
        compileDebug instanceof SwiftCompile
        compileDebug.source.files == [src] as Set
        compileDebug.objectFileDir.get().asFile == projectDir.file("build/obj/main/debug/shared")

  Tag        Type                         Name/Value
 0x0000000000000001 (NEEDED)             Shared library: [libstdc++.so.6]
 0x0000000000000001 (NEEDED)             Shared library: [libm.so.6]
 0x0000000000000001 (NEEDED)             Shared library: [libgcc_s.so.1]
 0x0000000000000001 (NEEDED)             Shared library: [libc.so.6]
 0x000000000000000e (SONAME)             Library soname: [heythere]

        when:
        app.library.writeSources(file("src/main"))
        settingsFile << """
            rootProject.name = 'lib'
        """
        buildFile << """
            apply plugin: 'cpp-library'

            library {
                linkage = [Linkage.STATIC, Linkage.SHARED]
                binaries.configureEach { binary ->

        server.expect(server.get("shared.gradle").send("""
            ${instrument('"shared"')}
            println 'Echo 1'
        """))
        run 'help'

        then:
        outputContains 'Echo 1'
        def scripts = scriptDetails()
        scriptHasChanged("shared", before, scripts)
        getCompileBuildFileOperationsCount() == 2 // classpath + body for shared build script
    }

- `release` - Generate debug symbols and optimize, but extract the debug symbols from the binary

Linkages - default to _shared_::
The linkage expresses whether a shared library or static library should be created. Libraries can produce a shared library, a static library or both.

The linkage can be configured as follows:

.Configure library linkages
====

apply plugin: "cpp"
model {
    components {
        main(NativeExecutableSpec) {
            sources {
                cpp.lib library: "hello", linkage: "shared"
                cpp.lib library: "greetings", linkage: "shared"
            }
        }
        hello(NativeLibrarySpec) {
            sources {
                cpp.lib library: "greetings", linkage: "static"
            }
        }

    @Shared attributes = AttributeTestUtil.attributesFactory().of(Attribute.of("someAttribute", String), "someValue")
    @Shared mavenMetadataFactory = DependencyManagementTestUtil.mavenMetadataFactory()
    @Shared ivyMetadataFactory = DependencyManagementTestUtil.ivyMetadataFactory()
    @Shared defaultVariant

    private ivyComponentMetadata(String[] deps) {
        def dependencies = deps.collect { name ->

        // given
        def shared = mavenRepo.module('org.gradle.test', 'shared', '1.0').publish()
        mavenRepo.module('org.gradle.test', 'compile', '1.0').dependsOn(shared).publish()
        mavenRepo.module('org.gradle.test', 'compileOnly', '1.0').dependsOn(shared).publish()
        mavenRepo.module('org.gradle.test', 'testCompileOnly', '1.0').dependsOn(shared).publish()

        // when
        runIdeaTask """