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

        !skipTestsProvider.isPresent()
    }
}
// end::skip-tests-condition[]

// tag::java-compiler-options[]
tasks.compileJava {
    options.isIncremental = true
    options.isFork = true
    options.isFailOnError = false
}
// end::java-compiler-options[]

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

        then:
        assertDaemonUsedJvm(otherJdk)
        wasForked()
        daemons.daemon.stops()
    }

    @Requires(IntegTestPreconditions.JavaHomeWithDifferentVersionAvailable)
    def "does not fork build when java home from gradle properties matches current process"() {
        def javaHome = AvailableJavaHomes.differentJdk.javaHome

    }

    private final String displayName;

    BuildInitTestFramework(String displayName) {
        this.displayName = displayName;
    }

    @Override
    public String getId() {
        return Names.idFor(this);
    }

    @Override
    public String toString() {
        return displayName;
    }

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

	MAFTER  = 0x0002 // mount goes after others in union directory
	MCREATE = 0x0004 // permit creation in mounted directory
	MCACHE  = 0x0010 // cache some data
	MMASK   = 0x0017 // all bits on
)

// Rfork flags
const (
	RFNAMEG  = 1 << 0
	RFENVG   = 1 << 1
	RFFDG    = 1 << 2
	RFNOTEG  = 1 << 3
	RFPROC   = 1 << 4
	RFMEM    = 1 << 5
	RFNOWAIT = 1 << 6
	RFCNAMEG = 1 << 10
	RFCENVG  = 1 << 11

            </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>

// 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