Extending map tests with null as default value.

10 files changed, 139 insertions, 109 deletions

diff --git a/subprojects/store/src/jmh/java/tools/refinery/store/map/benchmarks/ImmutablePutExecutionPlan.java b/subprojects/store/src/jmh/java/tools/refinery/store/map/benchmarks/ImmutablePutExecutionPlan.java
index 756d504e..5484f115 100644
--- a/subprojects/store/src/jmh/java/tools/refinery/store/map/benchmarks/ImmutablePutExecutionPlan.java
+++ b/subprojects/store/src/jmh/java/tools/refinery/store/map/benchmarks/ImmutablePutExecutionPlan.java
@@ -35,7 +35,7 @@ public class ImmutablePutExecutionPlan {
         @Setup(Level.Trial)
         public void setUpTrial() {
                 random = new Random();
-                values = MapTestEnvironment.prepareValues(nValues);
+                values = MapTestEnvironment.prepareValues(nValues, true);
         }
 
         public VersionedMapImpl<Integer, String> createSut() {
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 1f9d022f..c872b9da 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
@@ -19,9 +19,10 @@ import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class CommitFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency,
+                                                         boolean evilHash) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue,nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
                 VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
@@ -64,30 +65,33 @@ class CommitFuzzTest {
                 }
         }
 
-        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " +
+                        "seed={6} evil-hash={7}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed,
+                                                          boolean evilHash) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
+                                new Object[] { 2, 3 }, new Object[]{false,true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5} " +
+                        "seed={6} evil-hash={7}")
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         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 93ecfec3..a5a68b94 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
@@ -20,9 +20,10 @@ import java.util.stream.Stream;
 import static org.junit.jupiter.api.Assertions.*;
 
 class ContentEqualsFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency,
                                                          boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
                 Random r = new Random(seed);
@@ -80,33 +81,33 @@ class ContentEqualsFuzzTest {
                 MapTestEnvironment.compareTwoMaps(scenario, sut1, sut2);
         }
 
-        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} " +
-                        "evil-hash={6}")
+        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit frequency={5}" +
+                        "seed={6} evil-hash={7}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                                                          boolean evilHash) {
+        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[]{FuzzTestUtils.FAST_STEP_COUNT}, new Object[]{3, 32,
                                                 32 * 32},
-                                new Object[]{2, 3}, new Object[]{1, 10, 100}, new Object[]{1, 2, 3},
+                                new Object[]{2, 3}, new Object[]{false,true}, new Object[]{1, 10, 100}, new Object[]{1, 2, 3},
                                 new Object[]{false, true});
         }
 
-        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} " +
-                        "evil-hash={6}")
+        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit frequency={5}" +
+                        "seed={6} evil-hash={7}")
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                                                          boolean evilHash) {
+        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, boolean defaultNull, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                defaultNull, commitFrequency, evilHash);
         }
 
         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 e6334224..670b5445 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
@@ -20,17 +20,18 @@ import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class DiffCursorFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency,
                         boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
                 VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
-                iterativeRandomPutsAndCommitsThenDiffcursor(scenario, store, steps, maxKey, values, seed, commitFrequency);
+                iterativeRandomPutsAndCommitsThenDiffCursor(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
 
-        private void iterativeRandomPutsAndCommitsThenDiffcursor(String scenario, VersionedMapStore<Integer, String> store,
-                        int steps, int maxKey, String[] values, int seed, int commitFrequency) {
+        private void iterativeRandomPutsAndCommitsThenDiffCursor(String scenario, VersionedMapStore<Integer, String> store,
+                                                                                                                         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();
@@ -86,29 +87,33 @@ class DiffCursorFuzzTest {
 
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
+                        "commit frequency={5} seed={6} evil-hash={7}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        void parametrizedFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                  int seed,
                         boolean evilHash) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, commitFrequency, evilHash);
+                                noKeys, noValues, nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
+                                new Object[] { 2, 3 }, new Object[]{false,true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
+                        "commit frequency={5} seed={6} evil-hash={7}")
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed,
                         boolean evilHash) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         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 1ab431a8..d8e1a30f 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
@@ -22,31 +22,32 @@ import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class MultiThreadFuzzTest {
         public static final int noThreads = 32;
-        
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
+
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency,
+                                                         boolean evilHash) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue,nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
                 VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
-                
+
                 // 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);
                 }
-                
+
                 // initialize threads
                 Thread[] threads = new Thread[noThreads];
                 for(int i = 0; i<noThreads; i++) {
                         threads[i] = new Thread(runnables[i]);
                 }
-                
+
                 // start threads;
                 for(int i = 0; i<noThreads; i++) {
                         threads[i].start();
                 }
-                
+
                 // wait all the threads;
                 for(int i = 0; i<noThreads; i++) {
                         try {
@@ -55,40 +56,42 @@ class MultiThreadFuzzTest {
                                 fail("Thread "+i+" interrupted.");
                         }
                 }
-                
+
                 // collect errors
                 List<Throwable> errors = new LinkedList<>();
                 for(int i = 0; i<noThreads; i++) {
                         errors.addAll(runnables[i].getErrors());
                 }
-                
+
                 assertEquals(Collections.EMPTY_LIST, errors);
         }
 
-        @ParameterizedTest(name = "Multithread {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Multithread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " +
+                        "frequency={5} seed={6} evil-hash={7}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
-                runFuzzTest("MultithreadS" + steps + "K" + noKeys + "V" + noValues + "CF" + commitFrequency + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, boolean defaultNull, int commitFrequency,
+                                                          int seed, boolean evilHash) {
+                runFuzzTest("MultithreadS" + steps + "K" + noKeys + "V" + noValues + defaultNull + "CF" + commitFrequency +
+                                "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 10, 100 }, new Object[] { 1, 2, 3 },
+                                new Object[] { 2, 3 }, new Object[]{false, true}, new Object[] { 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Multithread {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Multithread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " +
+                        "frequency={5} seed={6} evil-hash={7}")
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency, int seed,
+                                                          boolean evilHash) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
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 d40c49c4..008258bd 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
@@ -19,8 +19,9 @@ 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 evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, boolean evilHash) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue,nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
                 VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
@@ -60,30 +61,34 @@ class MutableFuzzTest {
                 }
         }
 
-        @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} seed={4} evil-hash={5}")
+        @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} seed={5} " +
+                        "evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFuzz(int test, int steps, int noKeys, int noValues, int seed, boolean evilHash) {
+        void parametrizedFuzz(int test, int steps, int noKeys, int noValues, boolean defaultNull, int seed,
+                                                  boolean evilHash) {
                 runFuzzTest(
                                 "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
-                                seed, steps, noKeys, noValues, evilHash);
+                                seed, steps, noKeys, noValues, defaultNull, evilHash);
         }
 
         static Stream<Arguments> parametrizedFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT },
-                                new Object[] { 3, 32, 32 * 32, 32 * 32 * 32 * 32 }, new Object[] { 2, 3 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                                new Object[] { 3, 32, 32 * 32, 32 * 32 * 32 * 32 }, new Object[] { 2, 3 }, new Object[] { false, true },
+                                new Object[] { 1, 2, 3 }, new Object[] { false, true });
         }
-        
-        @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} seed={4} evil-hash={5}")
+
+        @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} seed={5} " +
+                        "evil-hash={6}")
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int test, int steps, int noKeys, int noValues, int seed, boolean evilHash) {
+        void parametrizedSlowFuzz(int test, int steps, int noKeys, int noValues, boolean nullDefault, int seed,
+                                                          boolean evilHash) {
                 runFuzzTest(
                                 "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
-                                seed, steps, noKeys, noValues, evilHash);
+                                seed, steps, noKeys, noValues, nullDefault, evilHash);
         }
 
         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 410705a2..6e15b8ca 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
@@ -19,9 +19,9 @@ import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class MutableImmutableCompareFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency, boolean evilHash) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
                 VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
@@ -57,30 +57,32 @@ class MutableImmutableCompareFuzzTest {
                 }
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
+                        "commit frequency={5} seed={6} evil-hash={7}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("fuzz")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, commitFrequency, evilHash);
+                                noKeys, noValues, nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
+                                new Object[] { 2, 3 }, new Object[]{false,true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} " +
+                        "commit frequency={5} seed={6} evil-hash={7}")
         @MethodSource
         @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, commitFrequency, evilHash);
+                                noKeys, noValues, nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
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 2e29a03f..35a54712 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
@@ -21,9 +21,10 @@ import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class RestoreFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency,
                         boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
                 VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
@@ -77,30 +78,32 @@ class RestoreFuzzTest {
 
         }
 
-        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5}" +
+                        " seed={6} evil-hash={7}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("smoke")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
+                                new Object[] { 2, 3 }, new Object[]{false, true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit frequency={5}" +
+                        " seed={6} evil-hash={7}")
         @MethodSource
         @Tag("smoke")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         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 914a0f63..ac033edb 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
@@ -21,9 +21,9 @@ import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 class SharedStoreFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
-                        boolean evilHash) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue);
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
+                                                         boolean nullDefault, int commitFrequency, boolean evilHash) {
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
                 List<VersionedMapStore<Integer, String>> stores = VersionedMapStoreImpl.createSharedVersionedMapStores(5, chp, values[0]);
@@ -39,7 +39,7 @@ class SharedStoreFuzzTest {
                 for(VersionedMapStore<Integer, String> store : stores) {
                         versioneds.add((VersionedMapImpl<Integer, String>) store.createMap());
                 }
-                                
+
                 List<Map<Integer, Long>> index2Version = new LinkedList<>();
                 for(int i = 0; i<stores.size(); i++) {
                         index2Version.add(new HashMap<>());
@@ -56,7 +56,7 @@ class SharedStoreFuzzTest {
                                         index2Version.get(storeIndex).put(i, version);
                                 }
                                 MapTestEnvironment.printStatus(scenario, stepIndex, steps, "building");
-                        }               
+                        }
                 }
                 // 2. create a non-versioned and
                 List<VersionedMapImpl<Integer, String>> reference = new LinkedList<>();
@@ -76,35 +76,37 @@ class SharedStoreFuzzTest {
                                         MapTestEnvironment.compareTwoMaps(scenario + ":" + index, reference.get(storeIndex), versioneds.get(storeIndex));
                                 }
                         }
-                        MapTestEnvironment.printStatus(scenario, index, steps, "comparison");   
+                        MapTestEnvironment.printStatus(scenario, index, steps, "comparison");
                 }
 
         }
 
-        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit " +
+                        "frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("smoke")
-        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedFastFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("SharedS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
-                                new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
+                                new Object[] { 2, 3 }, new Object[]{false, true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} commit " +
+                        "frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Tag("smoke")
         @Tag("slow")
-        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
-                        boolean evilHash) {
+        void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
+                                                          int seed, boolean evilHash) {
                 runFuzzTest("SharedS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
-                                commitFrequency, evilHash);
+                                nullDefault, commitFrequency, evilHash);
         }
 
         static Stream<Arguments> parametrizedSlowFuzz() {
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java
index 2d03ebaf..10ea2796 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/utils/MapTestEnvironment.java
@@ -9,9 +9,14 @@ import java.util.Map.Entry;
 import static org.junit.jupiter.api.Assertions.*;
 
 public class MapTestEnvironment<K, V> {
-        public static String[] prepareValues(int maxValue) {
+        public static String[] prepareValues(int maxValue, boolean nullDefault) {
                 String[] values = new String[maxValue];
-                values[0] = "DEFAULT";
+                if(nullDefault) {
+                        values[0] = null;
+                } else {
+                        values[0] = "DEFAULT";
+                }
+
                 for (int i = 1; i < values.length; i++) {
                         values[i] = "VAL" + i;
                 }