feat(runtime): enforce Java 17 for ARM64 (#6459)

Author: halibobo1205

framework/src/test/java/org/tron/core/exception/TronErrorTest.java

@@ -2,8 +2,11 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertThrows;
+import static org.junit.Assert.fail;
 import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.Mockito.mockStatic;
+import static org.mockito.Mockito.never;
+import static org.mockito.Mockito.times;
 
 import com.typesafe.config.Config;
 import com.typesafe.config.ConfigFactory;
@@ -127,25 +130,53 @@ public void shutdownBlockTimeInitTest() {
 
   @Test
   public void testThrowIfUnsupportedJavaVersion() {
-    runArchTest(true, false, true);
-    runArchTest(true, true, false);
-    runArchTest(false, false, false);
+    runArchTest("x86_64", "1.8", false);
+    runArchTest("x86_64", "11", true);
+    runArchTest("x86_64", "17", true);
+    runArchTest("aarch64", "17", false);
+    runArchTest("aarch64", "1.8", true);
+    runArchTest("aarch64", "11", true);
   }
 
-  private void runArchTest(boolean isX86, boolean isJava8, boolean expectThrow) {
+  private void runArchTest(String osArch, String javaVersion, boolean expectThrow) {
     try (MockedStatic<Arch> mocked = mockStatic(Arch.class)) {
+      boolean isX86 = "x86_64".equals(osArch);
+      boolean isArm64 = "aarch64".equals(osArch);
+
+      boolean isJava8 = "1.8".equals(javaVersion);
+      boolean isJava17 = "17".equals(javaVersion);
+
       mocked.when(Arch::isX86).thenReturn(isX86);
+      mocked.when(Arch::isArm64).thenReturn(isArm64);
+
       mocked.when(Arch::isJava8).thenReturn(isJava8);
-      mocked.when(Arch::getOsArch).thenReturn("x86_64");
-      mocked.when(Arch::javaSpecificationVersion).thenReturn("17");
-      mocked.when(Arch::withAll).thenReturn("");
+      mocked.when(Arch::isJava17).thenReturn(isJava17);
+
+      mocked.when(Arch::getOsArch).thenReturn(osArch);
+      mocked.when(Arch::javaSpecificationVersion).thenReturn(javaVersion);
+      mocked.when(Arch::withAll).thenReturn(String.format(
+          "Architecture: %s, Java Version: %s", osArch, javaVersion));
+
       mocked.when(Arch::throwIfUnsupportedJavaVersion).thenCallRealMethod();
 
       if (expectThrow) {
-        assertEquals(TronError.ErrCode.JDK_VERSION, assertThrows(
-            TronError.class, () -> Args.setParam(new String[]{}, Constant.TEST_CONF)).getErrCode());
+        TronError err = assertThrows(
+            TronError.class, () -> Args.setParam(new String[]{}, Constant.TEST_CONF));
+
+        String expectedJavaVersion = isX86 ? "1.8" : "17";
+        String expectedMessage = String.format(
+            "Java %s is required for %s architecture. Detected version %s",
+            expectedJavaVersion, osArch, javaVersion);
+        assertEquals(expectedMessage, err.getCause().getMessage());
+        assertEquals(TronError.ErrCode.JDK_VERSION, err.getErrCode());
+        mocked.verify(Arch::withAll, times(1));
       } else {
-        Arch.throwIfUnsupportedJavaVersion();
+        try {
+          Arch.throwIfUnsupportedJavaVersion();
+        } catch (Exception e) {
+          fail("Expected no exception, but got: " + e.getMessage());
+        }
+        mocked.verify(Arch::withAll, never());
       }
     }
   }

platform/src/main/java/common/org/tron/common/arch/Arch.java

@@ -69,11 +69,15 @@ public static boolean isJava8() {
     return javaSpecificationVersion().equals("1.8");
   }
 
+  public static boolean isJava17() {
+    return javaSpecificationVersion().equals("17");
+  }
+
   public static void throwIfUnsupportedJavaVersion() {
-    if (isX86() && !isJava8()) {
+    if ((isX86() && !isJava8()) || (isArm64() && !isJava17())) {
       logger.info(withAll());
       throw new UnsupportedOperationException(String.format(
-          "Java %s is required for %s architecture. Detected version %s", "1.8",
+          "Java %s is required for %s architecture. Detected version %s", isX86() ? "1.8" : "17",
           getOsArch(), javaSpecificationVersion()));
     }
   }