More smoke -> fuzz

9 files changed, 105 insertions, 91 deletions

diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/CommitFuzzTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/CommitFuzzTest.java
index 7bd024a4..e160df2b 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/CommitFuzzTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/CommitFuzzTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke;
+package org.eclipse.viatra.solver.data.map.tests.fuzz;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -9,7 +9,7 @@ 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.FuzzTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.fuzz.utils.FuzzTestUtils;
 import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
@@ -18,7 +18,7 @@ import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 class CommitFuzzTest {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -63,33 +63,33 @@ class CommitFuzzTest {
                 }
         }
 
-        @ParameterizedTest(name = "Immutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
-        @Tag("smoke")
-        void parametrizedFastSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        @Tag("fuzz")
+        void parametrizedFastFuzz(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,
+                runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedFastSmoke() {
+        static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Immutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Commit {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
-        @Tag("smoke")
+        @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        void parametrizedSlowFuzz(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,
+                runFuzzTest("CommitS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedSlowSmoke() {
-                return FuzzTestUtils.changeStepCount(parametrizedFastSmoke(), 1);
+        static Stream<Arguments> parametrizedSlowFuzz() {
+                return FuzzTestUtils.changeStepCount(parametrizedFastFuzz(), 1);
         }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/ContentEqualsFuzzTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/ContentEqualsFuzzTest.java
index 11e393d4..f7d3d548 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/ContentEqualsFuzzTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/ContentEqualsFuzzTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke;
+package org.eclipse.viatra.solver.data.map.tests.fuzz;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.fail;
@@ -16,7 +16,7 @@ import org.eclipse.viatra.solver.data.map.VersionedMap;
 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.FuzzTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.fuzz.utils.FuzzTestUtils;
 import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
@@ -25,7 +25,7 @@ import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 class ContentEqualsFuzzTest {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -110,33 +110,33 @@ class ContentEqualsFuzzTest {
                 assertEquals(sut1, sut2, "Maps are not equals");
         }
 
-        @ParameterizedTest(name = "Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
-        @Tag("smoke")
-        void parametrizedFastSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        @Tag("fuzz")
+        void parametrizedFastFuzz(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,
+                runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedFastSmoke() {
+        static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Immutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
-        @Tag("smoke")
+        @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        void parametrizedSlowFuzz(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,
+                runFuzzTest("CompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedSlowSmoke() {
-                return FuzzTestUtils.changeStepCount(parametrizedFastSmoke(), 1);
+        static Stream<Arguments> parametrizedSlowFuzz() {
+                return FuzzTestUtils.changeStepCount(parametrizedFastFuzz(), 1);
         }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/DiffCursorFuzzTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/DiffCursorFuzzTest.java
index ae1c49ff..4b79a98a 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/DiffCursorFuzzTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/DiffCursorFuzzTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke;
+package org.eclipse.viatra.solver.data.map.tests.fuzz;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -10,7 +10,7 @@ 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.FuzzTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.fuzz.utils.FuzzTestUtils;
 import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
@@ -19,7 +19,7 @@ import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 class DiffCursorFuzzTest {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -85,32 +85,32 @@ class DiffCursorFuzzTest {
 
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} 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,
+        @Tag("fuzz")
+        void parametrizedFuzz(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,
+                runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
                                 noKeys, noValues, commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedSmoke() {
+        static Stream<Arguments> parametrizedFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
-        @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
-        @Tag("smoke")
+        @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        void parametrizedSlowFuzz(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,
+                runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedSlowSmoke() {
-                return FuzzTestUtils.changeStepCount(parametrizedSmoke(), 1);
+        static Stream<Arguments> parametrizedSlowFuzz() {
+                return FuzzTestUtils.changeStepCount(parametrizedFuzz(), 1);
         }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableFuzzTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/MutableFuzzTest.java
index 13ef1eb6..2d589dc9 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableFuzzTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/MutableFuzzTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke;
+package org.eclipse.viatra.solver.data.map.tests.fuzz;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -9,7 +9,7 @@ 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.FuzzTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.fuzz.utils.FuzzTestUtils;
 import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
@@ -18,7 +18,7 @@ import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 class MutableFuzzTest {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean evilHash) {
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
 
@@ -59,19 +59,33 @@ class MutableFuzzTest {
                 }
         }
 
-        @ParameterizedTest(name = "Mutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} seed={4} evil-hash={5}")
+        @ParameterizedTest(name = "Mutable {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"),
+        @Tag("fuzz")
+        void parametrizedFuzz(int test, int steps, int noKeys, int noValues, int seed, boolean evilHash) {
+                runFuzzTest(
+                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
                                 seed, steps, noKeys, noValues, evilHash);
         }
 
-        static Stream<Arguments> parametrizedSmoke() {
+        static Stream<Arguments> parametrizedFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT },
                                 new Object[] { 3, 32, 32 * 32, 32 * 32 * 32 * 32 }, new Object[] { 2, 3 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
+        
+        @ParameterizedTest(name = "Mutable {index}/{0} Steps={1} Keys={2} Values={3} seed={4} evil-hash={5}")
+        @MethodSource
+        @Tag("fuzz")
+        @Tag("slow")
+        void parametrizedSlowFuzz(int test, int steps, int noKeys, int noValues, int seed, boolean evilHash) {
+                runFuzzTest(
+                                "MutableS" + steps + "K" + noKeys + "V" + noValues + "s" + seed + "H" + (evilHash ? "Evil" : "Normal"),
+                                seed, steps, noKeys, noValues, evilHash);
+        }
+
+        static Stream<Arguments> parametrizedSlowFuzz() {
+                return FuzzTestUtils.changeStepCount(parametrizedFuzz(), 1);
+        }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableImmutableCompareFuzzTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/MutableImmutableCompareFuzzTest.java
index 77d55d5a..cc2abfe4 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableImmutableCompareFuzzTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/MutableImmutableCompareFuzzTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke;
+package org.eclipse.viatra.solver.data.map.tests.fuzz;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -9,7 +9,7 @@ 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.FuzzTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.fuzz.utils.FuzzTestUtils;
 import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
@@ -18,7 +18,7 @@ import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 class MutableImmutableCompareFuzzTest {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -56,33 +56,33 @@ class MutableImmutableCompareFuzzTest {
                 }
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
-        @Tag("smoke")
-        void parametrizedFastSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        @Tag("fuzz")
+        void parametrizedFastFuzz(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,
+                runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
                                 noKeys, noValues, commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedFastSmoke() {
+        static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Mutable-Immutable Compare Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Mutable-Immutable Compare {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
-        @Tag("smoke")
+        @Tag("fuzz")
         @Tag("slow")
-        void parametrizedSlowSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        void parametrizedSlowFuzz(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,
+                runFuzzTest("MutableImmutableCompareS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps,
                                 noKeys, noValues, commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedSlowSmoke() {
-                return FuzzTestUtils.changeStepCount(MutableImmutableCompareFuzzTest.parametrizedFastSmoke(), 1);
+        static Stream<Arguments> parametrizedSlowFuzz() {
+                return FuzzTestUtils.changeStepCount(MutableImmutableCompareFuzzTest.parametrizedFastFuzz(), 1);
         }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/RestoreFuzzTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/RestoreFuzzTest.java
index 5ce5734b..7d9f5372 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/RestoreFuzzTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/RestoreFuzzTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke;
+package org.eclipse.viatra.solver.data.map.tests.fuzz;
 
 import static org.junit.jupiter.api.Assertions.fail;
 
@@ -11,7 +11,7 @@ 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.FuzzTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.fuzz.utils.FuzzTestUtils;
 import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
@@ -20,7 +20,7 @@ import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 class RestoreFuzzTest {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -76,33 +76,33 @@ class RestoreFuzzTest {
 
         }
 
-        @ParameterizedTest(name = "Restore Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("smoke")
-        void parametrizedFastSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        void parametrizedFastFuzz(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,
+                runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedFastSmoke() {
+        static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Restore Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Restore {index}/{0} Steps={1} Keys={2} Values={3} 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,
+        void parametrizedSlowFuzz(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,
+                runFuzzTest("RestoreS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedSlowSmoke() {
-                return FuzzTestUtils.changeStepCount(RestoreFuzzTest.parametrizedFastSmoke(), 1);
+        static Stream<Arguments> parametrizedSlowFuzz() {
+                return FuzzTestUtils.changeStepCount(RestoreFuzzTest.parametrizedFastFuzz(), 1);
         }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/SharedStoreFuzzTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/SharedStoreFuzzTest.java
index 0326ebfa..800308b4 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/SharedStoreFuzzTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/SharedStoreFuzzTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke;
+package org.eclipse.viatra.solver.data.map.tests.fuzz;
 
 import java.util.HashMap;
 import java.util.LinkedList;
@@ -11,7 +11,7 @@ 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.FuzzTestUtils;
+import org.eclipse.viatra.solver.data.map.tests.fuzz.utils.FuzzTestUtils;
 import org.eclipse.viatra.solver.data.map.tests.utils.MapTestEnvironment;
 import org.junit.jupiter.api.Tag;
 import org.junit.jupiter.api.Timeout;
@@ -20,7 +20,7 @@ import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 class SharedStoreFuzzTest {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
+        private void runFuzzTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency,
                         boolean evilHash) {
                 String[] values = MapTestEnvironment.prepareValues(maxValue);
                 ContinousHashProvider<Integer> chp = MapTestEnvironment.prepareHashProvider(evilHash);
@@ -80,33 +80,33 @@ class SharedStoreFuzzTest {
 
         }
 
-        @ParameterizedTest(name = "Shared Store Test {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
         @MethodSource
         @Timeout(value = 10)
         @Tag("smoke")
-        void parametrizedFastSmoke(int tests, int steps, int noKeys, int noValues, int commitFrequency, int seed,
+        void parametrizedFastFuzz(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,
+                runFuzzTest("SharedS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedFastSmoke() {
+        static Stream<Arguments> parametrizedFastFuzz() {
                 return FuzzTestUtils.permutationWithSize(new Object[] { FuzzTestUtils.FAST_STEP_COUNT }, new Object[] { 3, 32, 32 * 32 },
                                 new Object[] { 2, 3 }, new Object[] { 1, 10, 100 }, new Object[] { 1, 2, 3 },
                                 new Object[] { false, true });
         }
 
-        @ParameterizedTest(name = "Shared Store Test {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5} evil-hash={6}")
+        @ParameterizedTest(name = "Shared Store {index}/{0} Steps={1} Keys={2} Values={3} 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,
+        void parametrizedSlowFuzz(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,
+                runFuzzTest("SharedS" + steps + "K" + noKeys + "V" + noValues + "s" + seed, seed, steps, noKeys, noValues,
                                 commitFrequency, evilHash);
         }
 
-        static Stream<Arguments> parametrizedSlowSmoke() {
-                return FuzzTestUtils.changeStepCount(RestoreFuzzTest.parametrizedFastSmoke(), 1);
+        static Stream<Arguments> parametrizedSlowFuzz() {
+                return FuzzTestUtils.changeStepCount(RestoreFuzzTest.parametrizedFastFuzz(), 1);
         }
 }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/FuzzTestUtils.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/utils/FuzzTestUtils.java
index 1e85020a..ec21bb7b 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/FuzzTestUtils.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/utils/FuzzTestUtils.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke.utils;
+package org.eclipse.viatra.solver.data.map.tests.fuzz.utils;
 
 import java.util.Arrays;
 import java.util.LinkedList;
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/FuzzTestUtilsTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/utils/FuzzTestUtilsTest.java
index e1b49dfd..3f4214bc 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/FuzzTestUtilsTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/fuzz/utils/FuzzTestUtilsTest.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map.tests.smoke.utils;
+package org.eclipse.viatra.solver.data.map.tests.fuzz.utils;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;