fix: Close hasher in tests (#24587)

Signed-off-by: Artur Kugal <artur.kugal@swirldslabs.com>

Author: akugal

platform-sdk/swirlds-virtualmap/src/test/java/com/swirlds/virtualmap/internal/hash/VirtualHasherHugeTest.java

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 package com.swirlds.virtualmap.internal.hash;
 
-import static com.swirlds.virtualmap.test.fixtures.VirtualMapTestUtils.VIRTUAL_MAP_CONFIG;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
 
 import com.swirlds.virtualmap.datasource.VirtualHashChunk;
@@ -44,8 +43,7 @@ void hugeTree() {
         // Go ahead and hash. I'm just going to check that the root hash produces *something*. I'm not worried
         // in this test as to the validity of this root hash since correctness is validated heavily in other
         // tests. In this test, I just want to be sure that we complete, and that we don't run out of memory.
-        final VirtualHasher hasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
-        final Hash rootHash = hasher.hash(
+        final Hash rootHash = defaultHasher.hash(
                 CHUNK_HEIGHT,
                 chunkPath -> new VirtualHashChunk(chunkPath, CHUNK_HEIGHT),
                 LongStream.range(firstLeafPath, lastLeafPath + 1)

platform-sdk/swirlds-virtualmap/src/test/java/com/swirlds/virtualmap/internal/hash/VirtualHasherTest.java

@@ -1,7 +1,6 @@
 // SPDX-License-Identifier: Apache-2.0
 package com.swirlds.virtualmap.internal.hash;
 
-import static com.swirlds.virtualmap.test.fixtures.VirtualMapTestUtils.VIRTUAL_MAP_CONFIG;
 import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNotNull;
@@ -55,11 +54,10 @@ class VirtualHasherTest extends VirtualHasherTestBase {
     @Tag(TestComponentTags.VMAP)
     @DisplayName("Null preloader produces NPE")
     void nullPreloaderProducesNPE() {
-        final VirtualHasher hasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
         final List<VirtualLeafBytes> leaves = new ArrayList<>();
         assertThrows(
                 NullPointerException.class,
-                () -> hasher.hash(CHUNK_HEIGHT, null, leaves.iterator(), 1, 2, null),
+                () -> defaultHasher.hash(CHUNK_HEIGHT, null, leaves.iterator(), 1, 2, null),
                 "Call should have produced an NPE");
     }
 
@@ -71,10 +69,9 @@ void nullPreloaderProducesNPE() {
     @DisplayName("Null stream produces NPE")
     void nullStreamProducesNPE() {
         final TestDataSource ds = new TestDataSource(1, 2, CHUNK_HEIGHT);
-        final VirtualHasher hasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
         assertThrows(
                 NullPointerException.class,
-                () -> hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, null, 1, 2, null),
+                () -> defaultHasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, null, 1, 2, null),
                 "Call should have produced an NPE");
     }
 
@@ -87,10 +84,9 @@ void nullStreamProducesNPE() {
     @SuppressWarnings({"MismatchedQueryAndUpdateOfCollection", "RedundantOperationOnEmptyContainer"})
     void emptyStreamProducesNull() {
         final TestDataSource ds = new TestDataSource(1, 2, CHUNK_HEIGHT);
-        final VirtualHasher hasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
         final List<VirtualLeafBytes> leaves = new ArrayList<>();
         assertNull(
-                hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, leaves.iterator(), 1, 2, null),
+                defaultHasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, leaves.iterator(), 1, 2, null),
                 "Call should have returned a null hash");
     }
 
@@ -102,11 +98,10 @@ void emptyStreamProducesNull() {
     @DisplayName("Invalid leaf paths")
     void invalidLeafPaths() {
         final TestDataSource ds = new TestDataSource(Path.INVALID_PATH, Path.INVALID_PATH, CHUNK_HEIGHT);
-        final VirtualHasher hasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
         final List<VirtualLeafBytes> emptyLeaves = new ArrayList<>();
         // Empty dirty leaves stream -> null hash
         assertNull(
-                hasher.hash(
+                defaultHasher.hash(
                         CHUNK_HEIGHT,
                         ds::loadHashChunk,
                         emptyLeaves.iterator(),
@@ -115,23 +110,23 @@ void invalidLeafPaths() {
                         null),
                 "Call should have produced null");
         assertNull(
-                hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, emptyLeaves.iterator(), Path.INVALID_PATH, 2, null),
+                defaultHasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, emptyLeaves.iterator(), Path.INVALID_PATH, 2, null),
                 "Call should have produced null");
         assertNull(
-                hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, emptyLeaves.iterator(), 1, Path.INVALID_PATH, null),
+                defaultHasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, emptyLeaves.iterator(), 1, Path.INVALID_PATH, null),
                 "Call should have produced null");
         assertNull(
-                hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, emptyLeaves.iterator(), 0, 2, null),
+                defaultHasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, emptyLeaves.iterator(), 0, 2, null),
                 "Call should have produced null");
         assertNull(
-                hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, emptyLeaves.iterator(), 1, 0, null),
+                defaultHasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, emptyLeaves.iterator(), 1, 0, null),
                 "Call should have produced null");
         // Non-empty dirty leaves stream + empty leaf path range -> IllegalStateException
         final List<VirtualLeafBytes> nonEmptyLeaves = new ArrayList<>();
         nonEmptyLeaves.add(appleLeaf(VirtualTestBase.A_PATH));
         assertThrows(
                 IllegalArgumentException.class,
-                () -> hasher.hash(
+                () -> defaultHasher.hash(
                         CHUNK_HEIGHT,
                         ds::loadHashChunk,
                         nonEmptyLeaves.iterator(),
@@ -141,11 +136,11 @@ void invalidLeafPaths() {
                 "Non-null leaves iterator + invalid paths should throw an exception");
         assertThrows(
                 IllegalArgumentException.class,
-                () -> hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, nonEmptyLeaves.iterator(), 0, 2, null),
+                () -> defaultHasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, nonEmptyLeaves.iterator(), 0, 2, null),
                 "Non-null leaves iterator + invalid paths should throw an exception");
         assertThrows(
                 IllegalArgumentException.class,
-                () -> hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, nonEmptyLeaves.iterator(), 1, 0, null),
+                () -> defaultHasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, nonEmptyLeaves.iterator(), 1, 0, null),
                 "Non-null leaves iterator + invalid paths should throw an exception");
     }
 
@@ -168,11 +163,10 @@ void hashingPermutations(final long firstLeafPath, final long lastLeafPath, fina
             throws Exception {
         final TestDataSource ds = new TestDataSource(firstLeafPath, lastLeafPath, CHUNK_HEIGHT);
         final HashingListener listener = new HashingListener();
-        final VirtualHasher hasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
         final Hash expected = hashTree(ds);
         final List<VirtualLeafBytes> leaves = invalidateNodes(ds, dirtyPaths.stream());
-        final Hash rootHash =
-                hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, listener);
+        final Hash rootHash = defaultHasher.hash(
+                CHUNK_HEIGHT, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, listener);
         assertEquals(expected, rootHash, "Hash value does not match expected");
 
         // Make sure the saver saw each dirty node exactly once.
@@ -196,8 +190,8 @@ void hashingPermutations(final long firstLeafPath, final long lastLeafPath, fina
         assertEquals(savedChunks.size(), seenChunks.size(), "Expected equals");
         assertCallsAreBalanced(listener);
 
-        final Hash hashItAgain =
-                hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, listener);
+        final Hash hashItAgain = defaultHasher.hash(
+                CHUNK_HEIGHT, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, listener);
         assertEquals(expected, hashItAgain, "Hash value does not match expected");
 
         for (int i = 0; i < leaves.size(); i++) {
@@ -209,8 +203,8 @@ void hashingPermutations(final long firstLeafPath, final long lastLeafPath, fina
             }
         }
         leaves.sort(Comparator.comparing(VirtualLeafBytes::path));
-        final Hash hashItOnceMore =
-                hasher.hash(CHUNK_HEIGHT, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, listener);
+        final Hash hashItOnceMore = defaultHasher.hash(
+                CHUNK_HEIGHT, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, listener);
         assertEquals(expected, hashItOnceMore, "Hash value does not match expected");
     }
 
@@ -342,7 +336,6 @@ void repeatedTest(final int chunkHeight) throws Exception {
         final long firstLeafPath = 52L;
         final long lastLeafPath = firstLeafPath * 2;
         final TestDataSource ds = new TestDataSource(firstLeafPath, lastLeafPath, chunkHeight);
-        final VirtualHasher hasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
         final Hash expected = hashTree(ds);
         final List<Long> dirtyLeafPaths = List.of(
                 53L, 56L, 59L, 63L, 66L, 72L, 76L, 77L, 80L, 81L, 82L, 83L, 85L, 87L, 88L, 94L, 96L, 100L, 104L);
@@ -351,8 +344,8 @@ void repeatedTest(final int chunkHeight) throws Exception {
         // this will *likely* find it.
         for (int i = 0; i < 500; i++) {
             final List<VirtualLeafBytes> leaves = invalidateNodes(ds, dirtyLeafPaths.stream());
-            final Hash rootHash =
-                    hasher.hash(chunkHeight, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, null);
+            final Hash rootHash = defaultHasher.hash(
+                    chunkHeight, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, null);
             assertEquals(expected, rootHash, "Expected equals");
         }
 
@@ -365,7 +358,7 @@ public synchronized void onHashChunkHashed(final VirtualHashChunk chunk) {
         };
         for (int i = 0; i < 500; i++) {
             final List<VirtualLeafBytes> leaves = invalidateNodes(ds, dirtyLeafPaths.stream());
-            final Hash rootHash = hasher.hash(
+            final Hash rootHash = defaultHasher.hash(
                     chunkHeight, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, listener);
             assertEquals(expected, rootHash, "Expected equals");
         }
@@ -377,7 +370,6 @@ void testAllDirtyLeaves(final int chunkHeight) throws Exception {
         final long firstLeafPath = 801;
         final long lastLeafPath = firstLeafPath * 2;
         final TestDataSource ds = new TestDataSource(firstLeafPath, lastLeafPath, chunkHeight);
-        final VirtualHasher hasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
         final Hash expected = hashTree(ds);
         final List<Long> dirtyLeafPaths =
                 LongStream.range(firstLeafPath, lastLeafPath + 1).boxed().toList();
@@ -389,13 +381,13 @@ public synchronized void onHashChunkHashed(final VirtualHashChunk chunk) {
             }
         };
         final List<VirtualLeafBytes> leaves = invalidateNodes(ds, dirtyLeafPaths.stream());
-        final Hash rootHash =
-                hasher.hash(chunkHeight, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, listener);
+        final Hash rootHash = defaultHasher.hash(
+                chunkHeight, ds::loadHashChunk, leaves.iterator(), firstLeafPath, lastLeafPath, listener);
         assertEquals(expected, rootHash, "Expected equals");
 
         final List<VirtualLeafBytes> oneDirtyLeaf = List.of(ds.getLeaf((firstLeafPath + lastLeafPath) / 2));
-        final Hash hashItAgain =
-                hasher.hash(chunkHeight, ds::loadHashChunk, oneDirtyLeaf.iterator(), firstLeafPath, lastLeafPath, null);
+        final Hash hashItAgain = defaultHasher.hash(
+                chunkHeight, ds::loadHashChunk, oneDirtyLeaf.iterator(), firstLeafPath, lastLeafPath, null);
         assertEquals(expected, hashItAgain, "Expected equals");
     }
 
@@ -438,6 +430,7 @@ void listenerCallCounts() throws Exception {
 
         // Validate the calls were all balanced
         assertCallsAreBalanced(listener);
+        hasher.shutdown();
     }
 
     /**
@@ -451,7 +444,6 @@ void listenerCallCounts() throws Exception {
     @DisplayName("Verify the hasher does not ask for internal records it will recreate")
     void hasherDoesNotAskForInternalsItWillRecreate() {
         final HashingListener listener = new HashingListener();
-        final VirtualHasher hasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
 
         // We will simulate growing the tree from 53 leaves to 106 leaves (doubling the size) and providing
         // all new leaves. This will guarantee that some internal nodes live at the paths that leaves used
@@ -469,7 +461,8 @@ void hasherDoesNotAskForInternalsItWillRecreate() {
 
         assertDoesNotThrow(
                 () -> {
-                    hasher.hash(CHUNK_HEIGHT, hashChunkReader, dirtyLeaves, firstLeafPath, lastLeafPath, listener);
+                    defaultHasher.hash(
+                            CHUNK_HEIGHT, hashChunkReader, dirtyLeaves, firstLeafPath, lastLeafPath, listener);
                 },
                 "Hashing should not throw an exception");
     }

platform-sdk/swirlds-virtualmap/src/test/java/com/swirlds/virtualmap/internal/hash/VirtualHasherTestBase.java

@@ -24,12 +24,28 @@
 import java.util.stream.Stream;
 import org.hiero.base.crypto.Cryptography;
 import org.hiero.base.crypto.Hash;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.params.provider.Arguments;
 
-public class VirtualHasherTestBase extends VirtualTestBase {
+class VirtualHasherTestBase extends VirtualTestBase {
 
     protected static final int CHUNK_HEIGHT = VIRTUAL_MAP_CONFIG.hashChunkHeight();
 
+    protected VirtualHasher defaultHasher;
+
+    @BeforeEach
+    void setup() {
+        defaultHasher = new VirtualHasher(VIRTUAL_MAP_CONFIG);
+    }
+
+    @AfterEach
+    void tearDown() {
+        if (defaultHasher != null) {
+            defaultHasher.shutdown();
+        }
+    }
+
     /**
      * Helper method for computing a list of {@link Arguments} of length {@code num}, each of which contains
      * a random list of dirty leave paths between {@code firstLeafPath} and {@code lastLeafPath}.

platform-sdk/swirlds-virtualmap/src/test/java/com/swirlds/virtualmap/internal/reconnect/ReconnectHashListenerTest.java

@@ -128,6 +128,7 @@ void flushOrder(int size) {
             assertEquals(expected, path, "Path did not match expectation. path=" + path + ", expected=" + expected);
             expected++;
         }
+        hasher.shutdown();
     }
 
     private VirtualLeafBytes leaf(long path) {