}

		realOut = out
		out = out + ".o"

	case "c-shared":
		ldflags = append(ldflags, "-shared", "-nostdlib")
		if cfg.Goos != "windows" {
			ldflags = append(ldflags, "-Wl,-z,nodelete")
		}
		ldflags = append(ldflags, goLibBegin...)
		ldflags = append(ldflags, "-lgo", "-lgcc_s", "-lgcc", "-lc", "-lgcc")

	case "shared":
		if cfg.Goos != "aix" {
			ldflags = append(ldflags, "-zdefs")
		}

	// Count is the number of values tested.
	Count int64

	// CoverageData is set if the value in shared memory expands coverage
	// and therefore may be interesting to the coordinator.
	CoverageData []byte

	// Err is the error string caused by the value in shared memory, which is
	// non-empty if the value in shared memory caused a crash.
	Err string

	// InternalErr is the error string caused by an internal error in the

				}
				// Assume that if pkg (runtime/cgo or math)
				// is already accounted for in a different shared library,
				// then that shared library also contains runtime,
				// so that anything we do will depend on that library,
				// so we don't need to include pkg in our shared library.
				if force || p.Shlib == "" || filepath.Base(p.Shlib) == pkg {

        installation("app/build/install/main/debug").exec().out == app.expectedOutput

        where:
        linkage << [SHARED, STATIC]
    }

    @ToBeFixedForConfigurationCache
    def "can compile and link against a c++ library with both static and shared linkages"() {
        createDirs("app", "cppGreeter")
        settingsFile << "include 'app', 'cppGreeter'"
        def cppGreeter = new CppGreeterFunction()

        project.library.linkage = [Linkage.SHARED, Linkage.STATIC]
        project.evaluate()

        then:
        def compileDebug = project.tasks.compileDebugSharedCpp
        compileDebug instanceof CppCompile
        compileDebug.source.files == [src] as Set
        compileDebug.objectFileDir.get().asFile == projectDir.file("build/obj/main/debug/shared")
        compileDebug.debuggable

         * 2b. If we use shared lock, and we succeed in step 1., then we just hold the lock. We don't write anything to the information region
         * since multiple processes can acquire shared lock (due to that we currently also don't support on demand shared locks).<br>
         * 2.c If we fail, we throw a timeout exception.
         * <br><br>
         *

        then:
        installation("build/install/main").exec().out == app.englishOutput

        then:
        file("build/libs/hello/shared/link/new_output/_hello.lib").assertExists()
        file("build/libs/hello/shared/runtime/new_output/_hello.dll").assertExists()
    }

    @Requires(UnitTestPreconditions.CanInstallExecutable)
    @ToBeFixedForConfigurationCache

			qm.resourceChanges.Add(event)
		},
	}
	shared, err := qm.informerFactory.ForResource(resource)
	if err == nil {
		logger.V(4).Info("QuotaMonitor using a shared informer", "resource", resource.String())
		shared.Informer().AddEventHandlerWithResyncPeriod(handlers, qm.resyncPeriod())
		return shared.Informer().GetController(), nil
	}
	logger.V(4).Error(err, "QuotaMonitor unable to use a shared informer", "resource", resource.String())

import static org.gradle.language.nativeplatform.internal.Dimensions.useHostAsDefaultTargetMachine;

/**
 * <p>A plugin that produces a shared library from Swift source.</p>
 *
 * <p>Adds compile, link and install tasks to build the shared library. Defaults to looking for source files in `src/main/swift`.</p>
 *
 * <p>Adds a {@link SwiftComponent} extension to the project to allow configuration of the library.</p>
 *

In <<declaring_dependencies_between_subprojects#javadependencies_2,this example>>, the `:services:person-service` project depends on both the `:api` and `:shared` projects.
The `:api` project also depends on the `:shared` project.

Assuming you are working on a single project, the `:api` project, you have been making changes but have not built the entire project since performing a `clean`.