"""

        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")
                    }
                }
            """
        }
    }

  echo
  echo "where REMOTE is your personal fork (maybe ${UPSTREAM_REMOTE}? Consider swapping those.)."
  echo "OR consider setting UPSTREAM_REMOTE and FORK_REMOTE to different values."
  echo
  make-a-pr
  cleanbranch=""
  exit 0
fi

echo
echo "+++ I'm about to do the following to push to GitHub (and I'm assuming ${FORK_REMOTE} is your personal fork):"
echo

    ExecHandleBuilder setDisplayName(String displayName);

    /**
     * When true, spawn the process. That is, start the process and leave it running once successfully started. When false, fork the process (the default). That is, start the process and wait for it to complete.
     */
    ExecHandleBuilder setDaemon(boolean daemon);

    /**
     * Sets a handler for the output streams of the process.