def value = ${read.groovyExpression}
                    println("apply = " + value)

                    // Instance call
                    def sys = System
                    println("apply INSTANCE = " + sys.getProperty("INSTANCE"))

                    // Call from closure
                    def cl = { p ->
                        println("\$p CLOSURE = " + sys.getProperty("CLOSURE"))
                    }

import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Marks a type or a whole package as providing a non-null API by default.
 *
 * All parameter and return types are assumed to be {@link Nonnull} unless specifically marked as {@link Nullable}.
 *
 * All types of an annotated package inherit the package rule.
 * Subpackages do not inherit nullability rules and must be annotated.
 *
 * @since 4.2
 */

packageCycles {
    excludePatterns.add("org/gradle/**")
}

val prepareVersionsInfo = tasks.register<PrepareVersionsInfo>("prepareVersionsInfo") {
    destFile = layout.buildDirectory.file("generated-resources/all-released-versions/all-released-versions.properties")
    versions = moduleIdentity.releasedVersions.map {
        it.allPreviousVersions.joinToString(" ") { it.version }
    }

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

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

        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.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) {

        buildFile << """
            tasks.register("foo")
        """

        when:
        configurationCacheRun(":foo")
        then:
        def realizeOps = buildOperations.all(RealizeTaskBuildOperationType)
        realizeOps.size() == 2
        realizeOps*.details.each {
            assert it.taskPath == ":foo"
        }
        realizeOps.first().details.eager == false

            it.assertHasFirstCause("Could not resolve all files for configuration ':implementation'.")
        }
    }

        given:
        // Why the separate plugin? The Project.getProperties() is available in the build.gradle as getProperties().
        // Therefore, it is impossible to call System.getProperties() with static import there, and testing static
        // import is important because Groovy generates different code in this case.
        file("buildSrc/src/main/groovy/SomePlugin.groovy") << """