== 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'

                }
            """
        )
        // and: a settings script that uses the plugin
        withDefaultSettings().appendText(
            """
                pluginManagement {
                    includeBuild("plugins")
                }

                plugins {
                    id("my-settings-plugin")
                }

                // accessor function
                mySettingsExtension {

}
group = "buildlogic"

"""
        buildFile << '''
plugins {
    id('buildlogic.foo')
}
'''
        settingsFile << '''
            pluginManagement {
                includeBuild('included')
            }
        '''
        when:
        fails('runBrokenWorker')

        then:

        buildFile << """
            dependencies {
                implementation "org.test:child:1.0"
            }
        """
        settingsFile << """
            includeBuild "child"
        """
    }

    boolean supportsCompositeBuilds() {
        true
    }

    def withMultiProjectSources() {
        TestFile child = file("child").createDir()

            TestFile includedBuildDir = spec.testDirectory.file("build-logic")
            settingsFile(spec.testDirectory, scriptLanguage) << 'includeBuild("build-logic")'
            settingsFile(includedBuildDir, scriptLanguage) << addDefaultExclude(excludedFileName())
        }

        @Override
        String toString() {
            return "included build"

            rootProject.name = 'build-src'

            include 'my-plugin'
        """

        settingsFile << """
            pluginManagement {
                includeBuild 'build-src'
                repositories {
                    maven { url '${mavenRepo.uri}' }
                }
            }

            plugins {
                id 'my.plugin'
            }

    }

    BuildFixture includedBuild(String name) {
        return rootBuild.includedBuild(name)
    }

    class RootBuild extends BuildFixture {
        Map<String, BuildFixture> builds = [:]

        RootBuild(TestFile rootDirectory) {
            super('root', rootDirectory)
        }

        BuildFixture includedBuild(String name) {

        settingsFile.moveToDirectory(file('included'))
        buildFile.moveToDirectory(file('included'))
        settingsFile << """
            includeBuild 'included'
        """
        buildFile << """
            task run {
                dependsOn gradle.includedBuild('included').task(':app:resolve')
            }
        """

        when:
        runBuild("run")

        then: