}

        features {
            // https://www.jetbrains.com/help/teamcity/shared-resources.html#Viewing+Shared+Resources+Usage
            // https://blog.jetbrains.com/teamcity/2013/05/explaining-the-shared-resources-plugin/
            // we only allow 1 promotion job running at the same time to avoid website xml conflicts
            feature {

    }

    def "multiple threads can coordinate locking of a shared resource"() {
        given:
        sharedResourceLeaseRegistry.registerSharedResource('resource', 1)
        def threadCount = 10
        def started = new CountDownLatch(threadCount)

        when:
        async {
            threadCount.times {
                start {
                    started.countDown()
                    thread.blockUntil.releaseAll

// on a channel.
type Result struct {
	Val    any
	Err    error
	Shared bool
}

// Do executes and returns the results of the given function, making
// sure that only one execution is in-flight for a given key at a
// time. If a duplicate comes in, the duplicate caller waits for the
// original to complete and receives the same results.
// The return value shared indicates whether v was given to multiple callers.

    def "open locks cache directory with requested mode"() {
        final store = new DefaultPersistentDirectoryStore(cacheDir, "<display>", mode(Shared), null, lockManager, Mock(ExecutorFactory), buildOperationRunner)

        when:
        store.open()

        then:
        1 * lockManager.lock(cacheDir, mode(Shared), "<display> ($cacheDir)") >> lock

        when:
        store.close()

        then:
        _ * lock.state

				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"launcher",
					"time",
					"logging-api",
					"kotlin-dsl-plugins",
					"serialization",
					"toolchains-jvm-shared",
					"docs-asciidoctor-extensions-base",
					"internal-instrumentation-processor",
					"security",
					"input-tracking",
					"base-ide-plugins"
				]
			},
			{
				"parallelizationMethod":{

// The following shift tests are disabled in the shared
// testdata/check/shifts.go file because they don't work
// correctly with types2 at the moment. See go.dev/issue/52080.
// Make sure we keep testing them with go/types.
//
// TODO(gri) Once go.dev/issue/52080 is fixed, this file can be
//           deleted in favor of the re-enabled tests
//           in the shared file.

package p

func _() {
	var s uint

model {
    components {
        lib1(NativeLibrarySpec)
        lib2(NativeLibrarySpec)
    }
}
"""
    }

    @ToBeFixedForConfigurationCache
    def "dependencies of 2 language source sets are not shared when compiling"() {
        given:
        buildFile << """
model {
    components {
        main(NativeExecutableSpec) {
            sources {
                cpp {

    @Shared
        versionIdentifier = new DefaultModuleVersionIdentifier("org.test", "producer", "1.0")
    @Shared
        componentIdentifier = DefaultModuleComponentIdentifier.newId(versionIdentifier)
    @Shared
        attributes = AttributeTestUtil.attributesFactory().of(Attribute.of("someAttribute", String), "someValue")
    @Shared
        schema = createSchema()
    @Shared

			expect: authorizer.DecisionNoOpinion,
		},
		{
			name:   "allowed shared secret via pod",
			attrs:  authorizer.AttributesRecord{User: node0, ResourceRequest: true, Verb: "get", Resource: "secrets", Name: "secret0-shared", Namespace: "ns0"},
			expect: authorizer.DecisionAllow,
		},
		{
			name:   "allowed shared secret via pvc",

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