Fuzz test environment is parametrized by VersionedMapStoreBuilder configurations

10 files changed, 161 insertions, 135 deletions

diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java
index b61152f5..14a9e2e0 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/CommitFuzzTest.java
@@ -11,10 +11,8 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import tools.refinery.store.map.ContinousHashProvider;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.VersionedMapStoreBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
@@ -23,13 +21,11 @@ import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 class CommitFuzzTest {
 
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
-                                                         boolean nullDefault, int commitFrequency,
-                                                         boolean evilHash) {
+                                                         boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
-                VersionedMapImpl<Integer, String> sut = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                var sut = store.createMap();
                 MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
                 Random r = new Random(seed);
@@ -52,37 +48,37 @@ class CommitFuzzTest {
                         }
                         MapTestEnvironment.printStatus(scenario, index, steps, null);
                         if (index % commitFrequency == 0) {
-                                e.sut.commit();
+                                e.commit();
                         }
                 }
         }
 
-        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " +
-                        "seed={6} evil-hash={7}")
+        public static final String title = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " +
+                        "seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed,
-                                                          boolean evilHash) {
+                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                nullDefault, commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
-                                commitFrequencyOptions, randomSeedOptions, evilHashOptions);
+                                commitFrequencyOptions, randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " +
-                        "seed={6} evil-hash={7}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, boolean evilHash) {
+                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                nullDefault, commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java
index c17b0a95..b462ed40 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/ContentEqualsFuzzTest.java
@@ -6,7 +6,6 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 import tools.refinery.store.map.*;
-import tools.refinery.store.map.internal.VersionedMapImpl;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
@@ -22,20 +21,19 @@ import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 
 class ContentEqualsFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
-                                                         boolean nullDefault, int commitFrequency,
-                                                         boolean evilHash) {
+                                                         boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
+
 
                 Random r = new Random(seed);
 
-                iterativeRandomPutsAndCommitsThenCompare(scenario, chp, steps, maxKey, values, r, commitFrequency);
+                iterativeRandomPutsAndCommitsThenCompare(scenario, builder, steps, maxKey, values, r, commitFrequency);
         }
 
-        private void iterativeRandomPutsAndCommitsThenCompare(String scenario, ContinousHashProvider<Integer> chp,
+        private void iterativeRandomPutsAndCommitsThenCompare(String scenario, VersionedMapStoreBuilder<Integer, String> builder,
                                                                                                                   int steps, int maxKey, String[] values, Random r,
                                                                                                                   int commitFrequency) {
-                VersionedMapStore<Integer, String> store1 = new VersionedMapStoreImpl<>(chp, values[0]);
+                VersionedMapStore<Integer, String> store1 = builder.setDefaultValue(values[0]).buildOne();
                 VersionedMap<Integer, String> sut1 = store1.createMap();
 
                 // Fill one map
@@ -65,7 +63,7 @@ class ContentEqualsFuzzTest {
                 // Randomize the order of the content
                 Collections.shuffle(content, r);
 
-                VersionedMapStore<Integer, String> store2 = new VersionedMapStoreImpl<>(chp, values[0]);
+                VersionedMapStore<Integer, String> store2 = builder.setDefaultValue(values[0]).buildOne();
                 VersionedMap<Integer, String> sut2 = store2.createMap();
                 int index2 = 1;
                 for (SimpleEntry<Integer, String> entry : content) {
@@ -75,38 +73,39 @@ class ContentEqualsFuzzTest {
                 }
 
                 // Check the integrity of the maps
-                ((VersionedMapImpl<Integer, String>) sut1).checkIntegrity();
-                ((VersionedMapImpl<Integer, String>) sut2).checkIntegrity();
+                sut1.checkIntegrity();
+                sut2.checkIntegrity();
 
                 // Compare the two maps
                 MapTestEnvironment.compareTwoMaps(scenario, sut1, sut2);
         }
 
-        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit frequency={5}" +
-                        "seed={6} evil-hash={7}")
+        public static final String title = "Compare {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit frequency={5}" +
+                        "seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, boolean evilHash) {
+                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                nullDefault, commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
-                                commitFrequencyOptions, randomSeedOptions, evilHashOptions);
+                                commitFrequencyOptions, randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit frequency={5}" +
-                        "seed={6} evil-hash={7}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int commitFrequency,
-                                                          int seed, boolean evilHash) {
+                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                defaultNull, commitFrequency, evilHash);
+                                defaultNull, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java
index 90aa8e01..bf409a74 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/DiffCursorFuzzTest.java
@@ -1,33 +1,26 @@
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.fail;
-import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
-
-import java.util.Random;
-import java.util.stream.Stream;
-
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
-
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.map.DiffCursor;
-import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.*;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.Random;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
 class DiffCursorFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
-                                                         boolean nullDefault, int commitFrequency,
-                                                         boolean evilHash) {
+                                                         boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
+                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
                 iterativeRandomPutsAndCommitsThenDiffCursor(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
 
@@ -35,7 +28,7 @@ class DiffCursorFuzzTest {
                                                                                                                          int steps, int maxKey, String[] values, int seed, int commitFrequency) {
                 // 1. build a map with versions
                 Random r = new Random(seed);
-                VersionedMapImpl<Integer, String> versioned = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMap<Integer, String> versioned = store.createMap();
                 int largestCommit = -1;
 
                 for (int i = 0; i < steps; i++) {
@@ -56,7 +49,7 @@ class DiffCursorFuzzTest {
                                 System.out.println(scenario + ":" + index + "/" + steps + " building finished");
                 }
                 // 2. create a non-versioned map,
-                VersionedMapImpl<Integer, String> moving = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMap<Integer, String> moving = store.createMap();
                 Random r2 = new Random(seed + 1);
 
                 final int diffTravelFrequency = commitFrequency * 2;
@@ -88,31 +81,32 @@ class DiffCursorFuzzTest {
 
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
-                        "commit frequency={5} seed={6} evil-hash={7}")
+        public static final String title = "DiffCursor {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
+                        "commit frequency={5} seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                  int seed, boolean evilHash) {
+                                                  int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, nullDefault, commitFrequency, evilHash);
+                                noKeys, noValues, nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedFuzz() {
-                return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
-                                commitFrequencyOptions, randomSeedOptions, evilHashOptions);
+                return FuzzTestUtils.permutationWithSize(new Object[]{100}, keyCounts, valueCounts, nullDefaultOptions,
+                                commitFrequencyOptions, randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
-                        "commit frequency={5} seed={6} evil-hash={7}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, boolean evilHash) {
+                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                nullDefault, commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java
index 9325a938..ec2224b4 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadFuzzTest.java
@@ -15,27 +15,24 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import tools.refinery.store.map.ContinousHashProvider;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
+import tools.refinery.store.map.VersionedMapStoreBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class MultiThreadFuzzTest {
-        public static final int noThreads = 32;
+        public static final int noThreads = 10;
 
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
-                                                         boolean nullDefault, int commitFrequency,
-                                                         boolean evilHash) {
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
+                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
 
                 // initialize runnables
                 MultiThreadTestRunnable[] runnables = new MultiThreadTestRunnable[noThreads];
                 for (int i = 0; i < noThreads; i++) {
-                        runnables[i] = new MultiThreadTestRunnable(scenario + "-T" + (i + 1), store, steps, maxKey, values, seed, commitFrequency);
+                        runnables[i] = new MultiThreadTestRunnable(scenario + "-T" + (i + 1), store, steps, maxKey, values, seed
+                                         , commitFrequency);
                 }
 
                 // initialize threads
@@ -46,7 +43,8 @@ class MultiThreadFuzzTest {
 
                 // start threads;
                 for (int i = 0; i < noThreads; i++) {
-                        threads[i].start();
+                        runnables[i].run();
+                        //threads[i].start();
                 }
 
                 // wait all the threads;
@@ -67,32 +65,32 @@ class MultiThreadFuzzTest {
                 assertEquals(Collections.EMPTY_LIST, errors);
         }
 
-        @ParameterizedTest(name = "MultiThread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " +
-                        "frequency={5} seed={6} evil-hash={7}")
+        static final String title = "MultiThread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " +
+                         "frequency={5} seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int commitFrequency,
-                                                          int seed, boolean evilHash) {
+        void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull,
+                                                           int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("MultiThreadS" + steps + "K" + noKeys + "V" + noValues + defaultNull + "CF" + commitFrequency +
-                                "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, evilHash);
+                                 "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
-                                new Object[]{10, 100}, randomSeedOptions,
-                                evilHashOptions);
+                                 new Object[]{10, 100}, randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "MultiThread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " +
-                        "frequency={5} seed={6} evil-hash={7}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, int seed,
-                                                          boolean evilHash) {
+        void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
+                                                          int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                nullDefault, commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java
index 4415e4e5..f449ca97 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MultiThreadTestRunnable.java
@@ -8,8 +8,8 @@ import java.util.List;
 import java.util.Map;
 import java.util.Random;
 
+import tools.refinery.store.map.VersionedMap;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.internal.VersionedMapImpl;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 public class MultiThreadTestRunnable implements Runnable {
@@ -45,9 +45,17 @@ public class MultiThreadTestRunnable implements Runnable {
 
         @Override
         public void run() {
+                try{
+                        task();
+                } catch(Exception e) {
+                        e.printStackTrace();
+                }
+        }
+
+        private void task() {
                 // 1. build a map with versions
                 Random r = new Random(seed);
-                VersionedMapImpl<Integer, String> versioned = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMap<Integer, String> versioned =  store.createMap();
                 Map<Integer, Long> index2Version = new HashMap<>();
 
                 for (int i = 0; i < steps; i++) {
@@ -67,7 +75,7 @@ public class MultiThreadTestRunnable implements Runnable {
                         MapTestEnvironment.printStatus(scenario, index, steps, "building");
                 }
                 // 2. create a non-versioned
-                VersionedMapImpl<Integer, String> reference = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMap<Integer, String> reference = store.createMap();
                 r = new Random(seed);
                 Random r2 = new Random(seed + 1);
 
@@ -84,13 +92,17 @@ public class MultiThreadTestRunnable implements Runnable {
                         // go back to an existing state and compare to the reference
                         if (index % (commitFrequency) == 0) {
                                 versioned.restore(index2Version.get(i));
-                                MapTestEnvironment.compareTwoMaps(scenario + ":" + index, reference, versioned, errors);
+                                MapTestEnvironment.compareTwoMaps(scenario + ":" + index, reference, versioned, null);
 
                                 // go back to a random state (probably created by another thread)
                                 List<Long> states = new ArrayList<>(store.getStates());
+                                states.sort(Long::compare);
                                 Collections.shuffle(states, r2);
                                 for (Long state : states.subList(0, Math.min(states.size(), 100))) {
-                                        versioned.restore(state);
+                                        long x = state;
+                                        versioned.restore(x);
+                                        var clean = store.createMap(x);
+                                        MapTestEnvironment.compareTwoMaps(scenario + ":" + index, clean, versioned, null);
                                 }
                                 versioned.restore(index2Version.get(i));
                         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java
index ab37ef83..bdf72ce4 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableFuzzTest.java
@@ -12,21 +12,17 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.*;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class MutableFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
-                                                         boolean nullDefault, boolean evilHash) {
+                                                         boolean nullDefault, VersionedMapStoreBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
-                VersionedMapImpl<Integer, String> sut = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMap<Integer, String> sut = store.createMap();
                 MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
                 Random r = new Random(seed);
@@ -52,33 +48,34 @@ class MutableFuzzTest {
                 }
         }
 
-        @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} seed={5} " +
-                        "evil-hash={6}")
+        final String title = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} seed={5} " +
+                        "config={6}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int seed,
-                                                  boolean evilHash) {
+                                                  VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest(
-                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
-                                seed, steps, noKeys, noValues, defaultNull, evilHash);
+                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed,
+                                seed, steps, noKeys, noValues, defaultNull, builder);
         }
 
         static Stream<Arguments> parametrizedFuzz() {
                 return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
-                                randomSeedOptions, evilHashOptions);
+                                randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} seed={5} " +
-                        "evil-hash={6}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int seed,
-                                                          boolean evilHash) {
+                                                         VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest(
-                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
-                                seed, steps, noKeys, noValues, nullDefault, evilHash);
+                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed,
+                                seed, steps, noKeys, noValues, nullDefault, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java
index b58b06f9..cee15fe1 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/MutableImmutableCompareFuzzTest.java
@@ -71,7 +71,7 @@ class MutableImmutableCompareFuzzTest {
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
-                                commitFrequencyOptions, randomSeedOptions, evilHashOptions);
+                                commitFrequencyOptions, randomSeedOptions, new Object[]{false, true});
         }
 
         @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java
index 77b26c41..568aaac9 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/RestoreFuzzTest.java
@@ -14,9 +14,7 @@ import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
-import tools.refinery.store.map.ContinousHashProvider;
-import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreImpl;
+import tools.refinery.store.map.*;
 import tools.refinery.store.map.internal.VersionedMapImpl;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
@@ -24,11 +22,10 @@ import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 class RestoreFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
                                                          boolean nullDefault, int commitFrequency,
-                                                         boolean evilHash) {
+                                                         VersionedMapStoreBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
-                ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
+                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
 
                 iterativeRandomPutsAndCommitsThenRestore(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
@@ -37,7 +34,7 @@ class RestoreFuzzTest {
                                                                                                                   int steps, int maxKey, String[] values, int seed, int commitFrequency) {
                 // 1. build a map with versions
                 Random r = new Random(seed);
-                VersionedMapImpl<Integer, String> versioned = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMap<Integer, String> versioned = store.createMap();
                 Map<Integer, Long> index2Version = new HashMap<>();
 
                 for (int i = 0; i < steps; i++) {
@@ -57,7 +54,7 @@ class RestoreFuzzTest {
                         MapTestEnvironment.printStatus(scenario, index, steps, "building");
                 }
                 // 2. create a non-versioned and
-                VersionedMapImpl<Integer, String> reference = (VersionedMapImpl<Integer, String>) store.createMap();
+                VersionedMap<Integer, String> reference = store.createMap();
                 r = new Random(seed);
 
                 for (int i = 0; i < steps; i++) {
@@ -79,31 +76,32 @@ class RestoreFuzzTest {
 
         }
 
-        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5}" +
-                        " seed={6} evil-hash={7}")
+        public static final String title = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " +
+                        "seed={6} config={7}";
+
+        @ParameterizedTest(name = title)
         @MethodSource
         @Timeout(value = 10)
         @Tag("smoke")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, boolean evilHash) {
+                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                nullDefault, commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
-                                commitFrequencyOptions, randomSeedOptions, evilHashOptions);
+                                commitFrequencyOptions, randomSeedOptions, storeConfigs);
         }
 
-        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5}" +
-                        " seed={6} evil-hash={7}")
+        @ParameterizedTest(name = title)
         @MethodSource
         @Tag("smoke")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, boolean evilHash) {
+                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                nullDefault, commitFrequency, evilHash);
+                                nullDefault, commitFrequency, builder);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java
index 4462c55b..0544687a 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SharedStoreFuzzTest.java
@@ -96,7 +96,7 @@ class SharedStoreFuzzTest {
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(stepCounts, keyCounts, valueCounts, nullDefaultOptions,
-                                commitFrequencyOptions, randomSeedOptions, evilHashOptions);
+                                commitFrequencyOptions, randomSeedOptions, new Object[]{false, true});
         }
 
         @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit " +
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java
index add4ca5d..fb6b28d8 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestCollections.java
@@ -1,11 +1,43 @@
 package tools.refinery.store.map.tests.fuzz.utils;
 
+import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.tests.utils.MapTestEnvironment;
+
 public final class FuzzTestCollections {
         public static final Object[] stepCounts = {FuzzTestUtils.FAST_STEP_COUNT};
-        public static final Object[] keyCounts = {3, 32, 32 * 32};
+        public static final Object[] keyCounts = {1, 32, 32 * 32};
         public static final Object[] valueCounts = {2, 3};
         public static final Object[] nullDefaultOptions = {false, true};
-        public static final Object[] commitFrequencyOptions = {1, 10, 100};
-        public static final Object[] randomSeedOptions = {1, 2, 3};
-        public static final Object[] evilHashOptions = {false, true};
+        public static final Object[] commitFrequencyOptions = {10, 10, 100};
+        public static final Object[] randomSeedOptions = {1/*, 2, 3*/};
+        public static final Object[] storeConfigs = {
+                        // State based
+                        VersionedMapStoreBuilder.<Integer,String>builder()
+                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
+                                        .setStateBasedImmutableWhenCommitting(true)
+                                        .setHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.SHARED_NODE_CACHE),
+                        VersionedMapStoreBuilder.<Integer,String>builder()
+                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
+                                        .setStateBasedImmutableWhenCommitting(true)
+                                        .setHashProvider(MapTestEnvironment.prepareHashProvider(true))
+                                        .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.SHARED_NODE_CACHE),
+                        VersionedMapStoreBuilder.<Integer,String>builder()
+                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
+                                        .setStateBasedImmutableWhenCommitting(false)
+                                        .setHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.SHARED_NODE_CACHE),
+                        VersionedMapStoreBuilder.<Integer,String>builder()
+                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
+                                        .setStateBasedImmutableWhenCommitting(false)
+                                        .setHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.NO_NODE_CACHE),
+                        // Delta based
+                        VersionedMapStoreBuilder.<Integer,String>builder()
+                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.DELTA)
+                                        .setDeltaStorageStrategy(VersionedMapStoreBuilder.DeltaStorageStrategy.SET),
+                        VersionedMapStoreBuilder.<Integer,String>builder()
+                                        .setStrategy(VersionedMapStoreBuilder.StoreStrategy.DELTA)
+                                        .setDeltaStorageStrategy(VersionedMapStoreBuilder.DeltaStorageStrategy.LIST)
+        };
 }