+
Generates the `.vcxproj` file for the shared linkage of the `main` component.

`__projectName__DllVisualStudioFilters` — link:{groovyDslPath}/org.gradle.ide.visualstudio.tasks.GenerateFiltersFileTask.html[GenerateFiltersFileTask]::
+
Generates the `.vcxproj.filters` file for the shared linkage of the `main` component.

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

import org.gradle.internal.typeconversion.NotationParser
import spock.lang.Shared
import spock.lang.Specification
import spock.lang.Subject

class CapabilityNotationParserFactoryTest extends Specification {
    @Subject
    @Shared
    private NotationParser<Object, Capability> strictParser = new CapabilityNotationParserFactory(true).create()
    @Subject
    @Shared

	defer func(a, o string) {
		goarch = a
		goos = o
	}(goarch, goos)

	var modes = []string{
		// we assume that "exe" and "archive" always work
		"pie",
		"c-archive",
		"c-shared",
		"shared",
		"plugin",
	}

	for _, a := range okgoarch {
		goarch = a
		for _, o := range okgoos {
			if _, ok := cgoEnabled[o+"/"+a]; !ok {
				continue
			}
			goos = o
			for _, mode := range modes {

#include "textflag.h"

TEXT _rt0_arm_linux(SB),NOSPLIT|NOFRAME,$0
	MOVW	(R13), R0	// argc
	MOVW	$4(R13), R1		// argv
	MOVW	$_rt0_arm_linux1(SB), R4
	B		(R4)

// When building with -buildmode=c-shared, this symbol is called when the shared
// library is loaded.
TEXT _rt0_arm_linux_lib(SB),NOSPLIT,$0
	B	_rt0_arm_lib(SB)

TEXT _rt0_arm_linux1(SB),NOSPLIT|NOFRAME,$0
	// We first need to detect the kernel ABI, and warn the user

        when:
        succeeds("assemble", "parallelTask")

        then:
        assertTaskIsParallel("linkMainExecutable")
    }

    @ToBeFixedForConfigurationCache
    def "can execute link shared library tasks in parallel"() {
        given:
        withComponentsForAppAndSharedLib()
        createTaskThatRunsInParallelUsingCustomToolchainWith("linkMainLibSharedLibrary")

        when:

	if race.Enabled {
		race.Disable()
	}
	l, pid := p.pin()
	x := l.private
	l.private = nil
	if x == nil {
		// Try to pop the head of the local shard. We prefer
		// the head over the tail for temporal locality of
		// reuse.
		x, _ = l.shared.popHead()
		if x == nil {
			x = p.getSlow(pid)
		}
	}
	runtime_procUnpin()
	if race.Enabled {
		race.Enable()
		if x != nil {

import static org.junit.Assume.assumeTrue

@RequiresInstalledToolChain(ToolChainRequirement.SWIFTC)
class AbstractSwiftMixedLanguageIntegrationTest extends AbstractIntegrationSpec {
    public static final String SHARED = "SHARED"
    public static final String STATIC = "STATIC"
    def swiftToolChain = AvailableToolChains.getToolChain(ToolChainRequirement.SWIFTC)
    def cppToolChain = AvailableToolChains.getToolChain(ToolChainRequirement.CLANG)

#include "textflag.h"
#include "cgo/abi_arm64.h"

TEXT _rt0_arm64_linux(SB),NOSPLIT|NOFRAME,$0
	MOVD	0(RSP), R0	// argc
	ADD	$8, RSP, R1	// argv
	BL	main(SB)

// When building with -buildmode=c-shared, this symbol is called when the shared
// library is loaded.
TEXT _rt0_arm64_linux_lib(SB),NOSPLIT,$184
	// Preserve callee-save registers.
	SAVE_R19_TO_R28(24)
	SAVE_F8_TO_F15(104)

import org.gradle.internal.time.Clock
import org.gradle.testfixtures.ProjectBuilder
import org.gradle.util.TestUtil
import spock.lang.Shared
import spock.lang.Specification

public class TestNGTestFrameworkTest extends Specification {

    @Shared ObjectFactory objects = TestUtil.objectFactory()

    private project = ProjectBuilder.builder().build()
    Test testTask = TestUtil.createTask(Test, project)