add ByteArrayTest

Author: Little-Peony

framework/src/test/java/org/tron/common/utils/ByteArrayTest.java

@@ -23,10 +23,12 @@
 import static org.junit.Assert.fail;
 import static org.tron.common.utils.ByteArray.fromHex;
 import static org.tron.common.utils.ByteArray.jsonHexToInt;
+import static org.tron.common.utils.ByteArray.jsonHexToLong;
 
 import lombok.extern.slf4j.Slf4j;
 import org.bouncycastle.util.encoders.Hex;
 import org.junit.Test;
+import org.tron.core.exception.jsonrpc.JsonRpcInvalidParamsException;
 
 @Slf4j
 public class ByteArrayTest {
@@ -115,4 +117,128 @@ public void testFromHexWithPrefix() {
     String input1 = "1A3";
     assertEquals("01A3", fromHex(input1));
   }
+
+  @Test
+  public void testJsonHexToLong_ValidInputs() {
+    try {
+      // Test basic hex conversion
+      assertEquals(26L, jsonHexToLong("0x1A"));
+      assertEquals(255L, jsonHexToLong("0xFF"));
+      assertEquals(0L, jsonHexToLong("0x0"));
+      assertEquals(1L, jsonHexToLong("0x1"));
+      
+      // Test large values
+      assertEquals(4294967295L, jsonHexToLong("0xFFFFFFFF"));
+
+      // Test maximum long value
+      assertEquals(Long.MAX_VALUE, jsonHexToLong("0x7FFFFFFFFFFFFFFF"));  
+    } catch (JsonRpcInvalidParamsException e) {
+      fail("Exception should not have been thrown for valid hex strings: " + e.getMessage());
+    }
+  }
+
+  @Test
+  public void testJsonHexToLong_InvalidInputs() {
+    // Test null input
+    assertThrows(JsonRpcInvalidParamsException.class, () -> jsonHexToLong(null));
+    
+    // Test missing 0x prefix
+    assertThrows(JsonRpcInvalidParamsException.class, () -> jsonHexToLong("1A"));
+    
+    // Test too long input (DDoS protection)
+    StringBuilder tooLongStr = new StringBuilder("0x");
+    for (int i = 0; i < 20; i++) {
+      lontooLongStrgStr.append("F");
+    }
+    String tooLongHex = tooLongStr.toString(); // 22 characters total, exceeds MAX_HEX_LONG_LENGTH
+    assertThrows(JsonRpcInvalidParamsException.class, () -> jsonHexToLong(tooLongHex));
+    
+    // Test invalid hex characters
+    assertThrows(NumberFormatException.class, () -> jsonHexToLong("0xGG"));
+  }
+
+  @Test
+  public void testJsonHexToInt_ValidInputs() {
+    try {
+      // Test basic hex conversion
+      assertEquals(26, jsonHexToInt("0x1A"));
+      assertEquals(255, jsonHexToInt("0xFF"));
+      assertEquals(0, jsonHexToInt("0x0"));
+      assertEquals(1, jsonHexToInt("0x1"));
+      
+      // Test maximum int value
+      assertEquals(Integer.MAX_VALUE, jsonHexToInt("0x7FFFFFFF"));
+      
+      // Test large values
+      assertEquals(65535, jsonHexToInt("0xFFFF"));
+    } catch (Exception e) {
+      fail("Exception should not have been thrown for valid hex strings: " + e.getMessage());
+    }
+  }
+
+  @Test
+  public void testJsonHexToInt_InvalidInputs() {
+    // Test null input
+    assertThrows(Exception.class, () -> jsonHexToInt(null));
+    
+    // Test missing 0x prefix
+    assertThrows(Exception.class, () -> jsonHexToInt("1A"));
+    
+    // Test too long input (DDoS protection)
+    StringBuilder tooLongStr = new StringBuilder("0x");
+    for (int i = 0; i < 12; i++) {
+      tooLongStr.append("F");
+    }
+    String tooLongHex = tooLongStr.toString(); // 14 characters total, exceeds MAX_HEX_INT_LENGTH
+    assertThrows(Exception.class, () -> jsonHexToInt(tooLongHex));
+    
+    // Test invalid hex characters
+    assertThrows(NumberFormatException.class, () -> jsonHexToInt("0xGG"));
+  }
+
+  @Test
+  public void testJsonHexToLong_EdgeCases() {
+    try {
+      // Test minimum length valid input
+      assertEquals(0L, jsonHexToLong("0x0"));
+      
+      // Test a long hex string that's within limits but doesn't overflow
+      assertEquals(4095L, jsonHexToLong("0xFFF")); // 3 F's = 4095, safe value
+      
+      // Test length validation - this should pass length check
+      assertEquals(1048575L, jsonHexToLong("0xFFFFF")); // 5 F's = 1048575, safe value
+    } catch (JsonRpcInvalidParamsException e) {
+      fail("Exception should not have been thrown for edge case inputs: " + e.getMessage());
+    }
+  }
+
+  @Test
+  public void testJsonHexToInt_EdgeCases() {
+    try {
+      // Test minimum length valid input
+      assertEquals(0, jsonHexToInt("0x0"));
+      
+      // Test a hex string that's within limits but doesn't overflow
+      assertEquals(4095, jsonHexToInt("0xFFF")); // 3 F's = 4095, safe value
+      
+      // Test length validation - this should pass length check
+      assertEquals(1048575, jsonHexToInt("0xFFFFF")); // 5 F's = 1048575, safe value
+    } catch (Exception e) {
+      fail("Exception should not have been thrown for edge case inputs: " + e.getMessage());
+    }
+  }
+
+  @Test
+  public void testJsonHexToLong_OverflowHandling() {
+    // Test that Long.parseLong properly handles overflow by throwing NumberFormatException
+    // This tests values that pass length validation but cause overflow
+    assertThrows(NumberFormatException.class, () -> jsonHexToLong("0x8000000000000000")); // Long.MAX_VALUE + 1
+  }
+
+  @Test
+  public void testJsonHexToInt_OverflowHandling() {
+    // Test that Integer.parseInt properly handles overflow by throwing NumberFormatException
+    // This tests values that pass length validation but cause overflow
+    assertThrows(NumberFormatException.class, () -> jsonHexToInt("0x80000000")); // Integer.MAX_VALUE + 1
+  }
 }