};
    public static final Function<Project, JavaVersion> SOURCE_COMPATIBILITY = new Function<Project, JavaVersion>() {
        @Override
        public JavaVersion apply(Project p) {
            return p.getExtensions().getByType(JavaPluginExtension.class).getSourceCompatibility();
        }
    };
    public static final Function<Project, JavaVersion> TARGET_COMPATIBILITY = new Function<Project, JavaVersion>() {
        @Override

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.tasks

import org.gradle.api.JavaVersion
import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.AvailableJavaHomes
import org.gradle.integtests.fixtures.jvm.JavaToolchainFixture
import org.gradle.internal.jvm.Jvm

    private final static Set<String> ALL = [PmdPlugin.DEFAULT_PMD_VERSION, '5.0.5', '5.1.1', '5.3.3', '6.0.0', '6.13.0', '7.0.0'].asImmutable()

    static Set<String> getSupportedVersionsByJdk() {
        if (JavaVersion.current() <= JavaVersion.VERSION_21) {
            ALL
        } else {
            VersionCoverage.versionsAtLeast(ALL, '7.0.0')
        }
    }

import org.gradle.api.JavaVersion
import org.gradle.integtests.fixtures.AvailableJavaHomes
import org.gradle.internal.jvm.Jvm

class HigherToolchainGroovyCompileIntegrationTest extends AbstractToolchainGroovyCompileIntegrationTest {

    @Override
    Jvm computeJdkForTest() {
        AvailableJavaHomes.getAvailableJdk {

    id 'groovy'
}

dependencies {
    implementation localGroovy()
}

tasks.register('runScript', JavaExec) {
    mainClass = 'scope'
    classpath = sourceSets.main.runtimeClasspath
    if (JavaVersion.current().isCompatibleWith(JavaVersion.VERSION_1_9)) {
        jvmArgs = ['--add-opens', 'java.base/java.lang=ALL-UNNAMED']
    }

        """

        when:
        fails ':help'

        then:
        failure.assertHasErrorOutput("Dependency requires at least JVM runtime version ${JavaVersion.VERSION_HIGHER.majorVersion}. This build uses a Java ${JavaVersion.current().majorVersion} JVM.")

        where:
        id                  | pluginsBlock
        "plugins block"     | """
            plugins {

        if (jdk == null) {
            return []
        }
        return ScalaCoverage.scalaVersionsSupportedByJdk(jdk.javaVersion)
    }

    private static jdkForTest() {
        AvailableJavaHomes.getAvailableJdk {
            it.languageVersion > Jvm.current().javaVersion && JavaVersion.VERSION_16.isCompatibleWith(it.languageVersion)
        }
    }

    @Override
    Jvm computeJdkForTest() {

 */

package org.gradle.internal.typeconversion;

import org.gradle.api.JavaVersion;
import org.gradle.internal.exceptions.DiagnosticsVisitor;

public class JavaVersionFromCharSequenceNotationConverter implements NotationConverter<CharSequence, JavaVersion> {
    @Override
    public void convert(CharSequence notation, NotationConvertResult<? super JavaVersion> result) throws TypeConversionException {
        try {

class ParallelTestTaskIntegrationTest extends AbstractIntegrationSpec {
    String getVersion() {
        return "1.8"
    }

    JavaVersion getJavaVersion() {
        JavaVersion.toVersion(version)
    }

    JavaInfo getTarget() {
        return AvailableJavaHomes.getJdk(javaVersion)
    }


    def subprojects = ['a', 'b', 'c', 'd']

    def setup() {
        Assume.assumeTrue(target != null)

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.buildinit.plugins

import org.gradle.api.JavaVersion
import org.gradle.buildinit.plugins.fixtures.ScriptDslFixture
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitDsl
import org.gradle.buildinit.plugins.internal.modifiers.BuildInitTestFramework