+
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.

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

// build efficient, thread-safe free lists. However, it is not suitable for all
// free lists.
//
// An appropriate use of a Pool is to manage a group of temporary items
// silently shared among and potentially reused by concurrent independent
// clients of a package. Pool provides a way to amortize allocation overhead
// across many clients.
//

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

        then:
        assertTaskIsParallel("linkMainExecutable")
    }

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

        when:

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

package org.gradle.test.precondition

import spock.lang.Specification

class PredicateFileTest extends Specification {

    Set<Set<String>> values = [
        // Value NOT shared between single and multi cases
        ["value1"] as Set,
        // Value shared between single and multi cases
        ["value2"] as Set,
        ["value2", "value3"] as Set,
    ] as Set

    def "accept single values"() {
        when:

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)