plugins.apply(my.MyPlugin)
        """
        file("b/build.gradle") << """
            plugins.apply(my.MyPlugin)
        """

        when:
        executer.withArguments(ENABLE_CLI, "-Pshared-input=12", "-Da-input=14")
        def model = runBuildAction(new FetchCustomModelForEachProject())

        then:
        model.size() == 2
        model[0].message == "It works from project :a"

	for ; ; state = c.state.load() {
		switch {
		case !state.locked() && state.havePtr():
			if !c.state.update(&state, state.incReader()) {
				continue
			}
			// Counter unlocked or counter shared; has an initialized count pointer; acquired shared lock.
			if c.ptr.count == nil {
				for !c.state.update(&state, state.addExtra(uint64(n))) {
					// keep trying - we already took the reader lock
					state = c.state.load()
				}

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

        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:

        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
    }

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

// copied from linux/sched.h.
const (
	CLONE_VM             = 0x00000100 // set if VM shared between processes
	CLONE_FS             = 0x00000200 // set if fs info shared between processes
	CLONE_FILES          = 0x00000400 // set if open files shared between processes
	CLONE_SIGHAND        = 0x00000800 // set if signal handlers and blocked signals shared
	CLONE_PIDFD          = 0x00001000 // set if a pidfd should be placed in parent

    @Shared
    def socketError = new SocketException()
    @Shared
    def connectTimeout = new SocketTimeoutException()
    @Shared
    def cannotConnect = new HttpHostConnectException(null, null)
    @Shared
    def missing = status(404)
    @Shared
    def clientTimeout = status(408)
    @Shared
    def tooManyRequests = status(429)
    @Shared
    def forbidden = status(403)
    @Shared

    def "open locks cache directory with requested mode"() {
        final store = new DefaultPersistentDirectoryStore(cacheDir, "<display>", mode(Shared), null, lockManager, Mock(ExecutorFactory), buildOperationRunner)

        when:
        store.open()

        then:
        1 * lockManager.lock(cacheDir, mode(Shared), "<display> ($cacheDir)") >> lock

        when:
        store.close()

        then:
        _ * lock.state

				"parallelizationMethod":{
					"name":"TestDistribution"
				},
				"subprojects":[
					"launcher",
					"time",
					"logging-api",
					"kotlin-dsl-plugins",
					"serialization",
					"toolchains-jvm-shared",
					"docs-asciidoctor-extensions-base",
					"internal-instrumentation-processor",
					"security",
					"input-tracking",
					"base-ide-plugins"
				]
			},
			{
				"parallelizationMethod":{