Sonar fixes

16 files changed, 128 insertions, 126 deletions

diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/ContinousHashProvider.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/ContinousHashProvider.java
index 3f019b24..dd64f901 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/ContinousHashProvider.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/ContinousHashProvider.java
@@ -11,7 +11,7 @@ import org.eclipse.viatra.solver.data.map.internal.Node;
  * @param <K> Target java type.
  */
 public interface ContinousHashProvider<K> {
-        public static final int EFFECTIVE_BITS = Node.effectiveBits;
+        public static final int EFFECTIVE_BITS = Node.EFFECTIVE_BITS;
         public static final int EFFECTIVE_BIT_MASK = (1 << (EFFECTIVE_BITS)) - 1;
 
         /**
@@ -51,10 +51,10 @@ public interface ContinousHashProvider<K> {
                         for (int i = 0; i < ContinousHashProvider.MAX_PRACTICAL_DEPTH; i++) {
                                 int hash1 = getEffectiveHash(key1, i);
                                 int hash2 = getEffectiveHash(key2, i);
-                                for(int j = 0; j<Integer.SIZE/Node.branchingFactorBit; j++) {
-                                        final int factorMask = (1<<Node.branchingFactorBit)-1;
-                                        int hashFragment1 = (hash1>>>j*Node.branchingFactorBit) & factorMask;
-                                        int hashFragment2 = (hash2>>>j*Node.branchingFactorBit) & factorMask;
+                                for(int j = 0; j<Integer.SIZE/Node.BRANCHING_FACTOR_BITS; j++) {
+                                        final int factorMask = (1<<Node.BRANCHING_FACTOR_BITS)-1;
+                                        int hashFragment1 = (hash1>>>j*Node.BRANCHING_FACTOR_BITS) & factorMask;
+                                        int hashFragment2 = (hash2>>>j*Node.BRANCHING_FACTOR_BITS) & factorMask;
                                         var result = Integer.compare(hashFragment1, hashFragment2);
                                         if (result != 0) {
                                                 return result;
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/Versioned.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/Versioned.java
index 68970a94..e46be237 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/Versioned.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/Versioned.java
@@ -2,6 +2,6 @@ package org.eclipse.viatra.solver.data.map;
 
 public interface Versioned {
         public long commit();
-        //public void revert();
+        //maybe revert()?
         public void restore(long state);
 }
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/VersionedMapStoreConfiguration.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/VersionedMapStoreConfiguration.java
index 196adf2c..be768e98 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/VersionedMapStoreConfiguration.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/VersionedMapStoreConfiguration.java
@@ -1,12 +1,27 @@
 package org.eclipse.viatra.solver.data.map;
 
 public class VersionedMapStoreConfiguration {
+        
+        public VersionedMapStoreConfiguration() {
+                
+        }
+        public VersionedMapStoreConfiguration(boolean immutableWhenCommiting, boolean sharedNodeCacheInStore,
+                        boolean sharedNodeCacheInStoreGroups) {
+                super();
+                this.immutableWhenCommiting = immutableWhenCommiting;
+                this.sharedNodeCacheInStore = sharedNodeCacheInStore;
+                this.sharedNodeCacheInStoreGroups = sharedNodeCacheInStoreGroups;
+        }
+
         /**
          * If true root is replaced with immutable node when committed. Frees up memory
          * by releasing immutable nodes, but it may decrease performance by recreating
          * immutable nodes upon changes (some evidence).
          */
-        public boolean immutableWhenCommiting = true;
+        private boolean immutableWhenCommiting = true;
+        public boolean isImmutableWhenCommiting() {
+                return immutableWhenCommiting;
+        }
 
         /**
          * If true, all subnodes are cached within a {@link VersionedMapStore}. It
@@ -15,13 +30,19 @@ public class VersionedMapStoreConfiguration {
          * decrease performance (no example found). The option permits the efficient
          * implementation of version deletion.
          */
-        public boolean sharedNodeCacheInStore = true;
-
+        private boolean sharedNodeCacheInStore = true;
+        public boolean isSharedNodeCacheInStore() {
+                return sharedNodeCacheInStore;
+        }
+        
         /**
          * If true, all subnodes are cached within a group of
          * {@link VersionedMapStoreImpl#createSharedVersionedMapStores(int, ContinousHashProvider, Object, VersionedMapStoreConfiguration)}.
          * If {@link VersionedMapStoreConfiguration#sharedNodeCacheInStore} is
          * <code>false</code>, then it has currently no impact.
          */
-        public boolean sharedNodeCacheInStoreGroups = true;
+        private boolean sharedNodeCacheInStoreGroups = true;
+        public boolean isSharedNodeCacheInStoreGroups() {
+                return sharedNodeCacheInStoreGroups;
+        }
 }
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java
index 5bcbf0c4..ab55e4bc 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/VersionedMapStoreImpl.java
@@ -1,6 +1,7 @@
 package org.eclipse.viatra.solver.data.map;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -17,7 +18,7 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
         private final boolean immutableWhenCommiting;
 
         // Static data
-        protected final ContinousHashProvider<? super K> hashProvider;
+        protected final ContinousHashProvider<K> hashProvider;
         protected final V defaultValue;
 
         // Dynamic data
@@ -25,12 +26,12 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
         protected final Map<Node<K, V>, ImmutableNode<K, V>> nodeCache;
         protected long nextID = 0;
 
-        public VersionedMapStoreImpl(ContinousHashProvider<? super K> hashProvider, V defaultValue,
+        public VersionedMapStoreImpl(ContinousHashProvider<K> hashProvider, V defaultValue,
                         VersionedMapStoreConfiguration config) {
-                this.immutableWhenCommiting = config.immutableWhenCommiting;
+                this.immutableWhenCommiting = config.isImmutableWhenCommiting();
                 this.hashProvider = hashProvider;
                 this.defaultValue = defaultValue;
-                if (config.sharedNodeCacheInStore) {
+                if (config.isSharedNodeCacheInStore()) {
                         nodeCache = new HashMap<>();
                 } else {
                         nodeCache = null;
@@ -39,7 +40,7 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
 
         private VersionedMapStoreImpl(ContinousHashProvider<K> hashProvider, V defaultValue,
                         Map<Node<K, V>, ImmutableNode<K, V>> nodeCache, VersionedMapStoreConfiguration config) {
-                this.immutableWhenCommiting = config.immutableWhenCommiting;
+                this.immutableWhenCommiting = config.isImmutableWhenCommiting();
                 this.hashProvider = hashProvider;
                 this.defaultValue = defaultValue;
                 this.nodeCache = nodeCache;
@@ -53,19 +54,19 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
                         ContinousHashProvider<K> hashProvider, V defaultValue,
                         VersionedMapStoreConfiguration config) {
                 List<VersionedMapStore<K, V>> result = new ArrayList<>(amount);
-                if (config.sharedNodeCacheInStoreGroups) {
+                if (config.isSharedNodeCacheInStoreGroups()) {
                         Map<Node<K, V>, ImmutableNode<K, V>> nodeCache;
-                        if (config.sharedNodeCacheInStore) {
+                        if (config.isSharedNodeCacheInStore()) {
                                 nodeCache = new HashMap<>();
                         } else {
                                 nodeCache = null;
                         }
                         for (int i = 0; i < amount; i++) {
-                                result.add(new VersionedMapStoreImpl<K, V>(hashProvider, defaultValue, nodeCache, config));
+                                result.add(new VersionedMapStoreImpl<>(hashProvider, defaultValue, nodeCache, config));
                         }
                 } else {
                         for (int i = 0; i < amount; i++) {
-                                result.add(new VersionedMapStoreImpl<K, V>(hashProvider, defaultValue, config));
+                                result.add(new VersionedMapStoreImpl<>(hashProvider, defaultValue, config));
                         }
                 }
                 return result;
@@ -82,23 +83,23 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
 
         @Override
         public VersionedMap<K, V> createMap() {
-                return new VersionedMapImpl<K, V>(this, hashProvider, defaultValue);
+                return new VersionedMapImpl<>(this, hashProvider, defaultValue);
         }
 
         @Override
         public VersionedMap<K, V> createMap(long state) {
                 ImmutableNode<K, V> data = revert(state);
-                return new VersionedMapImpl<K, V>(this, hashProvider, defaultValue, data);
+                return new VersionedMapImpl<>(this, hashProvider, defaultValue, data);
         }
 
         public synchronized ImmutableNode<K, V> revert(long state) {
                 if (states.containsKey(state)) {
                         return states.get(state);
                 } else {
-                        ArrayList<Long> existingKeys = new ArrayList<Long>(states.keySet());
+                        ArrayList<Long> existingKeys = new ArrayList<>(states.keySet());
                         Collections.sort(existingKeys);
                         throw new IllegalArgumentException("Store does not contain state " + state + "! Avaliable states: "
-                                        + existingKeys.toArray().toString());
+                                        + Arrays.toString(existingKeys.toArray()));
                 }
         }
 
@@ -126,6 +127,6 @@ public class VersionedMapStoreImpl<K, V> implements VersionedMapStore<K, V> {
                 VersionedMap<K, V> map2 = createMap(toState);
                 Cursor<K, V> cursor1 = map1.getCursor();
                 Cursor<K, V> cursor2 = map2.getCursor();
-                return new MapDiffCursor<K, V>(this.hashProvider, this.defaultValue, cursor1, cursor2);
+                return new MapDiffCursor<>(this.hashProvider, this.defaultValue, cursor1, cursor2);
         }
 }
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java
index a469326e..99df4d48 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/ImmutableNode.java
@@ -66,7 +66,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                 int resultNodeMap = 0;
                 final Object[] resultContent = new Object[size];
                 int bitposition = 1;
-                for(int i = 0; i<factor; i++) {
+                for(int i = 0; i<FACTOR; i++) {
                         Object key = node.content[i*2];
                         if(key != null) {
                                 resultDataMap |= bitposition;
@@ -139,16 +139,14 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                                 if(value == defaultValue) {
                                         // delete
                                         MutableNode<K, V> mutable = this.toMutable();
-                                        Node<K, V> result = mutable.removeEntry(selectedHashFragment);
-                                        return result;
+                                        return mutable.removeEntry(selectedHashFragment);
                                 } else if(value == content[keyIndex+1]) {
                                         // dont change
                                         return this;
                                 } else {
                                         // update existing value
                                         MutableNode<K, V> mutable = this.toMutable();
-                                        Node<K, V> result = mutable.updateValue(value, selectedHashFragment);
-                                        return result;
+                                        return mutable.updateValue(value, selectedHashFragment);
                                 }
                         } else {
                                 if(value == defaultValue) {
@@ -157,8 +155,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                                 } else {
                                         // add new key + value
                                         MutableNode<K, V> mutable = this.toMutable();
-                                        Node<K, V> result = mutable.putValue(key, value, hashProvider, defaultValue, hash, depth);
-                                        return result;
+                                        return mutable.putValue(key, value, hashProvider, defaultValue, hash, depth);
                                 }
                         }
                 } else if((nodeMap & bitposition)!=0) {
@@ -174,14 +171,12 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                                 return this;
                         } else {
                                 MutableNode<K, V> mutable  = toMutable();
-                                Node<K, V> result = mutable.updateWithSubNode(selectedHashFragment, newsubNode, value.equals(defaultValue));
-                                return result;
+                                return mutable.updateWithSubNode(selectedHashFragment, newsubNode, value.equals(defaultValue));
                         }
                 } else {
                         // add new key + value
                         MutableNode<K, V> mutable = this.toMutable();
-                        Node<K, V> result = mutable.putValue(key, value, hashProvider, defaultValue, hash, depth);
-                        return result;
+                        return mutable.putValue(key, value, hashProvider, defaultValue, hash, depth);
                 }
         }
         
@@ -200,7 +195,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
         
         @Override
         protected MutableNode<K,V> toMutable() {
-                return new MutableNode<K,V>(this);
+                return new MutableNode<>(this);
         }
         
         @Override
@@ -219,7 +214,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
         boolean moveToNext(MapCursor<K, V> cursor) {
                 // 1. try to move to data
                 int datas = Integer.bitCount(this.dataMap);
-                if(cursor.dataIndex != MapCursor.IndexFinish) {
+                if(cursor.dataIndex != MapCursor.INDEX_FINISH) {
                         int newDataIndex = cursor.dataIndex + 1;
                         if(newDataIndex < datas) {
                                 cursor.dataIndex = newDataIndex;
@@ -227,7 +222,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                                 cursor.value = (V) this.content[newDataIndex*2+1];
                                 return true;
                         } else {
-                                cursor.dataIndex = MapCursor.IndexFinish;
+                                cursor.dataIndex = MapCursor.INDEX_FINISH;
                         }
                 }
                 
@@ -237,10 +232,10 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                 if(newNodeIndex < nodes) {
                         // 2.1 found next subnode, move down to the subnode
                         Node<K, V> subnode = (Node<K, V>) this.content[this.content.length-1-newNodeIndex];
-                        cursor.dataIndex = MapCursor.IndexStart;
+                        cursor.dataIndex = MapCursor.INDEX_START;
                         cursor.nodeIndexStack.pop();
                         cursor.nodeIndexStack.push(newNodeIndex);
-                        cursor.nodeIndexStack.push(MapCursor.IndexStart);
+                        cursor.nodeIndexStack.push(MapCursor.INDEX_START);
                         cursor.nodeStack.push(subnode);
                         return subnode.moveToNext(cursor);
                 } else {
@@ -270,7 +265,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                 builder.append("Immutable(");
                 boolean hadContent = false;
                 int dataMask = 1;
-                for(int i = 0; i<factor; i++) {
+                for(int i = 0; i<FACTOR; i++) {
                         if((dataMask & dataMap) != 0) {
                                 if(hadContent) {
                                         builder.append(",");
@@ -287,7 +282,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                 }
                 builder.append(")");
                 int nodeMask = 1;
-                for(int i = 0; i<factor; i++) {
+                for(int i = 0; i<FACTOR; i++) {
                         if((nodeMask & nodeMap)!=0) {
                                 @SuppressWarnings("unchecked")
                                 Node<K,V> subNode = (Node<K, V>) content[content.length-1-index(nodeMap, nodeMask)];
@@ -333,15 +328,9 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                         return false;
                 if (obj instanceof ImmutableNode<?,?>) {
                         ImmutableNode<?,?> other = (ImmutableNode<?,?>) obj;
-                        if (precalculatedHash != other.precalculatedHash)
+                        if (precalculatedHash != other.precalculatedHash || dataMap != other.dataMap || nodeMap != other.nodeMap || !Arrays.deepEquals(content, other.content))
                                 return false;
-                        if (dataMap != other.dataMap)
-                                return false;
-                        if (nodeMap != other.nodeMap)
-                                return false;
-                        if (!Arrays.deepEquals(content, other.content))
-                                return false;
-                        return true;
+                        else return true;
                 } else if(obj instanceof MutableNode<?,?>) {
                         return ImmutableNode.compareImmutableMutable(this, (MutableNode<?, ?>) obj);
                 } else {
@@ -355,7 +344,7 @@ public class ImmutableNode<K, V> extends Node<K, V> {
                 int datas = 0;
                 int nodes = 0;
                 final int immutableLength = immutable.content.length;
-                for(int i = 0; i<factor; i++) {
+                for(int i = 0; i<FACTOR; i++) {
                         Object key = mutable.content[i*2];
                         // For each key candidate
                         if(key != null) {
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/MapCursor.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/MapCursor.java
index a18d540d..97fbcd8f 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/MapCursor.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/MapCursor.java
@@ -10,8 +10,8 @@ import org.eclipse.viatra.solver.data.map.VersionedMap;
 
 public class MapCursor<K,V> implements Cursor<K,V> {
         // Constants
-        static int IndexStart = -1;
-        static int IndexFinish = -2;
+        static final int INDEX_START = -1;
+        static final int INDEX_FINISH = -2;
         
         // Tree stack
         ArrayDeque<Node<K,V>> nodeStack;
@@ -33,10 +33,10 @@ public class MapCursor<K,V> implements Cursor<K,V> {
                 this.nodeIndexStack = new ArrayDeque<>();
                 if(root != null) {
                         this.nodeStack.add(root);
-                        this.nodeIndexStack.push(IndexStart);
+                        this.nodeIndexStack.push(INDEX_START);
                 }
                 
-                this.dataIndex = IndexStart;
+                this.dataIndex = INDEX_START;
                 
                 // Initializing cache
                 this.key = null;
@@ -75,7 +75,7 @@ public class MapCursor<K,V> implements Cursor<K,V> {
         public boolean skipCurrentNode() {
                 nodeStack.pop();
                 nodeIndexStack.pop();
-                dataIndex = IndexFinish;
+                dataIndex = INDEX_FINISH;
                 return move();
         }
         @Override
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/MutableNode.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/MutableNode.java
index 322e2128..2f794a7b 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/MutableNode.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/MutableNode.java
@@ -10,18 +10,18 @@ public class MutableNode<K, V> extends Node<K, V> {
         protected Object[] content;
 
         protected MutableNode() {
-                this.content = new Object[2 * factor];
+                this.content = new Object[2 * FACTOR];
                 updateHash();
         }
 
-        public static <K, V> MutableNode<K, V> initialize(K key, V value,
-                        ContinousHashProvider<? super K> hashProvider, V defaultValue) {
+        public static <K, V> MutableNode<K, V> initialize(K key, V value, ContinousHashProvider<? super K> hashProvider,
+                        V defaultValue) {
                 if (value == defaultValue) {
                         return null;
                 } else {
                         int hash = hashProvider.getHash(key, 0);
                         int fragment = hashFragment(hash, 0);
-                        MutableNode<K, V> res = new MutableNode<K, V>();
+                        MutableNode<K, V> res = new MutableNode<>();
                         res.content[2 * fragment] = key;
                         res.content[2 * fragment + 1] = value;
                         res.updateHash();
@@ -35,10 +35,10 @@ public class MutableNode<K, V> extends Node<K, V> {
          * @param node
          */
         protected MutableNode(ImmutableNode<K, V> node) {
-                this.content = new Object[2 * factor];
+                this.content = new Object[2 * FACTOR];
                 int dataUsed = 0;
                 int nodeUsed = 0;
-                for (int i = 0; i < factor; i++) {
+                for (int i = 0; i < FACTOR; i++) {
                         int bitposition = 1 << i;
                         if ((node.dataMap & bitposition) != 0) {
                                 content[2 * i] = node.content[dataUsed * 2];
@@ -54,8 +54,7 @@ public class MutableNode<K, V> extends Node<K, V> {
 
         @SuppressWarnings("unchecked")
         @Override
-        public V getValue(K key, ContinousHashProvider<? super K> hashProvider, V defaultValue, int hash,
-                        int depth) {
+        public V getValue(K key, ContinousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth) {
                 int selectedHashFragment = hashFragment(hash, shiftDepth(depth));
                 K keyCandidate = (K) this.content[2 * selectedHashFragment];
                 if (keyCandidate != null) {
@@ -78,8 +77,8 @@ public class MutableNode<K, V> extends Node<K, V> {
 
         @SuppressWarnings("unchecked")
         @Override
-        public Node<K, V> putValue(K key, V value, ContinousHashProvider<? super K> hashProvider,
-                        V defaultValue, int hash, int depth) {
+        public Node<K, V> putValue(K key, V value, ContinousHashProvider<? super K> hashProvider, V defaultValue, int hash,
+                        int depth) {
                 int selectedHashFragment = hashFragment(hash, shiftDepth(depth));
                 K keyCandidate = (K) content[2 * selectedHashFragment];
                 if (keyCandidate != null) {
@@ -161,7 +160,7 @@ public class MutableNode<K, V> extends Node<K, V> {
                                         return null;
                                 }
                         } else {
-                                // check whether newNode is orphan;
+                                // check whether newNode is orphan
                                 MutableNode<K, V> immutableNewNode = newNode.isMutable();
                                 if (immutableNewNode != null) {
                                         int orphaned = immutableNewNode.isOrphaned();
@@ -197,7 +196,7 @@ public class MutableNode<K, V> extends Node<K, V> {
 
         protected int isOrphaned() {
                 int dataFound = -2;
-                for (int i = 0; i < factor; i++) {
+                for (int i = 0; i < FACTOR; i++) {
                         if (content[i * 2] != null) {
                                 if (dataFound >= 0) {
                                         return -1;
@@ -212,11 +211,10 @@ public class MutableNode<K, V> extends Node<K, V> {
         }
 
         @SuppressWarnings("unchecked")
-        private Node<K, V> moveDownAndSplit(ContinousHashProvider<? super K> hashProvider, K newKey,
-                        V newValue, K previousKey, int hashOfNewKey, int depth, int selectedHashFragmentOfCurrentDepth) {
+        private Node<K, V> moveDownAndSplit(ContinousHashProvider<? super K> hashProvider, K newKey, V newValue,
+                        K previousKey, int hashOfNewKey, int depth, int selectedHashFragmentOfCurrentDepth) {
                 V previousValue = (V) content[2 * selectedHashFragmentOfCurrentDepth + 1];
 
-                // final int newHash = newHash(hashProvider, newKey, hashOfNewKey, newDepth);
                 MutableNode<K, V> newSubNode = newNodeWithTwoEntries(hashProvider, previousKey, previousValue,
                                 hashProvider.getHash(previousKey, hashDepth(depth)), newKey, newValue, hashOfNewKey, depth + 1);
 
@@ -226,20 +224,14 @@ public class MutableNode<K, V> extends Node<K, V> {
                 return this;
         }
 
-        private MutableNode<K, V> newNodeWithTwoEntries(ContinousHashProvider<? super K> hashProvider, K key1,
-                        V value1, int oldHash1, K key2, V 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 +".");
-//              }
+        private MutableNode<K, V> newNodeWithTwoEntries(ContinousHashProvider<? super K> hashProvider, K key1, V value1,
+                        int oldHash1, K key2, V value2, int oldHash2, int newdepth) {
                 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<K, V> subNode = new MutableNode<K, V>();
+                MutableNode<K, V> subNode = new MutableNode<>();
                 if (newFragment1 != newFragment2) {
                         subNode.content[newFragment1 * 2] = key1;
                         subNode.content[newFragment1 * 2 + 1] = value1;
@@ -247,8 +239,8 @@ public class MutableNode<K, V> extends Node<K, V> {
                         subNode.content[newFragment2 * 2] = key2;
                         subNode.content[newFragment2 * 2 + 1] = value2;
                 } else {
-                        MutableNode<K, V> subSubNode = newNodeWithTwoEntries(hashProvider, key1, value1, newHash1, key2,
-                                        value2, newHash2, newdepth + 1);
+                        MutableNode<K, V> subSubNode = newNodeWithTwoEntries(hashProvider, key1, value1, newHash1, key2, value2,
+                                        newHash2, newdepth + 1);
                         subNode.content[newFragment1 * 2 + 1] = subSubNode;
                 }
                 subNode.updateHash();
@@ -270,7 +262,7 @@ public class MutableNode<K, V> extends Node<K, V> {
         @Override
         public long getSize() {
                 int size = 0;
-                for (int i = 0; i < factor; i++) {
+                for (int i = 0; i < FACTOR; i++) {
                         if (content[i * 2] != null) {
                                 size++;
                         } else {
@@ -297,8 +289,8 @@ public class MutableNode<K, V> extends Node<K, V> {
         @Override
         boolean moveToNext(MapCursor<K, V> cursor) {
                 // 1. try to move to data
-                if (cursor.dataIndex != MapCursor.IndexFinish) {
-                        for (int index = cursor.dataIndex + 1; index < factor; index++) {
+                if (cursor.dataIndex != MapCursor.INDEX_FINISH) {
+                        for (int index = cursor.dataIndex + 1; index < FACTOR; index++) {
                                 if (this.content[index * 2] != null) {
                                         // 1.1 found next data
                                         cursor.dataIndex = index;
@@ -307,19 +299,19 @@ public class MutableNode<K, V> extends Node<K, V> {
                                         return true;
                                 }
                         }
-                        cursor.dataIndex = MapCursor.IndexFinish;
+                        cursor.dataIndex = MapCursor.INDEX_FINISH;
                 }
 
                 // 2. look inside the subnodes
-                for (int index = cursor.nodeIndexStack.peek() + 1; index < factor; index++) {
+                for (int index = cursor.nodeIndexStack.peek() + 1; index < FACTOR; index++) {
                         if (this.content[index * 2] == null && this.content[index * 2 + 1] != null) {
                                 // 2.1 found next subnode, move down to the subnode
                                 Node<K, V> subnode = (Node<K, V>) this.content[index * 2 + 1];
 
-                                cursor.dataIndex = MapCursor.IndexStart;
+                                cursor.dataIndex = MapCursor.INDEX_START;
                                 cursor.nodeIndexStack.pop();
                                 cursor.nodeIndexStack.push(index);
-                                cursor.nodeIndexStack.push(MapCursor.IndexStart);
+                                cursor.nodeIndexStack.push(MapCursor.INDEX_START);
                                 cursor.nodeStack.push(subnode);
 
                                 return subnode.moveToNext(cursor);
@@ -350,7 +342,7 @@ public class MutableNode<K, V> extends Node<K, V> {
                 builder.append("Mutable(");
                 // print content
                 boolean hadContent = false;
-                for (int i = 0; i < factor; i++) {
+                for (int i = 0; i < FACTOR; i++) {
                         if (content[2 * i] != null) {
                                 if (hadContent) {
                                         builder.append(",");
@@ -366,7 +358,7 @@ public class MutableNode<K, V> extends Node<K, V> {
                 }
                 builder.append(")");
                 // print subnodes
-                for (int i = 0; i < factor; i++) {
+                for (int i = 0; i < FACTOR; i++) {
                         if (content[2 * i] == null && content[2 * i + 1] != null) {
                                 @SuppressWarnings("unchecked")
                                 Node<K, V> subNode = (Node<K, V>) content[2 * i + 1];
@@ -380,14 +372,14 @@ public class MutableNode<K, V> extends Node<K, V> {
         @Override
         public void checkIntegrity(ContinousHashProvider<? super K> hashProvider, V defaultValue, int depth) {
                 // check for orphan nodes
-                if(depth>0) {
+                if (depth > 0) {
                         int orphaned = isOrphaned();
-                        if(orphaned>=0) {
-                                throw new IllegalStateException("Orphaned node! " + orphaned + ": " +  content[2 * orphaned]);
+                        if (orphaned >= 0) {
+                                throw new IllegalStateException("Orphaned node! " + orphaned + ": " + content[2 * orphaned]);
                         }
                 }
-                // check the place of data 
-                for (int i = 0; i < factor; i++) {
+                // check the place of data
+                for (int i = 0; i < FACTOR; i++) {
                         if (this.content[2 * i] != null) {
                                 K key = (K) this.content[2 * i];
                                 V value = (V) this.content[2 * i + 1];
@@ -405,7 +397,7 @@ public class MutableNode<K, V> extends Node<K, V> {
                         }
                 }
                 // check subnodes
-                for (int i = 0; i < factor; i++) {
+                for (int i = 0; i < FACTOR; i++) {
                         if (this.content[2 * i + 1] != null && this.content[2 * i] == null) {
                                 Node<K, V> subNode = (Node<K, V>) this.content[2 * i + 1];
                                 subNode.checkIntegrity(hashProvider, defaultValue, depth + 1);
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/Node.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/Node.java
index f1efaa76..acf7a463 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/Node.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/Node.java
@@ -5,11 +5,11 @@ import java.util.Map;
 import org.eclipse.viatra.solver.data.map.ContinousHashProvider;
 
 public abstract class Node<K,V>{
-        public static final int branchingFactorBit = 5;
-        public static final int factor = 1<<branchingFactorBit;
-        protected static final int numberOfFactors = Integer.SIZE / branchingFactorBit;
-        protected static final int factorMask = factor-1;
-        public static final int effectiveBits = branchingFactorBit * numberOfFactors;
+        public static final int BRANCHING_FACTOR_BITS = 5;
+        public static final int FACTOR = 1<<BRANCHING_FACTOR_BITS;
+        protected static final int NUMBER_OF_FACTORS = Integer.SIZE / BRANCHING_FACTOR_BITS;
+        protected static final int FACTOR_MASK = FACTOR-1;
+        public static final int EFFECTIVE_BITS = BRANCHING_FACTOR_BITS * NUMBER_OF_FACTORS;
         
         /**
          * Calculates the index for the continuous hash.
@@ -17,7 +17,7 @@ public abstract class Node<K,V>{
          * @return The index of the continuous hash.
          */
         protected static int hashDepth(int depth) {
-                return depth/numberOfFactors;
+                return depth/NUMBER_OF_FACTORS;
         }
         
         /**
@@ -26,7 +26,7 @@ public abstract class Node<K,V>{
          * @return The segment of a hash code.
          */
         protected static int shiftDepth(int depth) {
-                return depth%numberOfFactors;
+                return depth%NUMBER_OF_FACTORS;
         }
         /**
          * Selects a segments from a complete hash for a given depth.
@@ -35,8 +35,8 @@ public abstract class Node<K,V>{
          * @return The segment as an integer.
          */
         protected static int hashFragment(int hash, int shiftDepth) {
-                if(shiftDepth<0 || Node.numberOfFactors<shiftDepth) throw new IllegalArgumentException("Invalid shift depth! valid intervall=[0;5], input="+shiftDepth);
-                return (hash >>> shiftDepth*branchingFactorBit) & factorMask;
+                if(shiftDepth<0 || Node.NUMBER_OF_FACTORS<shiftDepth) throw new IllegalArgumentException("Invalid shift depth! valid intervall=[0;5], input="+shiftDepth);
+                return (hash >>> shiftDepth*BRANCHING_FACTOR_BITS) & FACTOR_MASK;
         }
         
         /**
@@ -51,15 +51,15 @@ public abstract class Node<K,V>{
                 if(hashDepth>=ContinousHashProvider.MAX_PRACTICAL_DEPTH) {
                         throw new IllegalArgumentException("Key "+key+" have the clashing hashcode over the practical depth limitation ("+ContinousHashProvider.MAX_PRACTICAL_DEPTH+")!");
                 }
-                return depth%numberOfFactors == 0?
+                return depth%NUMBER_OF_FACTORS == 0?
                                 hashProvider.getHash(key, hashDepth) :
                                 hash;
         }
         
         
-        abstract public V getValue(K key, ContinousHashProvider<? super K> hashProvider, V defaultValue,  int hash, int depth);
-        abstract public Node<K,V> putValue(K key, V value, ContinousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth);
-        abstract public long getSize();
+        public abstract V getValue(K key, ContinousHashProvider<? super K> hashProvider, V defaultValue,  int hash, int depth);
+        public abstract Node<K,V> putValue(K key, V value, ContinousHashProvider<? super K> hashProvider, V defaultValue, int hash, int depth);
+        public abstract long getSize();
         
         abstract MutableNode<K, V> toMutable();
         public abstract ImmutableNode<K, V> toImmutable(
@@ -73,7 +73,7 @@ public abstract class Node<K,V>{
         abstract boolean moveToNext(MapCursor<K,V> cursor);
         
         ///////// FOR printing
-        abstract public void prettyPrint(StringBuilder builder, int depth, int code);
+        public abstract void prettyPrint(StringBuilder builder, int depth, int code);
         @Override
         public String toString() {
                 StringBuilder stringBuilder = new StringBuilder();
diff --git a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
index d04e7117..25473fd8 100644
--- a/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
+++ b/model-data/src/main/java/org/eclipse/viatra/solver/data/map/internal/VersionedMapImpl.java
@@ -20,13 +20,13 @@ import org.eclipse.viatra.solver.data.map.VersionedMapStoreImpl;
 public class VersionedMapImpl<K,V> implements VersionedMap<K,V>{
         protected final VersionedMapStoreImpl<K,V> store;
         
-        protected final ContinousHashProvider<? super K> hashProvider;
+        protected final ContinousHashProvider<K> hashProvider;
         protected final V defaultValue;
         protected Node<K,V> root;
         
         public VersionedMapImpl(
                         VersionedMapStoreImpl<K,V> store,
-                        ContinousHashProvider<? super K> hashProvider,
+                        ContinousHashProvider<K> hashProvider,
                         V defaultValue)
         {
                 this.store = store;
@@ -36,7 +36,7 @@ public class VersionedMapImpl<K,V> implements VersionedMap<K,V>{
         }
         public VersionedMapImpl(
                         VersionedMapStoreImpl<K,V> store,
-                        ContinousHashProvider<? super K> hashProvider,
+                        ContinousHashProvider<K> hashProvider,
                         V defaultValue, Node<K,V> data)
         {
                 this.store = store;
@@ -48,7 +48,7 @@ public class VersionedMapImpl<K,V> implements VersionedMap<K,V>{
         public V getDefaultValue() {
                 return defaultValue;
         }
-        public ContinousHashProvider<? super K> getHashProvider() {
+        public ContinousHashProvider<K> getHashProvider() {
                 return hashProvider;
         }
         @Override
@@ -100,15 +100,14 @@ public class VersionedMapImpl<K,V> implements VersionedMap<K,V>{
 
         @Override
         public Cursor<K, V> getCursor() {
-                MapCursor<K,V> cursor = new MapCursor<>(this.root,this);
-                return cursor;
+                return new MapCursor<>(this.root,this);
         }
         @Override
         public DiffCursor<K, V> getDiffCursor(long toVersion) {
                 Cursor<K, V> fromCursor = this.getCursor();
                 VersionedMap<K, V> toMap = this.store.createMap(toVersion);
                 Cursor<K, V> toCursor = toMap.getCursor();
-                return new MapDiffCursor<K, V>(this.hashProvider,this.defaultValue, fromCursor, toCursor);
+                return new MapDiffCursor<>(this.hashProvider,this.defaultValue, fromCursor, toCursor);
                 
         }
         
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/CommitSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/CommitSmokeTest.java
index 25ad81d2..ce526534 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/CommitSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/CommitSmokeTest.java
@@ -74,7 +74,7 @@ class CommitSmokeTest {
         }
 
         static Stream<Arguments> parametrizedFastSmoke() {
-                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
+                return SmokeTestUtils.permutationWithSize(new Object[] { SmokeTestUtils.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 });
         }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/ContentEqualsSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/ContentEqualsSmokeTest.java
index a8202b97..2fe2a9a5 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/ContentEqualsSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/ContentEqualsSmokeTest.java
@@ -1,7 +1,6 @@
 package org.eclipse.viatra.solver.data.map.tests.smoke;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;
 
 import java.util.AbstractMap.SimpleEntry;
@@ -122,7 +121,7 @@ class ContentEqualsSmokeTest {
         }
 
         static Stream<Arguments> parametrizedFastSmoke() {
-                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
+                return SmokeTestUtils.permutationWithSize(new Object[] { SmokeTestUtils.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 });
         }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/DiffCursorSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/DiffCursorSmokeTest.java
index c36fac47..61aa52c8 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/DiffCursorSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/DiffCursorSmokeTest.java
@@ -96,7 +96,7 @@ class DiffCursorSmokeTest {
         }
 
         static Stream<Arguments> parametrizedSmoke() {
-                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
+                return SmokeTestUtils.permutationWithSize(new Object[] { SmokeTestUtils.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 });
         }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableImmutableCompareSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableImmutableCompareSmokeTest.java
index ff409a66..159a761c 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableImmutableCompareSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableImmutableCompareSmokeTest.java
@@ -67,7 +67,7 @@ class MutableImmutableCompareSmokeTest {
         }
 
         static Stream<Arguments> parametrizedFastSmoke() {
-                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
+                return SmokeTestUtils.permutationWithSize(new Object[] { SmokeTestUtils.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 });
         }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableSmokeTest.java
index 999325f0..b91e927c 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/MutableSmokeTest.java
@@ -70,7 +70,7 @@ class MutableSmokeTest {
         }
 
         static Stream<Arguments> parametrizedSmoke() {
-                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 },
+                return SmokeTestUtils.permutationWithSize(new Object[] { SmokeTestUtils.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 });
         }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/RestoreSmokeTest.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/RestoreSmokeTest.java
index fa96f0c1..0b06a6a9 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/RestoreSmokeTest.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/RestoreSmokeTest.java
@@ -87,7 +87,7 @@ class RestoreSmokeTest {
         }
 
         static Stream<Arguments> parametrizedFastSmoke() {
-                return SmokeTestUtils.permutationWithSize(new Object[] { 1000 }, new Object[] { 3, 32, 32 * 32 },
+                return SmokeTestUtils.permutationWithSize(new Object[] { SmokeTestUtils.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 });
         }
diff --git a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/SmokeTestUtils.java b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/SmokeTestUtils.java
index 9eab854f..f1e5c857 100644
--- a/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/SmokeTestUtils.java
+++ b/model-data/src/test/java/org/eclipse/viatra/solver/data/map/tests/smoke/utils/SmokeTestUtils.java
@@ -8,7 +8,8 @@ import java.util.stream.Stream;
 import org.junit.jupiter.params.provider.Arguments;
 
 public final class SmokeTestUtils {
-        private static final int SLOW_STEP_COUNT = 32 * 32 * 32 * 32;
+        public static final int FAST_STEP_COUNT = 1000;
+        public static final int SLOW_STEP_COUNT = 32 * 32 * 32 * 32;
 
         private SmokeTestUtils() {
                 throw new IllegalStateException("This is a static utility class and should not be instantiated directly");