assert isComposite(gradle.parent)
            assert !isNested(gradle.parent)
"""

        then:
        execute(buildA, "jar")
    }

    def "included build with declared substitutions is flagged as a nested build with composite parent"() {
        when:
        buildA.settingsFile << """
            includeBuild('${buildB.toURI()}') {
                dependencySubstitution {

    void addAvailableModules(Set<Pair<ModuleVersionIdentifier, ProjectComponentIdentifier>> availableModules);
    void registerSubstitution(Action<DependencySubstitution> substitutions);

            group = 'g'
            dependencies {
                implementation 'g:sub-a'
            }
        """
    }

    def "Eclipse model respects composite build substitutions in root build"() {
        given:
        compositeIncludedRoot()

        when:
        def model = withConnection {
            getModel(HierarchicalEclipseProject)
        }

        then:

    private JvmInterceptorsSubstitution jvmInterceptorsSubstitution
    private GroovyInterceptorsSubstitution groovyInterceptorsSubstitution

    def setup() {
        // Substitutions should be set before the InstrumentedClasses is constructed
        jvmInterceptorsSubstitution = new JvmInterceptorsSubstitution(jvmBytecodeInterceptorSet())
        jvmInterceptorsSubstitution.setupForCurrentThread()

     * so it can be called on an instance of [subClass].
     *
     * Basically, it's a composition of inheritance-based substitutions for all the inheritance chain.
     *
     * On the following code:
     * ```
     * class A : B<String>
     * class B<T> : C<T, Int>
     * class C<X, Y>
     * ```
     *

        succeeds()

        then:
        executed(":${newPluginBuildName}:jar")
        pluginBuild.assertProjectPluginApplied()
    }

    def "included plugin build can not have dependency substitutions"() {
        given:
        def pluginBuild = pluginBuild("build-logic")
        settingsFile << """
            pluginManagement {
                includeBuild("$pluginBuild") {

        includedBuild.includedBuilds.empty
    }

    @Issue("https://github.com/gradle/gradle/issues/5167")
    @TargetGradleVersion(">=3.3")
    def "Included builds are present in the model when substitutions are used"() {
        given:
        singleProjectBuildInRootFolder("root") {
            settingsFile << """
                rootProject.name = 'root'
                includeBuild('includedBuild') {

        // attaches root project
        buildLoader.load(gradle.getSettings(), gradle);

        // Makes included build substitutions available for this build
        coordinator.registerSubstitutionsAvailableFor(gradle.getOwner());

        // Build buildSrc and export classpath to root project

        }
    }

    public void registerSubstitutionsProvidedBy(BuildState build) {
        if (build instanceof RootBuildState && registerRootSubstitutions) {
            // Make root build substitutions available
            doRegisterSubstitutions((RootBuildState) build);
        }
    }

    public void prepareForPluginResolution(IncludedBuildState build) {
        if (!registering.add(build)) {

            val allSubstitutors = buildList {
                combinations.forEach { typesPermutation ->
                    add(buildSubstitutor { substitutions(typeParameters.zip(typesPermutation).toMap()) })
                }
            }

            allSubstitutors.forEach { substitutor ->
                testContractsOnDeclarationSymbol(symbol, substitutor, testServices)