VersionedMapStoreFactoryBuilder.java is introduced, all tests are updated.

VersionedMapStoreBuilder.java is removed.

10 files changed, 102 insertions, 105 deletions

diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java
index 05cf5a74..993e5531 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/InOrderCursorTest.java
@@ -1,7 +1,8 @@
 package tools.refinery.store.map.tests;
 
 import org.junit.jupiter.api.Test;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.internal.InOrderMapCursor;
 import tools.refinery.store.map.internal.VersionedMapImpl;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
@@ -11,13 +12,14 @@ import static org.junit.jupiter.api.Assertions.*;
 class InOrderCursorTest {
         @Test
         void testCursor() {
-                var store = VersionedMapStoreBuilder.<Integer,String>builder()
-                                .setStrategy(VersionedMapStoreBuilder.StoreStrategy.STATE)
-                                .setStateBasedImmutableWhenCommitting(true)
-                                .setHashProvider(MapTestEnvironment.prepareHashProvider(false))
-                                .setStateBasedNodeSharingStrategy(VersionedMapStoreBuilder.StateStorageStrategy.SHARED_NODE_CACHE)
-                                .setDefaultValue("x")
-                                .buildOne();
+                var store = VersionedMapStore.<Integer,String>builder()
+                                .strategy(VersionedMapStoreFactoryBuilder.StoreStrategy.STATE)
+                                .stateBasedImmutableWhenCommitting(true)
+                                .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE)
+                                .defaultValue("x")
+                                .build()
+                                .createOne();
 
                 VersionedMapImpl<Integer,String> map = (VersionedMapImpl<Integer,String>) store.createMap();
                 checkMove(map,0);
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
index 2216db76..6889fd07 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/MapUnitTests.java
@@ -2,7 +2,6 @@ package tools.refinery.store.map.tests;
 
 import org.junit.jupiter.api.Test;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
 import tools.refinery.store.map.VersionedMapStoreImpl;
 import tools.refinery.store.model.TupleHashProvider;
 import tools.refinery.store.tuple.Tuple;
@@ -23,7 +22,7 @@ class MapUnitTests {
         @Test
         void deltaRestoreTest() {
                 VersionedMapStore<Integer,String> store =
-                                VersionedMapStoreBuilder.<Integer,String>builder().setDefaultValue("x").buildOne();
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
                 var map = store.createMap();
                 map.put(1,"val");
                 var version1 = map.commit();
@@ -36,7 +35,7 @@ class MapUnitTests {
         @Test
         void deltaRestoreTest2() {
                 VersionedMapStore<Integer,String> store =
-                                VersionedMapStoreBuilder.<Integer,String>builder().setDefaultValue("x").buildOne();
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
                 var map = store.createMap();
                 map.put(1,"x");
                 var version1 = map.commit();
@@ -48,7 +47,7 @@ class MapUnitTests {
         @Test
         void deltaRestoreTest3() {
                 VersionedMapStore<Integer,String> store =
-                                VersionedMapStoreBuilder.<Integer,String>builder().setDefaultValue("x").buildOne();
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
                 var map = store.createMap();
                 map.commit();
                 map.put(1,"1");
@@ -71,7 +70,7 @@ class MapUnitTests {
         @Test
         void deltaRestoreTest4() {
                 VersionedMapStore<Integer,String> store =
-                                VersionedMapStoreBuilder.<Integer,String>builder().setDefaultValue("x").buildOne();
+                                VersionedMapStore.<Integer,String>builder().defaultValue("x").build().createOne();
                 var map = store.createMap();
                 map.commit();
                 map.put(1,"1");
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 14a9e2e0..7977f772 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
@@ -1,30 +1,29 @@
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.fail;
-
-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.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 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 CommitFuzzTest {
 
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
-                                                         boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         boolean nullDefault, int commitFrequency,
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
                 var sut = store.createMap();
                 MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
@@ -61,7 +60,7 @@ class CommitFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
@@ -76,7 +75,7 @@ class CommitFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
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 b462ed40..99e76649 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
@@ -5,7 +5,10 @@ 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.*;
+import tools.refinery.store.map.Cursor;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
@@ -16,12 +19,13 @@ import java.util.List;
 import java.util.Random;
 import java.util.stream.Stream;
 
-import static org.junit.jupiter.api.Assertions.*;
+import static org.junit.jupiter.api.Assertions.fail;
 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, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         boolean nullDefault, int commitFrequency,
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
 
@@ -30,10 +34,10 @@ class ContentEqualsFuzzTest {
                 iterativeRandomPutsAndCommitsThenCompare(scenario, builder, steps, maxKey, values, r, commitFrequency);
         }
 
-        private void iterativeRandomPutsAndCommitsThenCompare(String scenario, VersionedMapStoreBuilder<Integer, String> builder,
+        private void iterativeRandomPutsAndCommitsThenCompare(String scenario, VersionedMapStoreFactoryBuilder<Integer, String> builder,
                                                                                                                   int steps, int maxKey, String[] values, Random r,
                                                                                                                   int commitFrequency) {
-                VersionedMapStore<Integer, String> store1 = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store1 = builder.defaultValue(values[0]).build().createOne();
                 VersionedMap<Integer, String> sut1 = store1.createMap();
 
                 // Fill one map
@@ -63,7 +67,7 @@ class ContentEqualsFuzzTest {
                 // Randomize the order of the content
                 Collections.shuffle(content, r);
 
-                VersionedMapStore<Integer, String> store2 = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store2 = builder.defaultValue(values[0]).build().createOne();
                 VersionedMap<Integer, String> sut2 = store2.createMap();
                 int index2 = 1;
                 for (SimpleEntry<Integer, String> entry : content) {
@@ -88,7 +92,7 @@ class ContentEqualsFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
@@ -103,7 +107,7 @@ class ContentEqualsFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 defaultNull, commitFrequency, builder);
         }
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 b087906d..3a8852a9 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
@@ -8,7 +8,7 @@ import org.junit.jupiter.params.provider.MethodSource;
 import tools.refinery.store.map.DiffCursor;
 import tools.refinery.store.map.VersionedMap;
 import tools.refinery.store.map.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
@@ -21,10 +21,10 @@ 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 commitBeforeDiffCursor,
-                                                         VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
                 iterativeRandomPutsAndCommitsThenDiffCursor(scenario, store, steps, maxKey, values, seed, commitFrequency,
                                 commitBeforeDiffCursor);
         }
@@ -109,7 +109,7 @@ class DiffCursorFuzzTest {
         @Tag("fuzz")
         void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
                                                   int commitFrequency, int seed, boolean commitBeforeDiffCursor,
-                                                  VersionedMapStoreBuilder<Integer, String> builder) {
+                                                  VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("DiffCursorS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
                                 noKeys, noValues, nullDefault, commitFrequency, commitBeforeDiffCursor, builder);
         }
@@ -124,7 +124,7 @@ class DiffCursorFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                        int seed, boolean commitBeforeDiffCursor, VersionedMapStoreBuilder<Integer, String> builder) {
+                        int seed, boolean commitBeforeDiffCursor, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("DiffCursorS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, commitBeforeDiffCursor, builder);
         }
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 ec2224b4..ea58e1b7 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
@@ -1,32 +1,31 @@
 package tools.refinery.store.map.tests.fuzz;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.fail;
-import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
-
-import java.util.Collections;
-import java.util.LinkedList;
-import java.util.List;
-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.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.Collections;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Stream;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
+
 class MultiThreadFuzzTest {
         public static final int noThreads = 10;
 
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
 
                 // initialize runnables
                 MultiThreadTestRunnable[] runnables = new MultiThreadTestRunnable[noThreads];
@@ -73,7 +72,7 @@ class MultiThreadFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull,
-                                                           int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                           int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("MultiThreadS" + steps + "K" + noKeys + "V" + noValues + defaultNull + "CF" + commitFrequency +
                                  "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, builder);
         }
@@ -88,7 +87,7 @@ class MultiThreadFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
-                                                          int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
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 bdf72ce4..61b17362 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
@@ -18,10 +18,10 @@ 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, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         boolean nullDefault, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
                 VersionedMap<Integer, String> sut = store.createMap();
                 MapTestEnvironment<Integer, String> e = new MapTestEnvironment<>(sut);
 
@@ -56,7 +56,7 @@ class MutableFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull, int seed,
-                                                  VersionedMapStoreBuilder<Integer, String> builder) {
+                                                  VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest(
                                 "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed,
                                 seed, steps, noKeys, noValues, defaultNull, builder);
@@ -72,7 +72,7 @@ class MutableFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int seed,
-                                                         VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest(
                                 "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed,
                                 seed, steps, noKeys, noValues, nullDefault, builder);
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 568aaac9..1661cccb 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
@@ -1,31 +1,31 @@
 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.HashMap;
-import java.util.Map;
-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.*;
-import tools.refinery.store.map.internal.VersionedMapImpl;
+import tools.refinery.store.map.VersionedMap;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
+import java.util.HashMap;
+import java.util.Map;
+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 RestoreFuzzTest {
         private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue,
                                                          boolean nullDefault, int commitFrequency,
-                                                         VersionedMapStoreBuilder<Integer, String> builder) {
+                                                         VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
 
                 iterativeRandomPutsAndCommitsThenRestore(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
@@ -84,7 +84,7 @@ class RestoreFuzzTest {
         @Timeout(value = 10)
         @Tag("smoke")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
@@ -99,7 +99,7 @@ class RestoreFuzzTest {
         @Tag("smoke")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault, int commitFrequency,
-                                                          int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
diff --git a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java
index e7d49227..0e1f9f9f 100644
--- a/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java
+++ b/subprojects/store/src/test/java/tools/refinery/store/map/tests/fuzz/SingleThreadFuzzTest.java
@@ -6,7 +6,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.VersionedMapStore;
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.fuzz.utils.FuzzTestUtils;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
@@ -15,10 +15,10 @@ import java.util.stream.Stream;
 import static tools.refinery.store.map.tests.fuzz.utils.FuzzTestCollections.*;
 
 class SingleThreadFuzzTest {
-        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreBuilder<Integer, String> builder) {
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean nullDefault, int commitFrequency, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue, nullDefault);
 
-                VersionedMapStore<Integer, String> store = builder.setDefaultValue(values[0]).buildOne();
+                VersionedMapStore<Integer, String> store = builder.defaultValue(values[0]).build().createOne();
 
                 // initialize runnables
                 MultiThreadTestRunnable runnable = new MultiThreadTestRunnable(scenario, store, steps, maxKey, values, seed, commitFrequency);
@@ -35,7 +35,7 @@ class SingleThreadFuzzTest {
         @Timeout(value = 10)
         @Tag("fuzz")
         void parametrizedFastFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean defaultNull,
-                                                          int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("SingleThreadS" + steps + "K" + noKeys + "V" + noValues + defaultNull + "CF" + commitFrequency +
                                 "s" + seed, seed, steps, noKeys, noValues, defaultNull, commitFrequency, builder);
         }
@@ -50,7 +50,7 @@ class SingleThreadFuzzTest {
         @Tag("fuzz")
         @Tag("slow")
         void parametrizedSlowFuzz(int ignoredTests, int steps, int noKeys, int noValues, boolean nullDefault,
-                                                          int commitFrequency, int seed, VersionedMapStoreBuilder<Integer, String> builder) {
+                                                          int commitFrequency, int seed, VersionedMapStoreFactoryBuilder<Integer, String> builder) {
                 runFuzzTest("SingleThreadS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 nullDefault, commitFrequency, builder);
         }
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 b344d9b9..94c9cba7 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,6 +1,7 @@
 package tools.refinery.store.map.tests.fuzz.utils;
 
-import tools.refinery.store.map.VersionedMapStoreBuilder;
+import tools.refinery.store.map.VersionedMapStore;
+import tools.refinery.store.map.VersionedMapStoreFactoryBuilder;
 import tools.refinery.store.map.tests.utils.MapTestEnvironment;
 
 public final class FuzzTestCollections {
@@ -12,34 +13,27 @@ public final class FuzzTestCollections {
         public static final Object[] randomSeedOptions = {1};
         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),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(true)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(true)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(true))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(false)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.SHARED_NODE_CACHE),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .stateBasedImmutableWhenCommitting(false)
+                                        .stateBasedHashProvider(MapTestEnvironment.prepareHashProvider(false))
+                                        .stateBasedSharingStrategy(VersionedMapStoreFactoryBuilder.SharingStrategy.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)
+                        VersionedMapStore.<Integer,String>builder()
+                                        .deltaTransactionStrategy(VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy.SET),
+                        VersionedMapStore.<Integer,String>builder()
+                                        .deltaTransactionStrategy(VersionedMapStoreFactoryBuilder.DeltaTransactionStrategy.LIST)
         };
 }