import org.gradle.process.internal.ExecHandleFactory;
import org.gradle.process.internal.JavaForkOptionsFactory;
import org.gradle.process.internal.worker.child.WorkerDirectoryProvider;
import org.gradle.workers.internal.ActionExecutionSpecFactory;
import org.gradle.workers.internal.WorkerDaemonFactory;

public class JavaToolchainServices extends AbstractGradleModuleServices {
    @Override

import org.gradle.process.internal.worker.request.Receiver;
import org.gradle.process.internal.worker.request.Request;
import org.gradle.process.internal.worker.request.RequestArgumentSerializers;
import org.gradle.process.internal.worker.request.RequestProtocol;
import org.gradle.process.internal.worker.request.RequestSerializerRegistry;
import org.gradle.process.internal.worker.request.ResponseProtocol;

 * limitations under the License.
 */

package org.gradle.process.internal.worker.child;

import java.io.File;

public interface WorkerDirectoryProvider {
    /**
     * Returns a File object representing the working directory for workers.
     */
    File getWorkingDirectory();

        this.gradleUserHomeDir = gradleUserHomeDirProvider.getGradleUserHomeDirectory();
    }

    @Override
    public File getWorkingDirectory() {
        File defaultWorkerDirectory = new File(gradleUserHomeDir, "workers");
        if (!defaultWorkerDirectory.exists()) {
            GFileUtils.mkdirs(defaultWorkerDirectory);
        }
        return defaultWorkerDirectory;
    }

        then:
        1 * clientsManager.reserveIdleClient(options) >> client
        1 * buildOperationRunner.call(_)
    }

    def "build worker operation is finished even if worker fails"() {
        when:
        factory.getWorker(requirement).execute(spec)

        then:
        1 * clientsManager.reserveIdleClient(options) >> client

            lock.lock();
            try {
                // Wait for work to be submitted if the queue is empty and our worker count is under max workers
                // This attempts to keep up to max workers threads alive once they've been started.
                while (queueState == QueueState.Working && queue.isEmpty() && (workerCount <= getMaxWorkerCount())) {
                    try {

/**
 * Implementation of {@link WorkerTestClassProcessorFactory} which instantiates a {@code JUnitPlatformTestClassProcessor}.
 * This class is loaded on test workers themselves and acts as the entry-point to running JUnit Platform tests on a test worker.
 */
class JUnitPlatformTestClassProcessorFactory implements WorkerTestClassProcessorFactory, Serializable {
    private final JUnitPlatformSpec spec;

import java.io.Serializable;

/**
 * Implementation of {@link WorkerTestClassProcessorFactory} which instantiates a {@link JUnitTestClassProcessor}.
 * This class is loaded on test workers themselves and acts as the entry-point to running JUnit 4 tests on a test worker.
 */
class JUnitTestClassProcessorFactory implements WorkerTestClassProcessorFactory, Serializable {
    private final JUnitSpec spec;

 */

package org.gradle.workers.internal;

import org.gradle.api.NonNullApi;
import org.gradle.initialization.BuildCancellationToken;
import org.gradle.internal.concurrent.Stoppable;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import java.util.concurrent.atomic.AtomicBoolean;

/**
 * A handler that stops all worker daemons when the build is cancelled.
 */

import java.util.List;

/**
 * Implementation of {@link WorkerTestClassProcessorFactory} which instantiates a {@link TestNGTestClassProcessor}.
 * This class is loaded on test workers themselves and acts as the entry-point to running TestNG tests on a test worker.
 */
class TestNgTestClassProcessorFactory implements WorkerTestClassProcessorFactory, Serializable {
    private final File testReportDir;
    private final TestNGSpec options;