test: restore shared state and clean up workers on failure

- Restore EffectiveCheckService's original executor in finally
- Stop and join SolidityNode test workers before restoring shared state
- Isolate BlockEventCache and restore it after history workers terminate
- Preserve interrupt status while waiting for worker cleanup

Author: 3for

framework/src/test/java/org/tron/core/event/HistoryEventServiceTest.java

@@ -5,6 +5,10 @@
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import com.google.common.util.concurrent.Uninterruptibles;
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.TimeUnit;
 import org.junit.After;
@@ -17,6 +21,7 @@
 import org.tron.core.ChainBaseManager;
 import org.tron.core.capsule.BlockCapsule.BlockId;
 import org.tron.core.db.Manager;
+import org.tron.core.services.event.BlockEventCache;
 import org.tron.core.services.event.BlockEventGet;
 import org.tron.core.services.event.BlockEventLoad;
 import org.tron.core.services.event.HistoryEventService;
@@ -35,9 +40,16 @@ public class HistoryEventServiceTest {
   private final BlockEventGet get = mock(BlockEventGet.class);
   private final ChainBaseManager chain = mock(ChainBaseManager.class);
   private final DynamicPropertiesStore properties = mock(DynamicPropertiesStore.class);
+  private final Map<String, Object> savedCacheState = new LinkedHashMap<>();
 
   @Before
   public void setUp() {
+    for (String field : new String[]{"solidNum", "head", "solidId", "blockEventMap", "numMap"}) {
+      savedCacheState.put(field, ReflectionTestUtils.getField(BlockEventCache.class, field));
+    }
+    // init() clears both maps, so use test-owned maps to preserve the original contents.
+    ReflectionTestUtils.setField(BlockEventCache.class, "blockEventMap", new ConcurrentHashMap<>());
+    ReflectionTestUtils.setField(BlockEventCache.class, "numMap", new ConcurrentHashMap<>());
     Manager manager = mock(Manager.class);
     when(manager.getChainBaseManager()).thenReturn(chain);
     when(manager.getDynamicPropertiesStore()).thenReturn(properties);
@@ -52,9 +64,20 @@ public void setUp() {
 
   @After
   public void tearDown() {
-    service.close();
-    Thread worker = (Thread) ReflectionTestUtils.getField(service, "thread");
-    Assert.assertTrue("History worker did not terminate", worker == null || !worker.isAlive());
+    try {
+      service.close();
+    } finally {
+      Thread worker = (Thread) ReflectionTestUtils.getField(service, "thread");
+      if (worker != null) {
+        worker.interrupt();
+        Uninterruptibles.joinUninterruptibly(worker, 5, TimeUnit.SECONDS);
+        Assert.assertFalse("History worker did not terminate", worker.isAlive());
+      }
+      // Restore only after the worker can no longer change the shared cache.
+      savedCacheState.forEach((field, value) ->
+          ReflectionTestUtils.setField(BlockEventCache.class, field, value));
+      savedCacheState.clear();
+    }
   }
 
   @Test

framework/src/test/java/org/tron/core/net/services/EffectiveCheckServiceTest.java

@@ -72,16 +72,21 @@ public void testFind() {
     ScheduledExecutorService executor = Mockito.mock(ScheduledExecutorService.class);
     Mockito.when(executor.submit(Mockito.any(Runnable.class)))
         .thenReturn(CompletableFuture.completedFuture(null));
-    ReflectUtils.setFieldValue(service, "executor", executor);
-    service.triggerNext();
-    ArgumentCaptor<Runnable> task = ArgumentCaptor.forClass(Runnable.class);
-    Mockito.verify(executor).submit(task.capture());
-    task.getValue().run();
-    Assert.assertNull(service.getCur());
+    ScheduledExecutorService originalExecutor = ReflectUtils.getFieldValue(service, "executor");
+    try {
+      ReflectUtils.setFieldValue(service, "executor", executor);
+      service.triggerNext();
+      ArgumentCaptor<Runnable> task = ArgumentCaptor.forClass(Runnable.class);
+      Mockito.verify(executor).submit(task.capture());
+      task.getValue().run();
+      Assert.assertNull(service.getCur());
 
-    ReflectUtils.invokeMethod(service, "resetCount");
-    InetSocketAddress cur = new InetSocketAddress("192.168.0.1", port);
-    service.setCur(cur);
-    service.onDisconnect(cur);
+      ReflectUtils.invokeMethod(service, "resetCount");
+      InetSocketAddress cur = new InetSocketAddress("192.168.0.1", port);
+      service.setCur(cur);
+      service.onDisconnect(cur);
+    } finally {
+      ReflectUtils.setFieldValue(service, "executor", originalExecutor);
+    }
   }
 }

framework/src/test/java/org/tron/program/SolidityNodeTest.java

@@ -7,6 +7,7 @@
 import static org.junit.Assert.assertTrue;
 import static org.mockito.Mockito.mock;
 
+import com.google.common.util.concurrent.Uninterruptibles;
 import com.google.protobuf.ByteString;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
@@ -551,6 +552,7 @@ public void testGetBlockProcessesOneBlock() throws Exception {
   @Test(timeout = 8000)
   @SuppressWarnings("unchecked")
   public void testGetBlockShutdownPaths() throws Exception {
+    boolean origFlag = getFlag();
     long origID     = atomicLong("ID").get();
     long origRemote = atomicLong("remoteBlockNum").get();
     Field clientField   = getField("databaseGrpcClient");
@@ -560,6 +562,7 @@ public void testGetBlockShutdownPaths() throws Exception {
 
     LinkedBlockingDeque<Block> queue =
         (LinkedBlockingDeque<Block>) getField("blockQueue").get(solidityNode);
+    Thread worker = null;
     try {
       // ── Part 1: interrupt during blockQueue.put() ──────────────────────────
       // Fill the queue to capacity so the next put() call blocks.
@@ -581,18 +584,18 @@ public void testGetBlockShutdownPaths() throws Exception {
       Method getBlockM = SolidityNode.class.getDeclaredMethod("getBlock");
       getBlockM.setAccessible(true);
       AtomicReference<Throwable> workerFailure = new AtomicReference<>();
-      Thread t = new Thread(() -> {
+      worker = new Thread(() -> {
         try {
           getBlockM.invoke(solidityNode);
         } catch (Exception e) {
           workerFailure.set(e);
         }
       });
-      t.start();
+      worker.start();
       Thread.sleep(200); // let the thread block inside blockQueue.put()
-      t.interrupt();     // simulate ExecutorService.shutdownNow()
-      t.join(4000);
-      assertFalse("getBlock must exit cleanly when interrupted during put()", t.isAlive());
+      worker.interrupt();     // simulate ExecutorService.shutdownNow()
+      worker.join(4000);
+      assertFalse("getBlock must exit cleanly when interrupted during put()", worker.isAlive());
       Assert.assertNull("getBlock worker failed", workerFailure.get());
       queue.clear();
       setFlag(true);
@@ -612,7 +615,8 @@ public void testGetBlockShutdownPaths() throws Exception {
       // Must return without throwing and without infinite retry.
       getBlockM.invoke(solidityNode);
     } finally {
-      setFlag(true);
+      stopWorker(worker);
+      setFlag(origFlag);
       queue.clear();
       atomicLong("ID").set(origID);
       atomicLong("remoteBlockNum").set(origRemote);
@@ -668,12 +672,12 @@ public void testProcessSolidityBlockProcessesQueuedBlock() throws Exception {
    */
   @Test(timeout = 8000)
   public void testProcessSolidityBlockHandlesInterrupt() throws Exception {
+    boolean origFlag = getFlag();
     TronNetDelegate mockDelegate = mock(TronNetDelegate.class);
     Mockito.when(mockDelegate.isHitDown()).thenReturn(false);
 
     Field delegateField = getField("tronNetDelegate");
     Object origDelegate = delegateField.get(solidityNode);
-    delegateField.set(solidityNode, mockDelegate);
 
     Method m = SolidityNode.class.getDeclaredMethod("processSolidityBlock");
     m.setAccessible(true);
@@ -686,20 +690,32 @@ public void testProcessSolidityBlockHandlesInterrupt() throws Exception {
       }
     });
     try {
+      delegateField.set(solidityNode, mockDelegate);
       t.start();
       Thread.sleep(150); // let the thread enter blockQueue.poll(1000 ms)
       t.interrupt();
       t.join(5000);
       assertFalse("processSolidityBlock must exit after interrupt", t.isAlive());
       Assert.assertNull("processSolidityBlock worker failed", workerFailure.get());
     } finally {
-      setFlag(true);
+      stopWorker(t);
+      setFlag(origFlag);
       delegateField.set(solidityNode, origDelegate);
     }
   }
 
   // ── private helpers ──────────────────────────────────────────────────────────
 
+  private void stopWorker(Thread worker) throws Exception {
+    // A timeout may interrupt the test thread before it reaches the normal shutdown path.
+    setFlag(false);
+    if (worker != null) {
+      worker.interrupt();
+      Uninterruptibles.joinUninterruptibly(worker, 5, TimeUnit.SECONDS);
+      assertFalse("Test worker must stop before restoring shared state", worker.isAlive());
+    }
+  }
+
   private static Field getField(String name) throws Exception {
     Field f = SolidityNode.class.getDeclaredField(name);
     f.setAccessible(true);