Data structure cleanup with Sonar

9 files changed, 121 insertions, 130 deletions

diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/CommitSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/CommitSmokeTest.java
index 5c340090..25ad81d2 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/CommitSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/CommitSmokeTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke.fast;
+package org.eclipse.viatra.solver.data.map.tests.smoke;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -9,15 +9,16 @@ import org.eclipse.viatra.solver.data.map.ContinousHashProvider;
 import org.eclipse.viatra.solver.data.map.VersionedMapStore;
 import org.eclipse.viatra.solver.data.map.VersionedMapStoreImpl;
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
-import org.eclipse.viatra.solver.data.map.tests.smoke.utils.TestPermuter;
-import org.eclipse.viatra.solver.data.map.tests.support.MapTestEnvironment;
+import org.eclipse.viatra.solver.data.map.tests.smoke.utils.SmokeTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
+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;
 
-public class CommitSmokeTest {
-        public void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+class CommitSmokeTest {
+        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -65,15 +66,30 @@ public class CommitSmokeTest {
         @ParameterizedTest(name = "Immutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
-        public void parametrizedSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        @Tag("smoke")
+        void parametrizedFastSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
                         boolean evilHash) {
                 runSmokeTest("SmokeCommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        public static Stream<Arguments> parametrizedSmoke() {
-                return TestPermuter.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
+        static Stream<Arguments> parametrizedFastSmoke() {
+                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
+
+        @ParameterizedTest(name = "Immutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @MethodSource
+        @Tag("smoke")
+        @Tag("slow")
+        void parametrizedSlowSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+                        boolean evilHash) {
+                runSmokeTest("SmokeCommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
+                                commitFrequency, evilHash);
+        }
+
+        static Stream<Arguments> parametrizedSlowSmoke() {
+                return SmokeTestUtils.changeStepCount(parametrizedFastSmoke(), 1);
+        }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/DiffCursorSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/DiffCursorSmokeTest.java
index ef51d05e..c36fac47 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/DiffCursorSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/DiffCursorSmokeTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke.fast;
+package org.eclipse.viatra.solver.data.map.tests.smoke;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -10,15 +10,16 @@ import org.eclipse.viatra.solver.data.map.DiffCursor;
 import org.eclipse.viatra.solver.data.map.VersionedMapStore;
 import org.eclipse.viatra.solver.data.map.VersionedMapStoreImpl;
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
-import org.eclipse.viatra.solver.data.map.tests.smoke.utils.TestPermuter;
-import org.eclipse.viatra.solver.data.map.tests.support.MapTestEnvironment;
+import org.eclipse.viatra.solver.data.map.tests.smoke.utils.SmokeTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
+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;
 
-public class DiffCursorSmokeTest {
-        public void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+class DiffCursorSmokeTest {
+        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -27,7 +28,7 @@ public class DiffCursorSmokeTest {
                 iterativeRandomPutsAndCommitsThenDiffcursor(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
 
-        void iterativeRandomPutsAndCommitsThenDiffcursor(String scenario, VersionedMapStore<Integer, String> store,
+        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);
@@ -87,14 +88,15 @@ public class DiffCursorSmokeTest {
         @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
+        @Tag("smoke")
         void parametrizedSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
                         boolean evilHash) {
                 runSmokeTest("SmokeMutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
                                 noKeys, noValues, commitFrequency, evilHash);
         }
 
-        public static Stream<Arguments> parametrizedSmoke() {
-                return TestPermuter.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
+        static Stream<Arguments> parametrizedSmoke() {
+                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/MutableImmutableCompareSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableImmutableCompareSmokeTest.java
index ac5571b3..115b1fec 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/MutableImmutableCompareSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableImmutableCompareSmokeTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke.fast;
+package org.eclipse.viatra.solver.data.map.tests.smoke;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -9,15 +9,16 @@ import org.eclipse.viatra.solver.data.map.ContinousHashProvider;
 import org.eclipse.viatra.solver.data.map.VersionedMapStore;
 import org.eclipse.viatra.solver.data.map.VersionedMapStoreImpl;
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
-import org.eclipse.viatra.solver.data.map.tests.smoke.utils.TestPermuter;
-import org.eclipse.viatra.solver.data.map.tests.support.MapTestEnvironment;
+import org.eclipse.viatra.solver.data.map.tests.smoke.utils.SmokeTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
+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;
 
-public class MutableImmutableCompareSmokeTest {
-        public void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+class MutableImmutableCompareSmokeTest {
+        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -32,7 +33,7 @@ public class MutableImmutableCompareSmokeTest {
                                 commitFrequency);
         }
 
-        void iterativeRandomPutsAndCommitsAndCompare(String scenario, VersionedMapImpl<Integer, String> immutable,
+        private void iterativeRandomPutsAndCommitsAndCompare(String scenario, VersionedMapImpl<Integer, String> immutable,
                         VersionedMapImpl<Integer, String> mutable, int steps, int maxKey, String[] values, Random r,
                         int commitFrequency) {
                 for (int i = 0; i < steps; i++) {
@@ -58,15 +59,30 @@ public class MutableImmutableCompareSmokeTest {
         @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
-        void parametrizedSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        @Tag("smoke")
+        void parametrizedFastSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
                         boolean evilHash) {
                 runSmokeTest("SmokeMutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
                                 noKeys, noValues, commitFrequency, evilHash);
         }
 
-        public static Stream<Arguments> parametrizedSmoke() {
-                return TestPermuter.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
+        static Stream<Arguments> parametrizedFastSmoke() {
+                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
+
+        @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @MethodSource
+        @Tag("smoke")
+        @Tag("slow")
+        void parametrizedSlowSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+                        boolean evilHash) {
+                runSmokeTest("SmokeMutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
+                                noKeys, noValues, commitFrequency, evilHash);
+        }
+
+        static Stream<Arguments> parametrizedSlowSmoke() {
+                return SmokeTestUtils.changeStepCount(MutableImmutableCompareSmokeTest.parametrizedSlowSmoke(), 1);
+        }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/MutableSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableSmokeTest.java
index c24c220d..999325f0 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/MutableSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableSmokeTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke.fast;
+package org.eclipse.viatra.solver.data.map.tests.smoke;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -9,16 +9,16 @@ import org.eclipse.viatra.solver.data.map.ContinousHashProvider;
 import org.eclipse.viatra.solver.data.map.VersionedMapStore;
 import org.eclipse.viatra.solver.data.map.VersionedMapStoreImpl;
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
-import org.eclipse.viatra.solver.data.map.tests.smoke.utils.TestPermuter;
-import org.eclipse.viatra.solver.data.map.tests.support.MapTestEnvironment;
+import org.eclipse.viatra.solver.data.map.tests.smoke.utils.SmokeTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
+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;
 
-public class MutableSmokeTest {
-
-        public void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean evilHash) {
+class MutableSmokeTest {
+        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
@@ -31,7 +31,7 @@ public class MutableSmokeTest {
                 iterativeRandomPuts(scenario, steps, maxKey, values, e, r);
         }
 
-        void iterativeRandomPuts(String scenario, int steps, int maxKey, String[] values,
+        private void iterativeRandomPuts(String scenario, int steps, int maxKey, String[] values,
                         MapTestEnvironment<Integer, String> e, Random r) {
                 int stopAt = -1;
                 for (int i = 0; i < steps; i++) {
@@ -62,14 +62,15 @@ public class MutableSmokeTest {
         @ParameterizedTest(name = "Mutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} seed={4} evil-hash={5}")
         @MethodSource
         @Timeout(value = 10)
+        @Tag("smoke")
         void parametrizedSmoke(int test, int steps, int noKeys, int noValues, int seed, boolean evilHash) {
                 runSmokeTest(
                                 "SmokeS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
                                 seed, steps, noKeys, noValues, evilHash);
         }
 
-        public static Stream<Arguments> parametrizedSmoke() {
-                return TestPermuter.permutationWithSize(new Object[] { 1000 },
+        static Stream<Arguments> parametrizedSmoke() {
+                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 },
                                 new Object[] { 3, 32, 32 * 32, 32 * 32 * 32 * 32 }, new Object[] { 2, 3 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/RestoreSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/RestoreSmokeTest.java
index 4ca9b088..fa96f0c1 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/fast/RestoreSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/RestoreSmokeTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke.fast;
+package org.eclipse.viatra.solver.data.map.tests.smoke;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -11,15 +11,16 @@ import org.eclipse.viatra.solver.data.map.ContinousHashProvider;
 import org.eclipse.viatra.solver.data.map.VersionedMapStore;
 import org.eclipse.viatra.solver.data.map.VersionedMapStoreImpl;
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
-import org.eclipse.viatra.solver.data.map.tests.smoke.utils.TestPermuter;
-import org.eclipse.viatra.solver.data.map.tests.support.MapTestEnvironment;
+import org.eclipse.viatra.solver.data.map.tests.smoke.utils.SmokeTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
+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;
 
-public class RestoreSmokeTest {
-        public void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+class RestoreSmokeTest {
+        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -29,8 +30,8 @@ public class RestoreSmokeTest {
                 iterativeRandomPutsAndCommitsThenRestore(scenario, store, steps, maxKey, values, seed, commitFrequency);
         }
 
-        void iterativeRandomPutsAndCommitsThenRestore(String scenario, VersionedMapStore<Integer, String> store, int steps,
-                        int maxKey, String[] values, int seed, int commitFrequency) {
+        private void iterativeRandomPutsAndCommitsThenRestore(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();
@@ -75,18 +76,33 @@ public class RestoreSmokeTest {
 
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Restore Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
-        void parametrizedSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        @Tag("smoke")
+        void parametrizedFastSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
                         boolean evilHash) {
-                runSmokeTest("SmokeMutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, commitFrequency, evilHash);
+                runSmokeTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
+                                commitFrequency, evilHash);
         }
 
-        public static Stream<Arguments> parametrizedSmoke() {
-                return TestPermuter.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
+        static Stream<Arguments> parametrizedFastSmoke() {
+                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
+
+        @ParameterizedTest(name = "Restore Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @MethodSource
+        @Tag("smoke")
+        @Tag("slow")
+        void parametrizedSlowSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+                        boolean evilHash) {
+                runSmokeTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
+                                commitFrequency, evilHash);
+        }
+
+        static Stream<Arguments> parametrizedSlowSmoke() {
+                return SmokeTestUtils.changeStepCount(RestoreSmokeTest.parametrizedFastSmoke(), 1);
+        }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/slow/SlowSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/slow/SlowSmokeTest.java
deleted file mode 100644
index 004d30d9..00000000
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/slow/SlowSmokeTest.java
+++ /dev/null
@@ -1,77 +0,0 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke.slow;
-
-import java.util.Arrays;
-import java.util.stream.Stream;
-
-import org.eclipse.viatra.solver.data.map.tests.smoke.fast.CommitSmokeTest;
-import org.eclipse.viatra.solver.data.map.tests.smoke.fast.MutableImmutableCompareSmokeTest;
-import org.eclipse.viatra.solver.data.map.tests.smoke.fast.MutableSmokeTest;
-import org.eclipse.viatra.solver.data.map.tests.smoke.fast.RestoreSmokeTest;
-import org.junit.jupiter.api.Disabled;
-import org.junit.jupiter.params.ParameterizedTest;
-import org.junit.jupiter.params.provider.Arguments;
-import org.junit.jupiter.params.provider.MethodSource;
-
-@Disabled
-public class SlowSmokeTest {
-
-        private static int slowStepCount = 32 * 32 * 32 * 32;
-
-        private static Stream<Arguments> changeStepCount(Stream<Arguments> arguments) {
-                return arguments.map(x -> Arguments.of(updatedStepCount(x.get())));
-
-        }
-
-        private static Object[] updatedStepCount(Object[] arguments) {
-                Object[] copy = Arrays.copyOf(arguments, arguments.length);
-                copy[1] = slowStepCount;
-                return copy;
-        }
-
-        @ParameterizedTest(name = "Mutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} seed={4} evil-hash={5}")
-        @MethodSource
-        void smoke1(int test, int steps, int noKeys, int noValues, int seed, boolean evilHash) {
-                (new MutableSmokeTest()).runSmokeTest(
-                                "SmokeS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
-                                seed, steps, noKeys, noValues, evilHash);
-        }
-
-        private static Stream<Arguments> smoke1() {
-                return changeStepCount(MutableSmokeTest.parametrizedSmoke());
-        }
-
-        @ParameterizedTest(name = "Immutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
-        @MethodSource
-        void smoke2(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed, boolean evilHash) {
-                (new CommitSmokeTest()).runSmokeTest("SmokeCommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed,
-                                steps, noKeys, noValues, commitFrequency, evilHash);
-        }
-
-        private static Stream<Arguments> smoke2() {
-                return changeStepCount(CommitSmokeTest.parametrizedSmoke());
-        }
-
-        @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
-        @MethodSource
-        void smoke3(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed, boolean evilHash) {
-                (new MutableImmutableCompareSmokeTest()).runSmokeTest(
-                                "SmokeMutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, commitFrequency, evilHash);
-        }
-
-        private static Stream<Arguments> smoke3() {
-                return changeStepCount(MutableImmutableCompareSmokeTest.parametrizedSmoke());
-        }
-
-        @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
-        @MethodSource
-        void smoke4(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed, boolean evilHash) {
-                (new RestoreSmokeTest()).runSmokeTest(
-                                "SmokeMutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
-                                noKeys, noValues, commitFrequency, evilHash);
-        }
-
-        private static Stream<Arguments> smoke4() {
-                return changeStepCount(RestoreSmokeTest.parametrizedSmoke());
-        }
-}
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/TestPermuter.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/SmokeTestUtils.java
index 0f7b4642..9eab854f 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/TestPermuter.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/SmokeTestUtils.java
@@ -1,12 +1,29 @@
 package org.eclipse.viatra.solver.data.map.tests.smoke.utils;
 
+import java.util.Arrays;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.stream.Stream;
 
 import org.junit.jupiter.params.provider.Arguments;
 
-public class TestPermuter {
+public final class SmokeTestUtils {
+        private static final int SLOW_STEP_COUNT = 32 * 32 * 32 * 32;
+
+        private SmokeTestUtils() {
+                throw new IllegalStateException("This is a static utility class and should not be instantiated directly");
+        }
+
+        public static Stream<Arguments> changeStepCount(Stream<Arguments> arguments, int parameterIndex) {
+                return arguments.map(x -> Arguments.of(updatedStepCount(x.get(), parameterIndex)));
+        }
+
+        public static Object[] updatedStepCount(Object[] arguments, int parameterIndex) {
+                Object[] copy = Arrays.copyOf(arguments, arguments.length);
+                copy[parameterIndex] = SLOW_STEP_COUNT;
+                return copy;
+        }
+
         static List<List<Object>> permutationInternal(int from, Object[]... valueOption) {
                 if (valueOption.length == from) {
                         return List.of(List.of());
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/TestPermuterTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/SmoteTestUtilsTest.java
index 91f1c2e0..376b3e50 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/TestPermuterTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/SmoteTestUtilsTest.java
@@ -6,24 +6,24 @@ import java.util.List;
 
 import org.junit.jupiter.api.Test;
 
-class TestPermuterTest {
+class SmoteTestUtilsTest {
         @Test
         void permutationInternalTest() {
-                List<List<Object>> res = TestPermuter.permutationInternal(0, new Object[] { 1, 2, 3 },
+                List<List<Object>> res = SmokeTestUtils.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 = TestPermuter.permutation(new Object[] { 1, 2, 3 }, new Object[] { 'a', 'b', 'c' },
+                var res = SmokeTestUtils.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 = TestPermuter.permutation(new Object[] { 1, 2, 3 }, new Object[] { 'a', 'b', 'c' },
+                var res = SmokeTestUtils.permutation(new Object[] { 1, 2, 3 }, new Object[] { 'a', 'b', 'c' },
                                 new Object[] { "alpha", "beta", "gamma", "delta" });
                 var arguments = res.findFirst().get().get();
                 assertEquals(1, arguments[0]);
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/support/MapTestEnvironment.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/utils/MapTestEnvironment.java
index 6c55be62..59e5e913 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/support/MapTestEnvironment.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/utils/MapTestEnvironment.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.support;
+package org.eclipse.viatra.solver.data.map.tests.utils;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;