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

    @Override
    String logStatement() {
        "compiler daemon"
    }

    def setup() {
        executer.withArguments("-d")
    }

    def "respects fork options settings"() {
        goodCode()
        buildFile << """

     */
    @Input
    public boolean isFork() {
        return fork;
    }

    /**
     * Sets whether to run the compiler in its own process. Note that this does
     * not necessarily mean that a new process will be created for each compile task.
     * Defaults to {@code false}.
     */
    public void setFork(boolean fork) {
        this.fork = fork;
    }

    /**

func runtime_AfterFork()
func runtime_AfterForkInChild()

// Fork, dup fd onto 0..len(fd), and exec(argv0, argvv, envv) in child.
// If a dup or exec fails, write the errno error to pipe.
// (Pipe is close-on-exec so if exec succeeds, it will be closed.)
// In the child, this function must not acquire any locks, because
// they might have been locked at the time of the fork. This means
// no rescheduling, no malloc calls, and no new stack segments.

            plugins {
                id 'java'
            }

            ${dependsOnPidCapturingAnnotationProcessor}

            tasks.withType(JavaCompile).configureEach {
                options.fork = true
            }
        """
        file('src/main/java/Foo.java') << """
            @WorkerPid
            public class Foo {
                public static void main(String[] args) {

            options.fork = true
            options.incremental = true
            options.forkOptions.memoryInitialSize = compilerMemory
            options.forkOptions.memoryMaximumSize = compilerMemory
            options.forkOptions.jvmArgs.addAll(javaCompileJvmArgs)
        }

        tasks.withType(GroovyCompile).configureEach {
            groovyOptions.fork = true

subprojects {
    apply plugin: "groovy"

    dependencies {
        implementation localGroovy()
    }

    compileJava.options.fork = true

    // force creation of multiple daemons for Java compilation by alternating between two distinct sets of JVM args
    def count = (project.name - "project") as int
    compileJava.options.forkOptions.jvmArgs = count % 2 ? ["-dsa"] : ["-esa"]

        this.actionExecutionSpecFactory = actionExecutionSpecFactory;
    }

    public WorkerDaemonClient startDaemon(DaemonForkOptions forkOptions) {
        LOG.debug("Starting Gradle worker daemon with fork options {}.", forkOptions);
        Timer clock = Time.startTimer();

        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/example/MyTest.java") << """
            package example;
            public class MyTest {

	// any size, and never returns an error.
	//
	// "The subsystem is re-seeded from the kernel random number subsystem on a
	// regular basis, and also upon fork(2)." - arc4random(3)
	//
	// Note that despite its legacy name, it uses a secure CSPRNG (not RC4) in
	// all supported macOS versions.
	altGetRandom = func(b []byte) error { unix.ARC4Random(b); return nil }

class InProcessJavaCompilerIntegrationTest extends AbstractJavaCompilerIntegrationSpec {

    @Override
    String compilerConfiguration() {
        """
            compileJava.options.with {
                fork = false
            }
        """
    }

    @Override
    String logStatement() {
        "Java compiler API"
    }