How to use

JavaForkOptions

in

org.gradle.process

public void copyTo(JavaForkOptions target) {
  target.setJvmArgs(extraJvmArgs);
  target.setSystemProperties(mutableSystemProperties);
  target.setMinHeapSize(minHeapSize);
  target.setMaxHeapSize(maxHeapSize);
  target.setBootstrapClasspath(getBootstrapClasspath());
  target.setEnableAssertions(assertionsEnabled);
  target.setDebug(debug);
  target.systemProperties(immutableSystemProperties);
}

public void setDefaultCharacterEncoding(String defaultCharacterEncoding) {
  javaOptions.setDefaultCharacterEncoding(defaultCharacterEncoding);
}

public JavaExecHandleBuilder jvmArgs(Object... arguments) {
  javaOptions.jvmArgs(arguments);
  return this;
}

private void start() {
 workerExecutor.submit(config -> {
  config.setClasspath(getClasspath());
  config.setNamespace("gradle-clojure.tools.clojure-nrepl");
  config.setFunction("start!");
  config.setArgs(port, controlPort);
  config.forkOptions(fork -> {
   fork.setJvmArgs(getForkOptions().getJvmArgs());
   fork.setMinHeapSize(getForkOptions().getMemoryInitialSize());
   fork.setMaxHeapSize(getForkOptions().getMemoryMaximumSize());
   fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
  });
 });
}

@TaskAction
public void run() {
  new SpotBugsClasspathValidator(JavaVersion.current()).validateClasspath(
      getSpotbugsClasspath().getFiles().stream().map(File::getName).collect(Collectors.toSet()));
  SpotBugsSpec spec = generateSpec();
  //workaround for https://github.com/spotbugs/spotbugs-gradle-plugin/issues/61
  if(reports.getEnabledReports().isEmpty()) {
    getProject().getLogger().lifecycle("WARNING: No SpotBugs report(s) were configured; aborting execution of {}", getPath());
    return;
  }
  workerExecutor.submit(SpotBugsRunner.class, config -> {
    config.params(spec, getIgnoreFailures(), reports.getFirstEnabled().getDestination());
    config.setClasspath(getSpotbugsClasspath());
    config.setForkMode(ForkMode.ALWAYS);
    config.forkOptions( options -> {
      options.setDebug(spec.isDebugEnabled());
      options.setJvmArgs(spec.getJvmArgs());
      options.setMaxHeapSize(spec.getMaxHeapSize());
    });
    config.setIsolationMode(IsolationMode.PROCESS);
  });
}

public void setJvmArgs(List<String> arguments) {
  javaOptions.setJvmArgs(arguments);
}

public void setMaxHeapSize(String heapSize) {
  javaOptions.setMaxHeapSize(heapSize);
}

public void setMinHeapSize(String heapSize) {
  javaOptions.setMinHeapSize(heapSize);
}

public JavaExecHandleBuilder systemProperty(String name, Object value) {
  javaOptions.systemProperty(name, value);
  return this;
}

@Override
public void apply(Project project) {
  ScottPluginExtension extension = project.getExtensions().create(PLUGIN_EXTENSION_NAME, ScottPluginExtension.class, DEFAULT_SCOTT_VERSION);
  Configuration configuration = configureAgentDependencies(project,extension);
  project.afterEvaluate( p -> {
    Task test = p.getTasks().getByName("test");
    JavaForkOptions opts = (JavaForkOptions)test;
    opts.getJvmArgumentProviders().add(new ScottAgent(configuration,extension));
  });
}

public void setDebug(boolean enabled) {
  javaOptions.setDebug(enabled);
}

 @TaskAction
 public void compile() {
  File outputDir = getDestinationDir().get().getAsFile();
  if (!getProject().delete(outputDir)) {
   throw new GradleException("Cannot clean destination directory: " + outputDir.getAbsolutePath());
  }
  if (!outputDir.mkdirs()) {
   throw new GradleException("Cannot create destination directory: " + outputDir.getAbsolutePath());
  }

  FileCollection classpath = getClasspath().plus(getSourceRoots());

  clojureExecutor.exec(spec -> {
   spec.setClasspath(classpath);
   spec.setMain("gradle-clojure.tools.clojurescript-compiler");
   spec.args(getSourceRoots(), getOptions());
   spec.forkOptions(fork -> {
    fork.setJvmArgs(forkOptions.getJvmArgs());
    fork.setMinHeapSize(forkOptions.getMemoryInitialSize());
    fork.setMaxHeapSize(forkOptions.getMemoryMaximumSize());
    fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
   });
  });
 }
}

public void setJvmArgs(Iterable<?> arguments) {
  javaOptions.setJvmArgs(arguments);
}

public void submit(Action<ClojureWorkerConfiguration> action) {
 ClojureWorkerConfiguration config = new ClojureWorkerConfiguration();
 action.execute(config);
 FileCollection realClasspath = config.getClasspath().plus(resolveShim());
 workerExecutor.submit(ClojureWorker.class, worker -> {
  worker.setIsolationMode(IsolationMode.PROCESS);
  worker.params(config.getNamespace(), config.getFunction(), config.getArgs());
  config.getConfigureFork().forEach(worker::forkOptions);
  worker.forkOptions(fork -> fork.systemProperty("shim.classpath", realClasspath.getAsPath()));
  worker.classpath(resolveWorker());
 });
}

@Override
public void apply(Project project) {
  ScottPluginExtension extension = project.getExtensions().create(PLUGIN_EXTENSION_NAME, ScottPluginExtension.class, DEFAULT_SCOTT_VERSION);
  Configuration configuration = configureAgentDependencies(project,extension);
  project.afterEvaluate( p -> {
    Task test = p.getTasks().getByName("test");
    JavaForkOptions opts = (JavaForkOptions)test;
    opts.getJvmArgumentProviders().add(new ScottAgent(configuration,extension));
  });
}

 @TaskAction
 public void compile() {
  File outputDir = getDestinationDir().get().getAsFile();
  if (!getProject().delete(outputDir)) {
   throw new GradleException("Cannot clean destination directory: " + outputDir.getAbsolutePath());
  }
  if (!outputDir.mkdirs()) {
   throw new GradleException("Cannot create destination directory: " + outputDir.getAbsolutePath());
  }

  FileCollection classpath = getClasspath().plus(getSourceRoots());

  clojureExecutor.exec(spec -> {
   spec.setClasspath(classpath);
   spec.setMain("gradle-clojure.tools.clojurescript-compiler");
   spec.args(getSourceRoots(), getOptions());
   spec.forkOptions(fork -> {
    fork.setJvmArgs(forkOptions.getJvmArgs());
    fork.setMinHeapSize(forkOptions.getMemoryInitialSize());
    fork.setMaxHeapSize(forkOptions.getMemoryMaximumSize());
    fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
   });
  });
 }
}

public JavaExecHandleBuilder jvmArgs(Iterable<?> arguments) {
  javaOptions.jvmArgs(arguments);
  return this;
}

 @TaskAction
 public void exec() {
  workerExecutor.submit(config -> {
   config.setClasspath(getClasspath());
   config.setNamespace(getNamespace());
   config.setFunction(getFunction());
   config.setArgs(getArgs().toArray(new Object[getArgs().size()]));
   config.forkOptions(fork -> {
    fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
   });
  });
 }
}

private void start() {
 if (!getProject().delete(getTemporaryDir())) {
  throw new GradleException("Cannot clean temporary directory: " + getTemporaryDir().getAbsolutePath());
 }
 FileCollection cp = getProject().files(getTemporaryDir(), getClasspath());
 List<String> middleware = Stream.of(defaultMiddleware.getOrElse(Collections.emptyList()), userMiddleware.getOrElse(Collections.emptyList()))
   .flatMap(List::stream)
   .collect(Collectors.toList());
 clojureExecutor.exec(spec -> {
  spec.setClasspath(cp);
  spec.setMain("gradle-clojure.tools.clojure-nrepl");
  spec.setArgs(port, controlPort, handler.getOrNull(), middleware, Edn.keywordize(contextData));
  spec.forkOptions(fork -> {
   fork.setJvmArgs(getForkOptions().getJvmArgs());
   fork.setMinHeapSize(getForkOptions().getMemoryInitialSize());
   fork.setMaxHeapSize(getForkOptions().getMemoryMaximumSize());
   fork.setDefaultCharacterEncoding(StandardCharsets.UTF_8.name());
  });
 });
}

@TaskAction
private void setupDebug() throws IOException {
  target.jvmArgs(debugSpec.getJvmArgs());
}