substitutions.get() == 0
    }

    void substituteForCurrentThread(T substitution) {
        if (threadLocalDecorators.get() != original) {
            throw new IllegalStateException("already substituted for the current thread; proper cleanup might have been missed")
        }
        substitutions.incrementAndGet()
        threadLocalDecorators.set(substitution)
    }

    void cancelSubstitutionForCurrentThread() {

    def "substituted project dependencies are also substituted in the generated POM file"() {
        createBuildScripts("""
            dependencies {
                implementation project(":a")
            }

            configurations.all {
                resolutionStrategy.dependencySubstitution {
                    substitute(project(':a')).using(project(':b'))
                }

== Declaring the dependencies substituted by an included build

By default, Gradle will configure each included build in order to determine the dependencies it can provide. The algorithm for doing this is very simple: Gradle will inspect the `group` and `name` for the projects in the included build, and substitute project dependencies for any matching external dependency.

import org.jetbrains.kotlin.analysis.api.symbols.KaConstructorSymbol
import org.jetbrains.kotlin.name.Name

/**
 * A scope inside which use-site type-parameters of callable declarations may be substituted. Such declarations are represented as [KaCallableSignature].
 *
 * @see org.jetbrains.kotlin.analysis.api.components.KaScopeProviderMixIn.getTypeScope
 * @see KaCallableSignature
 */

The same rule _without_ the `platform` keyword would try to substitute _regular dependencies_ with a regular dependency, which is not what you want, so it's important to understand that the substitution rules apply on a _dependency specification_: it matches the requested dependency (`substitute XXX`) with a substitute (`using YYY`).

                }
                tasks.producer.dependsOn(slow)
            }
            project(':consumer') {
                dependencies {
                    // An external dependency that will be substituted with a dependency on project 'producer'
                    implementation "libs:producer:1.0"
                }
            }
        """

        when:
        succeeds(":resolve", "--parallel")

     * The properties available for use in the configuration file. These are substituted into the configuration file.
     */
    @Nullable
    @Optional
    @Input
    public Map<String, Object> getConfigProperties() {
        return configProperties;
    }

    /**
     * The properties available for use in the configuration file. These are substituted into the configuration file.
     */

```
cd my-app
echo "includeBuild '../my-utils'" >> settings.gradle
gradle run
```

With this configuration, the module dependencies from `my-app` to `my-utils` will always be substituted with project dependencies.

While simple, this approach has the downside of modifying the `my-app` build.

== Using separate composite build

            buildFile << """
                apply plugin: 'java-library'
            """
        }
    }

    def "EclipseProject model has closed project dependencies substituted in composite"() {
        setup:
        def workspace = eclipseWorkspace([project("buildA", buildA),
                                          project("buildB", buildB),

        "2.0"      | "2.0"         | 'moduleId("myorg", "ModuleC", "2.0")' | false                | "substitute project(':ModuleC') using module('myorg:ModuleC:2.0')"
        "2.1"      | "2.0"         | 'moduleId("myorg", "ModuleC", "2.1")' | false                | "substitute project(':ModuleC') using module('myorg:ModuleC:2.1')"