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

    }

    def "can use task selector"() {
        setup:
        settingsFile << '''
            rootProject.name = 'root'
            include 'a'
        '''
        buildFile << '''
            allprojects {
                tasks.register('foo')
            }
        '''
        file('a').mkdirs()

        when:
        launchTestWithTestFilter { tl ->
            tl.forTasks('foo', 'test')
        }

        //we should add coverage for nested multi-project builds with multiple parents.
        reactorProjects.add(mavenProject);
        List<ProjectBuildingResult> allProjects = builder.build(ImmutableList.of(pomFile), true, buildingRequest);
        CollectionUtils.collect(allProjects, reactorProjects, ProjectBuildingResult::getProject);

        MavenExecutionResult result = new DefaultMavenExecutionResult();
        result.setProject(mavenProject);

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

    BuildTestFile buildB

    def setup() {
        buildB = multiProjectBuild("buildB", ['b1', 'b2']) {
            buildFile << """
                allprojects {
                    apply plugin: 'java'
                }
"""
        }
        includedBuilds << buildB
    }

    def "generates build operations for tasks in included builds"() {
        given:

 */

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,

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

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