limitations under the License.
*/

/* Creates a zombie to be reaped by init. Useful for testing. */

#include <stdio.h>
#include <unistd.h>

int main() {
  pid_t pid;
  pid = fork();
  if (pid == 0) {
    while (getppid() > 1)
      ;
    printf("Child exiting: pid=%d ppid=%d\n", getpid(), getppid());
    return 0;
  } else if (pid > 0) {

        buildFile << """
            apply plugin: 'java'
            ${mavenCentralRepository()}
            dependencies { ${testImplementationConfiguration} 'junit:junit:4.13' }
            compileTestJava.options.fork = true
        """

        file("src/test/java/FooTest.java") << """
            public class FooTest {
                @org.junit.Test public void passes() {}

        """

        when:
        fails("runInWorker")

        then:
        failureCauseContains('Setting the working directory of a worker is not supported')
    }

    def "interesting worker daemon fork options are honored"() {
        OptionsVerifier optionsVerifier = new OptionsVerifier(file('process.json'))
        optionsVerifier.with {
            minHeap("128m")
            maxHeap("128m")

test.onlyIf("mySkipTests property is not set") {
    !skipTestsProvider.present
}
// end::skip-tests-condition[]

// tag::java-compiler-options[]
compileJava {
    options.incremental = true
    options.fork = true
    options.failOnError = false
}
// end::java-compiler-options[]

// tag::java-release-flag[]
compileJava {
    options.release = 7
}
// end::java-release-flag[]

            assert daemonOpts.contains("-Dfile.encoding=UTF-8")
        }
    }

    @Requires(IntegTestPreconditions.NotEmbeddedExecutor) // need to start Gradle process from command line to use GRADLE_OPTS
    def "forks new daemon when file encoding is set to different value via GRADLE_OPTS"() {
        setup:
        buildScript """
            println "GRADLE_VERSION: " + gradle.gradleVersion

            task verify {

     * @param args a {@link String} object.
     * @throws org.openjdk.jmh.runner.RunnerException if any.
     */
    public static void main(String... args) throws RunnerException {
        Options opts = new OptionsBuilder().forks(1).build();
        new Runner(opts).run();
    }

        then:
        def e = thrown(InvalidRunnerConfigurationException)
        e.message == "Debug mode is not allowed when environment variables are specified. " +
            "Debug mode runs 'in process' but we need to fork a separate process to pass environment variables. " +
            "To run with debug mode, please remove environment variables."
    }

import org.gradle.api.tasks.compile.BaseForkOptions;
import org.gradle.api.tasks.compile.ProviderAwareCompilerDaemonForkOptions;

/**
 * This class and its subclasses exist so that we have an isolatable instance
 * of the fork options that can be passed along with the compilation spec to a
 * worker executor.  Since {@link ProviderAwareCompilerDaemonForkOptions}
 * and its subclasses can accept user-defined {@link org.gradle.process.CommandLineArgumentProvider}

            }

            dependencies {
                errorprone("com.google.errorprone:error_prone_core:2.8.0")
            }

            tasks.withType(JavaCompile).configureEach {
                options.fork = true
                options.errorprone {
                    check("DoubleBraceInitialization", net.ltgt.gradle.errorprone.CheckSeverity.ERROR)
                }
            }
        """

                    // ~25MB
                    ext.memoryHog = new byte[1024*1024*25]

                    tasks.withType(JavaCompile).configureEach {
                        options.fork = true
                        options.forkOptions.jvmArgs << "-Dcounter=" + project.property("counter")
                    }
                }
            """
        }
    }