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)
                    }
                }
            }

    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)

        runBlockConfigureAction(SUBPROJECTS_DETAILS, projects, configureAction);
    }

    @Override
    public void allprojects(Iterable<? extends ProjectInternal> projects, Action<? super Project> configureAction) {
        runBlockConfigureAction(ALLPROJECTS_DETAILS, projects, configureAction);
    }

    @Override

        classpath("org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion")
    }
    repositories {
        mavenCentral()
        google()
    }
}

allprojects {
    repositories {
        mavenCentral()
        google()
    }

    /** This is a provisional method and may be removed */
    public List<MavenProject> getAllProjects() {
        return allProjects;
    }

    /** This is a provisional method and may be removed */
    public void setAllProjects(List<MavenProject> allProjects) {
        this.allProjects = allProjects;
    }

    /*if_not[MAVEN4]*/

    //
    // Deprecated
    //

                .assertHasFileName("Build file '$buildFile'")
                .assertHasLineNumber(3)
    }

    def "produces reasonable error when Gradle.allprojects action fails"() {
        def initScript = initScript """
allprojects {
    throw new RuntimeException("broken")
}
"""
        when:
        executer.usingInitScript(initScript)
        fails "a"

        then:

import spock.lang.Timeout

import static org.gradle.integtests.fixtures.ToBeFixedForConfigurationCache.Skip.INVESTIGATE

@Requires(IntegTestPreconditions.NotParallelExecutor)
@ToBeFixedForIsolatedProjects(because = "allprojects")
// no point, always runs in parallel
class ParallelTaskExecutionIntegrationTest extends AbstractIntegrationSpec implements ValidationMessageChecker {

    @Rule

        return StringUtils.capitalize(getName())
    }

    String getCompileTaskName() {
        return "compile${name.capitalize()}"
    }

    String projectGroovyDependencies(String allprojectsOrSubproject= 'allprojects') {
        this == GROOVY ?
            """
            ${allprojectsOrSubproject} {
                dependencies {
                    implementation localGroovy()
                }
            }
"""

        mavenRepo.module("group", "test2", "1.0").publish()

        createDirs("child1", "child2")
        settingsFile << """
rootProject.name = "main"
include "child1", "child2"
"""
        buildFile << """
allprojects {
    repositories {
        maven { url '${mavenRepo.uri}' }
    }
    configurations {
        compile
        create('default') { extendsFrom compile }
    }
}
artifacts {
    compile file("main.jar")