Task getLink();
    }

    /**
     * The shared library file.
     */
    File getSharedLibraryFile();

    /**
     * The shared library link file.
     */
    File getSharedLibraryLinkFile();

    /**
     * The shared library file.
     */
    void setSharedLibraryFile(File sharedLibraryFile);

    /**
     * The shared library link file.
     */

                    project(":shared", "test:shared:") {
                        artifact(classifier: 'one-preferred')
                    }
                    project(":shared", "test:shared:") {
                        artifact(classifier: 'two-preferred')
                    }
                }
                project(":shared", "test:shared:") {
                    variant('onePrefRuntimeElements', [

        srcDir: src/someLib/cpp

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

        )
    }

    def "captures shared scripts with same classpath"() {
        given:
        file("shared.gradle") << "println 'shared.gradle'"

        buildFile << """
            apply from: 'shared.gradle'
            println 'build.gradle'
        """

        succeeds "help"

        when: // already compiled shared script
        file('otherBuild/settings.gradle').touch()

        libAndPCHTasksExecuted("hello", "shared")
        libAndPCHTasksExecuted("hello", "static")
        pchCompiledOnceForEach([ getPCHHeaderDirName("hello", "shared"), getPCHHeaderDirName("hello", "static") ])

        when:
        librarySourceModified()

        then:
        args("--info")
        succeeds "assemble"
        pchNotCompiled("hello", "shared")
        pchNotCompiled("hello", "static")
    }

      -root
        -api
        -shared
          -api
          -model
        -services
          -utilities (renamed by user to 'util'
        -util
        -contrib
          -services
            -util
      */

        def settingsFile = file("settings.gradle")

        then:
        result.assertTasksExecuted(':compileDebugSharedCpp', ':linkDebugShared', ':assemble')
        sharedLibrary('build/lib/main/debug/shared/foo').assertExists()
    }

    @ToBeFixedForConfigurationCache
    def "can assemble static library followed by shared library"() {
        def library = new CppLib()
        makeSingleProject()
        settingsFile << """
            rootProject.name = 'foo'
        """

  </fileSets>

  <files>
    <file>
      <sources>
        <source>src/assembly/shared/validate.cmd</source>
        <source>src/assembly/shared/mvnvalidate.cmd</source>
        <source>src/assembly/shared/init.cmd</source>
        <source>src/assembly/shared/mvnlauncher.cmd</source>
        <source>src/assembly/shared/run.cmd</source>
      </sources>
      <destName>mvn.cmd</destName>

	return sharedMemMapFile(f, totalSize, removeOnClose)
}

// header returns a pointer to metadata within the shared memory region.
func (m *sharedMem) header() *sharedMemHeader {
	return (*sharedMemHeader)(unsafe.Pointer(&m.region[0]))
}

// valueRef returns the value currently stored in shared memory. The returned
// slice points to shared memory; it is not a copy.
func (m *sharedMem) valueRef() []byte {
	length := m.header().valueLen

[short] skip
[!cgo] skip '-buildmode=c-shared requires external linking'
[!buildmode:c-shared] stop

env GO111MODULE=on

go get rsc.io/fortune
go build -buildmode=c-shared -o external.so rsc.io/fortune
go version external.so
stdout '^external.so: .+'
go version -m external.so
stdout '^\tpath\trsc.io/fortune'
stdout '^\tmod\trsc.io/fortune\tv1.0.0'

-- go.mod --
module m

-- empty.go --
package main