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

            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:

        when:
        factory.open(tmpDir.testDirectory.file('foo'), "foo", [prop: 'value'], mode(Shared), null, null)
        factory.open(tmpDir.testDirectory.file('bar'), "bar", [prop: 'value'], mode(Shared), null, null)
        factory.open(tmpDir.testDirectory.file('baz'), "baz", [prop: 'value'], mode(Shared), null, null)

        and:
        factory.visitCaches(new CacheVisitor() {
            @Override

plugins {
    id("gradlebuild.kotlin-shared-runtime")
}

description = "Provides Kotlin DSL code that is shared between build-logic and runtime"

dependencies {
    compileOnly(platform("gradlebuild:build-platform"))
    compileOnly(kotlin("stdlib"))
    compileOnly("org.ow2.asm:asm-tree")
    compileOnly("com.google.code.findbugs:jsr305")

val makeFile = tasks.register("makeFile") {
    val sharedFile = layout.buildDirectory.file("some-subdir/shared-file.txt")
    outputs.file(sharedFile)
    doFirst {
        sharedFile.get().asFile.writeText("This file is shared across Gradle subprojects.")
    }
}

val sharedConfiguration by configurations.creating {
    isCanBeResolved = false
}

artifacts {
    add(sharedConfiguration.name, makeFile)

        library.displayName == "native library 'someLib'"
    }

    def "can use shared variant as requirement"() {
        when:
        def requirement = library.shared

        then:
        requirement.projectPath == 'project-path'
        requirement.libraryName == 'someLib'
        requirement.linkage == 'shared'
    }

    def "can use static variant as requirement"() {
        when:

import org.gradle.util.TestUtil
import org.junit.ClassRule
import spock.lang.Shared
import spock.lang.Specification

import java.util.function.Consumer

@CleanupTestDirectory
class GradleBuildBuilderTest extends Specification {
    @Shared
    @ClassRule
    public TestNameTestDirectoryProvider temporaryFolder = TestNameTestDirectoryProvider.newInstance(getClass())
    @Shared

// See the License for the specific language governing permissions and
// limitations under the License.

[[build_services]]
= Using Shared Build Services

Shared build services allow tasks to share state or resources.
For example, tasks might share a cache of pre-computed values or use a web service or database instance.

A build service is an object that holds the state for tasks to use.

    @Override
    public FileCollection getLinkFiles() {
        return createFileCollection(getSharedLibraryLinkFile(), "link files", "Shared library link files");
    }

    @Override
    public FileCollection getRuntimeFiles() {
        return createFileCollection(getSharedLibraryFile(), "runtime files", "Shared library runtime files");
    }