* limitations under the License.
 */

package org.gradle.process.internal;

public interface JavaForkOptionsFactory {
    JavaForkOptionsInternal newDecoratedJavaForkOptions();
    JavaForkOptionsInternal newJavaForkOptions();

    JavaForkOptionsInternal immutableCopy(JavaForkOptionsInternal options);

        def javaForkOptions1 = TestFiles.execFactory().newJavaForkOptions()
        javaForkOptions1.workingDir = systemSpecificAbsolutePath("foo")
        javaForkOptions1.minHeapSize = "128m"
        javaForkOptions1.maxHeapSize = "1g"
        javaForkOptions1.jvmArgs = ["-server", "-verbose:gc"]
        def javaForkOptions2 = TestFiles.execFactory().newJavaForkOptions()

        }

        @Override
        JavaForkOptionsInternal newDecoratedJavaForkOptions() {
            return newJavaForkOptions()
        }

        @Override
        JavaForkOptionsInternal newJavaForkOptions() {
            def forkOptions = delegate.newJavaForkOptions()
            forkOptions.setWorkingDir(temporaryFolder)
            return forkOptions
        }

        @Override

        this.forkOptionsFactory = forkOptionsFactory;
    }

    @Override
    public JavaForkOptions transform(BaseForkOptions baseForkOptions) {
        JavaForkOptions javaForkOptions = forkOptionsFactory.newJavaForkOptions();
        javaForkOptions.setMinHeapSize(baseForkOptions.getMemoryInitialSize());
        javaForkOptions.setMaxHeapSize(baseForkOptions.getMemoryMaximumSize());

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

    FileCollectionFactory fileCollectionFactory = TestFiles.fileCollectionFactory()

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

        then:

    }

    @Override
    public JavaForkOptionsInternal newDecoratedJavaForkOptions() {
        throw new UnsupportedOperationException();
    }

    @Override
    public JavaForkOptionsInternal newJavaForkOptions() {
        final DefaultJavaForkOptions forkOptions = new DefaultJavaForkOptions(fileResolver, fileCollectionFactory, new DefaultJavaDebugOptions());
        if (forkOptions.getExecutable() == null) {

    public DaemonForkOptionsBuilder(JavaForkOptionsFactory forkOptionsFactory) {
        this.forkOptionsFactory = forkOptionsFactory;
        this.javaForkOptions = forkOptionsFactory.newJavaForkOptions();
    }

    public DaemonForkOptionsBuilder keepAliveMode(KeepAliveMode keepAliveMode) {
        this.keepAliveMode = keepAliveMode;
        return this;
    }

        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
    }

        boolean testIsModule = javaModuleDetector.isModule(task.getModularity().getInferModulePath().get(), task.getTestClassesDirs());
        JavaForkOptions forkOptions = forkOptionsFactory.newJavaForkOptions();
        task.copyTo(forkOptions);
        String executable = forkOptions.getExecutable();
        return new DefaultTestTaskForkOptions(
            forkOptions.getWorkingDir(),
            executable,

    }

    def "can convert javaForkOptions to daemonForkOptions"() {
        WorkerSpec configuration = new DefaultProcessWorkerSpec(forkOptionsFactory.newJavaForkOptions(), objectFactory)

        given:
        configuration.forkOptions { options ->
            options.minHeapSize = "128m"
            options.maxHeapSize = "128m"
            options.systemProperty("foo", "bar")