Smoketest refactor splitting fast and slow smoke tests

13 files changed, 155 insertions, 33 deletions

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/MapUnitTests.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/MapUnitTests.java
deleted file mode 100644
index f4137375..00000000
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/MapUnitTests.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package org.eclipse.viatra.solver.data.map;
-
-public class MapUnitTests {
-
-}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/MapUnitTests.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/MapUnitTests.java
new file mode 100644
index 00000000..db68ae03
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/MapUnitTests.java
@@ -0,0 +1,5 @@
+package org.eclipse.viatra.solver.data.map.test;
+
+public class MapUnitTests {
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/TestPermuter.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/TestPermuter.java
index db97cdf5..d9e50508 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/TestPermuter.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/TestPermuter.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map;
+package org.eclipse.viatra.solver.data.map.test.smoke;
 
 import static org.junit.Assert.assertTrue;
 import static org.junit.jupiter.api.Assertions.assertEquals;
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest1Mutable.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest1Mutable.java
index ecc189dc..a1d37241 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest1Mutable.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest1Mutable.java
@@ -1,18 +1,23 @@
-package org.eclipse.viatra.solver.data.map;
+package org.eclipse.viatra.solver.data.map.test.smoke.fast;
 
 import static org.junit.Assert.fail;
 
 import java.util.Random;
 import java.util.stream.Stream;
 
+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.test.smoke.TestPermuter;
+import org.eclipse.viatra.solver.data.map.test.support.MapTestEnvironment;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 public class SmokeTest1Mutable {
         
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, boolean evilHash) {
+        public 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);
                 
@@ -65,9 +70,9 @@ public class SmokeTest1Mutable {
                 runSmokeTest("SmokeS"+steps+"K"+noKeys+"V"+noValues+"s"+seed+"H"+(evilHash?"Evil":"Normal"),seed,steps,noKeys,noValues,evilHash);
         }
         
-        private static Stream<Arguments> parametrizedSmoke(){
+        public static Stream<Arguments> parametrizedSmoke(){
                 return TestPermuter.permutationWithSize(
-                        new Object[] {1000,32*32*32*32},
+                        new Object[] {1000},
                         new Object[] {3,32, 32*32, 32*32*32*32},
                         new Object[] {2,3},
                         new Object[] {1,2,3},
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest2Commit.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest2Commit.java
index 8255746a..18cb9f58 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest2Commit.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest2Commit.java
@@ -1,17 +1,22 @@
-package org.eclipse.viatra.solver.data.map;
+package org.eclipse.viatra.solver.data.map.test.smoke.fast;
 
 import static org.junit.Assert.fail;
 
 import java.util.Random;
 import java.util.stream.Stream;
 
+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.test.smoke.TestPermuter;
+import org.eclipse.viatra.solver.data.map.test.support.MapTestEnvironment;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 public class SmokeTest2Commit {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency, boolean evilHash) {
+        public 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);
                 
@@ -70,9 +75,9 @@ public class SmokeTest2Commit {
                 runSmokeTest("SmokeCommitS"+steps+"K"+noKeys+"V"+noValues+"s"+seed,seed,steps,noKeys,noValues,commitFrequency,evilHash);
         }
         
-        private static Stream<Arguments> parametrizedSmoke(){
+        public static Stream<Arguments> parametrizedSmoke(){
                 return TestPermuter.permutationWithSize(
-                        new Object[] {1000,32*32*32*32},
+                        new Object[] {1000},
                         new Object[] {3,32, 32*32},
                         new Object[] {2,3},
                         new Object[] {1,10,100},
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest3MutableImmutableCompare.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest3MutableImmutableCompare.java
index ad03566a..b8dce3f5 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest3MutableImmutableCompare.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest3MutableImmutableCompare.java
@@ -1,17 +1,22 @@
-package org.eclipse.viatra.solver.data.map;
+package org.eclipse.viatra.solver.data.map.test.smoke.fast;
 
 import static org.junit.Assert.fail;
 
 import java.util.Random;
 import java.util.stream.Stream;
 
+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.test.smoke.TestPermuter;
+import org.eclipse.viatra.solver.data.map.test.support.MapTestEnvironment;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 public class SmokeTest3MutableImmutableCompare {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency, boolean evilHash) {
+        public 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);
                 
@@ -61,9 +66,9 @@ public class SmokeTest3MutableImmutableCompare {
                 runSmokeTest("SmokeMutableImmutableCompareS"+steps+"K"+noKeys+"V"+noValues+"s"+seed,seed,steps,noKeys,noValues,commitFrequency,evilHash);
         }
         
-        private static Stream<Arguments> parametrizedSmoke(){
+        public static Stream<Arguments> parametrizedSmoke(){
                 return TestPermuter.permutationWithSize(
-                        new Object[] {1000,32*32*32*32},
+                        new Object[] {1000},
                         new Object[] {3,32, 32*32},
                         new Object[] {2,3},
                         new Object[] {1,10,100},
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest4Restore.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest4Restore.java
index f0b3e56e..e024700a 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest4Restore.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest4Restore.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map;
+package org.eclipse.viatra.solver.data.map.test.smoke.fast;
 
 import static org.junit.Assert.fail;
 
@@ -7,13 +7,18 @@ import java.util.Map;
 import java.util.Random;
 import java.util.stream.Stream;
 
+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.test.smoke.TestPermuter;
+import org.eclipse.viatra.solver.data.map.test.support.MapTestEnvironment;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.Arguments;
 import org.junit.jupiter.params.provider.MethodSource;
 
 public class SmokeTest4Restore {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency, boolean evilHash) {
+        public 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);
                 
@@ -86,9 +91,9 @@ public class SmokeTest4Restore {
                 runSmokeTest("SmokeMutableImmutableCompareS"+steps+"K"+noKeys+"V"+noValues+"s"+seed,seed,steps,noKeys,noValues,commitFrequency,evilHash);
         }
         
-        private static Stream<Arguments> parametrizedSmoke(){
+        public static Stream<Arguments> parametrizedSmoke(){
                 return TestPermuter.permutationWithSize(
-                        new Object[] {1000,32*32*32*32},
+                        new Object[] {1000},
                         new Object[] {3,32, 32*32},
                         new Object[] {2,3},
                         new Object[] {1,10,100},
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest5DiffCursor.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest5DiffCursor.java
new file mode 100644
index 00000000..d25b6303
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest5DiffCursor.java
@@ -0,0 +1,5 @@
+package org.eclipse.viatra.solver.data.map.test.smoke.fast;
+
+public class SmokeTest5DiffCursor {
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest6SharedCache.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest6SharedCache.java
new file mode 100644
index 00000000..6cae74e0
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest6SharedCache.java
@@ -0,0 +1,5 @@
+package org.eclipse.viatra.solver.data.map.test.smoke.fast;
+
+public class SmokeTest6SharedCache {
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest7Multithread.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest7Multithread.java
new file mode 100644
index 00000000..591c1361
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/fast/SmokeTest7Multithread.java
@@ -0,0 +1,5 @@
+package org.eclipse.viatra.solver.data.map.test.smoke.fast;
+
+public class SmokeTest7Multithread {
+
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/slow/SmokeTestSlow.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/slow/SmokeTestSlow.java
new file mode 100644
index 00000000..936c0e8d
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/smoke/slow/SmokeTestSlow.java
@@ -0,0 +1,67 @@
+package org.eclipse.viatra.solver.data.map.test.smoke.slow;
+
+import java.util.Arrays;
+import java.util.stream.Stream;
+
+import org.eclipse.viatra.solver.data.map.test.smoke.TestPermuter;
+import org.eclipse.viatra.solver.data.map.test.smoke.fast.SmokeTest1Mutable;
+import org.eclipse.viatra.solver.data.map.test.smoke.fast.SmokeTest2Commit;
+import org.eclipse.viatra.solver.data.map.test.smoke.fast.SmokeTest3MutableImmutableCompare;
+import org.eclipse.viatra.solver.data.map.test.smoke.fast.SmokeTest4Restore;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+
+public class SmokeTestSlow {
+        
+        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 SmokeTest1Mutable()).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(SmokeTest1Mutable.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 SmokeTest2Commit()).runSmokeTest("SmokeCommitS"+steps+"K"+noKeys+"V"+noValues+"s"+seed,seed,steps,noKeys,noValues,commitFrequency,evilHash);
+        }
+        
+        private static Stream<Arguments> smoke2(){
+                return changeStepCount(SmokeTest2Commit.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 SmokeTest3MutableImmutableCompare()).runSmokeTest("SmokeMutableImmutableCompareS"+steps+"K"+noKeys+"V"+noValues+"s"+seed,seed,steps,noKeys,noValues,commitFrequency,evilHash);
+        }
+        
+        private static Stream<Arguments> smoke3(){
+                return changeStepCount(SmokeTest3MutableImmutableCompare.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 SmokeTest4Restore()).runSmokeTest("SmokeMutableImmutableCompareS"+steps+"K"+noKeys+"V"+noValues+"s"+seed,seed,steps,noKeys,noValues,commitFrequency,evilHash);
+        }
+        
+        private static Stream<Arguments> smoke4(){
+                return changeStepCount(SmokeTest4Restore.parametrizedSmoke());
+        }
+}
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/MapTestEnvironment.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/support/MapTestEnvironment.java
index e53dc9f9..ba1d0cff 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/MapTestEnvironment.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/support/MapTestEnvironment.java
@@ -1,4 +1,4 @@
-package org.eclipse.viatra.solver.data.map;
+package org.eclipse.viatra.solver.data.map.test.support;
 
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
@@ -10,6 +10,8 @@ import java.util.Map;
 import java.util.Map.Entry;
 import java.util.TreeMap;
 
+import org.eclipse.viatra.solver.data.map.ContinousHashProvider;
+import org.eclipse.viatra.solver.data.map.Cursor;
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
 
 public class MapTestEnvironment<KEY,VALUE> {
@@ -39,16 +41,11 @@ public class MapTestEnvironment<KEY,VALUE> {
                                 
                                 return result;
                         }
-                        
-                        @Override
-                        public boolean equals(Integer key1, Integer key2) {
-                                return key1.equals(key2);
-                        }
                 };
                 return chp;
         }
         
-        public static <KEY, VALUE> void compareTwoMaps(VersionedMapImpl<KEY, VALUE> map1, VersionedMapImpl<KEY, VALUE> map2) {
+        public static <KEY, VALUE> void compareTwoMaps(String title, VersionedMapImpl<KEY, VALUE> map1, VersionedMapImpl<KEY, VALUE> map2) {
                 //1. Comparing cursors.
                 Cursor<KEY, VALUE> cursor1 = map1.getCursor();
                 Cursor<KEY, VALUE> cursor2 = map2.getCursor();
@@ -64,12 +61,12 @@ public class MapTestEnvironment<KEY,VALUE> {
                 if(!cursor2.isTerminated()) fail("cursor 1 terminated before cursor 2");
                 
                 // 2.1. comparing hash codes
-                assertEquals(map1.hashCode(), map2.hashCode());
-                assertTrue(map1.equals(map2));
-                assertTrue(map2.equals(map1));
+                assertEquals(map1.hashCode(), map2.hashCode(), title+": hash code check");
+                assertTrue(title+": 1.equals(2)", map1.equals(map2));
+                assertTrue(title+": 2.equals(1)", map2.equals(map1));
         }
         
-        VersionedMapImpl<KEY, VALUE> sut;
+        public VersionedMapImpl<KEY, VALUE> sut;
         Map<KEY,VALUE> oracle = new HashMap<KEY, VALUE>();
         
         public MapTestEnvironment(VersionedMapImpl<KEY, VALUE> sut) {
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/support/PrimeTesting.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/support/PrimeTesting.java
new file mode 100644
index 00000000..e5717f3a
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/test/support/PrimeTesting.java
@@ -0,0 +1,23 @@
+package org.eclipse.viatra.solver.data.map.test.support;
+
+public class PrimeTesting {
+
+        public static void main(String[] args) {
+                int max = 2;
+                for(int i=2147482647; i<Integer.MAX_VALUE; i++) {
+                        if(isPrime(i) ) {
+                                max = i;
+                                System.out.println(max);
+                        }
+                }
+                System.out.println(max);
+        }
+        private static boolean isPrime(int x) {
+                for(int tester = 2; tester < Math.sqrt(x); tester++) {
+                        if(x%tester == 0) {
+                                return false;
+                        }
+                }
+                return true;
+        }
+}