From 716cde62b32fea025a794c019667f16408889ca4 Mon Sep 17 00:00:00 2001
From: maysam zoor <maysam_zoor@hotmail.com>
Date: Wed, 10 Mar 2021 18:09:10 +0100
Subject: [PATCH] update
---
.../simulation/DependencyGraphTranslator.java | 97 +++-
.../tmltranslator/simulation/PlanArrays.java | 43 ++
.../JFrameLatencyComparedDetailedPopup.java | 3 +-
.../JFrameLatencyDetailedAnalysis.java | 1 +
.../JFrameLatencyDetailedPopup.java | 4 +-
.../LatencyAnalysisParallelAlgorithms.java | 8 +-
.../TableRenderer.java | 8 +-
.../ComparisonOfSimulationTracesTest.java | 62 +++
.../ComparisonOfSimulationTracesTest.java | 50 ++
.../CompareLatencyInSimulationTracesTest.java | 162 +++++++
.../GraphLatencyAnalysisTest.java | 100 ++++
.../NestedStructurePLANTest.java | 99 ++++
.../GraphLatencyAnalysisTaintingTest.java | 101 +++++
.../input/seqGraph1.graphml | 429 ++++++++++++++++++
14 files changed, 1148 insertions(+), 19 deletions(-)
create mode 100644 ttool/src/test/java/ui/comparisonofsimulationtraces/ComparisonOfSimulationTracesTest.java
create mode 100644 ttool/src/test/java/ui/comparisonofsimulationtracesinxml/ComparisonOfSimulationTracesTest.java
create mode 100644 ttool/src/test/java/ui/graphlatencyanalysis/CompareLatencyInSimulationTracesTest.java
create mode 100644 ttool/src/test/java/ui/graphlatencyanalysis/GraphLatencyAnalysisTest.java
create mode 100644 ttool/src/test/java/ui/graphlatencyanalysis/NestedStructurePLANTest.java
create mode 100644 ttool/src/test/java/ui/graphlatencytainting/GraphLatencyAnalysisTaintingTest.java
create mode 100644 ttool/src/test/resources/ui/graphLatencyAnalysis/input/seqGraph1.graphml
diff --git a/src/main/java/tmltranslator/simulation/DependencyGraphTranslator.java b/src/main/java/tmltranslator/simulation/DependencyGraphTranslator.java
index d8730bbbb9..904d3ba554 100644
--- a/src/main/java/tmltranslator/simulation/DependencyGraphTranslator.java
+++ b/src/main/java/tmltranslator/simulation/DependencyGraphTranslator.java
@@ -43,6 +43,7 @@ import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
+import java.io.InputStream;
import java.io.Writer;
import java.math.BigDecimal;
import java.util.ArrayList;
@@ -153,6 +154,7 @@ public class DependencyGraphTranslator extends SwingWorker {
private Object[][] dataByTask = null;
private Object[][] dataByTaskMinMax = null;
private HashMap<Integer, Vector<SimulationTransaction>> dataByTaskR = new HashMap<Integer, Vector<SimulationTransaction>>();
+ private HashMap<Integer, Vector<SimulationTransaction>> mandatoryOptionalSimT = new HashMap<Integer, Vector<SimulationTransaction>>();
private HashMap<Integer, List<SimulationTransaction>> dataBydelayedTasks = new HashMap<Integer, List<SimulationTransaction>>();
private HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>> timeDelayedPerRow = new HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>>();
private HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>> timeDelayedPerRowMinMax = new HashMap<Integer, HashMap<String, ArrayList<ArrayList<Integer>>>>();
@@ -168,6 +170,7 @@ public class DependencyGraphTranslator extends SwingWorker {
private ArrayList<String> devicesToBeConsidered = new ArrayList<String>();
private Vector<SimulationTransaction> relatedsimTraces = new Vector<SimulationTransaction>();
private Vector<SimulationTransaction> delayDueTosimTraces = new Vector<SimulationTransaction>();
+ private Vector<SimulationTransaction> mandatoryOptional = new Vector<SimulationTransaction>();
private HashMap<String, ArrayList<SimulationTransaction>> relatedsimTraceswithTaint = new HashMap<String, ArrayList<SimulationTransaction>>();
private int nbOfNodes = 0;
private List<String> usedLabels = new ArrayList<String>();
@@ -205,8 +208,8 @@ public class DependencyGraphTranslator extends SwingWorker {
private static final String WAIT_REQ_LABEL = "Wait reqChannel_";
private static final String GET_REQ_ARG_LABEL = "getReqArg";
private static final String WAIT_ST = "Wait: ";
- private static final String WAIT_EVENT = "Wait event: ";
- private static final String SEND_EVENT = "Send event: ";
+ private static final String WAIT_EVENT = "Waitevent:";
+ private static final String SEND_EVENT = "Sendevent:";
private static final String STOP_AFTER_INFINITE_LOOP = "Stop after infinite loop";
private static final String START_OF_FORK = "startOfFork";
private static final String START_OF_JOIN = "startOfJoin";
@@ -2063,6 +2066,7 @@ public class DependencyGraphTranslator extends SwingWorker {
dataBydelayedTasks = new HashMap<Integer, List<SimulationTransaction>>();
dataByTask = null;
relatedsimTraces = new Vector<SimulationTransaction>();
+ mandatoryOptional = new Vector<SimulationTransaction>();
delayDueTosimTraces = new Vector<SimulationTransaction>();
dependencyGraphRelations.setRunnableTimePerDevice(new HashMap<String, ArrayList<ArrayList<Integer>>>());
if (path2 != null && path2.getLength() > 0) {
@@ -2072,7 +2076,7 @@ public class DependencyGraphTranslator extends SwingWorker {
GraphPath<Vertex, DefaultEdge> pathTochannel = DijkstraShortestPath.findPathBetween(g, v1, getvertex(ChannelName));
GraphPath<Vertex, DefaultEdge> pathFromChannel = DijkstraShortestPath.findPathBetween(g, getvertex(ChannelName),
getvertex(task22));
- if (pathTochannel != null && pathTochannel.getLength() > 0 && pathFromChannel != null && pathFromChannel.getLength() > 0) {
+ if (pathFromChannel != null && pathFromChannel.getLength() > 0) {
devicesToBeConsidered.addAll(busChList);
}
}
@@ -2720,6 +2724,23 @@ public class DependencyGraphTranslator extends SwingWorker {
dependencyGraphRelations.getRunnableTimePerDevice().put(dName, timeValuesList);
}
}
+ } else if (pathToDestination != null && pathToDestination.getLength() > 0) {
+ mandatoryOptional.add(st);
+ ArrayList<Integer> timeValues = new ArrayList<Integer>();
+ timeValues.add(0, Integer.valueOf(st.runnableTime));
+ timeValues.add(1, startTime);
+ String dName = st.deviceName + "_" + st.coreNumber;
+ if (!(st.runnableTime).equals(st.startTime)) {
+ if (dependencyGraphRelations.getRunnableTimePerDevice().containsKey(dName)) {
+ if (!dependencyGraphRelations.getRunnableTimePerDevice().get(dName).contains(timeValues)) {
+ dependencyGraphRelations.getRunnableTimePerDevice().get(dName).add(timeValues);
+ }
+ } else {
+ ArrayList<ArrayList<Integer>> timeValuesList = new ArrayList<ArrayList<Integer>>();
+ timeValuesList.add(timeValues);
+ dependencyGraphRelations.getRunnableTimePerDevice().put(dName, timeValuesList);
+ }
+ }
} else if (((st.deviceName.equals(task2DeviceName) && task2CoreNbr.equals(st.coreNumber))
|| (st.deviceName.equals(task1DeviceName) && task1CoreNbr.equals(st.coreNumber))
|| devicesToBeConsidered.contains(deviceName)) && !st.id.equals(idTask1) && !st.id.equals(idTask2)) {
@@ -2757,6 +2778,7 @@ public class DependencyGraphTranslator extends SwingWorker {
dataByTaskR.put(i, relatedsimTraces);
dataBydelayedTasks.put(i, delayDueTosimTraces);
timeDelayedPerRow.put(i, dependencyGraphRelations.getRunnableTimePerDevice());
+ mandatoryOptionalSimT.put(i, mandatoryOptional);
// dataByTask[i][5] = list.getModel();
// dataByTask[i][6] = totalTime;
}
@@ -3713,6 +3735,20 @@ public class DependencyGraphTranslator extends SwingWorker {
return dataByTaskRowDetails;
}
+ public String[][] getMandatoryOptionalByRow(int row) {
+ String[][] dataByTaskRowDetails = new String[mandatoryOptionalSimT.get(row).size()][5];
+ int i = 0;
+ for (SimulationTransaction st : mandatoryOptionalSimT.get(row)) {
+ dataByTaskRowDetails[i][0] = st.command;
+ dataByTaskRowDetails[i][1] = nameIDTaskList.get(st.id);
+ dataByTaskRowDetails[i][2] = st.deviceName + "_" + st.coreNumber;
+ dataByTaskRowDetails[i][3] = st.startTime;
+ dataByTaskRowDetails[i][4] = st.endTime;
+ i++;
+ }
+ return dataByTaskRowDetails;
+ }
+
// fill the detailed latency table once a row is selected
public Object[][] getTaskByRowDetailsMinMaxTaint(int row) {
String task12 = (String) dataByTaskMinMax[row][0];
@@ -3775,6 +3811,10 @@ public class DependencyGraphTranslator extends SwingWorker {
return dataByTaskR.get(row);
}
+ public List<SimulationTransaction> getMandatoryOptionalSimTTaks(int row) {
+ return mandatoryOptionalSimT.get(row);
+ }
+
public Vector<SimulationTransaction> getMinMaxTasksByRowTainted(int row) {
int maxStartTime = (int) dataByTaskMinMax[row][1];
int maxEndTime = (int) dataByTaskMinMax[row][3];
@@ -4142,18 +4182,25 @@ public class DependencyGraphTranslator extends SwingWorker {
}
// import graph in .graphml format
- public void importGraph(String filename) throws ExportException, IOException, ImportException {
- FileReader ps = new FileReader(filename + ".graphml");
+ public Graph<Vertex, DefaultEdge> importGraph(String filename) throws IOException {
+ InputStream inputStream = getClass().getResourceAsStream(filename + ".graphml");
+ Graph<Vertex, DefaultEdge> importedG = new DefaultDirectedGraph<>(DefaultEdge.class);
+ GraphMLImporter<Vertex, DefaultEdge> importer;
// gmlExporter.exportGraph(g, PS);
// FileWriter PS2 = new FileWriter(filename + "test.graphml");
- VertexProvider<String> vertexProvider = (id, attributes) -> {
- String cv = new String(id);
- return cv;
+ VertexProvider<Vertex> vertexProvider = (id, attributes) -> {
+ Vertex v = new Vertex(id, 0);
+ return v;
};
- EdgeProvider<String, DefaultEdge> edgeProvider = (from, to, label, attributes) -> new DefaultEdge();
- GraphMLImporter<String, DefaultEdge> importer = new GraphMLImporter<String, DefaultEdge>(vertexProvider, edgeProvider);
- Graph<String, DefaultEdge> importedGraph = null;
- importer.importGraph(importedGraph, ps);
+ EdgeProvider<Vertex, DefaultEdge> edgeProvider = (from, to, label, attributes) -> new DefaultEdge();
+ importer = new GraphMLImporter<Vertex, DefaultEdge>(vertexProvider, edgeProvider);
+ try {
+ importer.importGraph(importedG, inputStream);
+ } catch (ImportException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ return importedG;
}
public HashMap<String, String> getNameIDTaskList() {
@@ -4347,4 +4394,30 @@ public class DependencyGraphTranslator extends SwingWorker {
public DependencyGraphRelations getDependencyGraphRelations() {
return dependencyGraphRelations;
}
+
+ public boolean compareWithImported(String filename) {
+ try {
+ Graph<Vertex, DefaultEdge> importedGraph = importGraph(filename);
+ for (Vertex vg : g.vertexSet()) {
+ if (!importedGraph.vertexSet().contains(vg)) {
+ return false;
+ }
+ }
+ for (DefaultEdge vg : g.edgeSet()) {
+ if (!importedGraph.edgeSet().toString().contains(vg.toString())) {
+ return false;
+ }
+ }
+ if (g.vertexSet().size() != importedGraph.vertexSet().size()) {
+ return false;
+ }
+ if (g.edgeSet().size() != importedGraph.edgeSet().size()) {
+ return false;
+ }
+ } catch (IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ return true;
+ }
}
\ No newline at end of file
diff --git a/src/main/java/tmltranslator/simulation/PlanArrays.java b/src/main/java/tmltranslator/simulation/PlanArrays.java
index b16153a788..06f9906163 100644
--- a/src/main/java/tmltranslator/simulation/PlanArrays.java
+++ b/src/main/java/tmltranslator/simulation/PlanArrays.java
@@ -10,6 +10,7 @@ public class PlanArrays {
private List<String> onPathBehavior = new ArrayList<String>();
private List<String> offPathBehavior = new ArrayList<String>();
private List<String> offPathBehaviorCausingDelay = new ArrayList<String>();
+ private List<String> mandatoryOptional = new ArrayList<String>();
private static final String ZERO = "0";
private static final String DEVICE_NAME = "Device Name";
private String[] columnNames;
@@ -38,6 +39,23 @@ public class PlanArrays {
deviceNames1.add(deviceNameandcore);
}
}
+ for (SimulationTransaction st : dgraph.getMandatoryOptionalSimTTaks(row)) {
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ tmpEnd = Integer.parseInt(st.endTime);
+ if (tmpEnd > maxTime) {
+ maxTime = tmpEnd;
+ }
+ tmpStart = Integer.parseInt(st.startTime);
+ if (tmpStart < minTime) {
+ minTime = tmpStart;
+ }
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (!deviceNames1.contains(deviceNameandcore)) {
+ deviceNames1.add(deviceNameandcore);
+ }
+ }
for (SimulationTransaction st : dgraph.getRowDetailsByHW(row)) {
tmpEnd = Integer.parseInt(st.endTime);
if (st.coreNumber == null) {
@@ -85,6 +103,26 @@ public class PlanArrays {
}
}
}
+ for (SimulationTransaction st : dgraph.getMandatoryOptionalSimTTaks(row)) {
+ if (st.coreNumber == null) {
+ st.coreNumber = ZERO;
+ }
+ for (String dName : deviceNames1) {
+ String deviceNameandcore = st.deviceName + "_" + st.coreNumber;
+ if (deviceNameandcore.equals(dName)) {
+ length = Integer.parseInt(st.length);
+ for (int i = 0; i < length; i++) {
+ int columnnmber = Integer.parseInt(st.endTime) - minTime - i;
+ dataDetailedByTask[deviceNames1.indexOf(dName)][columnnmber] = dgraph.getNameIDTaskList().get(st.id);
+ ;
+ mandatoryOptional.add(dgraph.getNameIDTaskList().get(st.id) + columnNames[columnnmber]);
+ // if (!dgraph.getOnPath().contains(st)) {
+ // dgraph.getOnPath().add(st);
+ // }
+ }
+ }
+ }
+ }
HashMap<String, ArrayList<ArrayList<Integer>>> delayTime = dgraph.getRowDelayDetailsByHW(row);
for (SimulationTransaction st : dgraph.getRowDetailsByHW(row)) {
int startTime = Integer.valueOf(st.startTime);
@@ -308,4 +346,9 @@ public class PlanArrays {
public String[] getColumnNames() {
return columnNames;
}
+
+ public List<String> getMandatoryOptional() {
+ return mandatoryOptional;
+ }
+
}
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java
index 05e6f2cf21..6a9b92e677 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyComparedDetailedPopup.java
@@ -59,7 +59,6 @@ import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
-
import tmltranslator.simulation.DependencyGraphTranslator;
import tmltranslator.simulation.SimulationTransaction;
@@ -560,7 +559,7 @@ public class JFrameLatencyComparedDetailedPopup extends JFrame implements TableM
table.setFillsViewportHeight(true);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setAutoCreateRowSorter(true);
- TableRenderer tr = new TableRenderer(onPathBehavior, offPathBehaviorCausingDelay, offPathBehavior);
+ TableRenderer tr = new TableRenderer(onPathBehavior, offPathBehaviorCausingDelay, offPathBehavior, offPathBehavior);
int ncols = table.getColumnCount();
table.getModel().addTableModelListener(this);
TableColumnModel tcm = table.getColumnModel();
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
index 1e8d5948c8..58633d849e 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedAnalysis.java
@@ -511,6 +511,7 @@ public class JFrameLatencyDetailedAnalysis extends JFrame implements ActionListe
protected void generateDirectedGraph(TMLMapping<TGComponent> tmap, List<TMLComponentDesignPanel> cpanels) {
try {
dgraph = new DependencyGraphTranslator(tmap);
+ tc.setDgraph(dgraph);
pbar.setMaximum(dgraph.getNodeNbProgressBar());
pbar.setMinimum(0);
dgraph.addPropertyChangeListener(new PropertyChangeListener() {
diff --git a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
index 3cda41c3b4..9ab0c0677f 100644
--- a/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
+++ b/src/main/java/ui/simulationtraceanalysis/JFrameLatencyDetailedPopup.java
@@ -56,7 +56,6 @@ import javax.swing.table.DefaultTableModel;
import javax.swing.table.TableCellRenderer;
import javax.swing.table.TableColumn;
import javax.swing.table.TableColumnModel;
-
import tmltranslator.simulation.DependencyGraphTranslator;
import tmltranslator.simulation.PlanArrays;
@@ -229,7 +228,8 @@ public class JFrameLatencyDetailedPopup extends JFrame implements TableModelList
table.setFillsViewportHeight(true);
table.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
table.setAutoCreateRowSorter(true);
- TableRenderer tr = new TableRenderer(arrays.getOnPathBehavior(), arrays.getOffPathBehaviorCausingDelay(), arrays.getOffPathBehavior());
+ TableRenderer tr = new TableRenderer(arrays.getOnPathBehavior(), arrays.getOffPathBehaviorCausingDelay(), arrays.getOffPathBehavior(),
+ arrays.getMandatoryOptional());
int ncols = table.getColumnCount();
table.getModel().addTableModelListener(this);
TableColumnModel tcm = table.getColumnModel();
diff --git a/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java b/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java
index e59cb0cdcc..8fccc86300 100644
--- a/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java
+++ b/src/main/java/ui/simulationtraceanalysis/LatencyAnalysisParallelAlgorithms.java
@@ -6,7 +6,6 @@ import java.util.Vector;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPathExpressionException;
import org.xml.sax.SAXException;
-
import tmltranslator.TMLMapping;
import tmltranslator.simulation.DependencyGraphTranslator;
import tmltranslator.simulation.SimulationTransaction;
@@ -25,7 +24,7 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
private List<TMLComponentDesignPanel> cpanels;
private DependencyGraphTranslator dgraph, dgraph1, dgraph2;
private int row, row1, row2, row3, row4, selectedIndex;
- private Object[][] dataDetailedByTask, dataDetailedByTask2;
+ private Object[][] dataDetailedByTask, dataDetailedByTask2, dataMandatoryOptional;
private LatencyDetailedAnalysisMain main;
private MainGUI mainGUI;
private SimulationTrace selectedST;
@@ -45,6 +44,7 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
jFrameLDA.generateDirectedGraph(tmap, cpanels);
} else if (algorithmId == 2) {
dataDetailedByTask = dgraph.getTaskByRowDetails(row);
+ dataMandatoryOptional = dgraph.getMandatoryOptionalByRow(row);
} else if (algorithmId == 3) {
dataDetailedByTask = dgraph.getTaskByRowDetailsMinMaxTaint(row);
} else if (algorithmId == 4) {
@@ -222,6 +222,10 @@ public class LatencyAnalysisParallelAlgorithms implements Runnable {
this.dgraph1 = dgraph1;
}
+ public Object[][] getDataMandatoryOptional() {
+ return dataMandatoryOptional;
+ }
+
public void latencyDetailedAnalysis(JFrameCompareLatencyDetail jFrameCompareLatencyDetail, String task12, String task22, String task32,
String task42, Vector<SimulationTransaction> transFile12, Vector<SimulationTransaction> transFile22) {
cld = jFrameCompareLatencyDetail;
diff --git a/src/main/java/ui/simulationtraceanalysis/TableRenderer.java b/src/main/java/ui/simulationtraceanalysis/TableRenderer.java
index 407d06889b..f0970b2c79 100644
--- a/src/main/java/ui/simulationtraceanalysis/TableRenderer.java
+++ b/src/main/java/ui/simulationtraceanalysis/TableRenderer.java
@@ -17,14 +17,17 @@ class TableRenderer extends DefaultTableCellRenderer {
private List<String> onPathBehaviors = new Vector<String>();
private List<String> offPathBehaviors = new Vector<String>();
private List<String> offPathBehaviorCausingDelay = new Vector<String>();
+ private List<String> mandatoryOptionalByRow = new Vector<String>();
- public TableRenderer(List<String> onPathBehavior, List<String> offPathBehaviorCausingDelay, List<String> offPathBehavior) {
+ public TableRenderer(List<String> onPathBehavior, List<String> offPathBehaviorCausingDelay, List<String> offPathBehavior,
+ List<String> mandatoryOptionalByRow) {
this.onPathBehaviors = new Vector<String>();
this.offPathBehaviorCausingDelay = new Vector<String>();
this.offPathBehaviors = new Vector<String>();
this.onPathBehaviors = onPathBehavior;
this.offPathBehaviorCausingDelay = offPathBehaviorCausingDelay;
this.offPathBehaviors = offPathBehavior;
+ this.mandatoryOptionalByRow = mandatoryOptionalByRow;
}
public Component getTableCellRendererComponent(JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int column) {
@@ -44,6 +47,9 @@ class TableRenderer extends DefaultTableCellRenderer {
} else if (offPathBehaviors.contains(value.toString() + table.getColumnName(column))) {
randomColour = Color.orange;
// randomColour = Color.red;
+ } else if (mandatoryOptionalByRow.contains(value.toString() + table.getColumnName(column))) {
+ randomColour = Color.LIGHT_GRAY;
+ // randomColour = Color.red;
}
} else {
this.colorCell = false;
diff --git a/ttool/src/test/java/ui/comparisonofsimulationtraces/ComparisonOfSimulationTracesTest.java b/ttool/src/test/java/ui/comparisonofsimulationtraces/ComparisonOfSimulationTracesTest.java
new file mode 100644
index 0000000000..cde245810b
--- /dev/null
+++ b/ttool/src/test/java/ui/comparisonofsimulationtraces/ComparisonOfSimulationTracesTest.java
@@ -0,0 +1,62 @@
+package ui.comparisonofsimulationtraces;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.xml.sax.SAXException;
+
+import tmltranslator.simulation.CompareSimulationTrace;
+import ui.AbstractUITest;
+import ui.SimulationTrace;
+import ui.interactivesimulation.JFrameShowLatencyDetails;
+import ui.simulationtraceanalysis.JFrameCompareSimulationTraces;
+
+
+public class ComparisonOfSimulationTracesTest extends AbstractUITest {
+ protected static SimulationTrace selectedST1;
+ protected static SimulationTrace selectedST2;
+ protected static String STfilePath1;
+ protected static String STfilePath2;
+ private static JFrameCompareSimulationTraces cSimTrace;
+ private static CompareSimulationTrace newContentPane;
+ private static JFrameShowLatencyDetails showLatencyDetails;
+ private static final String PATH1 = "/ui/xmlCompare/input/simple.xml";
+ private static final String PATH2 = "/ui/xmlCompare/input/simplifiedWithSecurity.xml";
+
+ @BeforeClass
+ public static void setUpBeforeClass() throws Exception {
+ STfilePath1 = getBaseResourcesDir() + PATH1;
+ STfilePath2 = getBaseResourcesDir() + PATH2;
+ selectedST1 = new SimulationTrace("simple.xml", 6, STfilePath1);
+ selectedST2 = new SimulationTrace("simplifiedWithSecurity.xml", 6, STfilePath2);
+ }
+
+ @Test
+ public void loadTest() {
+ assertNotNull(selectedST1);
+ assertNotNull(selectedST2);
+ }
+
+ @Test
+ public void parseXMLTest() throws SAXException, IOException, ParserConfigurationException {
+ cSimTrace = new JFrameCompareSimulationTraces(mainGUI, "Compare Simulation simulation", selectedST1, false);
+ cSimTrace.setVisible(false);
+ cSimTrace.parseXML(STfilePath1, STfilePath2);
+ assertNotNull(cSimTrace.getTransFile1());
+ assertNotNull(cSimTrace.getTransFile2());
+ }
+
+ @Test
+ public void diffTest() throws SAXException, IOException, ParserConfigurationException {
+ newContentPane = new CompareSimulationTrace();
+ newContentPane.JPanelCompareXmlGraph(cSimTrace.getTransFile1(), cSimTrace.getTransFile2());
+ assertTrue(newContentPane.getTable().getRowCount() > 0);
+ }
+
+}
\ No newline at end of file
diff --git a/ttool/src/test/java/ui/comparisonofsimulationtracesinxml/ComparisonOfSimulationTracesTest.java b/ttool/src/test/java/ui/comparisonofsimulationtracesinxml/ComparisonOfSimulationTracesTest.java
new file mode 100644
index 0000000000..cc433be902
--- /dev/null
+++ b/ttool/src/test/java/ui/comparisonofsimulationtracesinxml/ComparisonOfSimulationTracesTest.java
@@ -0,0 +1,50 @@
+package ui.comparisonofsimulationtracesinxml;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.IOException;
+
+import javax.xml.parsers.ParserConfigurationException;
+
+import org.junit.BeforeClass;
+import org.junit.Test;
+import org.xml.sax.SAXException;
+
+import tmltranslator.simulation.CompareSimulationTrace;
+import ui.AbstractUITest;
+import ui.SimulationTrace;
+import ui.interactivesimulation.JFrameShowLatencyDetails;
+import ui.simulationtraceanalysis.JFrameCompareSimulationTraces;
+
+public class ComparisonOfSimulationTracesTest extends AbstractUITest {
+ private static final String PATH1 = "/ui/xmlCompare/input/simple.xml";
+ private static final String PATH2 = "/ui/xmlCompare/input/simplifiedWithSecurity.xml";
+ private static String STfilePath1 = getBaseResourcesDir() + PATH1;
+ private static String STfilePath2 = getBaseResourcesDir() + PATH2;
+
+ private JFrameCompareSimulationTraces cSimTrace;
+ private CompareSimulationTrace newContentPane;
+ private JFrameShowLatencyDetails showLatencyDetails;
+ private SimulationTrace selectedST1 = new SimulationTrace("", 6, STfilePath1);
+ private SimulationTrace selectedST2 = new SimulationTrace("", 6, STfilePath2);
+
+ @Test
+ public void loadTest() {
+ assertNotNull(selectedST1);
+ assertNotNull(selectedST2);
+ }
+
+ @Test
+ public void parseXMLTest() throws SAXException, IOException, ParserConfigurationException {
+ cSimTrace = new JFrameCompareSimulationTraces(mainGUI, "", selectedST1, false);
+ cSimTrace.setVisible(false);
+ cSimTrace.parseXML(STfilePath1, STfilePath2);
+ assertNotNull(cSimTrace.getTransFile1());
+ assertNotNull(cSimTrace.getTransFile2());
+ newContentPane = new CompareSimulationTrace();
+ newContentPane.JPanelCompareXmlGraph(cSimTrace.getTransFile1(), cSimTrace.getTransFile2());
+ assertTrue(newContentPane.getTable().getRowCount() > 0);
+ }
+
+}
\ No newline at end of file
diff --git a/ttool/src/test/java/ui/graphlatencyanalysis/CompareLatencyInSimulationTracesTest.java b/ttool/src/test/java/ui/graphlatencyanalysis/CompareLatencyInSimulationTracesTest.java
new file mode 100644
index 0000000000..78cd58bcf7
--- /dev/null
+++ b/ttool/src/test/java/ui/graphlatencyanalysis/CompareLatencyInSimulationTracesTest.java
@@ -0,0 +1,162 @@
+package ui.graphlatencyanalysis;
+
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map.Entry;
+import java.util.Vector;
+
+import javax.xml.parsers.ParserConfigurationException;
+import javax.xml.xpath.XPathExpressionException;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.xml.sax.SAXException;
+
+import tmltranslator.simulation.DependencyGraphTranslator;
+import tmltranslator.simulation.SimulationTransaction;
+import ui.AbstractUITest;
+import ui.SimulationTrace;
+import ui.TMLArchiPanel;
+import ui.simulationtraceanalysis.JFrameCompareLatencyDetail;
+import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
+import ui.simulationtraceanalysis.LatencyAnalysisParallelAlgorithms;
+import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
+
+public class CompareLatencyInSimulationTracesTest extends AbstractUITest {
+ private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
+ private static final String SIMULATIONTRACEPATHFILE1 = INPUT_PATH + "/graphTestSimulationTrace.xml";
+ private static final String SIMULATIONTRACEPATHFILE2 = INPUT_PATH + "/testFunc.xml";
+ private static final String MODELPATH = INPUT_PATH + "/GraphTestModel.xml";
+ private static final String MAPPINGDIAGNAME = "Architecture2";
+ private static final int OPERATOR1ID = 44;
+ private static final int OPERATOR2ID = 26;
+ private static final int OPERATOR3ID = 40;
+ private static final int OPERATOR4ID = 28;
+
+ private Vector<String> checkedTransactionsFile1 = new Vector<String>();
+ private Vector<String> checkedTransactionsFile2 = new Vector<String>();
+ private DependencyGraphTranslator dgraph1, dgraph2;
+ private String task1, task2, task3, task4;
+ private JFrameCompareLatencyDetail cld;
+ private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
+ private JFrameLatencyDetailedAnalysis jFrameLatencyDetailedAnalysis;
+ private Vector<SimulationTransaction> transFile1, transFile2;
+ private SimulationTrace simT1, simT2;
+ private File file1, file2;
+ private int row, row2;
+ private HashMap<String, Integer> checkedT1 = new HashMap<String, Integer>();
+ private HashMap<String, Integer> checkedT2 = new HashMap<String, Integer>();
+ // protected MainGUI mainGUI1 = null;
+ private Object[][] dataDetailedByTask, dataDetailedByTask2, dataHWDelayByTask, dataHWDelayByTask2;
+
+ public CompareLatencyInSimulationTracesTest() {
+ super();
+ }
+
+ @Before
+ public void GraphLatencyAnalysis()
+ throws XPathExpressionException, ParserConfigurationException, SAXException, IOException, InterruptedException {
+ mainGUI.openProjectFromFile(new File(getBaseResourcesDir() + MODELPATH));
+ final TMLArchiPanel panel = findArchiPanel(MAPPINGDIAGNAME);
+ simT1 = new SimulationTrace("", 6, (getBaseResourcesDir() + SIMULATIONTRACEPATHFILE1));
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, simT1, false, false, 3);
+ LatencyDetailedAnalysisMain.setCheckedTransactionsFile(new Vector<String>());
+ try {
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysisForXML(mainGUI, simT1, false, true, 1);
+ LatencyDetailedAnalysisMain.setTc(new LatencyAnalysisParallelAlgorithms(LatencyDetailedAnalysisMain));
+ cld = new JFrameCompareLatencyDetail(LatencyDetailedAnalysisMain, mainGUI, checkedTransactionsFile1,
+ LatencyDetailedAnalysisMain.getMap1(), LatencyDetailedAnalysisMain.getCpanels1(), simT1, false,
+ LatencyDetailedAnalysisMain.getTc());
+ if (cld == null) {
+ System.out.println("NULL Panel");
+ } else {
+ cld.setVisible(false);
+ }
+ } catch (XPathExpressionException | ParserConfigurationException | SAXException | IOException e) {
+ e.printStackTrace();
+ }
+ LatencyDetailedAnalysisMain.getTc().getT().join();
+ if (cld.getDgraph().getGraphsize() > 0) {
+ dgraph1 = cld.getDgraph();
+ checkedTransactionsFile1 = LatencyDetailedAnalysisMain.getCheckedTransactionsFile();
+ checkedT1 = LatencyDetailedAnalysisMain.getCheckedT1();
+ cld.setDgraph(null);
+ LatencyDetailedAnalysisMain.setCheckedTransactionsFile(new Vector<String>());
+ simT2 = new SimulationTrace("", 6, (getBaseResourcesDir() + SIMULATIONTRACEPATHFILE2));
+ try {
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysisForXML(mainGUI, simT2, false, true, 1);
+ } catch (XPathExpressionException | ParserConfigurationException | SAXException | IOException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ dgraph2 = new DependencyGraphTranslator(LatencyDetailedAnalysisMain.getMap1());
+ dgraph2.DrawDirectedGraph();
+ checkedTransactionsFile2 = LatencyDetailedAnalysisMain.getCheckedTransactionsFile();
+ checkedT2 = LatencyDetailedAnalysisMain.getCheckedT2();
+ }
+ }
+
+ @Test
+ public void parseFile() {
+ int graphsize = dgraph1.getGraphsize();
+ assertTrue(1 > 0);
+ graphsize = dgraph2.getGraphsize();
+ assertTrue(graphsize > 0);
+ assertTrue(checkedT1.size() == 3);
+ assertTrue(checkedT2.size() == 3);
+ for (Entry<String, Integer> cT : checkedT1.entrySet()) {
+ int id = cT.getValue();
+ String taskName = cT.getKey();
+ if (id == OPERATOR1ID) {
+ task1 = taskName;
+ } else if (id == OPERATOR2ID) {
+ task2 = taskName;
+ }
+ }
+ for (Entry<String, Integer> cT : checkedT2.entrySet()) {
+ int id = cT.getValue();
+ String taskName = cT.getKey();
+ if (id == OPERATOR3ID) {
+ task3 = taskName;
+ } else if (id == OPERATOR4ID) {
+ task4 = taskName;
+ }
+ }
+ file1 = new File(simT1.getFullPath());
+ file2 = new File(simT2.getFullPath());
+ transFile1 = cld.parseFile(file1);
+ transFile2 = cld.parseFile(file2);
+ cld.setDgraph2(dgraph2);
+ cld.latencyDetailedAnalysis(task1, task2, task3, task4, transFile1, transFile2, false, false, false);
+ cld.setVisible(false);
+ assertTrue(cld.getTableData().length > 0);
+ assertTrue(cld.getTableData2().length > 0);
+ assertTrue(cld.getTableData1MinMax().length > 0);
+ assertTrue(cld.getTableData2MinMax().length > 0);
+ // test row 1 table 1 and row 1 table 2
+ row = 1;
+ row2 = 1;
+ dataDetailedByTask = dgraph1.getTaskByRowDetails(row);
+ dataDetailedByTask2 = dgraph2.getTaskByRowDetails(row2);
+ dataHWDelayByTask = dgraph1.getTaskHWByRowDetails(row);
+ dataHWDelayByTask2 = dgraph2.getTaskHWByRowDetails(row2);
+ assertTrue(dataDetailedByTask.length > 0);
+ assertTrue(dataDetailedByTask2.length > 0);
+ assertTrue(dataHWDelayByTask.length > 0);
+ assertTrue(dataHWDelayByTask2.length > 0);
+ // test max table 1 and max table 2
+ dgraph1.getRowDetailsMinMax(row);
+ dataDetailedByTask = dgraph1.getTasksByRowMinMax(row);
+ dgraph2.getRowDetailsMinMax(row2);
+ dataDetailedByTask2 = dgraph2.getTasksByRowMinMax(row2);
+ dataHWDelayByTask = dgraph1.getTaskHWByRowDetailsMinMax(row);
+ dataHWDelayByTask2 = dgraph2.getTaskHWByRowDetailsMinMax(row2);
+ assertTrue(dataDetailedByTask.length > 0);
+ assertTrue(dataDetailedByTask2.length > 0);
+ assertTrue(dataHWDelayByTask.length > 0);
+ assertTrue(dataHWDelayByTask2.length > 0);
+ }
+}
\ No newline at end of file
diff --git a/ttool/src/test/java/ui/graphlatencyanalysis/GraphLatencyAnalysisTest.java b/ttool/src/test/java/ui/graphlatencyanalysis/GraphLatencyAnalysisTest.java
new file mode 100644
index 0000000000..1471c6c1a4
--- /dev/null
+++ b/ttool/src/test/java/ui/graphlatencyanalysis/GraphLatencyAnalysisTest.java
@@ -0,0 +1,100 @@
+package ui.graphlatencyanalysis;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map.Entry;
+import java.util.Vector;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import tmltranslator.simulation.DependencyGraphTranslator;
+import tmltranslator.simulation.SimulationTransaction;
+import ui.AbstractUITest;
+import ui.SimulationTrace;
+import ui.TMLArchiPanel;
+import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
+import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
+
+public class GraphLatencyAnalysisTest extends AbstractUITest {
+ private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
+ private static final String SIMULATIONTRACE_PATH = INPUT_PATH + "/graphTestSimulationTrace.xml";
+ private static final String modelPath = INPUT_PATH + "/GraphTestModel.xml";
+ private static final String mappingDiagName = "Architecture2";
+ private static final int OPERATOR1_ID = 44;
+ private static final int OPERATOR2_ID = 26;
+
+ private Vector<SimulationTransaction> transFile1;
+ private HashMap<String, Integer> checkedDropDown = new HashMap<String, Integer>();
+ private String task1;
+ private String task2;
+ private DependencyGraphTranslator dgt;
+ private Object[][] allLatencies, minMaxArray, taskHWByRowDetails, detailedLatency;
+ private JFrameLatencyDetailedAnalysis latencyDetailedAnalysis;
+ private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
+
+ @Before
+ public void GraphLatencyAnalysis() throws InterruptedException {
+ mainGUI.openProjectFromFile(new File(getBaseResourcesDir() + modelPath));
+ // mainGUI.openProjectFromFile(new File( modelPath));
+ final TMLArchiPanel panel = findArchiPanel(mappingDiagName);
+ if (panel == null) {
+ System.out.println("NULL Panel");
+ } else {
+ System.out.println("Non NULL Panel");
+ }
+ mainGUI.checkModelingSyntax(panel, true);
+ SimulationTrace file2 = new SimulationTrace("", 6, SIMULATIONTRACE_PATH);
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
+ LatencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
+ latencyDetailedAnalysis = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
+ if (latencyDetailedAnalysis != null) {
+ latencyDetailedAnalysis.setVisible(false);
+ latencyDetailedAnalysis.getTc().run();
+ try {
+ latencyDetailedAnalysis.getT().join();
+ } catch (InterruptedException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ dgt = latencyDetailedAnalysis.getDgraph();
+ }
+ }
+
+ @Test
+ public void parseFile() {
+ assertNotNull(latencyDetailedAnalysis);
+ int graphsize = dgt.getGraphsize();
+ assertTrue(graphsize >= 40);
+ checkedDropDown = latencyDetailedAnalysis.getCheckedT();
+ assertTrue(checkedDropDown.size() == 3);
+ transFile1 = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + SIMULATIONTRACE_PATH));
+ assertTrue(transFile1.size() == 175);
+ for (Entry<String, Integer> cT : checkedDropDown.entrySet()) {
+ int id = cT.getValue();
+ String taskName = cT.getKey();
+ if (id == OPERATOR1_ID) {
+ task1 = taskName;
+ } else if (id == OPERATOR2_ID) {
+ task2 = taskName;
+ }
+ }
+ allLatencies = dgt.latencyDetailedAnalysis(task1, task2, transFile1, false, false);
+ assertTrue(allLatencies.length == 10);
+ minMaxArray = dgt.latencyMinMaxAnalysis(task1, task2, transFile1);
+ dgt.getRowDetailsMinMax(1);
+ taskHWByRowDetails = dgt.getTasksByRowMinMax(1);
+ assertTrue(minMaxArray.length > 0);
+ assertTrue(taskHWByRowDetails.length == 15);
+ taskHWByRowDetails = dgt.getTaskHWByRowDetailsMinMax(1);
+ assertTrue(taskHWByRowDetails.length == 13);
+ detailedLatency = dgt.getTaskByRowDetails(7);
+ assertTrue(detailedLatency.length == 14);
+ detailedLatency = dgt.getTaskHWByRowDetails(7);
+ assertTrue(detailedLatency.length == 14);
+ }
+}
\ No newline at end of file
diff --git a/ttool/src/test/java/ui/graphlatencyanalysis/NestedStructurePLANTest.java b/ttool/src/test/java/ui/graphlatencyanalysis/NestedStructurePLANTest.java
new file mode 100644
index 0000000000..e8f3651ab9
--- /dev/null
+++ b/ttool/src/test/java/ui/graphlatencyanalysis/NestedStructurePLANTest.java
@@ -0,0 +1,99 @@
+package ui.graphlatencyanalysis;
+
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import java.awt.*;
+import java.io.File;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map.Entry;
+import java.util.Vector;
+import org.junit.Before;
+import org.junit.Test;
+import myutil.TraceManager;
+import tmltranslator.simulation.DependencyGraphTranslator;
+import tmltranslator.simulation.SimulationTransaction;
+import tmltranslator.simulation.Vertex;
+import ui.AbstractUITest;
+import ui.SimulationTrace;
+import ui.TMLArchiPanel;
+import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
+import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
+
+public class NestedStructurePLANTest extends AbstractUITest {
+ private static final String MAPPING_DIAG_NAME = "Architecture";
+ private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
+ private static final String SIMULATIONTRACE_PATH_FILE = INPUT_PATH + "/loopseqTrace.xml";
+ private static final String MODEL_PATH = INPUT_PATH + "/loopseqgraph.xml";
+ private static final int OPERATOR1_ID = 69;
+ private static final int OPERATOR2_ID = 53;
+ private static final String GRAPH = INPUT_PATH + "/seqGraph1";
+ private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
+ private JFrameLatencyDetailedAnalysis latencyDetailedAnalysis;
+ private DependencyGraphTranslator dgt;
+ private Vector<SimulationTransaction> transFile1;
+ private HashMap<String, Integer> checkedDropDown = new HashMap<String, Integer>();
+ private String task1;
+ private String task2;
+ private Object[][] allLatencies;
+
+ @Before
+ public void NestedStructurePLAN() throws InterruptedException {
+ mainGUI.openProjectFromFile(new File(getBaseResourcesDir() + MODEL_PATH));
+ final TMLArchiPanel panel = findArchiPanel(MAPPING_DIAG_NAME);
+ if (panel == null) {
+ System.out.println("NULL Panel");
+ } else {
+ System.out.println("Non NULL Panel");
+ }
+ mainGUI.checkModelingSyntax(panel, true);
+ SimulationTrace file2 = new SimulationTrace("", 6, SIMULATIONTRACE_PATH_FILE);
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
+ LatencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
+ latencyDetailedAnalysis = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
+ if (latencyDetailedAnalysis != null) {
+ latencyDetailedAnalysis.setVisible(false);
+ latencyDetailedAnalysis.getTc().run();
+ try {
+ latencyDetailedAnalysis.getT().join();
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ dgt = latencyDetailedAnalysis.getDgraph();
+ }
+ }
+
+ @Test
+ public void parseFile() {
+ assertNotNull(latencyDetailedAnalysis);
+ int graphsize = dgt.getGraphsize();
+ assertTrue(graphsize >= 57);
+ if (GRAPH != null) {
+ try {
+ Boolean test = dgt.compareWithImported(GRAPH);
+ assertTrue(test);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ transFile1 = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + SIMULATIONTRACE_PATH_FILE));
+ assertTrue(transFile1.size() == 38);
+ checkedDropDown = latencyDetailedAnalysis.getCheckedT();
+ for (Entry<String, Integer> cT : checkedDropDown.entrySet()) {
+ int id = cT.getValue();
+ String taskName = cT.getKey();
+ if (id == OPERATOR1_ID) {
+ task1 = taskName;
+ } else if (id == OPERATOR2_ID) {
+ task2 = taskName;
+ }
+ }
+ allLatencies = dgt.latencyDetailedAnalysis(task1, task2, transFile1, false, false);
+ assertTrue(allLatencies.length == 1);
+ assertTrue((int) allLatencies[0][1] == 60);
+ assertTrue((int) allLatencies[0][3] == 212);
+ assertTrue((int) allLatencies[0][4] == 152);
+ }
+}
diff --git a/ttool/src/test/java/ui/graphlatencytainting/GraphLatencyAnalysisTaintingTest.java b/ttool/src/test/java/ui/graphlatencytainting/GraphLatencyAnalysisTaintingTest.java
new file mode 100644
index 0000000000..3bfd7269d1
--- /dev/null
+++ b/ttool/src/test/java/ui/graphlatencytainting/GraphLatencyAnalysisTaintingTest.java
@@ -0,0 +1,101 @@
+package ui.graphlatencytainting;
+
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map.Entry;
+import java.util.Vector;
+
+import org.junit.Before;
+import org.junit.Test;
+
+import tmltranslator.simulation.DependencyGraphTranslator;
+import tmltranslator.simulation.SimulationTransaction;
+import ui.AbstractUITest;
+import ui.SimulationTrace;
+import ui.TMLArchiPanel;
+import ui.simulationtraceanalysis.JFrameLatencyDetailedAnalysis;
+import ui.simulationtraceanalysis.LatencyDetailedAnalysisMain;
+
+public class GraphLatencyAnalysisTaintingTest extends AbstractUITest {
+ // private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
+ private static final String INPUT_PATH = "/ui/graphLatencyAnalysis/input";
+ private static final String simulationTracePath = INPUT_PATH + "/tainting.xml";
+ private static final String modelPath = INPUT_PATH + "/GraphLatencyAnalysisTainting.xml";
+ private static final String mappingDiagName = "Architecture";
+ private Vector<SimulationTransaction> transFile1;
+ private Vector<String> dropDown;
+ private static final int operator1ID = 47;
+ private static final int operator2ID = 37;
+ private static String task1;
+ private static String task2;
+ private static DependencyGraphTranslator dgt;
+ private static Object[][] allLatencies, minMaxArray, taskHWByRowDetails, detailedLatency;
+ private JFrameLatencyDetailedAnalysis latencyDetailedAnalysis;
+ private LatencyDetailedAnalysisMain LatencyDetailedAnalysisMain;
+ private HashMap<String, Integer> checkedDropDown = new HashMap<String, Integer>();
+
+ @Before
+ public void GraphLatencyAnalysis() throws InterruptedException {
+ mainGUI.openProjectFromFile(new File(getBaseResourcesDir() + modelPath));
+ final TMLArchiPanel panel = findArchiPanel(mappingDiagName);
+ if (panel == null) {
+ System.out.println("NULL Panel");
+ } else {
+ System.out.println("Non NULL Panel");
+ }
+ mainGUI.checkModelingSyntax(panel, true);
+ SimulationTrace file2 = new SimulationTrace("tainting", 6, simulationTracePath);
+ LatencyDetailedAnalysisMain = new LatencyDetailedAnalysisMain(3, mainGUI, file2, false, false, 3);
+ LatencyDetailedAnalysisMain.getTc().setMainGUI(mainGUI);
+ LatencyDetailedAnalysisMain.latencyDetailedAnalysis(file2, panel, false, false, mainGUI);
+ latencyDetailedAnalysis = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis();
+ if (latencyDetailedAnalysis != null) {
+ latencyDetailedAnalysis.setVisible(false);
+ latencyDetailedAnalysis.getTc().run();
+ try {
+ latencyDetailedAnalysis.getT().join();
+ } catch (InterruptedException e) {
+ // TODO Auto-generated catch block
+ e.printStackTrace();
+ }
+ dgt = latencyDetailedAnalysis.getDgraph();
+ }
+ }
+
+ @Test
+ public void parseFile() {
+ assertNotNull(latencyDetailedAnalysis);
+ int graphsize = dgt.getGraphsize();
+ assertTrue(graphsize == 34);
+ checkedDropDown = latencyDetailedAnalysis.getCheckedT();
+ assertTrue(checkedDropDown.size() == 2);
+ transFile1 = LatencyDetailedAnalysisMain.getLatencyDetailedAnalysis().parseFile(new File(getBaseResourcesDir() + simulationTracePath));
+ assertTrue(transFile1.size() > 0);
+ for (Entry<String, Integer> cT : checkedDropDown.entrySet()) {
+ int id = cT.getValue();
+ String taskName = cT.getKey();
+ if (id == operator1ID) {
+ task1 = taskName;
+ } else if (id == operator2ID) {
+ task2 = taskName;
+ }
+ }
+ allLatencies = dgt.latencyDetailedAnalysis(task1, task2, transFile1, true, false);
+ assertTrue(allLatencies.length == 1);
+ assertTrue(allLatencies[0][4] == Integer.valueOf(105));
+ minMaxArray = dgt.latencyMinMaxAnalysis(task1, task2, transFile1);
+ dgt.getRowDetailsMinMax(1);
+ taskHWByRowDetails = dgt.getTasksByRowMinMax(0);
+ assertTrue(minMaxArray.length > 0);
+ assertTrue(taskHWByRowDetails.length == 12);
+ taskHWByRowDetails = dgt.getTaskHWByRowDetailsMinMax(0);
+ assertTrue(taskHWByRowDetails.length == 6);
+ detailedLatency = dgt.getTaskByRowDetails(0);
+ assertTrue(detailedLatency.length == 12);
+ detailedLatency = dgt.getTaskHWByRowDetails(0);
+ assertTrue(detailedLatency.length == 3);
+ }
+}
\ No newline at end of file
diff --git a/ttool/src/test/resources/ui/graphLatencyAnalysis/input/seqGraph1.graphml b/ttool/src/test/resources/ui/graphLatencyAnalysis/input/seqGraph1.graphml
new file mode 100644
index 0000000000..c81cd9696a
--- /dev/null
+++ b/ttool/src/test/resources/ui/graphLatencyAnalysis/input/seqGraph1.graphml
@@ -0,0 +1,429 @@
+<?xml version="1.0" encoding="UTF-8"?><graphml xmlns="http://graphml.graphdrawing.org/xmlns" xsi:schemaLocation="http://graphml.graphdrawing.org/xmlns http://graphml.graphdrawing.org/xmlns/1.0/graphml.xsd" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+<key id="vertex_label_key" for="node" attr.name="VertexLabel" attr.type="string"/>
+<key id="edge_label_key" for="edge" attr.name="EdgeLabel" attr.type="string"/>
+<graph edgedefault="directed">
+<node id="Bus0">
+<data key="vertex_label_key">Bus0</data>
+</node>
+<node id="Memory0">
+<data key="vertex_label_key">Memory0</data>
+</node>
+<node id="f__dataC__13">
+<data key="vertex_label_key">f__dataC__13</data>
+</node>
+<node id="f__data__16">
+<data key="vertex_label_key">f__data__16</data>
+</node>
+<node id="CPU_R">
+<data key="vertex_label_key">CPU_R</data>
+</node>
+<node id="f__rez">
+<data key="vertex_label_key">f__rez</data>
+</node>
+<node id="f__rez__start__39">
+<data key="vertex_label_key">f__rez__start__39</data>
+</node>
+<node id="f__rez__infiniteloop__54">
+<data key="vertex_label_key">f__rez__infiniteloop__54</data>
+</node>
+<node id="f__rez__rseq__44">
+<data key="vertex_label_key">f__rez__rseq__44</data>
+</node>
+<node id="f__rez__readchannel__53">
+<data key="vertex_label_key">f__rez__readchannel__53</data>
+</node>
+<node id="f__rez__stopstate__52">
+<data key="vertex_label_key">f__rez__stopstate__52</data>
+</node>
+<node id="f__rez__execc__51">
+<data key="vertex_label_key">f__rez__execc__51</data>
+</node>
+<node id="f__rez__stopstate__50">
+<data key="vertex_label_key">f__rez__stopstate__50</data>
+</node>
+<node id="f__rez__loop__49">
+<data key="vertex_label_key">f__rez__loop__49</data>
+</node>
+<node id="f__rez__execi__46">
+<data key="vertex_label_key">f__rez__execi__46</data>
+</node>
+<node id="f__rez__seq__43">
+<data key="vertex_label_key">f__rez__seq__43</data>
+</node>
+<node id="f__rez__d-delay__47">
+<data key="vertex_label_key">f__rez__d-delay__47</data>
+</node>
+<node id="f__rez__stopstate__48">
+<data key="vertex_label_key">f__rez__stopstate__48</data>
+</node>
+<node id="f__rez__execi__42">
+<data key="vertex_label_key">f__rez__execi__42</data>
+</node>
+<node id="f__rez__stopstate__45">
+<data key="vertex_label_key">f__rez__stopstate__45</data>
+</node>
+<node id="f__rez__execc__41">
+<data key="vertex_label_key">f__rez__execc__41</data>
+</node>
+<node id="f__rez__stopstate__40">
+<data key="vertex_label_key">f__rez__stopstate__40</data>
+</node>
+<node id="f__app">
+<data key="vertex_label_key">f__app</data>
+</node>
+<node id="f__app__start__20">
+<data key="vertex_label_key">f__app__start__20</data>
+</node>
+<node id="f__app__Waitevent:f__sendData__f__sendData__38">
+<data key="vertex_label_key">f__app__Waitevent:f__sendData__f__sendData__38</data>
+</node>
+<node id="f__app__readchannel__37">
+<data key="vertex_label_key">f__app__readchannel__37</data>
+</node>
+<node id="f__app__seq__26">
+<data key="vertex_label_key">f__app__seq__26</data>
+</node>
+<node id="f__app__execi__25">
+<data key="vertex_label_key">f__app__execi__25</data>
+</node>
+<node id="f__app__stopstate__24">
+<data key="vertex_label_key">f__app__stopstate__24</data>
+</node>
+<node id="f__app__execi__21">
+<data key="vertex_label_key">f__app__execi__21</data>
+</node>
+<node id="f__app__loop__0__36">
+<data key="vertex_label_key">f__app__loop__0__36</data>
+</node>
+<node id="f__app__execi__23">
+<data key="vertex_label_key">f__app__execi__23</data>
+</node>
+<node id="f__app__stopstate__22">
+<data key="vertex_label_key">f__app__stopstate__22</data>
+</node>
+<node id="f__app__action__33">
+<data key="vertex_label_key">f__app__action__33</data>
+</node>
+<node id="f__app__choice__34">
+<data key="vertex_label_key">f__app__choice__34</data>
+</node>
+<node id="f__app__writechannel__28">
+<data key="vertex_label_key">f__app__writechannel__28</data>
+</node>
+<node id="f__app__stopstate__27">
+<data key="vertex_label_key">f__app__stopstate__27</data>
+</node>
+<node id="f__app__execi__32">
+<data key="vertex_label_key">f__app__execi__32</data>
+</node>
+<node id="f__app__stopstate__30">
+<data key="vertex_label_key">f__app__stopstate__30</data>
+</node>
+<node id="f__app__execi__31">
+<data key="vertex_label_key">f__app__execi__31</data>
+</node>
+<node id="f__app__stopstate__29">
+<data key="vertex_label_key">f__app__stopstate__29</data>
+</node>
+<node id="CPU_S">
+<data key="vertex_label_key">CPU_S</data>
+</node>
+<node id="f__send">
+<data key="vertex_label_key">f__send</data>
+</node>
+<node id="f__send__start__56">
+<data key="vertex_label_key">f__send__start__56</data>
+</node>
+<node id="f__send__seq__66">
+<data key="vertex_label_key">f__send__seq__66</data>
+</node>
+<node id="f__send__d-delay__65">
+<data key="vertex_label_key">f__send__d-delay__65</data>
+</node>
+<node id="f__send__stopstate__64">
+<data key="vertex_label_key">f__send__stopstate__64</data>
+</node>
+<node id="f__send__execi__63">
+<data key="vertex_label_key">f__send__execi__63</data>
+</node>
+<node id="f__send__seq__62">
+<data key="vertex_label_key">f__send__seq__62</data>
+</node>
+<node id="f__send__rseq__61">
+<data key="vertex_label_key">f__send__rseq__61</data>
+</node>
+<node id="f__send__execc__60">
+<data key="vertex_label_key">f__send__execc__60</data>
+</node>
+<node id="f__send__stopstate__59">
+<data key="vertex_label_key">f__send__stopstate__59</data>
+</node>
+<node id="f__send__execi__58">
+<data key="vertex_label_key">f__send__execi__58</data>
+</node>
+<node id="f__send__stopstate__57">
+<data key="vertex_label_key">f__send__stopstate__57</data>
+</node>
+<node id="f__send__Sendevent:f__sendData__f__sendData__67">
+<data key="vertex_label_key">f__send__Sendevent:f__sendData__f__sendData__67</data>
+</node>
+<node id="f__send__writechannel__69">
+<data key="vertex_label_key">f__send__writechannel__69</data>
+</node>
+<node id="f__send__stopstate__68">
+<data key="vertex_label_key">f__send__stopstate__68</data>
+</node>
+<edge id="Bus0f__dataC__13" source="Bus0" target="f__dataC__13">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="Bus0f__data__16" source="Bus0" target="f__data__16">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="CPU_Rf__rez" source="CPU_R" target="f__rez">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rezf__rez__start__39" source="f__rez" target="f__rez__start__39">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__start__39f__rez__infiniteloop__54" source="f__rez__start__39" target="f__rez__infiniteloop__54">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__infiniteloop__54f__rez__rseq__44" source="f__rez__infiniteloop__54" target="f__rez__rseq__44">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__rseq__44f__rez__readchannel__53" source="f__rez__rseq__44" target="f__rez__readchannel__53">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__readchannel__53f__rez__stopstate__52" source="f__rez__readchannel__53" target="f__rez__stopstate__52">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__rseq__44f__rez__execc__51" source="f__rez__rseq__44" target="f__rez__execc__51">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__execc__51f__rez__stopstate__50" source="f__rez__execc__51" target="f__rez__stopstate__50">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__rseq__44f__rez__loop__49" source="f__rez__rseq__44" target="f__rez__loop__49">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__loop__49f__rez__execi__46" source="f__rez__loop__49" target="f__rez__execi__46">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__execi__46f__rez__seq__43" source="f__rez__execi__46" target="f__rez__seq__43">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__loop__49f__rez__d-delay__47" source="f__rez__loop__49" target="f__rez__d-delay__47">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__d-delay__47f__rez__stopstate__48" source="f__rez__d-delay__47" target="f__rez__stopstate__48">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__seq__43f__rez__execi__42" source="f__rez__seq__43" target="f__rez__execi__42">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__execi__42f__rez__stopstate__45" source="f__rez__execi__42" target="f__rez__stopstate__45">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__seq__43f__rez__execc__41" source="f__rez__seq__43" target="f__rez__execc__41">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__execc__41f__rez__stopstate__40" source="f__rez__execc__41" target="f__rez__stopstate__40">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="CPU_Rf__app" source="CPU_R" target="f__app">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__appf__app__start__20" source="f__app" target="f__app__start__20">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__start__20f__app__Waitevent:f__sendData__f__sendData__38" source="f__app__start__20" target="f__app__Waitevent:f__sendData__f__sendData__38">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__Waitevent:f__sendData__f__sendData__38f__app__readchannel__37" source="f__app__Waitevent:f__sendData__f__sendData__38" target="f__app__readchannel__37">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__readchannel__37f__app__seq__26" source="f__app__readchannel__37" target="f__app__seq__26">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__seq__26f__app__execi__25" source="f__app__seq__26" target="f__app__execi__25">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__execi__25f__app__stopstate__24" source="f__app__execi__25" target="f__app__stopstate__24">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__seq__26f__app__execi__21" source="f__app__seq__26" target="f__app__execi__21">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__execi__21f__app__loop__0__36" source="f__app__execi__21" target="f__app__loop__0__36">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__seq__26f__app__execi__23" source="f__app__seq__26" target="f__app__execi__23">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__execi__23f__app__stopstate__22" source="f__app__execi__23" target="f__app__stopstate__22">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__loop__0__36f__app__action__33" source="f__app__loop__0__36" target="f__app__action__33">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__action__33f__app__choice__34" source="f__app__action__33" target="f__app__choice__34">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__loop__0__36f__app__writechannel__28" source="f__app__loop__0__36" target="f__app__writechannel__28">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__writechannel__28f__app__stopstate__27" source="f__app__writechannel__28" target="f__app__stopstate__27">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__choice__34f__app__execi__32" source="f__app__choice__34" target="f__app__execi__32">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__execi__32f__app__stopstate__30" source="f__app__execi__32" target="f__app__stopstate__30">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__choice__34f__app__execi__31" source="f__app__choice__34" target="f__app__execi__31">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__execi__31f__app__stopstate__29" source="f__app__execi__31" target="f__app__stopstate__29">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="CPU_Sf__send" source="CPU_S" target="f__send">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__sendf__send__start__56" source="f__send" target="f__send__start__56">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__start__56f__send__seq__66" source="f__send__start__56" target="f__send__seq__66">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__seq__66f__send__d-delay__65" source="f__send__seq__66" target="f__send__d-delay__65">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__d-delay__65f__send__stopstate__64" source="f__send__d-delay__65" target="f__send__stopstate__64">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__seq__66f__send__execi__63" source="f__send__seq__66" target="f__send__execi__63">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__execi__63f__send__seq__62" source="f__send__execi__63" target="f__send__seq__62">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__seq__62f__send__rseq__61" source="f__send__seq__62" target="f__send__rseq__61">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__seq__62f__send__execc__60" source="f__send__seq__62" target="f__send__execc__60">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__execc__60f__send__stopstate__59" source="f__send__execc__60" target="f__send__stopstate__59">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__rseq__61f__send__execi__58" source="f__send__rseq__61" target="f__send__execi__58">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__execi__58f__send__stopstate__57" source="f__send__execi__58" target="f__send__stopstate__57">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__rseq__61f__send__Sendevent:f__sendData__f__sendData__67" source="f__send__rseq__61" target="f__send__Sendevent:f__sendData__f__sendData__67">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__Sendevent:f__sendData__f__sendData__67f__send__writechannel__69" source="f__send__Sendevent:f__sendData__f__sendData__67" target="f__send__writechannel__69">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__writechannel__69f__send__stopstate__68" source="f__send__writechannel__69" target="f__send__stopstate__68">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="CPU_RBus0" source="CPU_R" target="Bus0">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="Bus0CPU_R" source="Bus0" target="CPU_R">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="CPU_SBus0" source="CPU_S" target="Bus0">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="Bus0CPU_S" source="Bus0" target="CPU_S">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="Memory0Bus0" source="Memory0" target="Bus0">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="Bus0Memory0" source="Bus0" target="Memory0">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__40f__rez__loop__49" source="f__rez__stopstate__40" target="f__rez__loop__49">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__52f__rez__infiniteloop__54" source="f__rez__stopstate__52" target="f__rez__infiniteloop__54">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__50f__rez__infiniteloop__54" source="f__rez__stopstate__50" target="f__rez__infiniteloop__54">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__stopstate__30f__app__loop__0__36" source="f__app__stopstate__30" target="f__app__loop__0__36">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__48f__rez__infiniteloop__54" source="f__rez__stopstate__48" target="f__rez__infiniteloop__54">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__stopstate__29f__app__loop__0__36" source="f__app__stopstate__29" target="f__app__loop__0__36">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__Sendevent:f__sendData__f__sendData__67f__app__Waitevent:f__sendData__f__sendData__38" source="f__send__Sendevent:f__sendData__f__sendData__67" target="f__app__Waitevent:f__sendData__f__sendData__38">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__dataC__13f__rez__readchannel__53" source="f__dataC__13" target="f__rez__readchannel__53">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__data__16f__app__readchannel__37" source="f__data__16" target="f__app__readchannel__37">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__writechannel__69f__data__16" source="f__send__writechannel__69" target="f__data__16">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__writechannel__28f__dataC__13" source="f__app__writechannel__28" target="f__dataC__13">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__stopstate__24f__app__execi__21" source="f__app__stopstate__24" target="f__app__execi__21">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__45f__rez__execc__41" source="f__rez__stopstate__45" target="f__rez__execc__41">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__stopstate__64f__send__execi__63" source="f__send__stopstate__64" target="f__send__execi__63">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__stopstate__57f__send__execc__60" source="f__send__stopstate__57" target="f__send__execc__60">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__stopstate__68f__send__execc__60" source="f__send__stopstate__68" target="f__send__execc__60">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__app__stopstate__27f__app__execi__23" source="f__app__stopstate__27" target="f__app__execi__23">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__52f__rez__loop__49" source="f__rez__stopstate__52" target="f__rez__loop__49">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__52f__rez__execc__51" source="f__rez__stopstate__52" target="f__rez__execc__51">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__50f__rez__loop__49" source="f__rez__stopstate__50" target="f__rez__loop__49">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__50f__rez__readchannel__53" source="f__rez__stopstate__50" target="f__rez__readchannel__53">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__48f__rez__readchannel__53" source="f__rez__stopstate__48" target="f__rez__readchannel__53">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__rez__stopstate__48f__rez__execc__51" source="f__rez__stopstate__48" target="f__rez__execc__51">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__stopstate__57f__send__Sendevent:f__sendData__f__sendData__67" source="f__send__stopstate__57" target="f__send__Sendevent:f__sendData__f__sendData__67">
+<data key="edge_label_key">1.0</data>
+</edge>
+<edge id="f__send__stopstate__68f__send__execi__58" source="f__send__stopstate__68" target="f__send__execi__58">
+<data key="edge_label_key">1.0</data>
+</edge>
+</graph>
+</graphml>
--
GitLab