public void apply(Project target) {
                }
            }
        """

        file("settings.gradle.dcl") << """
            pluginManagement {
                includeBuild("build-logic")
            }

            plugins {
                id("com.example.restricted.ecosystem")
            }
        """

        file("build.gradle.dcl") << """

            }

            gradle.taskGraph.whenReady {
                project(':').apply from: 'includedWhenReady.gradle'
            }
        """

        settingsFile << """
            includeBuild 'included-build'
            include 'foo'
        """

        file("foo/build.gradle")
        file("foo/before.gradle") << ""
        file("foo/after.gradle") << ""
        file("foo/whenReady.gradle") << ""

        """)
    }

    private
    fun withK2BuildLogicConsumingBuild() {
        withSettings("""
            pluginManagement {
                ${mavenCentralRepository(KOTLIN)}
                includeBuild("build-logic")
            }
            rootProject.name = "k2-gradle"
        """)
        withBuildScript("""
            plugins { id("my-plugin") }
            project.tasks.register("myTask", MyTask::class)

        Assume.assumeFalse(pluginName in ['xctest', 'visual-studio', 'xcode', 'play-application'])

        def includedBuildFile = file("included/build.gradle")

        settingsFile << """
            includeBuild 'included'
        """

        applyPlugin(includedBuildFile)
        includedBuildFile << """
            tasks.configureEach {
                println("configuring \${it.path}")
            }

                useJUnitPlatform()
            }
        """
        file("settings.gradle.kts") << """
            rootProject.name = "GradleEclipseWTPWithIncludedBuild"

            includeBuild("includedBuild")
        """
        file("src/main/java/org/example/Main.java") << """
            package org.example;

            public class Main {
                public static void main(String[] args) {

                        id = "test.worker"
                        implementationClass = "com.example.BlankPlugin"
                    }
                }
            }
        """
        settingsFile << "includeBuild 'included'"
        buildFile << """
            plugins {
                id 'jvm-toolchains'
                id 'test.worker'
            }
            import com.example.TestWorkAction

== Converting `my-app` to a composite build

It's possible to make the above arrangement persistent, by making `my-app` a composite build that includes `my-utils`.

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

class ConfigurationCacheIncludedBuildLogicIntegrationTest extends AbstractConfigurationCacheIntegrationTest {
    TestFile pluginSourceFile

    def setup() {
        settingsFile << "includeBuild('build-logic')"
        def rootDir = file("build-logic")
        rootDir.file("settings.gradle") << """
            rootProject.name="lib"
        """
        rootDir.file("build.gradle") << """
            plugins {

        createDirs("m1", "m2", "m3")
        settingsFile << """
            dependencyResolutionManagement {
                repositories.maven { url "${mavenRepo.uri}" }
            }
            includeBuild '.' // enable global substitution for this build
            include 'm1', 'm2', 'm3'
        """

        buildFile << """
            allprojects {
                group = 'org.test'

        withFile("build-logic/src/main/kotlin/my-plugin.settings.gradle.kts", """
            extensions.create<MyExtension>("my")
        """)
        withSettings("""
            pluginManagement {
                includeBuild("build-logic")
            }
            plugins { id("my-plugin") }

            extensions.getByType(MyExtension::class).some("api.get")
            extensions.configure<MyExtension> { some("api.configure") }