delegate.copy(action)

    override fun getDescription(): String? =
        delegate.description

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

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

    override fun getBuildscript(): ScriptHandler =
        delegate.buildscript

subprojects {
    apply plugin: "groovy"

    dependencies {
        implementation localGroovy()
    }

    compileJava.options.fork = true

    // force creation of multiple daemons for Java compilation by alternating between two distinct sets of JVM args
    def count = (project.name - "project") as int
    compileJava.options.forkOptions.jvmArgs = count % 2 ? ["-dsa"] : ["-esa"]

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

    }

    @Override
    public void project(ProjectInternal project, Action<? super Project> configureAction) {
        runProjectConfigureAction(project, configureAction);
    }

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

    @Override

    }

    String providerOf(String expression) {
        return "project.provider { $expression }"
    }

    def setup() {
        createDirs("subproject")
        settingsFile("""
            include "subproject"

            rootProject.name = "${PROJECT_NAME}"
            gradle.rootProject {
                version = "${PROJECT_VERSION}"
            }
        """)

            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)

        because("Kotlin soak tests use AssertJ")
    }

    integTestDistributionRuntimeOnly(project(":distributions-full"))
}

tasks.register("soakTest") {
    description = "Run all soak tests defined in the :soak subproject"
    group = "CI Lifecycle"
    dependsOn(":soak:forkingIntegTest")