@Provides
    GlobalCacheLocations createGlobalCacheLocations(List<GlobalCache> globalCaches) {
        return new DefaultGlobalCacheLocations(globalCaches);
    }

    @Provides
    ExecFactory createExecFactory(ExecFactory parent, FileResolver fileResolver, FileCollectionFactory fileCollectionFactory, Instantiator instantiator, ObjectFactory objectFactory, JavaModuleDetector javaModuleDetector) {
        return parent.forContext()

import org.gradle.api.tasks.compile.BaseForkOptions
import spock.lang.Specification

class BaseForkOptionsConverterTest extends Specification {
    BaseForkOptionsConverter converter = new BaseForkOptionsConverter(TestFiles.execFactory())

    def "converts a base fork options to a java fork options"() {
        BaseForkOptions baseForkOptions = new BaseForkOptions()
        baseForkOptions.memoryInitialSize = "128m"

        return clientsManager.reserveIdleClient(forkOptions)
    }

    private JavaForkOptions javaForkOptions(String minHeap, String maxHeap, List<String> jvmArgs) {
        def options = TestFiles.execFactory().newJavaForkOptions()
        options.workingDir = systemSpecificAbsolutePath("foo")
        options.minHeapSize = minHeap
        options.maxHeapSize = maxHeap
        options.jvmArgs = jvmArgs
        return options

        TestFiles.fileCollectionFactory(),
        TestUtil.objectFactory(),
        Mock(Executor),
        new DefaultBuildCancellationToken(),
        temporaryFileProvider,
        null,
        TestFiles.execFactory().newJavaForkOptions()
    )

    FileCollectionFactory fileCollectionFactory = TestFiles.fileCollectionFactory()

    def cannotSetAllJvmArgs() {
        when:
        builder.setAllJvmArgs(asList("arg"))

import org.gradle.internal.service.ServiceRegistrationProvider;
import org.gradle.internal.service.scopes.Scope.Global;
import org.gradle.process.internal.DefaultExecActionFactory;
import org.gradle.process.internal.ExecFactory;
import org.gradle.process.internal.ExecHandleFactory;

import java.net.InetAddress;

/**

        return fileCollectionFactory.withResolver(fileResolver);
    }

    @Provides
    protected ExecFactory decorateExecFactory(ExecFactory parent, FileResolver fileResolver, FileCollectionFactory fileCollectionFactory, Instantiator instantiator, ObjectFactory objectFactory, JavaModuleDetector javaModuleDetector, ListenerManager listenerManager) {

    def buildOperationRunner = Mock(BuildOperationRunner)
    def asyncWorkerTracker = Mock(AsyncWorkTracker)
    def forkOptionsFactory = new TestForkOptionsFactory(TestFiles.execFactory())
    def objectFactory = Stub(ObjectFactory) {
        fileCollection() >> { TestFiles.fileCollectionFactory().configurableFiles() }
    }
    def workerDirectoryProvider = Stub(WorkerDirectoryProvider) {

import java.io.File;
import java.util.List;
import java.util.Map;
import java.util.concurrent.Executor;

import static java.util.Objects.requireNonNull;

public abstract class DefaultExecActionFactory implements ExecFactory {
    protected final FileResolver fileResolver;
    protected final Executor executor;
    protected final FileCollectionFactory fileCollectionFactory;
    protected final ObjectFactory objectFactory;

    def workerThreadRegistry = Mock(WorkerThreadRegistry)
    def buildOperationRunner = Mock(BuildOperationRunner)
    def asyncWorkTracker = Mock(AsyncWorkTracker)
    def forkOptionsFactory = TestFiles.execFactory(temporaryFolder.testDirectory)
    def objectFactory = Stub(ObjectFactory) {
        fileCollection() >> { TestFiles.fileCollectionFactory().configurableFiles() }
    }

            @Override
            Iterable<String> asArguments() {
                return ["First", "Second"]
            }
        }
        def javaForkOptions = TestFiles.execFactory().newJavaForkOptions()
        test.copyTo(javaForkOptions)

        then:
        javaForkOptions.getJvmArgs() == ['First', 'Second']
    }

    def "java version is determined with toolchain if set"() {