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

		}
		procs.waits[ret.pid] = waitc
		procs.Unlock()

		forkc <- ret

		var w waitErr
		for w.err == nil && w.Pid != ret.pid {
			w.err = Await(&w.Waitmsg)
		}
		waitc <- &w
		close(waitc)
	}()
	ret := <-forkc
	return ret.pid, ret.err
}

// Combination of fork and exec, careful to be thread safe.

        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;
        }
    }

 */

package org.gradle.smoketests

import org.gradle.testkit.runner.GradleRunner

class AnnotationProcessingSmokeTest extends AbstractSmokeTest {

    def 'project lombok works when options.fork=#fork'() {
        given:
        buildFile << """
            plugins {
                id("java")
            }
            ${mavenCentralRepository()}
            dependencies {

        javaCompile.destinationDirectory.fileValue(new File('somewhere'))
        def invalidExecutable = temporaryFolder.file("invalidExecutable")

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.executable = invalidExecutable
        javaCompile.createSpec()

        then:
        def e = thrown(AbstractProperty.PropertyQueryException)

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

    def "For every boolean is getter there is a get Getter"() {
        given:
        executer.requireDaemon().requireIsolatedDaemons() // We need to fork - if we do not fork Class-Decoration does not happen

        when:
        def convertedClasses = this.getClass().getResource( '/org/gradle/initialization/converted-types.txt' ).readLines()
        buildFile << """

// license that can be found in the LICENSE file.

//go:build unix

// Fork, exec, wait, etc.

package syscall

import (
	errorspkg "errors"
	"internal/bytealg"
	"runtime"
	"sync"
	"unsafe"
)

// ForkLock is used to synchronize creation of new file descriptors
// with fork.
//
// We want the child in a fork/exec sequence to inherit only the
// file descriptors we intend. To do that, we mark all file

}

String compilerMemory = getProperty('compilerMemory')
String testRunnerMemory = getProperty('testRunnerMemory')
int testForkEvery = getProperty('testForkEvery') as Integer

tasks.withType(JavaCompile) {
    options.fork = true
    options.forkOptions.memoryInitialSize=compilerMemory
    options.forkOptions.memoryMaximumSize=compilerMemory
}
tasks.withType(Test) {
    minHeapSize = testRunnerMemory
    maxHeapSize = testRunnerMemory