parametric testing and permutaters

2 files changed, 139 insertions, 29 deletions

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/SmokeTest1Mutable.java
index 76d40e3c..cf3b8d5e 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/SmokeTest1Mutable.java
@@ -3,9 +3,12 @@ package org.eclipse.viatra.solver.data.map;
 import static org.junit.Assert.fail;
 
 import java.util.Random;
+import java.util.stream.Stream;
 
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
-import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
 
 public class SmokeTest1Mutable {
         
@@ -86,34 +89,51 @@ public class SmokeTest1Mutable {
                 }
         }
         
-        @Test
-        void MiniSmokeK3V2v1() {
-                runSmokeTest("MiniSmokeK3V2v1",0, 1000, 3, 2);
+        @ParameterizedTest(name = "Mutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} seed={4}")
+        @MethodSource
+        void parametrizedSmoke(int test, int steps, int noKeys, int noValues, int seed) {
+                runSmokeTest("Smoke"+test+"S"+steps+"K"+noKeys+"V"+noValues+"s"+seed,seed,steps,noKeys,noValues);
         }
-        @Test
-        void MiniSmokeK3V2v2() {
-                runSmokeTest("MiniSmokeK3V2v2",1, 1000, 3, 2);
-        }
-        @Test
-        void MiniSmokeK3V2v3() {
-                runSmokeTest("MiniSmokeK3V2v3",3, 1000, 3, 2);
-        }
-        @Test
-        void MediumSmokeK3V2v1() {
-                runSmokeTest("MediumSmokeK3V2v1",1, 1000, 32, 2);
-        }
-        @Test
-        void MediumSmokeK3V2v2() {
-                runSmokeTest("MediumSmokeK3V2v2",2, 1000, 32, 2);
-        }
-        @Test
-        void MediumSmokeK3V2v3() {
-                runSmokeTest("MediumSmokeK3V2v3",3, 1000, 32, 2);
-        }
-        @Test
-        void SmokeLarge() {
-                var milis = System.currentTimeMillis();
-                runSmokeTest("SmokeLarge",0, 32*32*32*32, 32*32-1, 2);
-                System.out.println(System.currentTimeMillis()-milis);
+        
+        private static Stream<Arguments> parametrizedSmoke(){
+                return TestPermuter.permutationWithSize(
+                        new Object[] {1000,32*32*32*32},
+                        new Object[] {3,32, 32*32, 32*32*32*32},
+                        new Object[] {2,3},
+                        new Object[] {1,2,3}
+                );
         }
+
+
+        
+//      @Test
+//      void MiniSmokeK3V2v1() {
+//              runSmokeTest("MiniSmokeK3V2v1",0, 1000, 3, 2);
+//      }
+//      @Test
+//      void MiniSmokeK3V2v2() {
+//              runSmokeTest("MiniSmokeK3V2v2",1, 1000, 3, 2);
+//      }
+//      @Test
+//      void MiniSmokeK3V2v3() {
+//              runSmokeTest("MiniSmokeK3V2v3",3, 1000, 3, 2);
+//      }
+//      @Test
+//      void MediumSmokeK3V2v1() {
+//              runSmokeTest("MediumSmokeK3V2v1",1, 1000, 32, 2);
+//      }
+//      @Test
+//      void MediumSmokeK3V2v2() {
+//              runSmokeTest("MediumSmokeK3V2v2",2, 1000, 32, 2);
+//      }
+//      @Test
+//      void MediumSmokeK3V2v3() {
+//              runSmokeTest("MediumSmokeK3V2v3",3, 1000, 32, 2);
+//      }
+//      @Test
+//      void SmokeLarge() {
+//              var milis = System.currentTimeMillis();
+//              runSmokeTest("SmokeLarge",0, 32*32*32*32, 32*32-1, 2);
+//              System.out.println(System.currentTimeMillis()-milis);
+//      }
 }
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/TestPermuter.java
new file mode 100644
index 00000000..db97cdf5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/TestPermuter.java
@@ -0,0 +1,90 @@
+package org.eclipse.viatra.solver.data.map;
+
+import static org.junit.Assert.assertTrue;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+import java.util.LinkedList;
+import java.util.List;
+import java.util.stream.Stream;
+
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.provider.Arguments;
+
+public class TestPermuter {
+        private static List<List<Object>> permutation_internal(int from, Object[]... valueOption) {
+                if(valueOption.length == from) {
+                        return List.of(List.of()); // empty list
+                } else {
+                        Object[] permuteThis = valueOption[from];
+                        List<List<Object>> otherCombination = permutation_internal(from+1,valueOption);
+                        
+                        List<List<Object>> result = new LinkedList<>();
+                        for(Object permuteThisElement : permuteThis) {
+                                for(List<Object> otherCombinationList : otherCombination) {
+                                        List<Object> newResult = new LinkedList<>();
+                                        newResult.add(permuteThisElement);
+                                        newResult.addAll(otherCombinationList);
+                                        result.add(newResult);
+                                }
+                        }
+                        return result;
+                }
+        }
+        public static Stream<Arguments> permutation(Object[]... valueOption) {
+                List<List<Object>> permutations = permutation_internal(0, valueOption);
+                return permutations.stream().map(x -> Arguments.of(x.toArray()));
+        }
+        public static Stream<Arguments> permutationWithSize(Object[]... valueOption) {
+                int size = 1;
+                for(int i = 0; i< valueOption.length; i++) {
+                        size *= valueOption[i].length;
+                }
+                Object[][] newValueOption = new Object[valueOption.length+1][];
+                newValueOption[0] = new Object[] {size};
+                for(int i = 1; i<newValueOption.length; i++) {
+                        newValueOption[i]=valueOption[i-1];
+                }
+                return permutation(newValueOption);
+        }
+        
+        @Test
+        public void permutation_internalTest() {
+                List<List<Object>> res = permutation_internal(0,
+                        new Object[]{1,2,3},
+                        new Object[]{'a','b','c'},
+                        new Object[]{"alpha","beta","gamma","delta"}
+                );
+//              for(var permutation : res) {
+//                      System.out.print("[");
+//                      for(int index = 0; index<permutation.size(); index++) {
+//                              if(index!=0) System.out.print(",");
+//                              System.out.print(permutation.get(index));
+//                      }
+//                      System.out.println("]");
+//              }
+                assertTrue(res.size()==3*3*4);
+        }
+        
+        @Test
+        public void permutationTest1() {
+                var res = permutation(
+                        new Object[]{1,2,3},
+                        new Object[]{'a','b','c'},
+                        new Object[]{"alpha","beta","gamma","delta"}
+                );
+                assertTrue(res.count()==3*3*4);
+        }
+        @Test
+        public void permutationTest2() {
+                var res = permutation(
+                        new Object[]{1,2,3},
+                        new Object[]{'a','b','c'},
+                        new Object[]{"alpha","beta","gamma","delta"}
+                );
+                var arguments = res.findFirst().get().get();
+                assertEquals(arguments[0], 1);
+                assertEquals(arguments[1], 'a');
+                assertEquals(arguments[2], "alpha");
+                System.out.println(arguments[0]);
+        }
+}