case JavaCompileMultiTestInterceptor.Compiler.WORKER_JDK_COMPILER:
                buildFile << """
                    tasks.withType(JavaCompile) {
                        options.fork = true
                    }
                """
                break
            case JavaCompileMultiTestInterceptor.Compiler.WORKER_COMMAND_LINE_COMPILER:

# k8sleaderelection

        file('build.gradle') << """
        println "Used JRE: ${jreJavaHome.absolutePath.replace(File.separator, '/')}"
        apply plugin:'java'
        compileJava {
            options.fork = ${forkMode}
        }
        """
        when:
        executer.withJavaHome(jreJavaHome.absolutePath).withTasks("compileJava").run().output
        then:
        javaClassFile("org/test/JavaClazz.class").exists()

            </tr>
            <tr>
                <td>encoding</td>
                <td><literal>UTF-8</literal></td>
            </tr>
            <tr>
                <td>fork</td>
                <td><literal>true</literal></td>
            </tr>
            <tr>
                <td>forkOptions</td>
                <td></td>
            </tr>
            <tr>

func TestEPIPE(t *testing.T) {
	// This test cannot be run in parallel because of a race similar
	// to the one reported in https://go.dev/issue/22315.
	//
	// Even though the pipe is opened with O_CLOEXEC, if another test forks in
	// between the call to os.Pipe and the call to r.Close, that child process can
	// retain an open copy of r's file descriptor until it execs. If one of our
	// Write calls occurs during that interval it can spuriously succeed,

    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

import org.gradle.util.internal.CollectionUtils;

import java.util.ArrayList;
import java.util.List;

/**
 * Fork options for compilation that can accept user-defined {@link CommandLineArgumentProvider} objects.
 *
 * Only take effect if {@code fork} is {@code true}.
 *
 * @since 7.1
 */
@Incubating
public class ProviderAwareCompilerDaemonForkOptions extends BaseForkOptions {

import org.openjdk.jmh.annotations.Fork;
import org.openjdk.jmh.annotations.OutputTimeUnit;
import org.openjdk.jmh.annotations.Scope;
import org.openjdk.jmh.annotations.Setup;
import org.openjdk.jmh.annotations.State;
import org.openjdk.jmh.infra.Blackhole;

import java.util.concurrent.TimeUnit;

@State(Scope.Thread)
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Fork(2)
public class EvaluationContextPerfTest {

        javaCompile.destinationDirectory.fileValue(temporaryFolder.createDir())
        def invalidJavaHome = "invalidJavaHome"

        when:
        javaCompile.options.fork = true
        javaCompile.options.forkOptions.javaHome = new File("invalidJavaHome")
        javaCompile.createSpec()

        then:
        def e = thrown(AbstractProperty.PropertyQueryException)