executer.requireIsolatedDaemons()
    }

    def "forks build when JVM args are requested"() {
        requireJvmArg('-Xmx64m')

        file('build.gradle') << "println 'hello world'"

        when:
        succeeds()

        then:
        wasForked()

        and:
        daemons.daemon.stops()
    }

        configCache(true),
        isolatedProjects(true);

        final public boolean forks;
        final public boolean executeParallel;

        Executer(boolean forks) {
            this(forks, false);
        }

        Executer(boolean forks, boolean parallel) {
            this.forks = forks;
            this.executeParallel = parallel;
        }
    }

import org.apache.maven.api.annotations.Nonnull;

/**
 * Used if your Mojo needs to fork a <a href="/ref/3.0.4/maven-core/lifecycles.html">lifecycle</a>.
 *
 * @since 4.0.0
 */
@Experimental
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
@Inherited
public @interface Execute {
    /**
     * Lifecycle phase to fork. Note that specifying a phase overrides specifying a goal.
     * @return the phase

            if [ $? -eq 0 ]; then
              echo "Found a branch \"$branch\" in fork \"$user/$repo\", configuring this for the integration tests to be run against."
              target_branch=$branch
              target_user=$user
            else
              echo "Could not find fork \"$user/$repo\" or a branch \"$branch\" in this fork. Falling back to \"$target_branch\" in \"$target_user/$repo\"."
            fi
          else

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

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

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

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

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"]

class InProcessJavaCompilerIntegrationTest extends AbstractJavaCompilerIntegrationSpec {

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

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

    testImplementation(testFixtures(project(":logging")))

    jmhImplementation(project(":files"))
    jmhImplementation(project(":base-services"))
}

jmh {
    fork = 1
    threads = 2
    warmupIterations = 10
    synchronizeIterations = false

class CommandLineJavaCompilerIntegrationTest extends AbstractJavaCompilerIntegrationSpec {

    @Override
    String compilerConfiguration() {
        """
            compileJava.options.with {
                fork = true
                forkOptions.javaHome = file("${TextUtil.normaliseFileSeparators(Jvm.current().javaHome.toString())}")
            }
        """
    }

    @Override
    String logStatement() {

class CommandLineJavaCompilerForExecutableIntegrationTest extends AbstractJavaCompilerIntegrationSpec {

    @Override
    String compilerConfiguration() {
        """
            compileJava.options.with {
                fork = true
                forkOptions.executable = "${TextUtil.normaliseFileSeparators(Jvm.current().getExecutable("javac").absolutePath)}"
            }
        """
    }

    @Override
    String logStatement() {