npe fix

1 files changed, 131 insertions, 0 deletions

diff --git a/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest3CompareMutableWithImmutable.java b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest3CompareMutableWithImmutable.java
new file mode 100644
index 00000000..fecf3cc7
--- /dev/null
+++ b/Solvers/VIATRA-Solver/org.eclipse.viatra.solver.data/tests/org/eclipse/viatra/solver/data/map/SmokeTest3CompareMutableWithImmutable.java
@@ -0,0 +1,131 @@
+package org.eclipse.viatra.solver.data.map;
+
+import static org.junit.Assert.fail;
+
+import java.util.Random;
+
+import org.eclipse.viatra.solver.data.map.internal.VersionedMapImpl;
+import org.junit.jupiter.api.Test;
+
+public class SmokeTest3CompareMutableWithImmutable {
+        private void runSmokeTest(String scenario, int seed, int steps, int maxKey, int maxValue, int commitFrequency) {
+                String[] values = prepareValues(maxValue);
+                ContinousHashProvider<Integer> chp = prepareHashProvider();
+                
+                VersionedMapStore<Integer, String> store = new VersionedMapStoreImpl<Integer, String>(chp, values[0]);
+                VersionedMapImpl<Integer, String> sut = (VersionedMapImpl<Integer, String>) store.createMap();
+                MapTestEnvironment<Integer, String> e = new MapTestEnvironment<Integer, String>(sut);
+                
+                Random r = new Random(seed);
+                
+                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,
+                int steps,
+                int maxKey,
+                String[] values,
+                MapTestEnvironment<Integer, String> e,
+                Random r,
+                int commitFrequency)
+        {
+                int stopAt = -1;
+                for(int i=0; i<steps; i++) {
+                        int index = i+1;
+                        int nextKey = r.nextInt(maxKey);
+                        String nextValue = values[r.nextInt(values.length)];
+                        if(index == stopAt) {
+                                System.out.println("issue!");
+                                System.out.println("State before:");
+                                e.printComparison();
+                                e.sut.prettyPrint();
+                                System.out.println("Next: put("+nextKey+","+nextValue+")");
+                        }
+                        try {
+                                e.put(nextKey, nextValue);
+                                if(index == stopAt) {
+                                        e.sut.prettyPrint();
+                                }
+                                e.checkEquivalence(scenario+":"+index);
+                        } catch (Exception exception) {
+                                exception.printStackTrace();
+                                fail(scenario+":"+index+": exception happened: "+exception);
+                        }
+                        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);
+                        }
+                }
+        }
+        
+        @Test
+        void MiniSmokeK3V2v1() {
+                runSmokeTest("MiniSmokeK3V2v1",0, 1000, 3, 2, 10);
+        }
+        @Test
+        void MiniSmokeK3V2v2() {
+                runSmokeTest("MiniSmokeK3V2v2",1, 1000, 3, 2, 10);
+        }
+        @Test
+        void MiniSmokeK3V2v3() {
+                runSmokeTest("MiniSmokeK3V2v3",3, 1000, 3, 2, 10);
+        }
+        @Test
+        void MiniSmokeK3V3v1() {
+                runSmokeTest("MiniSmokeK3V2v1",0, 1000, 3, 3, 10);
+        }
+        @Test
+        void MiniSmokeK3V3v2() {
+                runSmokeTest("MiniSmokeK3V2v2",1, 1000, 3, 3, 10);
+        }
+        @Test
+        void MiniSmokeK3V3v3() {
+                runSmokeTest("MiniSmokeK3V2v3",3, 1000, 3, 3, 10);
+        }
+        @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);
+        }
+//      @Test
+//      void SmokeLarge() {
+//              runSmokeTest("SmokeLarge",0, 32*32*32*32, 32*32-1, 2);
+//      }
+}