implemented a hashing function for stacktrace strings. debugging the parsing.

4 files changed, 150 insertions, 19 deletions

diff --git a/src/main/java/org/schemaspy/DBFuzzer.java b/src/main/java/org/schemaspy/DBFuzzer.java
index 0218889..a73ddb9 100755
--- a/src/main/java/org/schemaspy/DBFuzzer.java
+++ b/src/main/java/org/schemaspy/DBFuzzer.java
@@ -74,6 +74,7 @@ public class DBFuzzer
                 evaluatorProcess.waitFor();
                 ReportVector mutationReport = new ReportVector(rootMutation);
                 mutationReport.parseFile("errorReports/parsedStackTrace_" + rootMutation.getId());
+                mutationReport.setStackTraceHash(mutationReport.hashStackTrace(mutationTree));
                 rootMutation.setReportVector(mutationReport);
                 mark = new Scorer().score(rootMutation, mutationTree);
                 rootMutation.setInterest_mark(mark);
@@ -213,7 +214,8 @@ public class DBFuzzer
                     Process evaluatorProcess = new ProcessBuilder("/bin/bash", "./stackTraceCParser.sh", analyzer.getCommandLineArguments().getTarget(), Integer.toString(currentMutation.getId())).start();
                     evaluatorProcess.waitFor();
                     ReportVector mutationReport = new ReportVector(currentMutation);
-                    mutationReport.parseFile("errorReports/parsedStackTrace_" + currentMutation.getId());
+                    mutationReport.parseFile("errorReports/parsedStackTrace_" + currentMutation.getId()); // initialises the reportVector stacktrace
+                    mutationReport.setStackTraceHash(mutationReport.hashStackTrace(mutationTree));
                     currentMutation.setReportVector(mutationReport);
                     mark = new Scorer().score(currentMutation, mutationTree);
                     currentMutation.setInterest_mark(mark);
diff --git a/src/main/java/org/schemaspy/model/ReportVector.java b/src/main/java/org/schemaspy/model/ReportVector.java
index f2e0aef..b17b8b7 100755
--- a/src/main/java/org/schemaspy/model/ReportVector.java
+++ b/src/main/java/org/schemaspy/model/ReportVector.java
@@ -5,11 +5,10 @@ import java.io.FileReader;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Random;
 
 public class ReportVector {
     private ArrayList<StackTraceLine> stackTrace;
-    private double stackTraceHash;
+    private double[] stackTraceHash;
     private int codeCoverage; //unused right now
     GenericTreeNode parentMutation;
 
@@ -19,9 +18,9 @@ public class ReportVector {
         stackTrace = new ArrayList<StackTraceLine>();
     }
 
-    public double getStackTraceHash() { return stackTraceHash; }
+    public double[] getStackTraceHash() { return stackTraceHash; }
 
-    public void setStackTraceHash(double stackTraceHash) { this.stackTraceHash = stackTraceHash; }
+    public void setStackTraceHash(double[] stackTraceHash) { this.stackTraceHash = stackTraceHash; }
 
     public ArrayList<StackTraceLine> getStackTrace() {
         return stackTrace;
@@ -118,6 +117,7 @@ public class ReportVector {
 
             StackTraceLine stl = new StackTraceLine(functionName,fileName,lineNumber);
             stackTrace.add(stl);
+
         }
     }
 
@@ -145,9 +145,48 @@ public class ReportVector {
         return true;
     }
 
-    public double hashStackTrace(GenericTree mutationTree,GenericTreeNode currentNode)
+    public double[] hashStackTrace(GenericTree mutationTree)
     {
-        Random rand = new Random();
-        return rand.nextDouble();
+        ArrayList<double[]> stackTraceLinesHashes = new ArrayList<>();
+        double var1=500,var2=500,var3=500;
+
+        if(parentMutation.getId() == 1)
+        {
+            for(StackTraceLine stl :stackTrace)
+            {
+                stl.setFileNameHash(500);
+                stl.setFunctionNameHash(500);
+            }
+            double [] tmp = {500,500,500};
+            return tmp;
+        }
+
+        for(StackTraceLine stl : this.getStackTrace())
+        {
+            var1 = stl.consistentFunctionNameHash(mutationTree);
+            stl.setFunctionNameHash(var1);
+            var2 = stl.consistentFileNameHash(mutationTree);
+            stl.setFileNameHash(var2);
+            var3 = stl.getLineNumber();
+
+
+            double[] lineHash = {var1,var2,var3};
+            stackTraceLinesHashes.add(lineHash);
+        }
+
+        double functionNameHashTotal=0,fileNameHashTotal=0,lineNumberHashTotal=0;
+        for(double[] lineHash : stackTraceLinesHashes)
+        {
+            functionNameHashTotal = functionNameHashTotal + lineHash[0];
+            fileNameHashTotal= fileNameHashTotal+ lineHash[1];
+            lineNumberHashTotal= lineNumberHashTotal+ lineHash[2];
+        }
+
+        int denominator = stackTraceLinesHashes.size();
+        double[] stackTraceHash ={functionNameHashTotal/denominator,fileNameHashTotal/denominator,lineNumberHashTotal/denominator};
+        return stackTraceHash;
+        
     }
+
+
 }
diff --git a/src/main/java/org/schemaspy/model/Scorer.java b/src/main/java/org/schemaspy/model/Scorer.java
index 95edea4..8591d1b 100755
--- a/src/main/java/org/schemaspy/model/Scorer.java
+++ b/src/main/java/org/schemaspy/model/Scorer.java
@@ -5,8 +5,6 @@ import org.apache.commons.math3.linear.RealMatrix;
 import org.apache.commons.math3.linear.RealVector;
 import org.apache.commons.math3.stat.StatUtils;
 
-
-import java.lang.reflect.Array;
 import java.util.*;
 
 /**
@@ -263,13 +261,12 @@ public class Scorer {
     {
         int i = 0;
         ReportVector rpv = gtn.getReportVector();
-        rpv.setStackTraceHash(rpv.hashStackTrace(mutationTree,gtn));
-        double[] tmp = {rpv.getStackTraceHash(),0,0};
+        double[] tmp = rpv.getStackTraceHash();
         predict = tmp;
         for(GenericTreeNode gtnLoop : mutationTree.toArray())
         {
 
-            double[] data = {gtnLoop.getReportVector().getStackTraceHash(),0,0};
+            double[] data = gtnLoop.getReportVector().getStackTraceHash();
             input[i] = data;
             i++;
         }
diff --git a/src/main/java/org/schemaspy/model/StackTraceLine.java b/src/main/java/org/schemaspy/model/StackTraceLine.java
index 328024a..155bb2b 100755
--- a/src/main/java/org/schemaspy/model/StackTraceLine.java
+++ b/src/main/java/org/schemaspy/model/StackTraceLine.java
@@ -3,7 +3,9 @@ package org.schemaspy.model;
 public class StackTraceLine {
 
     private String functionName;
+    private double functionNameHash;
     private String fileName;
+    private double fileNameHash;
     private int lineNumber;
 
     public StackTraceLine(String functionName, String fileName, int lineNumber) {
@@ -12,13 +14,17 @@ public class StackTraceLine {
         this.lineNumber = lineNumber;
     }
 
-    public String getfunctionName() {
-        return functionName;
-    }
+    public String getFunctionName() { return functionName; }
 
-    public void setfunctionName(String functionName) {
-        this.functionName = functionName;
-    }
+    public void setFunctionName(String functionName) { this.functionName = functionName; }
+
+    public double getFunctionNameHash() { return functionNameHash; }
+
+    public void setFunctionNameHash(double functionNameHash) { this.functionNameHash = functionNameHash; }
+
+    public double getFileNameHash() { return fileNameHash; }
+
+    public void setFileNameHash(double fileNameHash) { this.fileNameHash = fileNameHash; }
 
     public String getFileName() {
         return fileName;
@@ -51,4 +57,91 @@ public class StackTraceLine {
             return true;
         return false;
     }
+
+    public static double similarity(String s1, String s2) {
+        String longer = s1, shorter = s2;
+        if (s1.length() < s2.length()) { // longer should always have greater length
+            longer = s2; shorter = s1;
+        }
+        int longerLength = longer.length();
+        if (longerLength == 0) { return 1.0; /* both strings are zero length */ }
+        return (longerLength - editDistance(longer, shorter)) / (double) longerLength;
+    }
+
+    public static int editDistance(String s1, String s2) {
+        s1 = s1.toLowerCase();
+        s2 = s2.toLowerCase();
+
+        int[] costs = new int[s2.length() + 1];
+        for (int i = 0; i <= s1.length(); i++) {
+            int lastValue = i;
+            for (int j = 0; j <= s2.length(); j++) {
+                if (i == 0)
+                    costs[j] = j;
+                else {
+                    if (j > 0) {
+                        int newValue = costs[j - 1];
+                        if (s1.charAt(i - 1) != s2.charAt(j - 1))
+                            newValue = Math.min(Math.min(newValue, lastValue),
+                                    costs[j]) + 1;
+                        costs[j - 1] = lastValue;
+                        lastValue = newValue;
+                    }
+                }
+            }
+            if (i > 0)
+                costs[s2.length()] = lastValue;
+        }
+        return costs[s2.length()];
+    }
+
+    public double consistentFunctionNameHash(GenericTree mutationTree)
+    {
+        double maxSimilarity = 0.0;
+        StackTraceLine closestStl = null;
+        for(GenericTreeNode gtn: mutationTree.toArray())
+        {
+            for(StackTraceLine stl : gtn.getReportVector().getStackTrace())
+            {
+                double currentSimilarity = similarity(functionName,stl.getFunctionName());
+                if(currentSimilarity > maxSimilarity)
+                {
+                    maxSimilarity = currentSimilarity;
+                    closestStl = stl;
+                }
+            }
+        }
+
+        if(maxSimilarity == 0.0 || closestStl == null)
+            return maxSimilarity;
+        else
+        {
+            return closestStl.getFunctionNameHash() / maxSimilarity;
+        }
+    }
+
+    public double consistentFileNameHash(GenericTree mutationTree)
+    {
+        double maxSimilarity = 0.0;
+        StackTraceLine closestStl = null;
+        for(GenericTreeNode gtn: mutationTree.toArray())
+        {
+            for(StackTraceLine stl : gtn.getReportVector().getStackTrace())
+            {
+                double currentSimilarity = similarity(fileName,stl.getFileName());
+                if(currentSimilarity > maxSimilarity)
+                {
+                    maxSimilarity = currentSimilarity;
+                    closestStl = stl;
+                }
+            }
+        }
+
+        if(maxSimilarity == 0.0 || closestStl == null)
+            return maxSimilarity;
+        else
+        {
+            return closestStl.getFunctionNameHash() / maxSimilarity;
+        }
+    }
 }