test(http): address review comments - assertThrows, ASCII punctuation, finally guard

- Replace try/catch/fail pattern with Assert.assertThrows in UtilTest and ArgsTest (4 cases)
- Replace non-ASCII punctuation (→, —) with ASCII (->, -) in newly added test comments
- Hoist originalLimit before outer try in testJsonRpcSizeLimitIntegration so restore
  executes even when start() throws

Author: bladehan1

framework/src/test/java/org/tron/common/jetty/SizeLimitHandlerTest.java

@@ -58,7 +58,7 @@ public class SizeLimitHandlerTest {
 
   /**
    * Simulates the real servlet pattern: reads body via getReader(), wraps in
-   * broad catch(Exception) — mirrors what RateLimiterServlet + actual servlets do.
+   * broad catch(Exception) - mirrors what RateLimiterServlet + actual servlets do.
    */
   public static class BroadCatchServlet extends HttpServlet {
     @Override
@@ -214,17 +214,17 @@ public void testChunkedBodyExceedsLimit() throws Exception {
     String body = EntityUtils.toString(resp.getEntity());
     logger.info("Chunked oversized: status={}, body={}", status, body);
 
-    // catch(Exception) absorbs BadMessageException → 200 + error JSON, not 413.
-    // Body read IS truncated — OOM protection still effective.
+    // catch(Exception) absorbs BadMessageException -> 200 + error JSON, not 413.
+    // Body read IS truncated - OOM protection still effective.
     Assert.assertEquals(200, status);
     Assert.assertTrue("Error should be surfaced in response body",
         body.contains("Error"));
   }
 
   /**
    * When maxRequestSize is 0, SizeLimitHandler treats it as "reject all bodies > 0 bytes".
-   * Jetty's logic: {@code _requestLimit >= 0 && size > _requestLimit} — 0 >= 0 is true,
-   * so any non-empty body triggers 413. This is NOT "pass all" — it is a silent DoS
+   * Jetty's logic: {@code _requestLimit >= 0 && size > _requestLimit} - 0 >= 0 is true,
+   * so any non-empty body triggers 413. This is NOT "pass all" - it is a silent DoS
    * against the node's own API.
    */
   @Test
@@ -248,7 +248,7 @@ public void testZeroLimitRejectsAllBodies() throws Exception {
   /**
    * For pure ASCII JSON (the normal TRON API case), wire bytes and
    * {@code body.getBytes().length} (what {@code Util.checkBodySize()} measures)
-   * must be identical — the two enforcement layers agree exactly.
+   * must be identical - the two enforcement layers agree exactly.
    */
   @Test
   public void testWireBytesMatchCheckBodySizeForAsciiJson() throws Exception {
@@ -266,8 +266,8 @@ public void testWireBytesMatchCheckBodySizeForAsciiJson() throws Exception {
 
   /**
    * For UTF-8 JSON with multi-byte characters (CJK), wire bytes and
-   * {@code body.getBytes().length} must still be identical — UTF-8 round-trips
-   * through {@code request.getReader()} → {@code String.getBytes()} losslessly.
+   * {@code body.getBytes().length} must still be identical - UTF-8 round-trips
+   * through {@code request.getReader()} -> {@code String.getBytes()} losslessly.
    */
   @Test
   public void testWireBytesMatchCheckBodySizeForUtf8Json() throws Exception {
@@ -285,7 +285,7 @@ public void testWireBytesMatchCheckBodySizeForUtf8Json() throws Exception {
   /**
    * When the body contains {@code \r\n} line endings, {@code lines().collect()}
    * normalizes them to {@code \n} (on Linux) or the platform line separator.
-   * This makes {@code checkBodySize} measure fewer bytes than the wire —
+   * This makes {@code checkBodySize} measure fewer bytes than the wire -
    * a safe direction: checkBodySize never rejects what SizeLimitHandler accepts.
    */
   @Test

framework/src/test/java/org/tron/core/config/args/ArgsTest.java

@@ -453,12 +453,9 @@ public void testRpcMaxMessageSizeExceedsIntMax() {
     configMap.put("node.rpc.maxMessageSize", "3g");
     Config config = ConfigFactory.defaultOverrides()
         .withFallback(ConfigFactory.parseMap(configMap));
-    try {
-      Args.applyConfigParams(config);
-      Assert.fail("expected TronError for rpc maxMessageSize > Integer.MAX_VALUE");
-    } catch (TronError e) {
-      Assert.assertTrue(e.getMessage().contains("node.rpc.maxMessageSize must be non-negative"));
-    }
+    TronError e = Assert.assertThrows(TronError.class,
+        () -> Args.applyConfigParams(config));
+    Assert.assertTrue(e.getMessage().contains("node.rpc.maxMessageSize must be non-negative"));
   }
 
   @Test
@@ -468,12 +465,9 @@ public void testMaxMessageSizeNegativeValue() {
     configMap.put("node.rpc.maxMessageSize", "-4m");
     Config config = ConfigFactory.defaultOverrides()
         .withFallback(ConfigFactory.parseMap(configMap));
-    try {
-      Args.applyConfigParams(config);
-      Assert.fail("expected IllegalArgumentException for negative memory size");
-    } catch (IllegalArgumentException e) {
-      Assert.assertTrue(e.getMessage().contains("negative"));
-    }
+    IllegalArgumentException e = Assert.assertThrows(IllegalArgumentException.class,
+        () -> Args.applyConfigParams(config));
+    Assert.assertTrue(e.getMessage().contains("negative"));
   }
 
   @Test
@@ -483,12 +477,9 @@ public void testMaxMessageSizeInvalidUnit() {
     configMap.put("node.rpc.maxMessageSize", "4x");
     Config config = ConfigFactory.defaultOverrides()
         .withFallback(ConfigFactory.parseMap(configMap));
-    try {
-      Args.applyConfigParams(config);
-      Assert.fail("expected ConfigException.BadValue for invalid unit");
-    } catch (ConfigException.BadValue e) {
-      Assert.assertTrue(e.getMessage().contains("Could not parse size-in-bytes unit"));
-    }
+    ConfigException.BadValue e = Assert.assertThrows(ConfigException.BadValue.class,
+        () -> Args.applyConfigParams(config));
+    Assert.assertTrue(e.getMessage().contains("Could not parse size-in-bytes unit"));
   }
 
   @Test
@@ -498,11 +489,8 @@ public void testMaxMessageSizeNonNumeric() {
     configMap.put("node.http.maxMessageSize", "abc");
     Config config = ConfigFactory.defaultOverrides()
         .withFallback(ConfigFactory.parseMap(configMap));
-    try {
-      Args.applyConfigParams(config);
-      Assert.fail("expected ConfigException.BadValue for non-numeric value");
-    } catch (ConfigException.BadValue e) {
-      Assert.assertTrue(e.getMessage().contains("No number in size-in-bytes value"));
-    }
+    ConfigException.BadValue e = Assert.assertThrows(ConfigException.BadValue.class,
+        () -> Args.applyConfigParams(config));
+    Assert.assertTrue(e.getMessage().contains("No number in size-in-bytes value"));
   }
 }

framework/src/test/java/org/tron/core/jsonrpc/JsonrpcServiceTest.java

@@ -1114,8 +1114,8 @@ public void testWeb3ClientVersion() {
   @Test
   public void testJsonRpcSizeLimitIntegration() {
     long testLimit = 1024;
+    long originalLimit = fullNodeJsonRpcHttpService.getMaxRequestSize();
     try {
-      long originalLimit = fullNodeJsonRpcHttpService.getMaxRequestSize();
       fullNodeJsonRpcHttpService.setMaxRequestSize(testLimit);
 
       fullNodeJsonRpcHttpService.start();
@@ -1139,7 +1139,7 @@ public void testJsonRpcSizeLimitIntegration() {
             body.contains("result"));
         resp.close();
 
-        // Oversized request with Content-Length → 413 before JsonRpcServlet
+        // Oversized request with Content-Length -> 413 before JsonRpcServlet
         HttpPost overPost = new HttpPost(url);
         overPost.addHeader("Content-Type", "application/json");
         overPost.setEntity(new StringEntity(
@@ -1148,9 +1148,9 @@ public void testJsonRpcSizeLimitIntegration() {
         Assert.assertEquals(413, resp.getStatusLine().getStatusCode());
         resp.close();
 
-        // Chunked oversized → BadMessageException thrown during body read,
-        // absorbed by jsonrpc4j catch(Exception) → 200 with empty body.
-        // Body read IS truncated at the limit — OOM protection effective.
+        // Chunked oversized -> BadMessageException thrown during body read,
+        // absorbed by jsonrpc4j catch(Exception) -> 200 with empty body.
+        // Body read IS truncated at the limit - OOM protection effective.
         byte[] chunkedData = new String(new char[(int) testLimit * 2])
             .replace('\0', 'x').getBytes("UTF-8");
         HttpPost chunkedPost = new HttpPost(url);
@@ -1162,12 +1162,11 @@ public void testJsonRpcSizeLimitIntegration() {
         Assert.assertTrue("Chunked oversized should return empty body"
             + " (jsonrpc4j absorbs BadMessageException)", body.isEmpty());
         resp.close();
-      } finally {
-        fullNodeJsonRpcHttpService.setMaxRequestSize(originalLimit);
       }
     } catch (Exception e) {
       Assert.fail(e.getMessage());
     } finally {
+      fullNodeJsonRpcHttpService.setMaxRequestSize(originalLimit);
       fullNodeJsonRpcHttpService.stop();
     }
   }

framework/src/test/java/org/tron/core/services/http/UtilTest.java

@@ -143,12 +143,9 @@ public void testCheckBodySizeUsesHttpLimit() throws Exception {
       Util.checkBodySize(withinHttpLimit);
 
       String exceedsHttpLimit = new String(new char[201]).replace('\0', 'b');
-      try {
-        Util.checkBodySize(exceedsHttpLimit);
-        Assert.fail("expected exception for body exceeding httpMaxMessageSize");
-      } catch (Exception e) {
-        Assert.assertTrue(e.getMessage().contains("200"));
-      }
+      Exception e = Assert.assertThrows(Exception.class,
+          () -> Util.checkBodySize(exceedsHttpLimit));
+      Assert.assertTrue(e.getMessage().contains("200"));
     } finally {
       Args.getInstance().setHttpMaxMessageSize(originalHttpMax);
       Args.getInstance().setMaxMessageSize(originalRpcMax);