test(api): harden printBlockToJSON tests against drift

Coverage added/consolidated around the hand-rolled printBlockToJSON
from 0980488 so future regressions surface in tests, not at runtime.

- Merge testPrintBlockToJSONVisibleFalse into testPrintBlockToJSONWithTransactions
  via a boolean[]{true,false} loop; flag-driven encoding difference
  remains covered by testPrintBlockToJSONVisibleFlagAffectsAddressEncoding.
- testPrintBlockToJSONTransactionsKeyMatchesLegacyImpl: pin parity with
  the prior JsonFormat.printToString(block, ...) output for the
  transactions-key presence in both empty and non-empty cases.
- testPrintBlockToJSONCoversAllProtoTopLevelFields: reflect over
  Block's descriptor to fail fast if a new top-level proto field is
  added without extending the hand-rolled assembler.

Author: bladehan1

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

@@ -3,10 +3,13 @@
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.google.protobuf.ByteString;
+import com.google.protobuf.Descriptors;
 
 import java.security.InvalidParameterException;
 import java.util.ArrayList;
+import java.util.HashMap;
 import java.util.List;
+import java.util.Map;
 
 import org.apache.commons.lang3.StringUtils;
 import org.junit.After;
@@ -87,47 +90,30 @@ public void testPrintBlockToJSONEmptyTransactions() {
 
   @Test
   public void testPrintBlockToJSONWithTransactions() {
-    BlockCapsule blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
-        System.currentTimeMillis(), Sha256Hash.ZERO_HASH.getByteString());
-    TransactionCapsule txCap = getTransactionCapsuleExample();
-    blockCapsule.addTransaction(txCap);
-
-    JSONObject json = Util.printBlockToJSON(blockCapsule.getInstance(), true);
-    Assert.assertTrue(json.containsKey("blockID"));
-    Assert.assertTrue(json.containsKey("block_header"));
-    Assert.assertTrue(json.containsKey("transactions"));
-    Assert.assertFalse(json.getString("blockID").isEmpty());
-    JSONObject blockHeader = json.getJSONObject("block_header");
-    Assert.assertNotNull(blockHeader);
-    Assert.assertTrue(blockHeader.containsKey("raw_data"));
-
-    JSONArray txArray = json.getJSONArray("transactions");
-    Assert.assertEquals(1, txArray.size());
-    JSONObject txJson = txArray.getJSONObject(0);
-    Assert.assertTrue(txJson.containsKey("txID"));
-    Assert.assertTrue(txJson.containsKey("raw_data"));
-  }
-
-  @Test
-  public void testPrintBlockToJSONVisibleFalse() {
-    BlockCapsule blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
-        System.currentTimeMillis(), Sha256Hash.ZERO_HASH.getByteString());
-    TransactionCapsule txCap = getTransactionCapsuleExample();
-    blockCapsule.addTransaction(txCap);
-
-    JSONObject json = Util.printBlockToJSON(blockCapsule.getInstance(), false);
-    Assert.assertTrue(json.containsKey("blockID"));
-    Assert.assertTrue(json.containsKey("block_header"));
-    Assert.assertTrue(json.containsKey("transactions"));
-    JSONObject blockHeader = json.getJSONObject("block_header");
-    Assert.assertNotNull(blockHeader);
-    Assert.assertTrue(blockHeader.containsKey("raw_data"));
-
-    JSONArray txArray = json.getJSONArray("transactions");
-    Assert.assertEquals(1, txArray.size());
-    JSONObject txJson = txArray.getJSONObject(0);
-    Assert.assertTrue(txJson.containsKey("txID"));
-    Assert.assertTrue(txJson.containsKey("raw_data"));
+    // Structural invariants must hold under either visible flag; the flag-driven
+    // encoding difference is covered by testPrintBlockToJSONVisibleFlagAffectsAddressEncoding.
+    for (boolean visible : new boolean[]{true, false}) {
+      BlockCapsule blockCapsule = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
+          System.currentTimeMillis(), Sha256Hash.ZERO_HASH.getByteString());
+      blockCapsule.addTransaction(getTransactionCapsuleExample());
+
+      JSONObject json = Util.printBlockToJSON(blockCapsule.getInstance(), visible);
+
+      String msg = "visible=" + visible;
+      Assert.assertTrue(msg, json.containsKey("blockID"));
+      Assert.assertTrue(msg, json.containsKey("block_header"));
+      Assert.assertTrue(msg, json.containsKey("transactions"));
+      Assert.assertFalse(msg, json.getString("blockID").isEmpty());
+      JSONObject blockHeader = json.getJSONObject("block_header");
+      Assert.assertNotNull(msg, blockHeader);
+      Assert.assertTrue(msg, blockHeader.containsKey("raw_data"));
+
+      JSONArray txArray = json.getJSONArray("transactions");
+      Assert.assertEquals(msg, 1, txArray.size());
+      JSONObject txJson = txArray.getJSONObject(0);
+      Assert.assertTrue(msg, txJson.containsKey("txID"));
+      Assert.assertTrue(msg, txJson.containsKey("raw_data"));
+    }
   }
 
   @Test
@@ -165,6 +151,55 @@ public void testPrintBlockToJSONVisibleFlagAffectsAddressEncoding() {
     Assert.assertNotEquals(witnessVisible, witnessHidden);
   }
 
+  @Test
+  public void testPrintBlockToJSONTransactionsKeyMatchesLegacyImpl() {
+    // Legacy impl produced JSON via JsonFormat.printToString(block, selfType),
+    // which omits repeated fields when empty. New impl mirrors that with an
+    // explicit isEmpty() guard. Pin parity using JsonFormat output as ground
+    // truth so a future refactor can't quietly start emitting "transactions": []
+    // (or stop emitting the key when non-empty).
+    BlockCapsule empty = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
+        System.currentTimeMillis(), Sha256Hash.ZERO_HASH.getByteString());
+    assertTransactionsKeyMatchesLegacy(empty.getInstance(), false);
+
+    BlockCapsule nonEmpty = new BlockCapsule(1, Sha256Hash.ZERO_HASH,
+        System.currentTimeMillis(), Sha256Hash.ZERO_HASH.getByteString());
+    nonEmpty.addTransaction(getTransactionCapsuleExample());
+    assertTransactionsKeyMatchesLegacy(nonEmpty.getInstance(), true);
+  }
+
+  private static void assertTransactionsKeyMatchesLegacy(Protocol.Block block,
+      boolean expectTransactionsKey) {
+    JSONObject legacy = JSONObject.parseObject(JsonFormat.printToString(block, true));
+    Assert.assertEquals("legacy JsonFormat parity broken — proto behavior changed?",
+        expectTransactionsKey, legacy.containsKey("transactions"));
+
+    JSONObject actual = Util.printBlockToJSON(block, true);
+    Assert.assertEquals("new impl diverged from legacy on 'transactions' key presence",
+        expectTransactionsKey, actual.containsKey("transactions"));
+  }
+
+  @Test
+  public void testPrintBlockToJSONCoversAllProtoTopLevelFields() {
+    // Guards against proto field drift: the old impl delegated to JsonFormat on
+    // the whole Block message, so any new top-level Block field appeared
+    // automatically. The new impl hand-assembles the JSON, so a future proto
+    // field would be silently dropped. Reflect over Block's descriptor and
+    // assert every declared top-level field is handled.
+    Map<String, String> protoFieldToJsonKey = new HashMap<>();
+    protoFieldToJsonKey.put("block_header", "block_header");
+    // "transactions" is present only when non-empty; parity verified in
+    // testPrintBlockToJSONTransactionsKeyMatchesLegacyImpl.
+    protoFieldToJsonKey.put("transactions", "transactions");
+
+    for (Descriptors.FieldDescriptor f : Protocol.Block.getDescriptor().getFields()) {
+      Assert.assertTrue(
+          "Block proto field '" + f.getName() + "' is not handled by printBlockToJSON. "
+              + "If you added a new top-level field, extend printBlockToJSON and this test.",
+          protoFieldToJsonKey.containsKey(f.getName()));
+    }
+  }
+
   @Test
   public void testPrintTransactionList() {
     TransactionCapsule transactionCapsule = getTransactionCapsuleExample();