gradle.lifecycle.afterProject {
                println("after:" + $currentApplication)
            }
        """
        settingsFile '''
            pluginManagement {
                includeBuild 'build-logic'
            }
            plugins {
                id 'my-settings-plugin'
            }
        '''

        when:
        succeeds 'help'

        then:

     * @since 3.1
     */
    void includeBuild(Object rootProject);

    /**
     * Includes a build at the specified path to the composite build, with the supplied configuration.
     * @param rootProject The path to the root project directory for the build.
     * @param configuration An action to configure the included build.
     *
     * @since 3.1
     */

            rootProject {
                dependencies {
                    conf 'org:included:1.0'
                    conf 'org:foo:1.0'
                }
            }
            includedBuild("includeBuild") {
                settings {
                    rootProjectName = 'included'
                }
                rootProject {
                    group = 'org'
                    version = '1.0'

    }

    def "verify plugin portal is not used when defining pluginManagement repos in settings plugin"() {
        settingsFile << """
            pluginManagement {
                includeBuild("settings-script")
            }

            plugins {
                id 'settings-script'
            }

            pluginManagement.repositories.each { println it.url }
        """

        'yes'                   | "includeBuild('.')"
        // If substitutions for the root would be controllable (e.g. by the first include statement encountered) this would enable you to not have the ':subproject1' substitution
        // This documents the current behavior. It is unclear if this is a useful functionality to have.

    }

    private static Spec<Object> instanceOf(Class<?> cls) {
        return { cls.isInstance(it) }
    }

    private BuildTestFixture includedBuild(String name) {
        if (name != 'buildSrc') {
            settingsFile << """
                includeBuild '$name'
            """
        }
        new BuildTestFixture(testDirectory.createDir(name))
    }

            tasks.register("taskA")
        """
    }

    def setupCompositeBuildProject() {
        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'
            includeBuild 'c'
        """
        file("a/build.gradle") << """
            tasks.register("taskA")
            tasks.register("taskB") {
                dependsOn 'taskA'
            }

There are two ways to update the convention plugin in the example above into a binary plugin.

1. Use <<composite_builds.adoc#composite_builds,composite builds>>:
+
.settings.gradle.kts
[source,kotlin]
----
includeBuild("my-plugin")
----

2. <<publishing_gradle_plugins.adoc#sec:publishing_your_plugin,Publish the plugin>> to a repository:
+
.build.gradle.kts
[source,kotlin]
----
plugins {

            println("Applied script plugin")
        """

        settingsFile("""
            pluginManagement {
                includeBuild('included')
            }
        """)

        buildFile("""
            plugins {
                id("test-convention-plugin")
            }
        """)

        when:

            defaultDependencies {
                add(project.dependencies.create("org:default-dependency:1.0"))
            }
        }
    }
"""
        }

        settingsFile << """
    includeBuild '${producer.toURI()}'
"""
        buildFile << """
    apply plugin: 'java'
    repositories {
        maven { url '${mavenRepo.uri}' }
    }

    repositories {