public static void validateJdkVersion() {
    boolean warn = false;
    if (SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_1_8)) {
        // We need 1.8.0_111 at least
        String version = SystemUtils.JAVA_VERSION;
        int ix = version.lastIndexOf('_');
        if (ix > 0) {
            int patch = Integer.valueOf(version.substring(ix + 1));
            if (patch < 111) {
                warn = true;
            }
        }
    }
    else {
        // Not even Java 1.8
        warn = true;
    }

    if (warn) {
        new Log(VersionUtils.class).info(Style.yellow(
                "Please update your Java™ Runtime Environment (JRE) from %s to version 1.8.0_111 or newer.",
                SystemUtils.JAVA_VERSION));
    }
}
 

@Override
public List<CheckFailedResult> doCheck() {
    List<CheckFailedResult> result = new ArrayList<>();
    String javaVersion = SystemUtils.JAVA_VERSION;
    if (!SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_1_8) || !SystemUtils.isJavaVersionAtMost(JavaVersion.JAVA_11)) {
        result.add(new CheckFailedResult(
                String.format("Unsupported Java version detected: %s; Cuba supports Java 8, 9 or 11", javaVersion),
                null));
    }

    Properties prop = System.getProperties();
    String vendor = prop.getProperty("java.vendor");
    // Since OpenJ9 JVM is unsupported
    if (vendor != null && vendor.contains("OpenJ9")) {
        result.add(new CheckFailedResult(
                String.format("Possibly unsupported JVM from vendor: %s", vendor), null));
    }
    return result;
}
 

@Test
public void testJreModules() throws Exception {
    Assume.assumeTrue(SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_9));
    try (final ModularRuntimeImage mri = new ModularRuntimeImage(javaHome)) {
        final List<Path> modules = mri.modules();
        Assert.assertFalse(modules.isEmpty());
        for (final Path path : modules) {
            Files.walkFileTree(path, new ClassParserFilesVisitor("*.class"));
        }
    }
}
 

/**
 * Creates a new {@link ScriptRunner} instance according to the
 * type set with {@link #setRunnerType(RunnerType)}
 * @return the script runner
 */
public static ScriptRunner createRunner() {
    RunnerType t = runner.get();

    switch (t) {
        case AUTO:
            if (supportsV8()) {
                return createV8Runner();
            }
            if (SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_11)) {
                return createGraalRunner();
            }
            // fall back to JRE
            return createJreRunner();

        case JRE:
            return createJreRunner();

        case V8:
            return createV8Runner();

        case GRAALJS:
            return createGraalRunner();

        default:
            throw new RuntimeException("Invalid runner type");
    }
}
 

public ModularRuntimeImageTestCase(final String javaHome) throws IOException {
    this.javaHome = javaHome;
    Assume.assumeTrue(SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_9));
    this.modularRuntimeImage = new ModularRuntimeImage(javaHome);
}
 

@Test
public void givenSystemUtilsClass_whenCalledisJavaVersionAtLeast_thenCorrect() {
    assertThat(SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_RECENT)).isTrue();
}
 

@BeforeClass
public static void beforeClass() {
    Assume.assumeTrue(SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_1_8));
}
 

@BeforeClass
public static void beforeClass() {
    Assume.assumeTrue(SystemUtils.isJavaVersionAtLeast(JavaVersion.JAVA_1_8));
}
 

/**
 * Returns true if the system java version is at least as great as the input java version.
 *
 * @param version The java version, formated as %d.%d (eg, 1.8).
 * @return
 */
public boolean javaVersionIsAtLeast(String version) {
  String enumName = "JAVA_" + version.replace('.', '_');
  return SystemUtils.isJavaVersionAtLeast(JavaVersion.valueOf(enumName));
}