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

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

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

    def "nested action can run further nested actions"() {
        settingsFile << """
            rootProject.name = 'root'
            include 'a', 'b'
        """
        buildFile << """
            allprojects {
                apply plugin: CustomPlugin
                apply plugin: 'java'
            }
        """

        expect:
        def models = withConnection {

@FluidDependenciesResolveTest
class ResolvedConfigurationApiIntegrationTest extends AbstractHttpDependencyResolutionTest {
    def setup() {
        settingsFile << """
rootProject.name = 'test'
"""
        buildFile << """
allprojects {
    configurations {
        compile
        "default" {
            extendsFrom compile
        }
    }
}
"""
    }

        """
            plugins { `kotlin-dsl-base` }
            $kotlinDslBuildSrcConfig
        """
    }

    static String getKotlinDslBuildSrcConfig() {
        """
            allprojects {
                repositories {
                    ${mavenCentralRepositoryDefinition(GradleDsl.KOTLIN)}
                }
            }
        """
    }

 */

package org.gradle.internal.cc.impl

import org.gradle.api.internal.project.ProjectInternal


internal
enum class CrossProjectModelAccessPattern {
    DIRECT,
    CHILD,
    SUBPROJECT,
    ALLPROJECTS
}


internal
data class CrossProjectModelAccessInstance(
    val pattern: CrossProjectModelAccessPattern,
    val relativeTo: ProjectInternal,

    ZincScalaCompileFixture(GradleExecuter executer, TestDirectoryProvider testDir) {
        super(executer, testDir)
    }

    @Override
    String initScriptContent() {
        return """
            allprojects {
                $disableScalaDocIfInDaemonMode
            }
        """
    }

    static String getDisableScalaDocIfInDaemonMode() {
        return !GradleContextualExecuter.isDaemon() ? "" : """