message = String.format(
                    "Unsupported worker JDK version. Required: %s. Current: %s",
                    e2.getVersion().getMajorVersion(), JavaVersion.current().getMajorVersion()
                );
            } else {
                message = "Unsupported worker JDK version: " + JavaVersion.current().getMajorVersion();
            }

import org.gradle.api.NonNullApi;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

/**
 * Limits configured for workers in the current build.
 * <p>
 * Workers can be threads, processes or whatever Gradle considers a "worker".
 * <p>
 * Some examples:
 * <ul>
 *     <li>A thread running a task</li>
 *     <li>A test process</li>
 *     <li>A language compiler in a forked process</li>

 */

package org.gradle.workers;

import org.gradle.api.file.ConfigurableFileCollection;

/**
 * A worker spec providing the requirements of an isolated classpath.
 *
 * @since 5.6
 */
public interface ClassLoaderWorkerSpec extends WorkerSpec {
    /**
     * Gets the classpath associated with the worker.
     *
     * @return the classpath associated with the worker
     */

        return new DaemonForkOptions(forkOptions, keepAliveMode, classLoaderStructure);
    }

    /**
     * Users can add files that are held open by the worker process. This causes problems on Windows with persistent workers because
     * we cannot delete files that are held by the worker process.
     *
     * @param jvmArgs JVM arguments to check

        processed.gradleUserHomeDirPath == original.gradleUserHomeDirPath
        processed.serverAddress == original.serverAddress
        processed.workerId == original.workerId
        processed.displayName == original.displayName
        processed.workerAction instanceof TestAction
        processed.workerAction.value == original.workerAction.value
    }

 * limitations under the License.
 */

package org.gradle.process.internal.worker;

import org.gradle.internal.serialize.Serializer;

/**
 * Configures and builds multi-request workers. A multi-request worker runs zero or more requests in a forked worker process.
 *

                // TODO Only log expired workers count, log their "identity" once they are nameable/describable
                LOGGER.debug("Worker Daemon(s) expired to free some system memory {}", toExpire.size());
            }
            if (notExpirable > 0) {
                LOGGER.debug("{} Worker Daemon(s) had expiration disabled and were skipped", notExpirable);
            }

 * limitations under the License.
 */

package org.gradle.workers.internal

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.workers.fixtures.WorkerExecutorFixture

/**
 * Verifies that we can spawn large amounts of workers without running out of memory, because the old ones will be killed
 * if necessary.
 *
 * <p>

 */

package org.gradle.workers.internal;

import org.gradle.api.Describable;
import org.gradle.api.logging.LogLevel;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.process.ExecResult;
import org.gradle.process.internal.health.memory.JvmMemoryStatus;
import org.gradle.process.internal.worker.MultiRequestClient;
import org.gradle.process.internal.worker.WorkerProcess;

import java.util.Optional;

     */
    void setParallelProjectExecutionEnabled(boolean parallelProjectExecution);

    /**
     * Returns the maximum number of concurrent workers used for underlying build operations.
     *
     * Workers can be threads, processes or whatever Gradle considers a "worker". Some examples:
     *
     * <ul>
     *     <li>A thread running a task</li>
     *     <li>A test process</li>