class GradleLifecycleIntegrationTest extends AbstractIntegrationSpec {

    def withSettingsPluginInBuildLogic() {
        settingsFile '''
            pluginManagement {
                includeBuild 'build-logic'
            }
            plugins {
                id 'my-settings-plugin'
            }
            dsl {
                parameter = "42"
            }
        '''
    }

        result.plainTextOutput.matches("(?s).*Compiling with toolchain.*")
    }

    private String settingsForBuildWithIncludedBuilds() {
        return """
            pluginManagement {
                includeBuild 'plugin1'
            }

            ${applyToolchainResolverPlugin("CustomToolchainResolver", singleUrlResolverCode(uri))}

            rootProject.name = 'main'
        """
    }

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

        when:
        succeeds 'help'

        then:

    def "incremental artifact transform in buildscript block for included build runs without exception"() {
        createDirs("a", "included")
        settingsFile << """
            includeBuild("included") {
                dependencySubstitution {
                    substitute(module("com.test:lib")).using(project(":b"))
                }
            }
            include ":a"
        """

    }

    def "can fetch GradleProject model for an included build project"() {
        settingsFile << """
            rootProject.name = 'root'
            includeBuild("included1")
            include("lib1")
        """

        file("included1/settings.gradle") << """
            rootProject.name = 'included1'
            include("lib2")
        """

                    """
                        plugins { id("producer-plugin") }
                    """
                )
            }
        }
        withSettings(
            """
                includeBuild("build-logic")
            """
        )
        withBuildScript(
            """
                plugins { id("consumer-plugin") }
            """
        )

        // when:

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 {

        for (GradleBuild includedBuild : buildModel.getIncludedBuilds()) {
            if (!result.includedBuildIdeaProjects.containsKey(includedBuild)) {
                IdeaProject includedBuildProject = controller.getModel(includedBuild, IdeaProject.class);
                result.includedBuildIdeaProjects.put(includedBuild, includedBuildProject);
                collectAllNestedBuilds(includedBuild, controller, result);
            }

                    {
                        "type": "org.gradle.api.initialization.ConfigurableIncludedBuild",
                        "member": "Implemented interface org.gradle.api.initialization.IncludedBuild",
                        "changes": ["Interface has been removed"],
                        "acceptation": "@Incubating interface has been removed"
                    }
                ]
            }
        """])

        delegate.gradle

    override fun getSharedServices() = delegate.sharedServices

    override fun getIncludedBuilds(): MutableCollection<IncludedBuild> =
        delegate.includedBuilds

    override fun includedBuild(name: String): IncludedBuild =
        delegate.includedBuild(name)

    override fun getPlugins(): PluginContainer =
        delegate.plugins

    override fun apply(closure: Closure<Any>) =