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

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// 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.

    @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");
    }

import org.gradle.api.Incubating;

import java.io.File;

/**
 * A shared library that exists at a known location on the filesystem.
 */
@Incubating
public interface PrebuiltSharedLibraryBinary extends SharedLibraryBinary {
    /**
     * The shared library file.
     */
    void setSharedLibraryFile(File sharedLibraryFile);

    /**
     * The shared library link file.
     */

        srcDir: src/nativeLib/cpp

Binaries
    Shared library 'nativeLib:sharedLibrary'
        build using task: :nativeLibSharedLibrary
        build type: build type 'debug'
        flavor: flavor 'default'
        target platform: platform '$currentNative'
        tool chain: Tool chain 'clang' (Clang)
        shared library file: build/libs/nativeLib/shared/libnativeLib.dylib
    Static library 'nativeLib:staticLibrary'

metadata:
  name: home
  namespace: site-ns
spec:
  parentRefs:
  - name: shared-gateway
    namespace: infra-ns
  rules:
  - backendRefs:
    - name: home
      port: 8080
---
apiVersion: gateway.networking.k8s.io/v1beta1
kind: HTTPRoute
metadata:
  name: login
  namespace: site-ns
spec:
  parentRefs:
  - name: shared-gateway
    namespace: infra-ns
  rules:
  - matches:
    - path: