result == cache
        1 * cacheFactory.open(sharedCacheDir, null, [:], mode(Shared), _, NO_CLEANUP) >> cache
        0 * cacheFactory._
    }

    void createsGlobalCacheWithProperties() {
        when:
        builder.withProperties(properties).open()

        then:
        1 * cacheFactory.open(sharedCacheDir, null, properties, mode(Shared), _, NO_CLEANUP) >> cache
    }

 */

package org.gradle.docs.releasenotes

import org.jsoup.Jsoup
import org.jsoup.nodes.Document
import spock.lang.Shared
import spock.lang.Specification

class StaticReleaseNotesTest extends Specification {
    @Shared File renderedFile
    @Shared Document renderedDocument
    @Shared String renderedText

    def setupSpec() {
        def context = new ReleaseNotesTestContext()

> Task :producer:makeFile

> Task :consumer:showFile

				case "arm64":
					codegenArg = "-shared"
				}

			case "dragonfly", "freebsd", "illumos", "linux", "netbsd", "openbsd", "solaris":
				// Use -shared so that the result is
				// suitable for inclusion in a PIE or
				// shared library.
				codegenArg = "-shared"
			}
		}
		cfg.ExeSuffix = ".a"
		ldBuildmode = "c-archive"
	case "c-shared":
		pkgsFilter = oneMainPkg
		if gccgo {

        lockInfoAccess.clearLockInfo(lockFileAccess);
    }

    public FileLockOutcome tryLockInfo(boolean shared) throws IOException {
        return lockInfoAccess.tryLock(lockFileAccess, shared);
    }

    public FileLockOutcome tryLockState(boolean shared) throws IOException {
        return lockStateAccess.tryLock(lockFileAccess, shared);
    }

    /**
     * Reads the lock state from the lock file.
     */

//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris

package main

// Test a shared library created by -buildmode=c-shared that does not
// export anything.

import (
	"fmt"
	"os"
	"syscall"
)

// To test this we want to communicate between the main program and
// the shared library without using any exported symbols.  The init
// function creates a pipe and Dups the read end to a known number

/**
 * <p>Marks a task property as being a holder to a {@link BuildService}.</p>
 *
 * <p>
 * When you annotate a shared build service property with this annotation,
 * there is no need to explicitly declare the association between the task and the service;
 * also, if you provide a service name to the annotation, and a shared build service is
 * registered with that name, it will be automatically assigned to the property when the
 * task is created.

                return backingCache
            }
        }
    }

    def "acquires lock on open and releases on close when lock mode is shared"() {
        def access = newAccess(Shared)

        when:
        access.open()

        then:
        1 * lockManager.lock(lockFile, mode(Shared), "<display-name>") >> lock
        1 * initializationAction.requiresInitialization(lock) >> false
        _ * lock.state
        0 * _._

            signal.trigger()
        }

        where:
        lockMode << [Exclusive, Shared]
    }

    def "cannot acquire lock with mode #lockMode while another lock manager in same process is holding shared lock"() {
        given:
        def file = tmpDir.file("lock-file.bin")
        createLock(Shared, file)

        when:
        createLock(lockMode, file, manager2)

        then:

              <exclude>src/assembly/shared/init</exclude>
              <exclude>src/assembly/shared/init.cmd</exclude>
              <exclude>src/assembly/shared/mvnlauncher</exclude>
              <exclude>src/assembly/shared/mvnlauncher.cmd</exclude>
              <exclude>src/assembly/shared/mvnvalidate</exclude>
              <exclude>src/assembly/shared/mvnvalidate.cmd</exclude>