test(p2p): improve test coverage from 35% to 76%

Add comprehensive unit tests to meet CI coverage gate requirements
(changed files > 60%, overall delta < -0.1%).

New test files (27):
- connection/: Channel, ChannelManager, HandshakeService, KeepAlive,
  NodeDetect, ConnPoolService, UpgradeController, P2pProtobufDecoder,
  MessageHandler, PeerClient, P2pChannelInitializer, StatusMessage,
  P2pDisconnectMessage
- dns/: DnsManager, AliClient, AwsClient, PublishService
- discover/: FindNodeMessage, NeighborsMessage, Message, PacketDecoder,
  MessageHandler, DiscoverTask
- utils/web3j: Numeric, Strings, Hash, ECKeyPair
- stats: StatsManager
- exception: DnsException
- P2pService, P2pConfig

Exclude proto-generated code from jacoco coverage calculation
(consistent with checkstyle exclusion).

Author: Barbatos

p2p/build.gradle

@@ -91,4 +91,9 @@ jacocoTestReport {
         xml.enabled = true
         html.enabled = true
     }
+    afterEvaluate {
+        classDirectories.from = classDirectories.files.collect {
+            fileTree(dir: it, exclude: '**/protos/**')
+        }
+    }
 }

p2p/src/test/java/org/tron/p2p/P2pConfigTest.java

@@ -0,0 +1,77 @@
+package org.tron.p2p;
+
+import org.junit.Assert;
+import org.junit.Test;
+
+public class P2pConfigTest {
+
+  @Test
+  public void testDefaultValues() {
+    P2pConfig config = new P2pConfig();
+    Assert.assertNotNull(config.getSeedNodes());
+    Assert.assertTrue(config.getSeedNodes().isEmpty());
+    Assert.assertNotNull(config.getActiveNodes());
+    Assert.assertTrue(config.getActiveNodes().isEmpty());
+    Assert.assertNotNull(config.getTrustNodes());
+    Assert.assertTrue(config.getTrustNodes().isEmpty());
+    Assert.assertNotNull(config.getNodeID());
+    Assert.assertEquals(64, config.getNodeID().length);
+    Assert.assertEquals(18888, config.getPort());
+    Assert.assertEquals(1, config.getNetworkId());
+    Assert.assertEquals(8, config.getMinConnections());
+    Assert.assertEquals(50, config.getMaxConnections());
+    Assert.assertEquals(2, config.getMinActiveConnections());
+    Assert.assertEquals(2, config.getMaxConnectionsWithSameIp());
+    Assert.assertTrue(config.isDiscoverEnable());
+    Assert.assertFalse(config.isDisconnectionPolicyEnable());
+    Assert.assertFalse(config.isNodeDetectEnable());
+    Assert.assertNotNull(config.getTreeUrls());
+    Assert.assertTrue(config.getTreeUrls().isEmpty());
+    Assert.assertNotNull(config.getPublishConfig());
+  }
+
+  @Test
+  public void testSettersAndGetters() {
+    P2pConfig config = new P2pConfig();
+
+    config.setPort(19999);
+    Assert.assertEquals(19999, config.getPort());
+
+    config.setNetworkId(42);
+    Assert.assertEquals(42, config.getNetworkId());
+
+    config.setMinConnections(10);
+    Assert.assertEquals(10, config.getMinConnections());
+
+    config.setMaxConnections(100);
+    Assert.assertEquals(100, config.getMaxConnections());
+
+    config.setMinActiveConnections(5);
+    Assert.assertEquals(5, config.getMinActiveConnections());
+
+    config.setMaxConnectionsWithSameIp(3);
+    Assert.assertEquals(3, config.getMaxConnectionsWithSameIp());
+
+    config.setDiscoverEnable(false);
+    Assert.assertFalse(config.isDiscoverEnable());
+
+    config.setDisconnectionPolicyEnable(true);
+    Assert.assertTrue(config.isDisconnectionPolicyEnable());
+
+    config.setNodeDetectEnable(true);
+    Assert.assertTrue(config.isNodeDetectEnable());
+
+    byte[] customId = new byte[64];
+    config.setNodeID(customId);
+    Assert.assertArrayEquals(customId, config.getNodeID());
+
+    config.setIp("10.0.0.1");
+    Assert.assertEquals("10.0.0.1", config.getIp());
+
+    config.setLanIp("192.168.0.1");
+    Assert.assertEquals("192.168.0.1", config.getLanIp());
+
+    config.setIpv6("::1");
+    Assert.assertEquals("::1", config.getIpv6());
+  }
+}

p2p/src/test/java/org/tron/p2p/P2pServiceTest.java

@@ -0,0 +1,104 @@
+package org.tron.p2p;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Set;
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+import org.tron.p2p.base.Parameter;
+import org.tron.p2p.exception.P2pException;
+
+public class P2pServiceTest {
+
+  private P2pService p2pService;
+
+  @Before
+  public void init() {
+    p2pService = new P2pService();
+    // Reset handler state
+    Parameter.handlerList = new ArrayList<>();
+    Parameter.handlerMap = new HashMap<>();
+  }
+
+  @After
+  public void cleanup() {
+    try {
+      p2pService.close();
+    } catch (Exception e) {
+      // ignore cleanup errors
+    }
+  }
+
+  @Test
+  public void testGetVersion() {
+    Assert.assertEquals(Parameter.version, p2pService.getVersion());
+  }
+
+  @Test
+  public void testRegisterHandler() throws P2pException {
+    P2pEventHandler handler = new P2pEventHandler() {
+      {
+        Set<Byte> types = new HashSet<>();
+        types.add((byte) 0x50);
+        this.messageTypes = types;
+      }
+    };
+    p2pService.register(handler);
+    Assert.assertTrue(Parameter.handlerList.contains(handler));
+    Assert.assertEquals(handler, Parameter.handlerMap.get((byte) 0x50));
+  }
+
+  @Test(expected = P2pException.class)
+  public void testRegisterDuplicateTypeThrows() throws P2pException {
+    P2pEventHandler handler1 = new P2pEventHandler() {
+      {
+        Set<Byte> types = new HashSet<>();
+        types.add((byte) 0x60);
+        this.messageTypes = types;
+      }
+    };
+    P2pEventHandler handler2 = new P2pEventHandler() {
+      {
+        Set<Byte> types = new HashSet<>();
+        types.add((byte) 0x60);
+        this.messageTypes = types;
+      }
+    };
+    p2pService.register(handler1);
+    p2pService.register(handler2); // should throw
+  }
+
+  @Test
+  public void testRegisterHandlerWithNullMessageTypes() throws P2pException {
+    P2pEventHandler handler = new P2pEventHandler() {};
+    // messageTypes is null by default
+    p2pService.register(handler);
+    Assert.assertTrue(Parameter.handlerList.contains(handler));
+  }
+
+  @Test
+  public void testCloseIdempotent() throws Exception {
+    // Set up minimal config to allow close without NPE
+    // The close method checks isShutdown flag
+    Field isShutdownField = P2pService.class.getDeclaredField("isShutdown");
+    isShutdownField.setAccessible(true);
+
+    // First close
+    isShutdownField.set(p2pService, false);
+    // We can't call start() without real network, but we can test the idempotent close
+    isShutdownField.set(p2pService, true);
+    // Second close should be a no-op
+    p2pService.close();
+    Assert.assertTrue((boolean) isShutdownField.get(p2pService));
+  }
+
+  @Test
+  public void testGetP2pStats() {
+    // statsManager is initialized in constructor, getP2pStats should work
+    Assert.assertNotNull(p2pService.getP2pStats());
+  }
+}