def firstVersion = DefaultJavaLanguageVersion.of(firstValue)
        def secondVersion = DefaultJavaLanguageVersion.of(secondValue)

        then:
        firstVersion.canCompileOrRun(secondVersion) == firstVersion >= secondVersion
        secondVersion.canCompileOrRun(firstVersion) == secondVersion >= firstVersion
    }

    private static int getVersion() {
        Math.max(Math.abs(new Random().nextInt()), 5)
    }

    }

    @Override
    public boolean canCompileOrRun(JavaLanguageVersion other) {
        return compareTo(other) >= 0;
    }

    @Override
    public int compareTo(JavaLanguageVersion other) {
        return Integer.compare(version, other.asInt());
    }

    @Override
    public boolean canCompileOrRun(int otherVersion) {
        return version >= otherVersion;
    }

     *
     * @param other the language version to check
     *
     * @return {@code true} if this version can compile or run code from the other version, {@code false} otherwise
     */
    boolean canCompileOrRun(JavaLanguageVersion other);

    /**
     * Indicates if this version can compile or run code based on the passed in language version.
     * <p>

    jvmArgs("-Xmx${project.the<IntegrationTestExtension>().testJvmXmx.get()}", "-XX:+HeapDumpOnOutOfMemoryError")

    val testJavaVersion = JavaLanguageVersion.of(project.testJavaVersion)
    if (!testJavaVersion.canCompileOrRun(8)) {
        jvmArgs("-XX:MaxPermSize=768m")
    }

        }

        return getDefaultSpec();
    }

    private T chooseSpecForToolchain() {
        File toolchainJavaHome = toolchain.getInstallationPath().getAsFile();
        if (!toolchain.getLanguageVersion().canCompileOrRun(8)) {
            return getCommandLineSpec(Jvm.forHome(toolchainJavaHome).getJavacExecutable());
        }

        if (compileOptions.isFork()) {
            return chooseSpecFromCompileOptions(toolchainJavaHome);

        JavaLanguageVersion javaLanguageVersion = JavaLanguageVersion.of(forkingSpec.getJavaLanguageVersion());
        if (javaLanguageVersion.canCompileOrRun(9)) {
            // In JDK 9 and above the compiler internal classes are bundled with the rest of the JDK, but we need to export it to gain access.
            javaForkOptions.jvmArgs(

            );
        }
    }

    private boolean isToolchainCompatibleWithJava8() {
        return getToolchain().getLanguageVersion().canCompileOrRun(8);
    }

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

    val launcher = project.javaToolchains.launcherFor {
        languageVersion = jvmVersionForTest()
        vendor = project.testJavaVendor.orNull
    }
    javaLauncher = launcher
    if (jvmVersionForTest().canCompileOrRun(9)) {
        // Required by JdkTools and JdkJavaCompiler
        jvmArgs(listOf("--add-exports=jdk.compiler/com.sun.tools.javac.api=ALL-UNNAMED"))