import org.gradle.process.JavaForkOptions;
import org.gradle.process.internal.JavaForkOptionsInternal;

public class DaemonForkOptions {
    private final JavaForkOptionsInternal forkOptions;
    private final KeepAliveMode keepAliveMode;
    private final ClassLoaderStructure classLoaderStructure;

    DaemonForkOptions(JavaForkOptionsInternal forkOptions,
                      KeepAliveMode keepAliveMode,

    private final DaemonForkOptions forkOptions;

    public ForkedWorkerRequirement(File workerDirectory, File projectCacheDir, DaemonForkOptions forkOptions) {
        super(workerDirectory, projectCacheDir, forkOptions.getClassLoaderStructure());
        this.forkOptions = forkOptions;
    }

    public DaemonForkOptions getForkOptions() {
        return forkOptions;
    }

    }

    @Override
    public IsolatedClassLoaderWorkerRequirement getIsolatedWorkerRequirement(DaemonForkOptions daemonForkOptions) {
        return new IsolatedClassLoaderWorkerRequirement(daemonForkOptions.getJavaForkOptions().getWorkingDir(), projectCacheDir.getDir(), daemonForkOptions.getClassLoaderStructure());
    }

    }

    @Override
    public IsolatedClassLoaderWorkerRequirement getIsolatedWorkerRequirement(DaemonForkOptions daemonForkOptions) {
        // Compiler daemons do not rely on project cache directory
        return new ForkedWorkerRequirement(daemonForkOptions.getJavaForkOptions().getWorkingDir(), projectCacheDir.getDir(), daemonForkOptions);
    }

        }

        when:
        def daemonForkOptions = workerExecutor.getWorkerRequirement(runnable.class, configuration, null).forkOptions

        then:
        daemonForkOptions.javaForkOptions.minHeapSize == "128m"
        daemonForkOptions.javaForkOptions.maxHeapSize == "128m"
        daemonForkOptions.javaForkOptions.allJvmArgs.contains("-Dfoo=bar")
        daemonForkOptions.javaForkOptions.allJvmArgs.contains("-foo")

    /**
     * Executes a compiler specified by the {@link CompilerParameters}
     */
    DefaultWorkResult execute(CompilerParameters parameters, DaemonForkOptions daemonForkOptions);

    abstract class CompilerParameters implements WorkParameters, Serializable {
        private final String compilerClassName;
        private final Object[] compilerInstanceParameters;

    static final int OS_MEMORY_GB = 6

    def defaultOptions = daemonForkOptions(null, null, ['default-options'])
    def oneGbOptions = daemonForkOptions('1g', '1g', ['one-gb-options'])
    def twoGbOptions = daemonForkOptions('2g', '2g', ['two-gb-options'])
    def threeGbOptions = daemonForkOptions('3g', '3g', ['three-gb-options'])
    def reportsMemoryUsage = true

    }

    abstract IsolatedClassLoaderWorkerRequirement getIsolatedWorkerRequirement(DaemonForkOptions daemonForkOptions);

    @Override
    public DefaultWorkResult execute(CompilerParameters parameters, DaemonForkOptions daemonForkOptions) {
        IsolatedClassLoaderWorkerRequirement workerRequirement = getIsolatedWorkerRequirement(daemonForkOptions);
        BuildOperationAwareWorker worker = workerFactory.getWorker(workerRequirement);

import java.util.Optional;

class WorkerDaemonClient implements Stoppable, Describable {
    public static final String DISABLE_EXPIRATION_PROPERTY_KEY = "org.gradle.workers.internal.disable-daemons-expiration";
    private final DaemonForkOptions forkOptions;
    private final MultiRequestClient<TransportableActionExecutionSpec, DefaultWorkResult> workerClient;
    private final WorkerProcess workerProcess;
    private final LogLevel logLevel;

        def daemonForkOptions = Mock(DaemonForkOptions)
        def actionExecutionSpecFactory = Stub(ActionExecutionSpecFactory) {
            newTransportableSpec(_) >> { Mock(TransportableActionExecutionSpec) }
        }
        def workerProcess = workerDaemonProcess.start()