}

    def "ignores excludes patterns when specified for one of shared resources/sources folders"() {
        given:
        def patterns = ["**/*.java"]
        javaTree = dirTree("shared", [], [])
        resourcesTree = dirTree("shared", patterns, [])
        when:
        def folders = regularSourceFolders()
        then:
        folders.find { it.dir.path.endsWith("shared") }.excludes == []
    }

			false,
		},
		{
			// 'directory' is a directory on mount
			// /var/lib/docker/devicemapper/test/shared that is shared, but one
			// of its parent is private.
			"nested-shared",
			"/var/lib/docker/devicemapper/test/shared/my/test/directory",
			true,
		},
		{
			// /var/lib/foo is a mount point and it's shared
			"shared-mount",
			"/var/lib/foo",
			true,
		},
		{
			// /var/lib/bar is a mount point and it's private

            apply plugin: 'swift-library'
            library.linkage = [Linkage.SHARED, Linkage.STATIC]
        """
    }

    @Override
    String getDevelopmentBinaryCompileTask() {
        return ":compileDebugSharedSwift"
    }

    @Override
    void assertComponentUnderTestWasBuilt() {
        file("build/modules/main/debug/shared/${componentUnderTest.moduleName}.swiftmodule").assertIsFile()

package unix

import "unsafe"

// SysvShmAttach attaches the Sysv shared memory segment associated with the
// shared memory identifier id.
func SysvShmAttach(id int, addr uintptr, flag int) ([]byte, error) {
	addr, errno := shmat(id, addr, flag)
	if errno != nil {
		return nil, errno
	}

	// Retrieve the size of the shared memory to enable slice creation
	var info SysvShmDesc

    C++ source 'hello:cpp'
        srcDir: src/hello/cpp

Binaries
    Shared library 'hello:sharedLibrary'
        build using task: :helloSharedLibrary
        build type: build type 'debug'
        flavor: flavor 'default'
        target platform: platform 'current'
        tool chain: Tool chain 'clang' (Clang)
        shared library file: build/libs/hello/shared/libhello.dylib
    Static library 'hello:staticLibrary'

        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()

        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'
        """