def submit = 'workerExecutor.noIsolation().submit(TestWork) { }'
        buildFile << """
            import javax.inject.Inject
            import org.gradle.workers.*

            class WorkerTask extends DefaultTask {

                @Inject
                WorkerExecutor getWorkerExecutor() {
                    throw new UnsupportedOperationException()

            "\"-Porg.gradle.performance.db.username=%performance.db.username%\"",
            "-DenableTestDistribution=%enableTestDistribution%",
            "-Dorg.gradle.workers.max=%maxParallelForks%",
            "-PmaxParallelForks=%maxParallelForks%",
            pluginPortalUrlOverride,
            "-s",
            "--no-configuration-cache",
            "%additional.gradle.parameters%",

    implementation(project(":launcher"))
    implementation(project(":resources"))
    implementation(project(":testing-base"))
    implementation(project(":testing-jvm"))
    implementation(project(":workers"))
    implementation(project(":testing-base-infrastructure"))
    implementation(libs.guava)
    implementation(libs.commonsIo)

    api(libs.jsr305)
    api(project(":base-services"))

    api(project(":core"))
    api(project(":core-api"))
    api(project(":files"))
    api(project(":platform-base"))
    api(project(":platform-jvm"))
    api(project(":process-services"))
    api(project(":workers"))

    api(libs.groovy)
    api(libs.inject)
    api(libs.jsr305)

    implementation(project(":dependency-management"))
    implementation(project(":logging"))
    implementation(project(":model-core"))

    integTestImplementation(testFixtures(project(":plugins-java-base")))
    integTestImplementation(testFixtures(project(":plugins-jvm-test-fixtures")))
    integTestImplementation(testFixtures(project(":workers")))

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

packageCycles {

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

description = "Infrastructure that bootstraps a worker process"

gradlebuildJava.usedInWorkers()

dependencies {
    api(projects.stdlibJavaExtensions)
    api(projects.serialization)
    api(project(":base-services"))
    api(project(":build-operations"))
    api(project(":logging"))
    api(project(":logging-api"))
    api(project(":messaging"))

 */
package org.gradle.api.internal.tasks.testing.filter;

import java.io.Serializable;
import java.util.Set;

/**
 * Specification describing a Test's filters. This class is serialized and used in test workers.
 */
public class TestFilterSpec implements Serializable {
    private final Set<String> includedTests;
    private final Set<String> excludedTests;
    private final Set<String> includedTestsCommandLine;

        and:
        file("init.gradle") << """
allprojects {
    task worker
}
rootProject {
    task root(dependsOn: allprojects*.worker)
}
        """

        when:
        executer.withArguments("-I", "init.gradle")
        run "root"

        then:
        result.assertTasksExecuted(':worker', ':a:worker', ':b:worker', ':root')
    }

}

description = "Contains declarations for instrumentation of plugins. Adds interceptors, bytecode upgrades etc."

dependencies {
    // All dependencies should be compileOnly, since this project is added also to worker classpath, so we don't pollute it.
    // If we need some dependency also at runtime we need to build a separate classpath and add it to :launcher project or :distributions-core project directly.
    compileOnly(project(":core"))

import org.gradle.internal.service.ServiceRegistration;
import org.gradle.internal.service.ServiceRegistrationProvider;
import org.gradle.internal.service.scopes.AbstractGradleModuleServices;
import org.gradle.workers.WorkerExecutor;

/**
 * Provides the various build initialization services.
 */
public class BuildInitServices extends AbstractGradleModuleServices {
    @Override