Formatting fuzz tests + improving code qualitz

12 files changed, 107 insertions, 129 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 c872b9da..cd32337e 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
@@ -22,12 +22,12 @@ class CommitFuzzTest {
         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);
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
                 VersionedMapImpl<Integer, String> sut = (VersionedMapImpl<Integer, String>) store.createMap();
-                MapTestEnvironment<Integer, String> e = new MapTestEnvironment<Integer, String>(sut);
+                MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
                 Random r = new Random(seed);
 
@@ -35,24 +35,13 @@ class CommitFuzzTest {
         }
 
         private void iterativeRandomPutsAndCommits(String scenario, int steps, int maxKey, String[] values,
-                        MapTestEnvironment<Integer, String> e, Random r, int commitFrequency) {
-                int stopAt = -1;
+                                                                                           MapTestEnvironment<Integer, String> e, Random r, int commitFrequency) {
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
                         int nextKey = r.nextInt(maxKey);
                         String nextValue = values[r.nextInt(values.length)];
-                        if (index == stopAt) {
-                                System.out.println("issue!");
-                                System.out.println("State before:");
-                                e.printComparison();
-                                e.sut.prettyPrint();
-                                System.out.println("Next: put(" + nextKey + "," + nextValue + ")");
-                        }
                         try {
                                 e.put(nextKey, nextValue);
-                                if (index == stopAt) {
-                                        e.sut.prettyPrint();
-                                }
                                 e.checkEquivalence(scenario + ":" + index);
                         } catch (Exception exception) {
                                 exception.printStackTrace();
@@ -78,9 +67,9 @@ class CommitFuzzTest {
         }
 
         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[]{false,true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(new Object[]{FuzzTestUtils.FAST_STEP_COUNT}, new Object[]{3, 32, 32 * 32},
+                                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} nullDefault={4} commit frequency={5} " +
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 a5a68b94..996bfa03 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
@@ -34,7 +34,7 @@ class ContentEqualsFuzzTest {
         private void iterativeRandomPutsAndCommitsThenCompare(String scenario, ContinousHashProvider<Integer> chp,
                                                                                                                   int steps, int maxKey, String[] values, Random r,
                                                                                                                   int commitFrequency) {
-                VersionedMapStore<Integer, String> store1 = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapStore<Integer, String> store1 = new VersionedMapStoreImpl<>(chp, values[0]);
                 VersionedMap<Integer, String> sut1 = store1.createMap();
 
                 // Fill one map
@@ -64,7 +64,7 @@ class ContentEqualsFuzzTest {
                 // Randomize the order of the content
                 Collections.shuffle(content, r);
 
-                VersionedMapStore<Integer, String> store2 = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapStore<Integer, String> store2 = new VersionedMapStoreImpl<>(chp, values[0]);
                 VersionedMap<Integer, String> sut2 = store2.createMap();
                 int index2 = 1;
                 for (SimpleEntry<Integer, String> entry : content) {
@@ -95,7 +95,7 @@ class ContentEqualsFuzzTest {
         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[]{false,true}, 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});
         }
 
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 670b5445..4f7f48b5 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
@@ -22,11 +22,11 @@ import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 class DiffCursorFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
                                                          boolean nullDefault, int commitFrequency,
-                        boolean evilHash) {
+                                                         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]);
+                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
                 iterativeRandomPutsAndCommitsThenDiffCursor(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
 
@@ -62,7 +62,7 @@ class DiffCursorFuzzTest {
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
                         if (index % diffTravelFrequency == 0) {
-                                // difftravel
+                                // diff-travel
                                 long travelToVersion = r2.nextInt(largestCommit + 1);
                                 DiffCursor<Integer, String> diffCursor = moving.getDiffCursor(travelToVersion);
                                 moving.putAll(diffCursor);
@@ -94,16 +94,17 @@ class DiffCursorFuzzTest {
         @Tag("fuzz")
         void parametrizedFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
                                                   int seed,
-                        boolean evilHash) {
+                                                  boolean evilHash) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
                                 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[]{false,true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(new Object[]{FuzzTestUtils.FAST_STEP_COUNT}, new Object[]{3, 32, 32 * 32},
+                                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} nullDefault={4} " +
                         "commit frequency={5} seed={6} evil-hash={7}")
         @MethodSource
@@ -111,7 +112,7 @@ class DiffCursorFuzzTest {
         @Tag("slow")
         void parametrizedSlowFuzz(int tests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
                                                           int seed,
-                        boolean evilHash) {
+                                                          boolean evilHash) {
                 runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, evilHash);
         }
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 d8e1a30f..5412d958 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
@@ -26,64 +26,64 @@ class MultiThreadFuzzTest {
         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);
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(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);
+                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++) {
+                for (int i = 0; i < noThreads; i++) {
                         threads[i] = new Thread(runnables[i]);
                 }
 
                 // start threads;
-                for(int i = 0; i<noThreads; i++) {
+                for (int i = 0; i < noThreads; i++) {
                         threads[i].start();
                 }
 
                 // wait all the threads;
-                for(int i = 0; i<noThreads; i++) {
+                for (int i = 0; i < noThreads; i++) {
                         try {
                                 threads[i].join();
                         } catch (InterruptedException e) {
-                                fail("Thread "+i+" interrupted.");
+                                fail("Thread " + i + " interrupted.");
                         }
                 }
 
                 // collect errors
                 List<Throwable> errors = new LinkedList<>();
-                for(int i = 0; i<noThreads; i++) {
+                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} defaultNull={4} commit " +
+        @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, 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);
+                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[]{false, true}, new Object[] { 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(new Object[]{FuzzTestUtils.FAST_STEP_COUNT}, new Object[]{3, 32, 32 * 32},
+                                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} defaultNull={4} commit " +
+        @ParameterizedTest(name = "MultiThread {index}/{0} Steps={1} Keys={2} Values={3} defaultNull={4} commit " +
                         "frequency={5} seed={6} evil-hash={7}")
         @MethodSource
         @Tag("fuzz")
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 f77f9ee5..4415e4e5 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
@@ -13,17 +13,17 @@ import tools.refinery.store.map.internal.VersionedMapImpl;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 public class MultiThreadTestRunnable implements Runnable {
-        String scenario;
-        VersionedMapStore<Integer, String> store;
-        int steps;
-        int maxKey;
-        String[] values;
-        int seed;
-        int commitFrequency;
-        List<Throwable> errors = new LinkedList<>();
-        
+        final String scenario;
+        final VersionedMapStore<Integer, String> store;
+        final int steps;
+        final int maxKey;
+        final String[] values;
+        final int seed;
+        final int commitFrequency;
+        final List<Throwable> errors = new LinkedList<>();
+
         public MultiThreadTestRunnable(String scenario, VersionedMapStore<Integer, String> store, int steps,
-                        int maxKey, String[] values, int seed, int commitFrequency) {
+                                                                   int maxKey, String[] values, int seed, int commitFrequency) {
                 super();
                 this.scenario = scenario;
                 this.store = store;
@@ -38,11 +38,11 @@ public class MultiThreadTestRunnable implements Runnable {
                 AssertionError error = new AssertionError(message);
                 errors.add(error);
         }
-        
+
         public List<Throwable> getErrors() {
                 return errors;
         }
-        
+
         @Override
         public void run() {
                 // 1. build a map with versions
@@ -66,10 +66,10 @@ public class MultiThreadTestRunnable implements Runnable {
                         }
                         MapTestEnvironment.printStatus(scenario, index, steps, "building");
                 }
-                // 2. create a non-versioned 
+                // 2. create a non-versioned
                 VersionedMapImpl<Integer, String> reference = (VersionedMapImpl<Integer, String>) store.createMap();
                 r = new Random(seed);
-                Random r2 = new Random(seed+1);
+                Random r2 = new Random(seed + 1);
 
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
@@ -84,12 +84,12 @@ 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, errors);
+
                                 // go back to a random state (probably created by another thread)
                                 List<Long> states = new ArrayList<>(store.getStates());
                                 Collections.shuffle(states, r2);
-                                for(Long state : states.subList(0, Math.min(states.size(), 100))) {
+                                for (Long state : states.subList(0, Math.min(states.size(), 100))) {
                                         versioned.restore(state);
                                 }
                                 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 008258bd..2448268a 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
@@ -21,12 +21,12 @@ 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) {
-                String[] values = MapTestEnvironment.prepareValues(maxValue,nullDefault);
+                String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
                 VersionedMapImpl<Integer, String> sut = (VersionedMapImpl<Integer, String>) store.createMap();
-                MapTestEnvironment<Integer, String> e = new MapTestEnvironment<Integer, String>(sut);
+                MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
                 Random r = new Random(seed);
 
@@ -34,24 +34,14 @@ class MutableFuzzTest {
         }
 
         private void iterativeRandomPuts(String scenario, int steps, int maxKey, String[] values,
-                        MapTestEnvironment<Integer, String> e, Random r) {
-                int stopAt = -1;
+                                                                         MapTestEnvironment<Integer, String> e, Random r) {
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
                         int nextKey = r.nextInt(maxKey);
                         String nextValue = values[r.nextInt(values.length)];
-                        if (index == stopAt) {
-                                System.out.println("issue!");
-                                System.out.println("State before:");
-                                e.printComparison();
-                                e.sut.prettyPrint();
-                                System.out.println("Next: put(" + nextKey + "," + nextValue + ")");
-                        }
+
                         try {
                                 e.put(nextKey, nextValue);
-                                if (index == stopAt) {
-                                        e.sut.prettyPrint();
-                                }
                                 e.checkEquivalence(scenario + ":" + index);
                         } catch (Exception exception) {
                                 exception.printStackTrace();
@@ -74,9 +64,9 @@ class MutableFuzzTest {
         }
 
         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[] { false, true },
-                                new Object[] { 1, 2, 3 }, new Object[] { false, true });
+                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[]{false, true},
+                                new Object[]{1, 2, 3}, new Object[]{false, true});
         }
 
         @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} nullDefault={4} seed={5} " +
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 6e15b8ca..07ca4f69 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
@@ -24,7 +24,7 @@ class MutableImmutableCompareFuzzTest {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
-                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
                 VersionedMapImpl<Integer, String> immutable = (VersionedMapImpl<Integer, String>) store.createMap();
                 VersionedMapImpl<Integer, String> mutable = (VersionedMapImpl<Integer, String>) store.createMap();
 
@@ -35,8 +35,8 @@ class MutableImmutableCompareFuzzTest {
         }
 
         private void iterativeRandomPutsAndCommitsAndCompare(String scenario, VersionedMapImpl<Integer, String> immutable,
-                        VersionedMapImpl<Integer, String> mutable, int steps, int maxKey, String[] values, Random r,
-                        int commitFrequency) {
+                                                                                                                 VersionedMapImpl<Integer, String> mutable, int steps, int maxKey, String[] values, Random r,
+                                                                                                                 int commitFrequency) {
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
                         int nextKey = r.nextInt(maxKey);
@@ -69,9 +69,9 @@ class MutableImmutableCompareFuzzTest {
         }
 
         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[]{false,true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(new Object[]{FuzzTestUtils.FAST_STEP_COUNT}, new Object[]{3, 32, 32 * 32},
+                                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} 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 35a54712..e0366381 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
@@ -23,17 +23,17 @@ 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) {
+                                                         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]);
+                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<>(chp, values[0]);
 
                 iterativeRandomPutsAndCommitsThenRestore(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
 
         private void iterativeRandomPutsAndCommitsThenRestore(String scenario, VersionedMapStore<Integer, String> store,
-                        int steps, int maxKey, String[] values, int seed, int commitFrequency) {
+                                                                                                                  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();
@@ -90,9 +90,9 @@ class RestoreFuzzTest {
         }
 
         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[]{false, true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(new Object[]{FuzzTestUtils.FAST_STEP_COUNT}, new Object[]{3, 32, 32 * 32},
+                                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} nullDefault={4} commit frequency={5}" +
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 ac033edb..a576b1c8 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
@@ -32,22 +32,22 @@ class SharedStoreFuzzTest {
         }
 
         private void iterativeRandomPutsAndCommitsThenRestore(String scenario, List<VersionedMapStore<Integer, String>> stores,
-                        int steps, int maxKey, String[] values, int seed, int commitFrequency) {
+                                                                                                                  int steps, int maxKey, String[] values, int seed, int commitFrequency) {
                 // 1. maps with versions
                 Random r = new Random(seed);
                 List<VersionedMapImpl<Integer, String>> versioneds = new LinkedList<>();
-                for(VersionedMapStore<Integer, String> store : stores) {
+                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++) {
+                for (int i = 0; i < stores.size(); i++) {
                         index2Version.add(new HashMap<>());
                 }
 
                 for (int i = 0; i < steps; i++) {
                         int stepIndex = i + 1;
-                        for (int storeIndex = 0; storeIndex<versioneds.size(); storeIndex++) {
+                        for (int storeIndex = 0; storeIndex < versioneds.size(); storeIndex++) {
                                 int nextKey = r.nextInt(maxKey);
                                 String nextValue = values[r.nextInt(values.length)];
                                 versioneds.get(storeIndex).put(nextKey, nextValue);
@@ -60,14 +60,14 @@ class SharedStoreFuzzTest {
                 }
                 // 2. create a non-versioned and
                 List<VersionedMapImpl<Integer, String>> reference = new LinkedList<>();
-                for(VersionedMapStore<Integer, String> store : stores) {
+                for (VersionedMapStore<Integer, String> store : stores) {
                         reference.add((VersionedMapImpl<Integer, String>) store.createMap());
                 }
                 r = new Random(seed);
 
                 for (int i = 0; i < steps; i++) {
                         int index = i + 1;
-                        for (int storeIndex = 0; storeIndex<versioneds.size(); storeIndex++) {
+                        for (int storeIndex = 0; storeIndex < versioneds.size(); storeIndex++) {
                                 int nextKey = r.nextInt(maxKey);
                                 String nextValue = values[r.nextInt(values.length)];
                                 reference.get(storeIndex).put(nextKey, nextValue);
@@ -93,9 +93,9 @@ class SharedStoreFuzzTest {
         }
 
         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[]{false, true}, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
-                                new Object[] { false, true });
+                return FuzzTestUtils.permutationWithSize(new Object[]{FuzzTestUtils.FAST_STEP_COUNT}, new Object[]{3, 32, 32 * 32},
+                                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} nullDefault={4} commit " +
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtils.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtils.java
index e75d7f5a..92208e48 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtils.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtils.java
@@ -51,14 +51,12 @@ public final class FuzzTestUtils {
 
         public static Stream<Arguments> permutationWithSize(Object[]... valueOption) {
                 int size = 1;
-                for (int i = 0; i < valueOption.length; i++) {
-                        size *= valueOption[i].length;
+                for (Object[] objects : valueOption) {
+                        size *= objects.length;
                 }
                 Object[][] newValueOption = new Object[valueOption.length + 1][];
-                newValueOption[0] = new Object[] { size };
-                for (int i = 1; i < newValueOption.length; i++) {
-                        newValueOption[i] = valueOption[i - 1];
-                }
+                newValueOption[0] = new Object[]{size};
+                System.arraycopy(valueOption, 0, newValueOption, 1, newValueOption.length - 1);
                 return permutation(newValueOption);
         }
 }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtilsTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtilsTest.java
index 72f2a46c..8c641205 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtilsTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/utils/FuzzTestUtilsTest.java
@@ -1,31 +1,36 @@
 package tools.refinery.store.map.tests.fuzz.utils;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.util.List;
+import java.util.Optional;
 
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.provider.Arguments;
 
 class FuzzTestUtilsTest {
         @Test
         void permutationInternalTest() {
-                List<List<Object>> res = FuzzTestUtils.permutationInternal(0, new Object[] { 1, 2, 3 },
-                                new Object[] { 'a', 'b', 'c' }, new Object[] { "alpha", "beta", "gamma", "delta" });
+                List<List<Object>> res = FuzzTestUtils.permutationInternal(0, new Object[]{1, 2, 3},
+                                new Object[]{'a', 'b', 'c'}, new Object[]{"alpha", "beta", "gamma", "delta"});
                 assertEquals(3 * 3 * 4, res.size());
         }
 
         @Test
         void permutationTest1() {
-                var res = FuzzTestUtils.permutation(new Object[] { 1, 2, 3 }, new Object[] { 'a', 'b', 'c' },
-                                new Object[] { "alpha", "beta", "gamma", "delta" });
+                var res = FuzzTestUtils.permutation(new Object[]{1, 2, 3}, new Object[]{'a', 'b', 'c'},
+                                new Object[]{"alpha", "beta", "gamma", "delta"});
                 assertEquals(3 * 3 * 4, res.count());
         }
 
         @Test
         void permutationTest2() {
-                var res = FuzzTestUtils.permutation(new Object[] { 1, 2, 3 }, new Object[] { 'a', 'b', 'c' },
-                                new Object[] { "alpha", "beta", "gamma", "delta" });
-                var arguments = res.findFirst().get().get();
+                var res = FuzzTestUtils.permutation(new Object[]{1, 2, 3}, new Object[]{'a', 'b', 'c'},
+                                new Object[]{"alpha", "beta", "gamma", "delta"});
+                Optional<Arguments> first = res.findFirst();
+                assertTrue(first.isPresent());
+                var arguments = first.get().get();
                 assertEquals(1, arguments[0]);
                 assertEquals('a', arguments[1]);
                 assertEquals("alpha", arguments[2]);
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 10ea2796..30f38201 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
@@ -11,7 +11,7 @@ import static org.junit.jupiter.api.Assertions.*;
 public class MapTestEnvironment<K, V> {
         public static String[] prepareValues(int maxValue, boolean nullDefault) {
                 String[] values = new String[maxValue];
-                if(nullDefault) {
+                if (nullDefault) {
                         values[0] = null;
                 } else {
                         values[0] = "DEFAULT";
@@ -26,23 +26,18 @@ public class MapTestEnvironment<K, V> {
         public static ContinousHashProvider<Integer> prepareHashProvider(final boolean evil) {
                 // Use maxPrime = 2147483629
 
-                ContinousHashProvider<Integer> chp = new ContinousHashProvider<Integer>() {
-
-                        @Override
-                        public int getHash(Integer key, int index) {
-                                if (evil && index < 15 && index < key / 3) {
-                                        return 7;
-                                }
-                                int result = 1;
-                                final int prime = 31;
+                return (key, index) -> {
+                        if (evil && index < 15 && index < key / 3) {
+                                return 7;
+                        }
+                        int result = 1;
+                        final int prime = 31;
 
-                                result = prime * result + key;
-                                result = prime * result + index;
+                        result = prime * result + key;
+                        result = prime * result + index;
 
-                                return result;
-                        }
+                        return result;
                 };
-                return chp;
         }
 
         public static void printStatus(String scenario, int actual, int max, String stepName) {