def buildOperationIdFile = file('build-operation-id.txt')

    def forkingOptions(Jvm javaVersion) {
        return """
            options.fork = true
            // We don't use toolchains here for consistency with the rest of the test suite
            options.forkOptions.javaHome = file('${javaVersion.javaHome}')
        """
    }

    @Rule final TestNameTestDirectoryProvider tmpDir = new TestNameTestDirectoryProvider(getClass())
    private BuildCancellationToken buildCancellationToken = Mock(BuildCancellationToken)

    void "forks process"() {
        given:
        def out = new ByteArrayOutputStream()
        def err = new ByteArrayOutputStream()

        def execHandle = handle()
                .args(args(TestApp.class, "arg1", "arg2"))

        <artifactId>maven-it-plugin-expression</artifactId>
        <version>2.1-SNAPSHOT</version>
      </plugin>
      <plugin>
        <groupId>org.apache.maven.its.plugins</groupId>
        <artifactId>maven-it-plugin-fork</artifactId>
        <version>2.1-SNAPSHOT</version>
      </plugin>
    </plugins>
  </build>

  <profiles>
    <profile>
      <id>test</id>
      <activation>
        <property>

 * limitations under the License.
 */
package org.gradle.process;

import java.io.File;
import java.util.Map;

/**
 * <p>Specifies the options to use to fork a process.</p>
 */
public interface ProcessForkOptions {
    /**
     * Returns the name of the executable to use.
     *
     * @return The executable.
     */
    String getExecutable();

    /**

import org.gradle.api.tasks.Optional;
import org.gradle.internal.HasInternalProtocol;

import javax.annotation.Nullable;
import java.util.List;
import java.util.Map;

/**
 * <p>Specifies the options to use to fork a Java process.</p>
 */
@HasInternalProtocol
public interface JavaForkOptions extends ProcessForkOptions {
    /**
     * Returns the system properties which will be used for the process.
     *

                        <version>3.8.0</version>
                        <configuration>
                            <source>1.8</source>
                            <target>1.8</target>
                            <fork>true</fork>
                            <meminitial>${config.compilerMemory}</meminitial>
                            <maxmem>${config.compilerMemory}</maxmem>
                        </configuration>
                    </plugin>

            long parsed = MemoryAmount.parseNotation(forkOptionsMaxHeapSize);
            if (parsed != -1) {
                // From fork options
                return parsed;
            }

            // If we don't know what the max heap is, approximate it based on OS total memory
            // according to JVM documentation

        buildFile << """
            apply plugin: 'java'
            ${mavenCentralRepository()}
            dependencies { ${testImplementationConfiguration} 'junit:junit:4.13' }
            compileTestJava.options.fork = true  // forked as 'Gradle Test Executor 1'
        """

        file("src/test/java/MyTest.java") << """
            package example;
            public class MyTest {

            task runInWorker(type: WorkerTask) {
                isolationMode = 'processIsolation'
            }

            tasks.withType(JavaCompile) {
                options.fork = true
            }
        """

        when:
        args("--info")
        succeeds "compileJava", "runInWorker"

        then:
        sinceSnapshot().count("Started Gradle worker daemon") == 2

//sys	Seek(fd int, offset int64, whence int) (newoffset int64, err error) = SYS_lseek
//sys	getcwd(buf []byte) (n int, err error)
//sys	sysctl(mib []_C_int, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error)
//sysnb fork() (pid int, err error)
//sysnb execve(path *byte, argv **byte, envp **byte) (err error)
//sysnb exit(res int) (err error)
//sys   ptrace(request int, pid int, addr uintptr, data uintptr) (err error)