hash code fix and test environment reorganization

7 files changed, 179 insertions, 203 deletions

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java
index 229aee74..19b0720d 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java
@@ -110,10 +110,8 @@ public class ImmutableNode<KEY, VALUE> extends Node<KEY, VALUE> {
                 else if((nodeMap & bitposition) != 0) {
                         int keyIndex = content.length-1-index(nodeMap, bitposition);
                         ImmutableNode<KEY,VALUE> subNode = (ImmutableNode<KEY,VALUE>) content[keyIndex];
-                        int newHash = depth%numberOfFactors == 0?
-                                        hashProvider.getHash(key, hashDepth(depth)) :
-                                        hash;
                         int newDepth = depth+1;
+                        int newHash = newHash(hashProvider, key, hash, newDepth);
                         return subNode.getValue(key, hashProvider, defaultValue, newHash, newDepth);
                 }
                 // the key is not stored at all
@@ -160,8 +158,8 @@ public class ImmutableNode<KEY, VALUE> extends Node<KEY, VALUE> {
                         
                         int keyIndex = content.length-1-index(dataMap, bitposition);
                         ImmutableNode<KEY,VALUE> subNode = (ImmutableNode<KEY,VALUE>) content[keyIndex];
-                        int newHash = newHash(hashProvider, key, selectedHashFragment, depth);
                         int newDepth = depth+1;
+                        int newHash = newHash(hashProvider, key, hash, newDepth);
                         Node<KEY,VALUE> newsubNode = subNode.putValue(key, value, hashProvider, defaultValue, newHash, newDepth);
                         
                         if(subNode == newsubNode) {
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/MutableNode.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/MutableNode.java
index 6e177d9f..4d216785 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/MutableNode.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/MutableNode.java
@@ -26,6 +26,7 @@ public class MutableNode<KEY,VALUE> extends Node<KEY,VALUE> {
                         MutableNode<KEY, VALUE> res = new MutableNode<KEY, VALUE>();
                         res.content[2*fragment] = key;
                         res.content[2*fragment+1] = value;
+                        res.updateHash();
                         return res;
                 }
         }
@@ -49,25 +50,25 @@ public class MutableNode<KEY,VALUE> extends Node<KEY,VALUE> {
                                 nodeUsed++;
                         }
                 }
-                updateHash();
+                this.cachedHash = node.hashCode();
         }
         
         @SuppressWarnings("unchecked")
         @Override
         public VALUE getValue(KEY key, ContinousHashProvider<? super KEY> hashProvider, VALUE defaultValue, int hash, int depth) {
                 int selectedHashFragment = hashFragment(hash,shiftDepth(depth));
-                KEY keyCandidate = (KEY) content[2*selectedHashFragment];
+                KEY keyCandidate = (KEY) this.content[2*selectedHashFragment];
                 if(keyCandidate != null) {
                         if(hashProvider.equals(keyCandidate, key)) {
-                                return (VALUE) content[2*selectedHashFragment+1];
+                                return (VALUE) this.content[2*selectedHashFragment+1];
                         } else {
                                 return defaultValue;
                         }
                 } else {
                         Node<KEY,VALUE> nodeCandidate = (Node<KEY,VALUE>) content[2*selectedHashFragment+1];
                         if(nodeCandidate != null) {
-                                int newHash = newHash(hashProvider, key, hash, depth);
                                 int newDepth = depth+1;
+                                int newHash = newHash(hashProvider, key, hash, newDepth);
                                 return nodeCandidate.getValue(key, hashProvider, defaultValue, newHash, newDepth);
                         } else {
                                 return defaultValue;
@@ -81,38 +82,6 @@ public class MutableNode<KEY,VALUE> extends Node<KEY,VALUE> {
                 }
                 return false;
         }
-
-        private MutableNode<KEY,VALUE> createNewNode(
-                        ContinousHashProvider<? super KEY> hashProvider,
-                        KEY key1, VALUE value1, int oldHash1,
-                        KEY key2, VALUE value2, int oldHash2,
-                        int newdepth)
-        {
-                int newHash1 = newHash(hashProvider, key1, oldHash1, newdepth);
-                int newHash2 = newHash(hashProvider, key2, oldHash2, newdepth);
-                int newFragment1 = hashFragment(newHash1, newdepth);
-                int newFragment2 = hashFragment(newHash2, newdepth);
-                
-                MutableNode<KEY,VALUE> subNode = new MutableNode<KEY,VALUE>();
-                if(newFragment1 != newFragment2) {
-                        subNode.content[newFragment1*2]=key1;
-                        subNode.content[newFragment1*2+1]=value1;
-                        
-                        subNode.content[newFragment2*2]=key2;
-                        subNode.content[newFragment2*2+1]=value2;
-                        subNode.updateHash();
-                        return subNode;
-                } else {
-                        MutableNode<KEY,VALUE> subSubNode = createNewNode(
-                                        hashProvider,
-                                        key1, value1, newHash1,
-                                        key2, value2, newHash2,
-                                        newdepth+1);
-                        subNode.content[newFragment1*2+1] = subSubNode;
-                        subNode.updateHash();
-                        return subNode;
-                }
-        }
         
         @SuppressWarnings("unchecked")
         @Override
@@ -120,28 +89,34 @@ public class MutableNode<KEY,VALUE> extends Node<KEY,VALUE> {
                 int selectedHashFragment = hashFragment(hash,shiftDepth(depth));
                 KEY keyCandidate = (KEY) content[2*selectedHashFragment];
                 if(keyCandidate != null) {
+                        // If has key
                         if(hashProvider.equals(keyCandidate,key)) {
-                                // Update entry
+                                // The key is equals to an existing key -> update entry
                                 if(value == defaultValue) {
                                         return removeEntry(selectedHashFragment);
                                 } else {
                                         return updateValue(value,selectedHashFragment);
                                 }
                         } else {
+                                // The key is not equivalent to an existing key on the same hash bin
+                                //   -> split entry if it is necessary 
                                 if(value == defaultValue) {
-                                        // dont need to add new node
+                                        // Value is default -> do not need to add new node
                                         return this;
                                 } else {
-                                        // Split entry: data -> node
-                                        return moveDown(key, value, hashProvider, hash, depth, selectedHashFragment, keyCandidate);
+                                        // Value is not default -> Split entry data to a new node
+                                        return moveDownAndSplit(hashProvider, key, value, keyCandidate, hash, depth, selectedHashFragment);
                                 }
                         }
                 } else {
+                        // If it does not have key, check for value
                         Node<KEY,VALUE> nodeCandidate =  (Node<KEY,VALUE>) content[2*selectedHashFragment+1];
                         if(nodeCandidate != null) {
+                                // If it has value, it is a subnode -> upate that
                                 Node<KEY, VALUE> newNode = nodeCandidate.putValue(key, value, hashProvider, defaultValue, newHash(hashProvider, key, hash, depth+1), depth+1);
                                 return updateSubNode(selectedHashFragment,newNode);
                         } else {
+                                // If it does not have value, put it in the empty place
                                 if(value == defaultValue) {
                                         // dont need to add new key-value pair
                                         return this;
@@ -152,6 +127,8 @@ public class MutableNode<KEY,VALUE> extends Node<KEY,VALUE> {
                         }
                 }
         }
+        
+
 
         private Node<KEY, VALUE> addEntry(KEY key, VALUE value, int selectedHashFragment) {
                 content[2*selectedHashFragment] = key;
@@ -189,24 +166,60 @@ public class MutableNode<KEY,VALUE> extends Node<KEY,VALUE> {
         }
         
         @SuppressWarnings("unchecked")
-        private Node<KEY, VALUE> moveDown(
-                        KEY key, VALUE value,
-                        ContinousHashProvider<? super KEY> hashProvider, int hash,
-                        int depth, int selectedHashFragment, KEY keyCandidate) {
-                KEY previousKey = keyCandidate;
-                VALUE previousValue = (VALUE) content[2*selectedHashFragment+1];
-                
-                MutableNode<KEY,VALUE> subNode = createNewNode(
+        private Node<KEY, VALUE> moveDownAndSplit(
+                        ContinousHashProvider<? super KEY> hashProvider,
+                        KEY newKey, VALUE newValue, KEY previousKey,
+                        int hashOfNewKey, int depth, int selectedHashFragmentOfCurrentDepth)
+        {
+                VALUE previousValue = (VALUE) content[2*selectedHashFragmentOfCurrentDepth+1];
+                                
+                //final int newHash = newHash(hashProvider, newKey, hashOfNewKey, newDepth);
+                MutableNode<KEY,VALUE> newSubNode = newNodeWithTwoEntries(
                         hashProvider,
                         previousKey, previousValue, hashProvider.getHash(previousKey, hashDepth(depth)),
-                        key, value, hash,
+                        newKey, newValue, hashOfNewKey,
                         depth+1);
                 
-                content[2*selectedHashFragment] = null;
-                content[2*selectedHashFragment+1] = subNode;
+                content[2*selectedHashFragmentOfCurrentDepth] = null;
+                content[2*selectedHashFragmentOfCurrentDepth+1] = newSubNode;
                 updateHash();
                 return this;
         }
+        private MutableNode<KEY,VALUE> newNodeWithTwoEntries(
+                        ContinousHashProvider<? super KEY> hashProvider,
+                        KEY key1, VALUE value1, int oldHash1,
+                        KEY key2, VALUE value2, int oldHash2,
+                        int newdepth)
+        {
+//              final int depthLimit = 4000;
+//              if(newdepth>depthLimit) {
+//                      final int newHashes = 4000/numberOfFactors;
+//                      throw new IllegalArgumentException(
+//                              "Continuous hash was same " + newHashes + " times for non-equivalent objects " + key1 + " and " + key2 +".");
+//              }
+                int newHash1 = newHash(hashProvider, key1, oldHash1, newdepth);
+                int newHash2 = newHash(hashProvider, key2, oldHash2, newdepth);
+                int newFragment1 = hashFragment(newHash1, shiftDepth(newdepth));
+                int newFragment2 = hashFragment(newHash2, shiftDepth(newdepth));
+                
+                MutableNode<KEY,VALUE> subNode = new MutableNode<KEY,VALUE>();
+                if(newFragment1 != newFragment2) {
+                        subNode.content[newFragment1*2]=key1;
+                        subNode.content[newFragment1*2+1]=value1;
+                        
+                        subNode.content[newFragment2*2]=key2;
+                        subNode.content[newFragment2*2+1]=value2;
+                } else {
+                        MutableNode<KEY,VALUE> subSubNode = newNodeWithTwoEntries(
+                                        hashProvider,
+                                        key1, value1, newHash1,
+                                        key2, value2, newHash2,
+                                        newdepth+1);
+                        subNode.content[newFragment1*2+1] = subSubNode;
+                }
+                subNode.updateHash();
+                return subNode;
+        }
         
         Node<KEY, VALUE> removeEntry(int selectedHashFragment) {
                 content[2*selectedHashFragment] = null;
@@ -334,6 +347,40 @@ public class MutableNode<KEY,VALUE> extends Node<KEY,VALUE> {
                         }
                 }
         }
+        @SuppressWarnings({"unchecked"})
+        @Override
+        public void checkIntegrity(ContinousHashProvider<? super KEY> hashProvider, VALUE defaultValue, int depth) {
+                for(int i = 0; i<factor; i++) {
+                        if(this.content[2*i] != null) {
+                                KEY key = (KEY) this.content[2*i];
+                                VALUE value = (VALUE) this.content[2*i+1];
+                                
+                                if(value == defaultValue) {
+                                        throw new IllegalStateException("Node contains default value!");
+                                }
+                                int hashCode = hashProvider.getHash(key, hashDepth(depth));
+                                int shiftDepth = shiftDepth(depth);
+                                int selectedHashFragment = hashFragment(hashCode, shiftDepth);
+                                if(i != selectedHashFragment) {
+                                        throw new IllegalStateException(
+                                                "Key "+key+" with hash code "+hashCode+" is in bad place! Fragment=" + selectedHashFragment +", Place="+i);
+                                }
+                        }
+                }
+                for(int i = 0; i<factor; i++) {
+                        if(this.content[2*i+1] != null && this.content[2*i] == null) {
+                                Node<KEY,VALUE> subNode = (Node<KEY, VALUE>) this.content[2*i+1];
+                                subNode.checkIntegrity(hashProvider, defaultValue, depth+1);
+                        }
+                }
+                int oldHash = this.cachedHash;
+                updateHash();
+                int newHash = this.cachedHash;
+                if(oldHash != newHash) {
+                        throw new IllegalStateException("Hash code was not up to date! (old="+oldHash+",new="+newHash+")");
+                }
+        }
+        
         
         protected void updateHash() {
                 final int prime = 31;
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/Node.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/Node.java
index 7d547dce..d83c86b7 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/Node.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/Node.java
@@ -74,5 +74,6 @@ public abstract class Node<KEY,VALUE>{
                 prettyPrint(stringBuilder, 0, -1);
                 return stringBuilder.toString();
         }
+        public void checkIntegrity(ContinousHashProvider<? super KEY> hashProvider, VALUE defaultValue, int depth) {}
         
 }
diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
index e32fa94b..fd5c9b41 100644
--- a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/src/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
@@ -2,7 +2,6 @@ package org.eclipse.viatra.solver.data.map.internal;
 
 import java.util.Iterator;
 import java.util.Map;
-import java.util.WeakHashMap;
 
 import org.eclipse.viatra.solver.data.map.ContinousHashProvider;
 import org.eclipse.viatra.solver.data.map.Cursor;
@@ -142,4 +141,9 @@ public class VersionedMapImpl<KEY,VALUE> implements VersionedMap<KEY,VALUE>{
                         System.out.println("empty tree");
                 }
         }
+        public void checkIntegrity() {
+                if(this.root != null) {
+                        this.root.checkIntegrity(hashProvider, defaultValue, 0);
+                }
+        }
 }
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/MapTestEnvironment.java
index 1dcf7a63..11e1c1a7 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/MapTestEnvironment.java
@@ -11,6 +11,41 @@ import java.util.TreeMap;
 import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
 
 public class MapTestEnvironment<KEY,VALUE> {
+        public static String[] prepareValues(int maxValue) {
+                String[] values = new String[maxValue];
+                values[0] = "DEFAULT";
+                for(int i = 1; i<values.length; i++) {
+                        values[i] = "VAL"+i;
+                }
+                return values;
+        }
+        
+        //private static final int maxPrime = 2147483629;
+        public static ContinousHashProvider<Integer> prepareHashProvider(final boolean evil) {
+                ContinousHashProvider<Integer> chp = new ContinousHashProvider<Integer>() {
+                        
+                        @Override
+                        public int getHash(Integer key, int index) {
+                                if(evil && index < 100 && index < key/3) {
+                                        return 7;
+                                }
+                                int result = 1;
+                                final int prime = 31;
+                                
+                                result = prime*result + key;
+                                result = prime*result + index;
+                                
+                                return result;
+                        }
+                        
+                        @Override
+                        public boolean equals(Integer key1, Integer key2) {
+                                return key1.equals(key2);
+                        }
+                };
+                return chp;
+        }
+        
         VersionedMapImpl<KEY, VALUE> sut;
         Map<KEY,VALUE> oracle = new HashMap<KEY, VALUE>();
         
@@ -28,6 +63,14 @@ public class MapTestEnvironment<KEY,VALUE> {
         }
         
         public void checkEquivalence(String title) {
+                // 0. Checking integrity
+                try {
+                        sut.checkIntegrity();
+                } catch(IllegalStateException e) {
+                        fail(title + ":  " + e.getMessage());
+                }
+                
+                
                 // 1. Checking: if Reference contains <key,value> pair, then SUT contains <key,value> pair.
                 // Tests get functions
                 for(Entry<KEY, VALUE> entry : oracle.entrySet()) {
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 cf3b8d5e..4e6e46e3 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
@@ -12,9 +12,9 @@ import org.junit.jupiter.params.provider.MethodSource;
 
 public class SmokeTest1Mutable {
         
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue) {
-                String[] values = prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = prepareHashProvider();
+        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);
                 
                 VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
                 VersionedMapImpl<Integer, String> sut = (VersionedMapImpl<Integer, String>) store.createMap();
@@ -25,36 +25,6 @@ public class SmokeTest1Mutable {
                 iterativeRandomPuts(scenario, steps, maxKey, values, e, r);
         }
 
-
-
-        private String[] prepareValues(int maxValue) {
-                String[] values = new String[maxValue];
-                values[0] = "DEFAULT";
-                for(int i = 1; i<values.length; i++) {
-                        values[i] = "VAL"+i;
-                }
-                return values;
-        }
-        private ContinousHashProvider<Integer> prepareHashProvider() {
-                ContinousHashProvider<Integer> chp = new ContinousHashProvider<Integer>() {
-                        
-                        @Override
-                        public int getHash(Integer key, int index) {
-                                int result = 1;
-                                final int prime = 31;
-                                result = prime*result + key;
-                                result = prime*result + index;
-                                return result;
-                        }
-                        
-                        @Override
-                        public boolean equals(Integer key1, Integer key2) {
-                                return key1.equals(key2);
-                        }
-                };
-                return chp;
-        }
-        
         void iterativeRandomPuts(
                 String scenario,
                 int steps,
@@ -89,10 +59,10 @@ public class SmokeTest1Mutable {
                 }
         }
         
-        @ParameterizedTest(name = "Mutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} seed={4}")
+        @ParameterizedTest(name = "Mutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} seed={4}, evil-hash={5}")
         @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);
+        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);
         }
         
         private static Stream<Arguments> parametrizedSmoke(){
@@ -100,7 +70,8 @@ public class SmokeTest1Mutable {
                         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}
+                        new Object[] {1,2,3},
+                        new Object[] {false,true}
                 );
         }
 
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/SmokeTest2Commit.java
index 337725a6..fa57f2d3 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/SmokeTest2Commit.java
@@ -3,14 +3,17 @@ 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 SmokeTest2Commit {
-        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency) {
-                String[] values = prepareValues(maxValue);
-                ContinousHashProvider<Integer> chp = prepareHashProvider();
+        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);
                 
                 VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
                 VersionedMapImpl<Integer, String> sut = (VersionedMapImpl<Integer, String>) store.createMap();
@@ -20,36 +23,6 @@ public class SmokeTest2Commit {
                 
                 iterativeRandomPutsAndCommits(scenario, steps, maxKey, values, e, r, commitFrequency);
         }
-
-
-
-        private String[] prepareValues(int maxValue) {
-                String[] values = new String[maxValue];
-                values[0] = "DEFAULT";
-                for(int i = 1; i<values.length; i++) {
-                        values[i] = "VAL"+i;
-                }
-                return values;
-        }
-        private ContinousHashProvider<Integer> prepareHashProvider() {
-                ContinousHashProvider<Integer> chp = new ContinousHashProvider<Integer>() {
-                        
-                        @Override
-                        public int getHash(Integer key, int index) {
-                                int result = 1;
-                                final int prime = 31;
-                                result = prime*result + key;
-                                result = prime*result + index;
-                                return result;
-                        }
-                        
-                        @Override
-                        public boolean equals(Integer key1, Integer key2) {
-                                return key1.equals(key2);
-                        }
-                };
-                return chp;
-        }
         
         void iterativeRandomPutsAndCommits(
                 String scenario,
@@ -84,88 +57,27 @@ public class SmokeTest2Commit {
                         }
                         if(index%10000==0) System.out.println(scenario+":"+index+" finished");
                         if(index%commitFrequency == 0) {
-                                long version = e.sut.commit();
-                                System.out.println(scenario+":"+index+": Commit! " + version);
+                                e.sut.commit();
+                                //System.out.println(scenario+":"+index+": Commit! version=" + version);
                         }
                 }
         }
         
-        // Mini smoke frequent commints
-        @Test
-        void MiniSmokeFrequentK3V2v1() {
-                runSmokeTest("MiniSmokeK3V2v1",0, 1000, 3, 2, 1);
-        }
-        @Test
-        void MiniSmokeFrequentK3V2v2() {
-                runSmokeTest("MiniSmokeK3V2v2",1, 1000, 3, 2, 1);
-        }
-        @Test
-        void MiniSmokeFrequentK3V2v3() {
-                runSmokeTest("MiniSmokeK3V2v3",3, 1000, 3, 2, 1);
-        }
-        @Test
-        void MiniSmokeFrequentK3V3v1() {
-                runSmokeTest("MiniSmokeK3V2v1",0, 1000, 3, 3, 1);
-        }
-        @Test
-        void MiniSmokeFrequentK3V3v2() {
-                runSmokeTest("MiniSmokeK3V2v2",1, 1000, 3, 3, 1);
-        }
-        @Test
-        void MiniSmokeFrequentK3V3v3() {
-                runSmokeTest("MiniSmokeK3V2v3",3, 1000, 3, 3, 1);
-        }
-        // Mini smoke rare commits
-        @Test
-        void MiniSmokeRareK3V2v1() {
-                runSmokeTest("MiniSmokeK3V2v1",0, 1000, 3, 2, 100);
-        }
-        @Test
-        void MiniSmokeRareK3V2v2() {
-                runSmokeTest("MiniSmokeK3V2v2",1, 1000, 3, 2, 100);
-        }
-        @Test
-        void MiniSmokeKRare3V2v3() {
-                runSmokeTest("MiniSmokeK3V2v3",3, 1000, 3, 2, 100);
-        }
-        @Test
-        void MiniSmokeRareK3V3v1() {
-                runSmokeTest("MiniSmokeK3V2v1",0, 1000, 3, 3, 100);
-        }
-        @Test
-        void MiniSmokeRareK3V3v2() {
-                runSmokeTest("MiniSmokeK3V2v2",1, 1000, 3, 3, 100);
-        }
-        @Test
-        void MiniSmokeRareK3V3v3() {
-                runSmokeTest("MiniSmokeK3V2v3",3, 1000, 3, 3, 100);
-        }
         
-        // Medium smoke
-        @Test
-        void MediumSmokeK3V2v1() {
-                runSmokeTest("MediumSmokeK3V2v1",1, 1000, 32, 2, 10);
-        }
-        @Test
-        void MediumSmokeK3V2v2() {
-                runSmokeTest("MediumSmokeK3V2v2",2, 1000, 32, 2, 10);
-        }
-        @Test
-        void MediumSmokeK3V2v3() {
-                runSmokeTest("MediumSmokeK3V2v3",3, 1000, 32, 2, 10);
+        @ParameterizedTest(name = "Immutable Smoke {index}/{0} Steps={1} Keys={2} Values={3} commit frequency={4} seed={5}")
+        @MethodSource
+        void parametrizedSmoke(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);
         }
         
-        //Large Smoke
-        @Test
-        void SmokeLargeRareCommit() {
-                runSmokeTest("SmokeLarge",0, 32*32*32*32, 32*32-1, 2, 100);
-        }
-        @Test
-        void SmokeLargeNormalCommit() {
-                runSmokeTest("SmokeLarge",0, 32*32*32*32, 32*32-1, 2, 10);
-        }
-        @Test
-        void SmokeLargeFrequentCommit() {
-                runSmokeTest("SmokeLarge",0, 32*32*32*32, 32*32-1, 2, 1);
+        private static Stream<Arguments> parametrizedSmoke(){
+                return TestPermuter.permutationWithSize(
+                        new Object[] {1000,32*32*32*32},
+                        new Object[] {3,32, 32*32},
+                        new Object[] {2,3},
+                        new Object[] {1,10,100},
+                        new Object[] {1,2,3},
+                        new Object[] {false,true}
+                );
         }
 }