then:
        !link.linkedFile.present
        !link.importLibrary.present

        when:
        link.linkedFile = tmpDir.file("shared/lib.dll")

        then:
        link.importLibrary.get().asFile == tmpDir.file("shared/lib.lib")

        when:
        link.importLibrary.set(tmpDir.file("import/lib_debug.lib"))
        link.linkedFile.set(tmpDir.file("ignore-me"))

        then:

     * These packages affect both classes and resources.
     * Subpackages of the provided packages are also shared with the implementation classpath.
     *
     * @return The list of packages which are shared from the application to the implementation classpath.
     */
    Set<String> getSharedPackages();

    JavaExecHandleBuilder getJavaCommand();

            .replaceAll("platform '[\\w+\\-]+'","platform 'current'")
            .replaceAll("(build/libs/.+/shared/(\\w+))\\.so") { "${it[1]}.dylib" }
            .replaceAll("((build/libs/.+/shared/)(\\w+))\\.dll") { "${it[2]}lib${it[3]}.dylib" }
            .replaceAll("((build/libs/.+/static/)(\\w+))\\.lib") { "${it[2]}lib${it[3]}.a" }

        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
====

exit:
	MOVD	$0, R0
	MOVD	$1, R16	// sys_exit
	SVC	$0x80
	B	exit

// When linking with -buildmode=c-archive or -buildmode=c-shared,
// this symbol is called from a global initialization function.
//
// Note that all currently shipping darwin/arm64 platforms require
// cgo and do not support c-shared.
TEXT _rt0_arm64_darwin_lib(SB),NOSPLIT,$152
	// Preserve callee-save registers.
	SAVE_R19_TO_R28(8)
	SAVE_F8_TO_F15(88)

        binary.headerDirs.toString() == "Headers for shared library 'main:sharedLibrary'"

        and:
        binary.linkFiles.files == [binary.sharedLibraryLinkFile] as Set
        binary.linkFiles.buildDependencies.getDependencies(Stub(Task)) == [lifecycleTask] as Set
        binary.linkFiles.toString() == "Link files for shared library 'main:sharedLibrary'"

        and:

    /**
     * A separate cache instance for each Gradle version. This is the default.
     */
    CachePerVersion,
    /**
     * A single cache instance shared by all Gradle versions. It is the caller's responsibility to make sure that this is shared only with
     * those versions of Gradle that are compatible with the cache implementation and contents.
     */
    SharedCache

import spock.lang.Shared
import spock.lang.Specification

class LoggingBuildOperationProgressBroadcasterTest extends Specification {

    def outputEventListenerManager = Mock(OutputEventListenerManager)
    def buildOperationProgressEventEmitter = Mock(BuildOperationProgressEventEmitter)

    @Shared
    def testOperationId = Mock(OperationIdentifier)

    @Shared

// license that can be found in the LICENSE file.

#include "textflag.h"

TEXT _rt0_arm64_android(SB),NOSPLIT|NOFRAME,$0
	MOVD	$_rt0_arm64_linux(SB), R4
	B	(R4)

// When building with -buildmode=c-shared, this symbol is called when the shared
// library is loaded.
TEXT _rt0_arm64_android_lib(SB),NOSPLIT|NOFRAME,$0
	MOVW	$1, R0                            // argc
	MOVD	$_rt0_arm64_android_argv(SB), R1  // **argv
	MOVD	$_rt0_arm64_linux_lib(SB), R4