testImplementation(libs.nativePlatform) {
        because("Required for SystemInfo")
    }

    integTestImplementation(projects.messaging)
    // TODO: Make these available for all integration tests? Maybe all tests?
    integTestImplementation(libs.jetbrainsAnnotations)

    testFixturesApi(testFixtures(project(":language-jvm")))
    testFixturesImplementation(project(":base-services"))

    }

    @Rule ConcurrentTestUtil concurrent = new ConcurrentTestUtil()

    def "the registry can be concurrently written to"() {
        when:
        // obtain localhost address ahead of time as the first call in a JVM can take multiple secs in some systems
        def localhost = Inet6Address.getLocalHost()
        def registry = registry("someDir").get(DaemonRegistry)
        5.times { idx ->
            concurrent.start {

    integTestImplementation(libs.guava)
    integTestImplementation(libs.ant)
    integTestImplementation(libs.samplesCheck) {
        exclude(group = "org.codehaus.groovy", module = "groovy-all")
    }
    integTestImplementation(testFixtures(project(":core")))
    integTestImplementation(testFixtures(project(":model-core")))

    integTestDistributionRuntimeOnly(project(":distributions-full"))
}

import org.gradle.test.fixtures.AbstractProjectBuilderSpec

import static org.gradle.util.TestUtil.createChildProject

class NewDefaultProjectTest extends AbstractProjectBuilderSpec {
    def "provides all tasks recursively"() {
        def a = createChildProject(project, "a")

        [project, a].each { it.task "foo"; it.task "bar" }

        when:
        def rootTasks = project.getAllTasks(true)

            javaForkOptions.jvmArgs(
                "--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED",
                "--add-exports=jdk.compiler/com.sun.tools.javac.util=ALL-UNNAMED"
            );
        } else {
            // In JDK 8 and below, the compiler internal classes are in tools.jar.
            File toolsJar = jvm.getToolsJar();

        val numClosureArgs = delegate.maximumNumberOfParameters
        val finalArgs: Array<out Any> = args.take(numClosureArgs).map { trackingProjectAccess(crossProjectModelAccess, referrerProject, it) }.toTypedArray()
        delegate.call(*finalArgs)
    }

    override fun setDelegate(delegateObject: Any) {
        delegate.delegate = trackingProjectAccess(crossProjectModelAccess, referrerProject, delegateObject)
    }

 * limitations under the License.
 */

package org.gradle.internal.file;

import java.io.File;

public interface FileModeAccessor {
    /**
     * @param f The file to get the mode for. Note that all symlinks are followed.
     * @return The unix mode of the file
     */
    int getUnixMode(File f) throws Exception;

dependencies {
    runtime(project(":installation-beacon"))
    runtime(project(":api-metadata"))
    runtime(project(":daemon-server")) {
        because("This is the Gradle daemon implementation, which transitively depends on all other core projects.")
    }
    runtime(project(":gradle-cli-main")) {
        because("This is the entry point of the `gradle` command.")
    }
    runtime(project(":daemon-main")) {

     * to be the {@code expectedReceiver} passed to the constructor.
     *
     * @param invocation the arguments supplied by the caller
     * @param consumer the class that invokes the intercepted call
     * @return the value to return to the caller
     * @throws Throwable if necessary to propagate it to the caller
     */
    protected abstract Object interceptSafe(Invocation invocation, String consumer) throws Throwable;

 * limitations under the License.
 */

package org.gradle.api;

import javax.annotation.Nullable;

/**
 * <p><code>GradleException</code> is the base class of all exceptions thrown by Gradle.</p>
 */
public class GradleException extends RuntimeException {
    public GradleException() {
        super();
    }

    public GradleException(String message) {