TestedVersions.gretty.findAll {
            JavaVersion.current().isCompatibleWith(it.javaMinVersion as JavaVersion) &&
                (it.javaMaxVersion == null || JavaVersion.current() <= JavaVersion.toVersion(it.javaMaxVersion))
        }
    }

        AttributeValue<Integer> jvmVersionAttribute = failure.getRequestedAttributes().findEntry(TargetJvmVersion.TARGET_JVM_VERSION_ATTRIBUTE);
        return JavaVersion.toVersion(jvmVersionAttribute.get());
    }

    @Override
    public boolean canDescribeFailure(IncompatibleGraphVariantFailure failure) {

        return candidate.getIncompatibleAttributes().stream()
            .filter(this::isJVMVersionAttribute)
            .map(jvmVersionAttribute -> JavaVersion.toVersion(Objects.requireNonNull(jvmVersionAttribute.getProvided())))
            .min(Comparator.comparing(JavaVersion::getMajorVersion));
    }

        maybeAddOpensJvmArgs(getJavaLauncher().get(), forkOptions);
    }

    private static void maybeAddOpensJvmArgs(JavaLauncher javaLauncher, JavaForkOptions forkOptions) {
        if (JavaVersion.toVersion(javaLauncher.getMetadata().getJavaRuntimeVersion()).isJava9Compatible()) {
            forkOptions.jvmArgs("--add-opens", OPEN_MODULES_ARG);
        }
    }

    /**
     * Java launcher used to start the worker process

        } finally {
            lock.unlock();
        }
    }

    private FileLock lockBuildLogicQueueFile() {
        return fileLockManager.lock(
            new File(projectCacheDir.getDir(), "noVersion/buildLogic"),
            mode(FileLockManager.LockMode.Exclusive),
            "build logic queue"
        );
    }

            if (flagIndex != -1 && flagIndex + 1 < compilerArgs.size()) {
                return Integer.parseInt(String.valueOf(compilerArgs.get(flagIndex + 1)));
            } else {
                return JavaVersion.toVersion(compileTask.getTargetCompatibility()).getMajorVersionNumber();
            }
        }).max(Comparator.naturalOrder()).get();
    }

    JavaVersion getJavaVersion() {
        return JavaVersion.toVersion(getToolchain().getLanguageVersion().asInt());
    }

    private void configureCompileOptions(DefaultJavaCompileSpec spec) {
        if (compileOptions.getRelease().isPresent()) {
            spec.setRelease(compileOptions.getRelease().get());
        } else {
            String toolchainVersion = JavaVersion.toVersion(getToolchain().getLanguageVersion().asInt()).toString();

        convention.testReportDirName == 'tests'
    }

   def "source and target compatibility default to current jvm version"() {
        given:
        JavaVersion currentJvmVersion = JavaVersion.toVersion(System.properties["java.version"])
        expect:
        convention.sourceCompatibility == currentJvmVersion
        convention.targetCompatibility == currentJvmVersion
    }

        return ["1.6", "1.7", "1.8", "11", "15", "16", "17", "18", "19", "20", "21", "22"]
    }

    static JavaVersion toJavaVersion(String version) {
        return JavaVersion.toVersion(version)
    }

    def withJavaProjectUsingToolchainsForJavaVersion(String version) {
        def javaVersion = toJavaVersion(version)
        def target = AvailableJavaHomes.getJdk(javaVersion)

        JavaVersion rawSourceCompatibility = javaExtension.getRawSourceCompatibility();
        if (rawSourceCompatibility != null) {
            return rawSourceCompatibility;
        }
        return JavaVersion.toVersion(compileTask.getJavaLauncher().get().getMetadata().getLanguageVersion().toString());
    }