staticLibrary("build/libs/helloStatic/static/helloStatic").assertExistsAndDelete()
        sharedLibrary("build/libs/helloShared/shared/helloShared").assertExistsAndDelete()
        installation("build/install/main")
            .assertIncludesLibraries("helloShared")
            .exec().out == "Hello staticHello shared"
    }

    @ToBeFixedForConfigurationCache

import javax.annotation.concurrent.ThreadSafe;
import java.io.File;
import java.util.Optional;

/**
 * Manages the shared services that are scoped to a particular Gradle user home dir and which can be shared by multiple build invocations. These shared services also include the global services.
 *
 * <p>A plugin can contribute shared services to this scope by providing an implementation of {@link GradleModuleServices}.
 */
@ThreadSafe

            if (toolChain in VisualCpp) {
                cCompiler.args "/Zi"
                linker.args "/DEBUG"
            }
        }
    }
}
// end::compiler-args[]

// tag::all-shared-libraries[]
// For any shared library binaries built with Visual C++,
// define the DLL_EXPORT macro
model {
    binaries {
        withType(SharedLibraryBinarySpec) {
            if (toolChain in VisualCpp) {

	Shared     = flag.Bool("shared", false, "generate code that can be linked into a shared library")
	Dynlink    = flag.Bool("dynlink", false, "support references to Go symbols defined in other shared libraries")
	Linkshared = flag.Bool("linkshared", false, "generate code that will be linked against Go shared libraries")

        expect:
        emptyDir.assertDoesNotExist()

        when:
        def cache = new DefaultPersistentDirectoryCache(emptyDir, "<display-name>", properties, mode(FileLockManager.LockMode.Shared), initializationAction, cacheCleanup, lockManager, Mock(ExecutorFactory), buildOperationRunner)
        try {
            cache.open()
        } finally {
            cache.close()
        }

        then:

    def "has useful string representation"() {
        expect:
        binary.toString() == "prebuilt shared library 'lib:name'"
        binary.displayName == "prebuilt shared library 'lib:name'"
        binary.linkFiles.toString() == "link files for prebuilt shared library 'lib:name'"
        binary.runtimeFiles.toString() == "runtime files for prebuilt shared library 'lib:name'"
    }

    def "uses library file when link file not set"() {
        given:

import org.junit.ClassRule
import spock.lang.Shared
import spock.lang.Specification
import spock.lang.Unroll

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

import static org.gradle.cache.FileLockManager.LockMode.Shared

class DefaultLockOptionsTest extends Specification {
    def "can make copy of options"() {
        def builder = DefaultLockOptions.mode(Exclusive).useCrossVersionImplementation()

        when:
        def copy = builder.copyWithMode(Shared)

        then:
        !copy.is(builder)
        copy.mode == Shared
        copy.useCrossVersionImplementation
    }

kind: Gateway
metadata:
  name: shared-gateway
  namespace: infra-ns
spec:
  gatewayClassName: shared-gateway-class
  listeners:
  - name: https
    hostname: "foo.example.com"
    protocol: HTTPS
    port: 443
    allowedRoutes:
      namespaces:
        from: Selector
        selector:
          matchLabels:
            shared-gateway-access: "true"
    tls:
      certificateRefs:

import static org.gradle.cache.FileLockManager.LockMode.Shared

class DefaultFileLockManagerWithNewProtocolTest extends AbstractFileLockManagerTest {
    @Override
    protected DefaultLockOptions options() {
        return DefaultLockOptions.mode(FileLockManager.LockMode.OnDemand)
    }

    def "a lock has been updated when never written to"() {
        given:
        def lock = createLock(Shared)
        def state = lock.state