minor fixes to the output filters.

Author: Reiner Jung

evaluate-user-behaviors/src/main/java/org/iobserve/evaluation/ComparisonOutputStage.java

@@ -19,8 +19,13 @@
 import java.io.File;
 import java.io.FileWriter;
 import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
 
 import org.iobserve.analysis.cdoruserbehavior.filter.models.CallInformation;
+import org.iobserve.analysis.cdoruserbehavior.filter.models.EntryCallEdge;
 import org.iobserve.analysis.cdoruserbehavior.filter.models.EntryCallNode;
 
 import teetime.framework.AbstractConsumerStage;
@@ -49,7 +54,37 @@ protected void execute(final ComparisonResult result) throws IOException {
         final FileWriter fw = new FileWriter(this.outputFile);
         final BufferedWriter writer = new BufferedWriter(fw);
 
-        writer.write("= " + this.outputFile.getName() + " =");
+        final int baselineNodeCount = result.getBaselineNodes().size();
+        final int testModelNodeCount = result.getTestModelNodes().size();
+        final int missingNodeCount = result.getMissingNodes().size();
+        final int additionalNodeCount = result.getAdditionalNodes().size();
+
+        final int baselineEdgeCount = result.getBaselineEdges().size();
+        final int testModelEdgeCount = result.getTestModelEdges().size();
+        final int missingEdgeCount = result.getMissingEdgeCount();
+        final int additionalEdgeCount = result.getAdditionalEdgeCount();
+
+        writer.write("CP;" + this.outputFile.getName() + ";" + baselineNodeCount + ";" + baselineEdgeCount + ";"
+                + testModelNodeCount + ";" + testModelEdgeCount + ";" + missingNodeCount + ";" + additionalNodeCount
+                + ";" + missingEdgeCount + ";" + additionalEdgeCount + ";"
+                + (double) missingNodeCount / (double) baselineNodeCount + ";"
+                + (double) additionalNodeCount / (double) baselineNodeCount + ";"
+                + (double) missingEdgeCount / (double) baselineEdgeCount + ";"
+                + (double) additionalEdgeCount / (double) baselineEdgeCount + "\n");
+
+        final List<EntryCallNode> allNodes = this.createAllNodesList(result.getBaselineNodes(),
+                result.getTestModelNodes());
+        final List<EntryCallEdge> allEdges = this.createAllEdgesList(result.getBaselineEdges(),
+                result.getTestModelEdges());
+
+        this.generateNodeCallInformation(writer, "baseline;" + this.outputFile.getName() + ";", allNodes,
+                result.getBaselineNodes());
+        this.generateNodeCallInformation(writer, "compared;" + this.outputFile.getName() + ";", allNodes,
+                result.getTestModelNodes());
+        writer.write("baseline;------------------------------------------ edges\n");
+        writer.write("compared;------------------------------------------ edges\n");
+        this.generateEdges(writer, "baseline;" + this.outputFile.getName() + ";", allEdges, result.getBaselineEdges());
+        this.generateEdges(writer, "compared;" + this.outputFile.getName() + ";", allEdges, result.getTestModelEdges());
         writer.write("Nodes:\n\tmissing=" + result.getMissingNodes().size() + "\n\tadditional="
                 + result.getAdditionalNodes().size() + "\n");
         for (final EntryCallNode node : result.getMissingNodes()) {
@@ -86,4 +121,158 @@ protected void execute(final ComparisonResult result) throws IOException {
         fw.close();
     }
 
+    private List<EntryCallEdge> createAllEdgesList(List<EntryCallEdge> baselineEdges,
+            List<EntryCallEdge> testModelEdges) {
+        final List<EntryCallEdge> result = new ArrayList<>();
+        for (final EntryCallEdge edge : baselineEdges) {
+            final EntryCallEdge duplicateEdge = new EntryCallEdge();
+            duplicateEdge.setCalls(edge.getCalls());
+            duplicateEdge.setSource(edge.getSource());
+            duplicateEdge.setTarget(edge.getTarget());
+            result.add(duplicateEdge);
+        }
+
+        for (final EntryCallEdge edge : testModelEdges) {
+            if (!this.edgeExists(baselineEdges, edge)) {
+                result.add(edge);
+            } else {
+                final EntryCallEdge duplicateEdge = this.findEdge(result, edge);
+                duplicateEdge.addCalls(edge.getCalls());
+            }
+        }
+        return result;
+    }
+
+    private boolean edgeExists(List<EntryCallEdge> edges, EntryCallEdge findEdge) {
+        if (this.findEdge(edges, findEdge) != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private EntryCallEdge findEdge(List<EntryCallEdge> edges, EntryCallEdge findEdge) {
+        for (final EntryCallEdge edge : edges) {
+            if (findEdge.getSource().getSignature().equals(edge.getSource().getSignature())
+                    && findEdge.getTarget().getSignature().equals(edge.getTarget().getSignature())) {
+                return edge;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Get all nodes used in this comparison.
+     *
+     * @param baselineNodes
+     * @param testModelNodes
+     * @return
+     */
+    private List<EntryCallNode> createAllNodesList(List<EntryCallNode> baselineNodes,
+            List<EntryCallNode> testModelNodes) {
+        final List<EntryCallNode> result = new ArrayList<>();
+        result.addAll(baselineNodes);
+        for (final EntryCallNode node : testModelNodes) {
+            if (!this.nodeExists(baselineNodes, node)) {
+                result.add(node);
+            }
+        }
+        return result;
+    }
+
+    private boolean nodeExists(List<EntryCallNode> nodes, EntryCallNode findNode) {
+        if (this.findNode(nodes, findNode) != null) {
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    private EntryCallNode findNode(List<EntryCallNode> nodes, EntryCallNode findNode) {
+        for (final EntryCallNode node : nodes) {
+            if (findNode.getSignature().equals(node.getSignature())) {
+                return node;
+            }
+        }
+
+        return null;
+    }
+
+    private void generateNodeCallInformation(BufferedWriter writer, String prefix, List<EntryCallNode> allNodes,
+            List<EntryCallNode> selectedNodes) throws IOException {
+        for (final EntryCallNode referenceNode : allNodes) {
+            final EntryCallNode printNode = this.findNode(selectedNodes, referenceNode);
+            if (printNode != null) {
+                final Set<CallInformation> allEntryCallInformation = this.generateAllEntryCallInformationList(
+                        referenceNode.getEntryCallInformation(), printNode.getEntryCallInformation());
+                writer.write(prefix + printNode.getSignature().substring(18) + "\n");
+                this.generateCallInformation(writer, prefix + "\t", allEntryCallInformation,
+                        printNode.getEntryCallInformation());
+            } else {
+                writer.write(prefix + " -- \n");
+            }
+        }
+    }
+
+    private Set<CallInformation> generateAllEntryCallInformationList(Set<CallInformation> entryCallInformation,
+            Set<CallInformation> supplementalCallInfo) {
+        final Set<CallInformation> allEntryCallInformation = new HashSet<>();
+        allEntryCallInformation.addAll(entryCallInformation);
+        for (final CallInformation information : supplementalCallInfo) {
+            boolean exists = false;
+            for (final CallInformation referenceInfo : allEntryCallInformation) {
+                if (referenceInfo.getInformationSignature().equals(information.getInformationSignature())
+                        && referenceInfo.getInformationCode() == information.getInformationCode()) {
+                    exists = true;
+                }
+            }
+            if (!exists) {
+                allEntryCallInformation.add(information);
+            }
+        }
+
+        return allEntryCallInformation;
+    }
+
+    private void generateCallInformation(BufferedWriter writer, String prefix,
+            Set<CallInformation> allEntryCallInformation, Set<CallInformation> entryCallInformation)
+            throws IOException {
+
+        for (final CallInformation information : allEntryCallInformation) {
+            if (this.isContainedIn(entryCallInformation, information)) {
+                writer.write(
+                        prefix + information.getInformationSignature() + "=" + information.getInformationCode() + "\n");
+            } else {
+                writer.write(prefix + information.getInformationSignature() + "---\n");
+            }
+        }
+    }
+
+    private boolean isContainedIn(Set<CallInformation> entryCallInformation, CallInformation information) {
+        for (final CallInformation referenceInfo : entryCallInformation) {
+            if (referenceInfo.getInformationSignature().equals(information.getInformationSignature())
+                    && referenceInfo.getInformationCode() == information.getInformationCode()) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void generateEdges(BufferedWriter writer, String prefix, List<EntryCallEdge> allEdges,
+            List<EntryCallEdge> selectedEdges) throws IOException {
+        for (final EntryCallEdge referenceEdge : allEdges) {
+            final EntryCallEdge printEdge = this.findEdge(selectedEdges, referenceEdge);
+            if (printEdge != null) {
+                writer.write(prefix + printEdge.getSource().getSignature().substring(18) + " -- " + printEdge.getCalls()
+                        + ":" + referenceEdge.getCalls() + " -> " + printEdge.getTarget().getSignature().substring(18)
+                        + "\n");
+            } else {
+                writer.write(prefix + referenceEdge.getSource().getSignature().substring(18) + " -- " + "X" + ":"
+                        + referenceEdge.getCalls() + " -> " + referenceEdge.getTarget().getSignature().substring(18)
+                        + "\n");
+            }
+        }
+    }
+
 }

evaluate-user-behaviors/src/main/java/org/iobserve/evaluation/ComparisonResult.java

@@ -18,6 +18,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+import org.iobserve.analysis.cdoruserbehavior.filter.models.EntryCallEdge;
 import org.iobserve.analysis.cdoruserbehavior.filter.models.EntryCallNode;
 
 /**
@@ -30,6 +31,11 @@ public class ComparisonResult {
     private final List<EntryCallNode> missingNodes = new ArrayList<>();
     private final List<EntryCallNode> additionalNodes = new ArrayList<>();
     private final List<EntryCallNode> similarNodes = new ArrayList<>();
+    private final List<EntryCallNode> baselineNodes = new ArrayList<>();
+    private final List<EntryCallNode> testModelNodes = new ArrayList<>();
+
+    private final List<EntryCallEdge> baselineEdges = new ArrayList<>();
+    private final List<EntryCallEdge> testModelEdges = new ArrayList<>();
 
     private int missingEdgeCount;
     private int additionalEdgeCount;
@@ -66,4 +72,20 @@ public List<EntryCallNode> getSimilarNodes() {
         return this.similarNodes;
     }
 
+    public List<EntryCallNode> getBaselineNodes() {
+        return this.baselineNodes;
+    }
+
+    public List<EntryCallEdge> getBaselineEdges() {
+        return this.baselineEdges;
+    }
+
+    public List<EntryCallNode> getTestModelNodes() {
+        return this.testModelNodes;
+    }
+
+    public List<EntryCallEdge> getTestModelEdges() {
+        return this.testModelEdges;
+    }
+
 }

evaluate-user-behaviors/src/main/java/org/iobserve/evaluation/ModelComparisonStage.java

@@ -58,6 +58,12 @@ protected void execute() throws Exception {
 
         if (this.baselineModel != null && this.testModel != null) {
             final ComparisonResult result = new ComparisonResult();
+
+            result.getBaselineNodes().addAll(this.baselineModel.getEntryCallNodes());
+            result.getBaselineEdges().addAll(this.baselineModel.getEntryCallEdges());
+            result.getTestModelNodes().addAll(this.testModel.getEntryCallNodes());
+            result.getTestModelEdges().addAll(this.testModel.getEntryCallEdges());
+
             /** M2: Similarity Ratio */
             /**
              * Number of differences and similarities of two behavior graphs and the