class ToolingApiIdeaModelCrossVersionSpec extends ToolingApiSpecification implements WithOldConfigurationsSupport {
    def "Provides target module name for module dependencies"() {


        file('build.gradle').text = """
subprojects {
    apply plugin: 'java'
}

project(':impl') {
    apply plugin: 'idea'

    dependencies {
        ${implementationConfiguration} project(':api')
    }
}
"""

 */

package org.gradle.internal.cc.impl

class ConfigurationCacheMultiProjectIntegrationTest extends AbstractConfigurationCacheIntegrationTest {

    def "reuses cache for absolute task invocation from subproject dir across dirs"() {
        given:
        settingsFile << """
            include 'a', 'b'
        """
        buildScript """
            task ok
        """
        def a = createDir('a')

        """

        buildFile """
            println("lifecycle: <evaluating> '\${project.path}'")
            subprojects { println("lifecycle: <root>.subprojects '\${it.path}'") }
        """

        groovyFile "a/build.gradle", """
            println("lifecycle: <evaluating> " + project)
        """

        when:
        succeeds("help")

import org.gradle.plugins.ide.tooling.r33.FetchEclipseProjects

@TargetGradleVersion(">=6.8")
class CompositeBuildModuleNamesCrossVersionSpec extends ToolingApiSpecification {

    def "name conflict between subproject and included build does not break IDEA import"() {
        given:
        settingsFile << """
            rootProject.name = 'module-main'
            include 'module-b'

        if (includeSubprojects) {
            // Try to delay configuring all the subprojects
            configurer.configure(project.getMutableModel());
            if (taskNameResolver.tryFindUnqualifiedTaskCheaply(taskName, project.getMutableModel())) {
                // An exact match in the target project - can just filter tasks by path to avoid configuring subprojects at this point

plugins {
    id("gradlebuild.distribution.api-java")
}

description = """Base for test suites.

This project is a implementation dependency of many other testing-related subprojects in the Gradle build.

This project is separate from testing-base to avoid needing to be Java 6 compatible.
"""

dependencies {
    api(projects.stdlibJavaExtensions)
    api(project(":base-services"))
    api(project(":core-api"))

            it.path == 'b1'
        }
    }

    def "EclipseProject model honours custom project name"() {
        when:
        buildB.buildFile << """
            subprojects {
                apply plugin: 'eclipse'
                eclipse {
                    project.name = project.name + "-renamed"
                }
            }
            project(":b1") {

        settingsFile << "include 'child'"
        buildFile """
class ContactConvention {
    def contacts(String arg) { arg }
}

convention.plugins.contacts = new ContactConvention()

subprojects {
    ext.contacts = { throw new RuntimeException() }
    assert contacts("a") == "a"
}
"""

        executer.expectDocumentedDeprecationWarning(

    private
    val buildModel = CIBuildModel(
        projectId = "Gradle_Check",
        branch = VersionedSettingsBranch("master"),
        buildScanTags = listOf("Check"),
        subprojects = JsonBasedGradleSubprojectProvider(File("../.teamcity/subprojects.json"))
    )

    @Test
    fun `create correct PerformanceTest build type for Linux`() {
        val performanceTest = PerformanceTest(
            buildModel,
            Stage(

Instead :testing-jvm-infrastructure loads classes from this project via reflection due to the above noted Java version issue.
We make sure to include this subproject as a runtime dependency in :distributions-core to ensure we include it with the Gradle distribution.
"""

dependencies {
    api(projects.stdlibJavaExtensions)
    api(projects.testingBaseInfrastructure)