given:
        file("buildSrc/build.gradle") << """
            allprojects {
                apply plugin: 'java'
            }
        """
        buildFile << """
            allprojects {
                apply plugin: 'java'
            }
        """
        file("included/build.gradle") << """
            allprojects {
                apply plugin: 'java'
            }
        """

        buildFile << """
            allprojects {
                apply plugin: 'groovy'

                dependencies {
                    implementation localGroovy()
                }
            }
        """
    }

    private void withTests() {
        buildFile << """
            allprojects {
                dependencies{

        enableProblemsApiCheck()
        createDirs("a", "b")
        settingsFile << """
            rootProject.name = 'test'
            include 'a', 'b'
        """
        buildFile << """
            allprojects { task someTask }
            project(':a') { task someTaskA }
            project(':b') { task someTaskB }
        """

        when:
        fails "someTest"

        then:

        projectDir.file('settings.gradle').text = '''
include "a"
rootProject.name = 'root'
'''
        projectDir.file('build.gradle').text = """
allprojects { apply plugin: 'java' }
${mavenCentralRepository()}
dependencies {
    ${implementationConfiguration} 'commons-lang:commons-lang:2.5'
    ${implementationConfiguration} project(':a')

        // compute the projects mapping
        if (allProjects == null) {
            List<MavenProject> allProjects = session.getAllProjects();
            if (allProjects != null) {
                Map<String, Map<String, Map<String, MavenProject>>> map = new HashMap<>();
                allProjects.forEach(project -> map.computeIfAbsent(project.getGroupId(), k -> new HashMap<>())

        }

        override fun allprojects(action: Action<in Project>) {
            delegate.allprojects(referrer, action)
        }

        override fun allprojects(configureClosure: Closure<*>) {
            delegate.allprojects(referrer, ConfigureUtil.configureUsing(configureClosure))
        }

        override fun allprojects(referrer: ProjectInternal, configureAction: Action<in Project>) {

        mavenRepo.module("org.other", "externalB", "2.1").publish()

        and:
        createDirs("a", "b")
        file('settings.gradle') << "include 'a', 'b'"

        and:
        buildFile << """
allprojects {
    repositories { maven { url '$mavenRepo.uri' } }
}
project(":a") {
    configurations {
        api
        'default' { extendsFrom api }
    }
    dependencies {
        api "org.other:externalA:1.2"

            includeBuild 'includedBuild'
        """
        buildFile << '''
            def buildType = Attribute.of('buildType', String)
            def flavor = Attribute.of('flavor', String)
            allprojects {
                dependencies {
                    attributesSchema {
                        attribute(buildType)
                        attribute(flavor)
                    }
                }
            }

                    maven { url "${mavenRepo.uri}" }
                }
"""
        }

        buildB = multiProjectBuild("buildB", ['b1', 'b2']) {
            buildFile << """
                allprojects {
                    apply plugin: 'java-library'
                    apply plugin: 'idea'
                    repositories {
                        maven { url "${mavenRepo.uri}" }
                    }

    override fun zipTree(zipPath: Any): FileTree =
        delegate.zipTree(zipPath)

    override fun allprojects(action: Action<in Project>) =
        delegate.allprojects(action)

    override fun allprojects(configureClosure: Closure<*>) =
        delegate.allprojects(configureClosure)

    override fun <T : Any?> container(type: Class<T>): NamedDomainObjectContainer<T> =
        delegate.container(type)